website: merge x.blog branch
The x.blog branch was created out-of-band by rewriting the
x/blog history to have this repo's first commit as its initial commit
and moving all the work into a blog/ subdirectory.
This merge brings the blog/ subdirectory into the main branch
of x/website.
After this merge, all work on the blog will happen here in x/website,
first in the blog/ directory and then eventually merged into the website
proper.
Change-Id: I25b94377a1f111ee0a640afcb7e2e4a4384d0733
diff --git a/.prettierrc b/.prettierrc
new file mode 100644
index 0000000..1502887
--- /dev/null
+++ b/.prettierrc
@@ -0,0 +1,4 @@
+{
+ "singleQuote": true,
+ "trailingComma": "es5"
+}
\ No newline at end of file
diff --git a/README.md b/README.md
index eedef26..ec3d08e 100644
--- a/README.md
+++ b/README.md
@@ -1,17 +1,36 @@
-# Go Website
+# Go website
-This repository holds the Go Website server code and content.
+[](https://pkg.go.dev/golang.org/x/website)
-## Download/Install
+This repo holds content and serving programs for the golang.org web site.
-The easiest way to install is to run `go get -u golang.org/x/website`. You can
-also manually git clone the repository to `$GOPATH/src/golang.org/x/website`.
+Content is in _content/. Server code is in cmd/ and internal/.
+
+To run the server to preview local content changes, use:
+
+ go run ./cmd/golangorg
+
+The supporting programs cmd/admingolangorg and cmd/googlegolangorg
+are the servers for admin.golang.org and google.golang.org.
+(They do not use the _content/ directory.)
+
+Each command directory has its own README.md explaining deployment.
+
+## JS/CSS Formatting
+
+This repository uses [prettier](https://prettier.io/) to format JS and CSS files.
+
+The version of `prettier` used is 1.18.2.
+
+It is encouraged that all JS and CSS code be run through this before submitting
+a change. However, it is not a strict requirement enforced by CI.
## Report Issues / Send Patches
This repository uses Gerrit for code changes. To learn how to submit changes to
this repository, see https://golang.org/doc/contribute.html.
-The main issue tracker for the time repository is located at
+The main issue tracker for the website repository is located at
https://github.com/golang/go/issues. Prefix your issue with "x/website:" in the
subject line, so it is easy to find.
+
diff --git a/_content/doc/articles/go_command.html b/_content/doc/articles/go_command.html
new file mode 100644
index 0000000..5b6fd4d
--- /dev/null
+++ b/_content/doc/articles/go_command.html
@@ -0,0 +1,254 @@
+<!--{
+ "title": "About the go command"
+}-->
+
+<p>The Go distribution includes a command, named
+"<code><a href="/cmd/go/">go</a></code>", that
+automates the downloading, building, installation, and testing of Go packages
+and commands. This document talks about why we wrote a new command, what it
+is, what it's not, and how to use it.</p>
+
+<h2>Motivation</h2>
+
+<p>You might have seen early Go talks in which Rob Pike jokes that the idea
+for Go arose while waiting for a large Google server to compile. That
+really was the motivation for Go: to build a language that worked well
+for building the large software that Google writes and runs. It was
+clear from the start that such a language must provide a way to
+express dependencies between code libraries clearly, hence the package
+grouping and the explicit import blocks. It was also clear from the
+start that you might want arbitrary syntax for describing the code
+being imported; this is why import paths are string literals.</p>
+
+<p>An explicit goal for Go from the beginning was to be able to build Go
+code using only the information found in the source itself, not
+needing to write a makefile or one of the many modern replacements for
+makefiles. If Go needed a configuration file to explain how to build
+your program, then Go would have failed.</p>
+
+<p>At first, there was no Go compiler, and the initial development
+focused on building one and then building libraries for it. For
+expedience, we postponed the automation of building Go code by using
+make and writing makefiles. When compiling a single package involved
+multiple invocations of the Go compiler, we even used a program to
+write the makefiles for us. You can find it if you dig through the
+repository history.</p>
+
+<p>The purpose of the new go command is our return to this ideal, that Go
+programs should compile without configuration or additional effort on
+the part of the developer beyond writing the necessary import
+statements.</p>
+
+<h2>Configuration versus convention</h2>
+
+<p>The way to achieve the simplicity of a configuration-free system is to
+establish conventions. The system works only to the extent that those conventions
+are followed. When we first launched Go, many people published packages that
+had to be installed in certain places, under certain names, using certain build
+tools, in order to be used. That's understandable: that's the way it works in
+most other languages. Over the last few years we consistently reminded people
+about the <code>goinstall</code> command
+(now replaced by <a href="/cmd/go/#hdr-Download_and_install_packages_and_dependencies"><code>go get</code></a>)
+and its conventions: first, that the import path is derived in a known way from
+the URL of the source code; second, that the place to store the sources in
+the local file system is derived in a known way from the import path; third,
+that each directory in a source tree corresponds to a single package; and
+fourth, that the package is built using only information in the source code.
+Today, the vast majority of packages follow these conventions.
+The Go ecosystem is simpler and more powerful as a result.</p>
+
+<p>We received many requests to allow a makefile in a package directory to
+provide just a little extra configuration beyond what's in the source code.
+But that would have introduced new rules. Because we did not accede to such
+requests, we were able to write the go command and eliminate our use of make
+or any other build system.</p>
+
+<p>It is important to understand that the go command is not a general
+build tool. It cannot be configured and it does not attempt to build
+anything but Go packages. These are important simplifying
+assumptions: they simplify not only the implementation but also, more
+important, the use of the tool itself.</p>
+
+<h2>Go's conventions</h2>
+
+<p>The <code>go</code> command requires that code adheres to a few key,
+well-established conventions.</p>
+
+<p>First, the import path is derived in a known way from the URL of the
+source code. For Bitbucket, GitHub, Google Code, and Launchpad, the
+root directory of the repository is identified by the repository's
+main URL, without the <code>http://</code> prefix. Subdirectories are named by
+adding to that path.
+For example, the Go example programs are obtained by running</p>
+
+<pre>
+git clone https://github.com/golang/example
+</pre>
+
+<p>and thus the import path for the root directory of that repository is
+"<code>github.com/golang/example</code>".
+The <a href="https://godoc.org/github.com/golang/example/stringutil">stringutil</a>
+package is stored in a subdirectory, so its import path is
+"<code>github.com/golang/example/stringutil</code>".</p>
+
+<p>These paths are on the long side, but in exchange we get an
+automatically managed name space for import paths and the ability for
+a tool like the go command to look at an unfamiliar import path and
+deduce where to obtain the source code.</p>
+
+<p>Second, the place to store sources in the local file system is derived
+in a known way from the import path, specifically
+<code>$GOPATH/src/<import-path></code>.
+If unset, <code>$GOPATH</code> defaults to a subdirectory
+named <code>go</code> in the user's home directory.
+If <code>$GOPATH</code> is set to a list of paths, the go command tries
+<code><dir>/src/<import-path></code> for each of the directories in
+that list.
+</p>
+
+<p>Each of those trees contains, by convention, a top-level directory named
+"<code>bin</code>", for holding compiled executables, and a top-level directory
+named "<code>pkg</code>", for holding compiled packages that can be imported,
+and the "<code>src</code>" directory, for holding package source files.
+Imposing this structure lets us keep each of these directory trees
+self-contained: the compiled form and the sources are always near each
+other.</p>
+
+<p>These naming conventions also let us work in the reverse direction,
+from a directory name to its import path. This mapping is important
+for many of the go command's subcommands, as we'll see below.</p>
+
+<p>Third, each directory in a source tree corresponds to a single
+package. By restricting a directory to a single package, we don't have
+to create hybrid import paths that specify first the directory and
+then the package within that directory. Also, most file management
+tools and UIs work on directories as fundamental units. Tying the
+fundamental Go unit—the package—to file system structure means
+that file system tools become Go package tools. Copying, moving, or
+deleting a package corresponds to copying, moving, or deleting a
+directory.</p>
+
+<p>Fourth, each package is built using only the information present in
+the source files. This makes it much more likely that the tool will
+be able to adapt to changing build environments and conditions. For
+example, if we allowed extra configuration such as compiler flags or
+command line recipes, then that configuration would need to be updated
+each time the build tools changed; it would also be inherently tied
+to the use of a specific toolchain.</p>
+
+<h2>Getting started with the go command</h2>
+
+<p>Finally, a quick tour of how to use the go command.
+As mentioned above, the default <code>$GOPATH</code> on Unix is <code>$HOME/go</code>.
+We'll store our programs there.
+To use a different location, you can set <code>$GOPATH</code>;
+see <a href="/doc/code.html">How to Write Go Code</a> for details.
+
+<p>We first add some source code. Suppose we want to use
+the indexing library from the codesearch project along with a left-leaning
+red-black tree. We can install both with the "<code>go get</code>"
+subcommand:</p>
+
+<pre>
+$ go get github.com/google/codesearch/index
+$ go get github.com/petar/GoLLRB/llrb
+$
+</pre>
+
+<p>Both of these projects are now downloaded and installed into <code>$HOME/go</code>,
+which contains the two directories
+<code>src/github.com/google/codesearch/index/</code> and
+<code>src/github.com/petar/GoLLRB/llrb/</code>, along with the compiled
+packages (in <code>pkg/</code>) for those libraries and their dependencies.</p>
+
+<p>Because we used version control systems (Mercurial and Git) to check
+out the sources, the source tree also contains the other files in the
+corresponding repositories, such as related packages. The "<code>go list</code>"
+subcommand lists the import paths corresponding to its arguments, and
+the pattern "<code>./...</code>" means start in the current directory
+("<code>./</code>") and find all packages below that directory
+("<code>...</code>"):</p>
+
+<pre>
+$ cd $HOME/go/src
+$ go list ./...
+github.com/google/codesearch/cmd/cgrep
+github.com/google/codesearch/cmd/cindex
+github.com/google/codesearch/cmd/csearch
+github.com/google/codesearch/index
+github.com/google/codesearch/regexp
+github.com/google/codesearch/sparse
+github.com/petar/GoLLRB/example
+github.com/petar/GoLLRB/llrb
+$
+</pre>
+
+<p>We can also test those packages:</p>
+
+<pre>
+$ go test ./...
+? github.com/google/codesearch/cmd/cgrep [no test files]
+? github.com/google/codesearch/cmd/cindex [no test files]
+? github.com/google/codesearch/cmd/csearch [no test files]
+ok github.com/google/codesearch/index 0.203s
+ok github.com/google/codesearch/regexp 0.017s
+? github.com/google/codesearch/sparse [no test files]
+? github.com/petar/GoLLRB/example [no test files]
+ok github.com/petar/GoLLRB/llrb 0.231s
+$
+</pre>
+
+<p>If a go subcommand is invoked with no paths listed, it operates on the
+current directory:</p>
+
+<pre>
+$ cd github.com/google/codesearch/regexp
+$ go list
+github.com/google/codesearch/regexp
+$ go test -v
+=== RUN TestNstateEnc
+--- PASS: TestNstateEnc (0.00s)
+=== RUN TestMatch
+--- PASS: TestMatch (0.00s)
+=== RUN TestGrep
+--- PASS: TestGrep (0.00s)
+PASS
+ok github.com/google/codesearch/regexp 0.018s
+$ go install
+$
+</pre>
+
+<p>That "<code>go install</code>" subcommand installs the latest copy of the
+package into the pkg directory. Because the go command can analyze the
+dependency graph, "<code>go install</code>" also installs any packages that
+this package imports but that are out of date, recursively.</p>
+
+<p>Notice that "<code>go install</code>" was able to determine the name of the
+import path for the package in the current directory, because of the convention
+for directory naming. It would be a little more convenient if we could pick
+the name of the directory where we kept source code, and we probably wouldn't
+pick such a long name, but that ability would require additional configuration
+and complexity in the tool. Typing an extra directory name or two is a small
+price to pay for the increased simplicity and power.</p>
+
+<h2>Limitations</h2>
+
+<p>As mentioned above, the go command is not a general-purpose build
+tool.
+In particular, it does not have any facility for generating Go
+source files <em>during</em> a build, although it does provide
+<a href="/cmd/go/#hdr-Generate_Go_files_by_processing_source"><code>go</code>
+<code>generate</code></a>,
+which can automate the creation of Go files <em>before</em> the build.
+For more advanced build setups, you may need to write a
+makefile (or a configuration file for the build tool of your choice)
+to run whatever tool creates the Go files and then check those generated source files
+into your repository. This is more work for you, the package author,
+but it is significantly less work for your users, who can use
+"<code>go get</code>" without needing to obtain and build
+any additional tools.</p>
+
+<h2>More information</h2>
+
+<p>For more information, read <a href="/doc/code.html">How to Write Go Code</a>
+and see the <a href="/cmd/go/">go command documentation</a>.</p>
diff --git a/_content/doc/articles/index.html b/_content/doc/articles/index.html
new file mode 100644
index 0000000..9ddd669
--- /dev/null
+++ b/_content/doc/articles/index.html
@@ -0,0 +1,8 @@
+<!--{
+ "Title": "/doc/articles/"
+}-->
+
+<p>
+See the <a href="/doc/#articles">Documents page</a> and the
+<a href="/blog/index">Blog index</a> for a complete list of Go articles.
+</p>
diff --git a/_content/doc/articles/race_detector.html b/_content/doc/articles/race_detector.html
new file mode 100644
index 0000000..09188c1
--- /dev/null
+++ b/_content/doc/articles/race_detector.html
@@ -0,0 +1,440 @@
+<!--{
+ "Title": "Data Race Detector",
+ "Template": true
+}-->
+
+<h2 id="Introduction">Introduction</h2>
+
+<p>
+Data races are among the most common and hardest to debug types of bugs in concurrent systems.
+A data race occurs when two goroutines access the same variable concurrently and at least one of the accesses is a write.
+See the <a href="/ref/mem/">The Go Memory Model</a> for details.
+</p>
+
+<p>
+Here is an example of a data race that can lead to crashes and memory corruption:
+</p>
+
+<pre>
+func main() {
+ c := make(chan bool)
+ m := make(map[string]string)
+ go func() {
+ m["1"] = "a" // First conflicting access.
+ c <- true
+ }()
+ m["2"] = "b" // Second conflicting access.
+ <-c
+ for k, v := range m {
+ fmt.Println(k, v)
+ }
+}
+</pre>
+
+<h2 id="Usage">Usage</h2>
+
+<p>
+To help diagnose such bugs, Go includes a built-in data race detector.
+To use it, add the <code>-race</code> flag to the go command:
+</p>
+
+<pre>
+$ go test -race mypkg // to test the package
+$ go run -race mysrc.go // to run the source file
+$ go build -race mycmd // to build the command
+$ go install -race mypkg // to install the package
+</pre>
+
+<h2 id="Report_Format">Report Format</h2>
+
+<p>
+When the race detector finds a data race in the program, it prints a report.
+The report contains stack traces for conflicting accesses, as well as stacks where the involved goroutines were created.
+Here is an example:
+</p>
+
+<pre>
+WARNING: DATA RACE
+Read by goroutine 185:
+ net.(*pollServer).AddFD()
+ src/net/fd_unix.go:89 +0x398
+ net.(*pollServer).WaitWrite()
+ src/net/fd_unix.go:247 +0x45
+ net.(*netFD).Write()
+ src/net/fd_unix.go:540 +0x4d4
+ net.(*conn).Write()
+ src/net/net.go:129 +0x101
+ net.func·060()
+ src/net/timeout_test.go:603 +0xaf
+
+Previous write by goroutine 184:
+ net.setWriteDeadline()
+ src/net/sockopt_posix.go:135 +0xdf
+ net.setDeadline()
+ src/net/sockopt_posix.go:144 +0x9c
+ net.(*conn).SetDeadline()
+ src/net/net.go:161 +0xe3
+ net.func·061()
+ src/net/timeout_test.go:616 +0x3ed
+
+Goroutine 185 (running) created at:
+ net.func·061()
+ src/net/timeout_test.go:609 +0x288
+
+Goroutine 184 (running) created at:
+ net.TestProlongTimeout()
+ src/net/timeout_test.go:618 +0x298
+ testing.tRunner()
+ src/testing/testing.go:301 +0xe8
+</pre>
+
+<h2 id="Options">Options</h2>
+
+<p>
+The <code>GORACE</code> environment variable sets race detector options.
+The format is:
+</p>
+
+<pre>
+GORACE="option1=val1 option2=val2"
+</pre>
+
+<p>
+The options are:
+</p>
+
+<ul>
+<li>
+<code>log_path</code> (default <code>stderr</code>): The race detector writes
+its report to a file named <code>log_path.<em>pid</em></code>.
+The special names <code>stdout</code>
+and <code>stderr</code> cause reports to be written to standard output and
+standard error, respectively.
+</li>
+
+<li>
+<code>exitcode</code> (default <code>66</code>): The exit status to use when
+exiting after a detected race.
+</li>
+
+<li>
+<code>strip_path_prefix</code> (default <code>""</code>): Strip this prefix
+from all reported file paths, to make reports more concise.
+</li>
+
+<li>
+<code>history_size</code> (default <code>1</code>): The per-goroutine memory
+access history is <code>32K * 2**history_size elements</code>.
+Increasing this value can avoid a "failed to restore the stack" error in reports, at the
+cost of increased memory usage.
+</li>
+
+<li>
+<code>halt_on_error</code> (default <code>0</code>): Controls whether the program
+exits after reporting first data race.
+</li>
+
+<li>
+<code>atexit_sleep_ms</code> (default <code>1000</code>): Amount of milliseconds
+to sleep in the main goroutine before exiting.
+</li>
+</ul>
+
+<p>
+Example:
+</p>
+
+<pre>
+$ GORACE="log_path=/tmp/race/report strip_path_prefix=/my/go/sources/" go test -race
+</pre>
+
+<h2 id="Excluding_Tests">Excluding Tests</h2>
+
+<p>
+When you build with <code>-race</code> flag, the <code>go</code> command defines additional
+<a href="/pkg/go/build/#hdr-Build_Constraints">build tag</a> <code>race</code>.
+You can use the tag to exclude some code and tests when running the race detector.
+Some examples:
+</p>
+
+<pre>
+// +build !race
+
+package foo
+
+// The test contains a data race. See issue 123.
+func TestFoo(t *testing.T) {
+ // ...
+}
+
+// The test fails under the race detector due to timeouts.
+func TestBar(t *testing.T) {
+ // ...
+}
+
+// The test takes too long under the race detector.
+func TestBaz(t *testing.T) {
+ // ...
+}
+</pre>
+
+<h2 id="How_To_Use">How To Use</h2>
+
+<p>
+To start, run your tests using the race detector (<code>go test -race</code>).
+The race detector only finds races that happen at runtime, so it can't find
+races in code paths that are not executed.
+If your tests have incomplete coverage,
+you may find more races by running a binary built with <code>-race</code> under a realistic
+workload.
+</p>
+
+<h2 id="Typical_Data_Races">Typical Data Races</h2>
+
+<p>
+Here are some typical data races. All of them can be detected with the race detector.
+</p>
+
+<h3 id="Race_on_loop_counter">Race on loop counter</h3>
+
+<pre>
+func main() {
+ var wg sync.WaitGroup
+ wg.Add(5)
+ for i := 0; i < 5; i++ {
+ go func() {
+ fmt.Println(i) // Not the 'i' you are looking for.
+ wg.Done()
+ }()
+ }
+ wg.Wait()
+}
+</pre>
+
+<p>
+The variable <code>i</code> in the function literal is the same variable used by the loop, so
+the read in the goroutine races with the loop increment.
+(This program typically prints 55555, not 01234.)
+The program can be fixed by making a copy of the variable:
+</p>
+
+<pre>
+func main() {
+ var wg sync.WaitGroup
+ wg.Add(5)
+ for i := 0; i < 5; i++ {
+ go func(j int) {
+ fmt.Println(j) // Good. Read local copy of the loop counter.
+ wg.Done()
+ }(i)
+ }
+ wg.Wait()
+}
+</pre>
+
+<h3 id="Accidentally_shared_variable">Accidentally shared variable</h3>
+
+<pre>
+// ParallelWrite writes data to file1 and file2, returns the errors.
+func ParallelWrite(data []byte) chan error {
+ res := make(chan error, 2)
+ f1, err := os.Create("file1")
+ if err != nil {
+ res <- err
+ } else {
+ go func() {
+ // This err is shared with the main goroutine,
+ // so the write races with the write below.
+ _, err = f1.Write(data)
+ res <- err
+ f1.Close()
+ }()
+ }
+ f2, err := os.Create("file2") // The second conflicting write to err.
+ if err != nil {
+ res <- err
+ } else {
+ go func() {
+ _, err = f2.Write(data)
+ res <- err
+ f2.Close()
+ }()
+ }
+ return res
+}
+</pre>
+
+<p>
+The fix is to introduce new variables in the goroutines (note the use of <code>:=</code>):
+</p>
+
+<pre>
+ ...
+ _, err := f1.Write(data)
+ ...
+ _, err := f2.Write(data)
+ ...
+</pre>
+
+<h3 id="Unprotected_global_variable">Unprotected global variable</h3>
+
+<p>
+If the following code is called from several goroutines, it leads to races on the <code>service</code> map.
+Concurrent reads and writes of the same map are not safe:
+</p>
+
+<pre>
+var service map[string]net.Addr
+
+func RegisterService(name string, addr net.Addr) {
+ service[name] = addr
+}
+
+func LookupService(name string) net.Addr {
+ return service[name]
+}
+</pre>
+
+<p>
+To make the code safe, protect the accesses with a mutex:
+</p>
+
+<pre>
+var (
+ service map[string]net.Addr
+ serviceMu sync.Mutex
+)
+
+func RegisterService(name string, addr net.Addr) {
+ serviceMu.Lock()
+ defer serviceMu.Unlock()
+ service[name] = addr
+}
+
+func LookupService(name string) net.Addr {
+ serviceMu.Lock()
+ defer serviceMu.Unlock()
+ return service[name]
+}
+</pre>
+
+<h3 id="Primitive_unprotected_variable">Primitive unprotected variable</h3>
+
+<p>
+Data races can happen on variables of primitive types as well (<code>bool</code>, <code>int</code>, <code>int64</code>, etc.),
+as in this example:
+</p>
+
+<pre>
+type Watchdog struct{ last int64 }
+
+func (w *Watchdog) KeepAlive() {
+ w.last = time.Now().UnixNano() // First conflicting access.
+}
+
+func (w *Watchdog) Start() {
+ go func() {
+ for {
+ time.Sleep(time.Second)
+ // Second conflicting access.
+ if w.last < time.Now().Add(-10*time.Second).UnixNano() {
+ fmt.Println("No keepalives for 10 seconds. Dying.")
+ os.Exit(1)
+ }
+ }
+ }()
+}
+</pre>
+
+<p>
+Even such "innocent" data races can lead to hard-to-debug problems caused by
+non-atomicity of the memory accesses,
+interference with compiler optimizations,
+or reordering issues accessing processor memory .
+</p>
+
+<p>
+A typical fix for this race is to use a channel or a mutex.
+To preserve the lock-free behavior, one can also use the
+<a href="/pkg/sync/atomic/"><code>sync/atomic</code></a> package.
+</p>
+
+<pre>
+type Watchdog struct{ last int64 }
+
+func (w *Watchdog) KeepAlive() {
+ atomic.StoreInt64(&w.last, time.Now().UnixNano())
+}
+
+func (w *Watchdog) Start() {
+ go func() {
+ for {
+ time.Sleep(time.Second)
+ if atomic.LoadInt64(&w.last) < time.Now().Add(-10*time.Second).UnixNano() {
+ fmt.Println("No keepalives for 10 seconds. Dying.")
+ os.Exit(1)
+ }
+ }
+ }()
+}
+</pre>
+
+<h3 id="Unsynchronized_send_and_close_operations">Unsynchronized send and close operations</h3>
+
+<p>
+As this example demonstrates, unsynchronized send and close operations
+on the same channel can also be a race condition:
+</p>
+
+<pre>
+c := make(chan struct{}) // or buffered channel
+
+// The race detector cannot derive the happens before relation
+// for the following send and close operations. These two operations
+// are unsynchronized and happen concurrently.
+go func() { c <- struct{}{} }()
+close(c)
+</pre>
+
+<p>
+According to the Go memory model, a send on a channel happens before
+the corresponding receive from that channel completes. To synchronize
+send and close operations, use a receive operation that guarantees
+the send is done before the close:
+</p>
+
+<pre>
+c := make(chan struct{}) // or buffered channel
+
+go func() { c <- struct{}{} }()
+<-c
+close(c)
+</pre>
+
+<h2 id="Supported_Systems">Supported Systems</h2>
+
+<p>
+ The race detector runs on
+ <code>linux/amd64</code>, <code>linux/ppc64le</code>,
+ <code>linux/arm64</code>, <code>freebsd/amd64</code>,
+ <code>netbsd/amd64</code>, <code>darwin/amd64</code>,
+ <code>darwin/arm64</code>, and <code>windows/amd64</code>.
+</p>
+
+<h2 id="Runtime_Overheads">Runtime Overhead</h2>
+
+<p>
+The cost of race detection varies by program, but for a typical program, memory
+usage may increase by 5-10x and execution time by 2-20x.
+</p>
+
+<p>
+The race detector currently allocates an extra 8 bytes per <code>defer</code>
+and <code>recover</code> statement. Those extra allocations <a
+href="https://golang.org/issue/26813">are not recovered until the goroutine
+exits</a>. This means that if you have a long-running goroutine that is
+periodically issuing <code>defer</code> and <code>recover</code> calls,
+the program memory usage may grow without bound. These memory allocations
+will not show up in the output of <code>runtime.ReadMemStats</code> or
+<code>runtime/pprof</code>.
+</p>
diff --git a/_content/doc/articles/wiki/edit.html b/_content/doc/articles/wiki/edit.html
new file mode 100644
index 0000000..044c3be
--- /dev/null
+++ b/_content/doc/articles/wiki/edit.html
@@ -0,0 +1,6 @@
+<h1>Editing {{.Title}}</h1>
+
+<form action="/save/{{.Title}}" method="POST">
+<div><textarea name="body" rows="20" cols="80">{{printf "%s" .Body}}</textarea></div>
+<div><input type="submit" value="Save"></div>
+</form>
diff --git a/_content/doc/articles/wiki/final-noclosure.go b/_content/doc/articles/wiki/final-noclosure.go
new file mode 100644
index 0000000..d894e7d
--- /dev/null
+++ b/_content/doc/articles/wiki/final-noclosure.go
@@ -0,0 +1,105 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+package main
+
+import (
+ "errors"
+ "html/template"
+ "io/ioutil"
+ "log"
+ "net/http"
+ "regexp"
+)
+
+type Page struct {
+ Title string
+ Body []byte
+}
+
+func (p *Page) save() error {
+ filename := p.Title + ".txt"
+ return ioutil.WriteFile(filename, p.Body, 0600)
+}
+
+func loadPage(title string) (*Page, error) {
+ filename := title + ".txt"
+ body, err := ioutil.ReadFile(filename)
+ if err != nil {
+ return nil, err
+ }
+ return &Page{Title: title, Body: body}, nil
+}
+
+func viewHandler(w http.ResponseWriter, r *http.Request) {
+ title, err := getTitle(w, r)
+ if err != nil {
+ return
+ }
+ p, err := loadPage(title)
+ if err != nil {
+ http.Redirect(w, r, "/edit/"+title, http.StatusFound)
+ return
+ }
+ renderTemplate(w, "view", p)
+}
+
+func editHandler(w http.ResponseWriter, r *http.Request) {
+ title, err := getTitle(w, r)
+ if err != nil {
+ return
+ }
+ p, err := loadPage(title)
+ if err != nil {
+ p = &Page{Title: title}
+ }
+ renderTemplate(w, "edit", p)
+}
+
+func saveHandler(w http.ResponseWriter, r *http.Request) {
+ title, err := getTitle(w, r)
+ if err != nil {
+ return
+ }
+ body := r.FormValue("body")
+ p := &Page{Title: title, Body: []byte(body)}
+ err = p.save()
+ if err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ return
+ }
+ http.Redirect(w, r, "/view/"+title, http.StatusFound)
+}
+
+func renderTemplate(w http.ResponseWriter, tmpl string, p *Page) {
+ t, err := template.ParseFiles(tmpl + ".html")
+ if err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ return
+ }
+ err = t.Execute(w, p)
+ if err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ }
+}
+
+var validPath = regexp.MustCompile("^/(edit|save|view)/([a-zA-Z0-9]+)$")
+
+func getTitle(w http.ResponseWriter, r *http.Request) (string, error) {
+ m := validPath.FindStringSubmatch(r.URL.Path)
+ if m == nil {
+ http.NotFound(w, r)
+ return "", errors.New("invalid Page Title")
+ }
+ return m[2], nil // The title is the second subexpression.
+}
+
+func main() {
+ http.HandleFunc("/view/", viewHandler)
+ http.HandleFunc("/edit/", editHandler)
+ http.HandleFunc("/save/", saveHandler)
+ log.Fatal(http.ListenAndServe(":8080", nil))
+}
diff --git a/_content/doc/articles/wiki/final-noerror.go b/_content/doc/articles/wiki/final-noerror.go
new file mode 100644
index 0000000..250236d
--- /dev/null
+++ b/_content/doc/articles/wiki/final-noerror.go
@@ -0,0 +1,56 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+package main
+
+import (
+ "html/template"
+ "io/ioutil"
+ "log"
+ "net/http"
+)
+
+type Page struct {
+ Title string
+ Body []byte
+}
+
+func (p *Page) save() error {
+ filename := p.Title + ".txt"
+ return ioutil.WriteFile(filename, p.Body, 0600)
+}
+
+func loadPage(title string) (*Page, error) {
+ filename := title + ".txt"
+ body, err := ioutil.ReadFile(filename)
+ if err != nil {
+ return nil, err
+ }
+ return &Page{Title: title, Body: body}, nil
+}
+
+func editHandler(w http.ResponseWriter, r *http.Request) {
+ title := r.URL.Path[len("/edit/"):]
+ p, err := loadPage(title)
+ if err != nil {
+ p = &Page{Title: title}
+ }
+ t, _ := template.ParseFiles("edit.html")
+ t.Execute(w, p)
+}
+
+func viewHandler(w http.ResponseWriter, r *http.Request) {
+ title := r.URL.Path[len("/view/"):]
+ p, _ := loadPage(title)
+ t, _ := template.ParseFiles("view.html")
+ t.Execute(w, p)
+}
+
+func main() {
+ http.HandleFunc("/view/", viewHandler)
+ http.HandleFunc("/edit/", editHandler)
+ log.Fatal(http.ListenAndServe(":8080", nil))
+}
diff --git a/_content/doc/articles/wiki/final-parsetemplate.go b/_content/doc/articles/wiki/final-parsetemplate.go
new file mode 100644
index 0000000..0b90cbd
--- /dev/null
+++ b/_content/doc/articles/wiki/final-parsetemplate.go
@@ -0,0 +1,94 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+package main
+
+import (
+ "html/template"
+ "io/ioutil"
+ "log"
+ "net/http"
+ "regexp"
+)
+
+type Page struct {
+ Title string
+ Body []byte
+}
+
+func (p *Page) save() error {
+ filename := p.Title + ".txt"
+ return ioutil.WriteFile(filename, p.Body, 0600)
+}
+
+func loadPage(title string) (*Page, error) {
+ filename := title + ".txt"
+ body, err := ioutil.ReadFile(filename)
+ if err != nil {
+ return nil, err
+ }
+ return &Page{Title: title, Body: body}, nil
+}
+
+func viewHandler(w http.ResponseWriter, r *http.Request, title string) {
+ p, err := loadPage(title)
+ if err != nil {
+ http.Redirect(w, r, "/edit/"+title, http.StatusFound)
+ return
+ }
+ renderTemplate(w, "view", p)
+}
+
+func editHandler(w http.ResponseWriter, r *http.Request, title string) {
+ p, err := loadPage(title)
+ if err != nil {
+ p = &Page{Title: title}
+ }
+ renderTemplate(w, "edit", p)
+}
+
+func saveHandler(w http.ResponseWriter, r *http.Request, title string) {
+ body := r.FormValue("body")
+ p := &Page{Title: title, Body: []byte(body)}
+ err := p.save()
+ if err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ return
+ }
+ http.Redirect(w, r, "/view/"+title, http.StatusFound)
+}
+
+func renderTemplate(w http.ResponseWriter, tmpl string, p *Page) {
+ t, err := template.ParseFiles(tmpl + ".html")
+ if err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ return
+ }
+ err = t.Execute(w, p)
+ if err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ }
+}
+
+var validPath = regexp.MustCompile("^/(edit|save|view)/([a-zA-Z0-9]+)$")
+
+func makeHandler(fn func(http.ResponseWriter, *http.Request, string)) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ m := validPath.FindStringSubmatch(r.URL.Path)
+ if m == nil {
+ http.NotFound(w, r)
+ return
+ }
+ fn(w, r, m[2])
+ }
+}
+
+func main() {
+ http.HandleFunc("/view/", makeHandler(viewHandler))
+ http.HandleFunc("/edit/", makeHandler(editHandler))
+ http.HandleFunc("/save/", makeHandler(saveHandler))
+ log.Fatal(http.ListenAndServe(":8080", nil))
+}
diff --git a/_content/doc/articles/wiki/final-template.go b/_content/doc/articles/wiki/final-template.go
new file mode 100644
index 0000000..5028664
--- /dev/null
+++ b/_content/doc/articles/wiki/final-template.go
@@ -0,0 +1,68 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+package main
+
+import (
+ "html/template"
+ "io/ioutil"
+ "log"
+ "net/http"
+)
+
+type Page struct {
+ Title string
+ Body []byte
+}
+
+func (p *Page) save() error {
+ filename := p.Title + ".txt"
+ return ioutil.WriteFile(filename, p.Body, 0600)
+}
+
+func loadPage(title string) (*Page, error) {
+ filename := title + ".txt"
+ body, err := ioutil.ReadFile(filename)
+ if err != nil {
+ return nil, err
+ }
+ return &Page{Title: title, Body: body}, nil
+}
+
+func editHandler(w http.ResponseWriter, r *http.Request) {
+ title := r.URL.Path[len("/edit/"):]
+ p, err := loadPage(title)
+ if err != nil {
+ p = &Page{Title: title}
+ }
+ renderTemplate(w, "edit", p)
+}
+
+func viewHandler(w http.ResponseWriter, r *http.Request) {
+ title := r.URL.Path[len("/view/"):]
+ p, _ := loadPage(title)
+ renderTemplate(w, "view", p)
+}
+
+func saveHandler(w http.ResponseWriter, r *http.Request) {
+ title := r.URL.Path[len("/save/"):]
+ body := r.FormValue("body")
+ p := &Page{Title: title, Body: []byte(body)}
+ p.save()
+ http.Redirect(w, r, "/view/"+title, http.StatusFound)
+}
+
+func renderTemplate(w http.ResponseWriter, tmpl string, p *Page) {
+ t, _ := template.ParseFiles(tmpl + ".html")
+ t.Execute(w, p)
+}
+
+func main() {
+ http.HandleFunc("/view/", viewHandler)
+ http.HandleFunc("/edit/", editHandler)
+ http.HandleFunc("/save/", saveHandler)
+ log.Fatal(http.ListenAndServe(":8080", nil))
+}
diff --git a/_content/doc/articles/wiki/final.go b/_content/doc/articles/wiki/final.go
new file mode 100644
index 0000000..b1439b0
--- /dev/null
+++ b/_content/doc/articles/wiki/final.go
@@ -0,0 +1,92 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+package main
+
+import (
+ "html/template"
+ "io/ioutil"
+ "log"
+ "net/http"
+ "regexp"
+)
+
+type Page struct {
+ Title string
+ Body []byte
+}
+
+func (p *Page) save() error {
+ filename := p.Title + ".txt"
+ return ioutil.WriteFile(filename, p.Body, 0600)
+}
+
+func loadPage(title string) (*Page, error) {
+ filename := title + ".txt"
+ body, err := ioutil.ReadFile(filename)
+ if err != nil {
+ return nil, err
+ }
+ return &Page{Title: title, Body: body}, nil
+}
+
+func viewHandler(w http.ResponseWriter, r *http.Request, title string) {
+ p, err := loadPage(title)
+ if err != nil {
+ http.Redirect(w, r, "/edit/"+title, http.StatusFound)
+ return
+ }
+ renderTemplate(w, "view", p)
+}
+
+func editHandler(w http.ResponseWriter, r *http.Request, title string) {
+ p, err := loadPage(title)
+ if err != nil {
+ p = &Page{Title: title}
+ }
+ renderTemplate(w, "edit", p)
+}
+
+func saveHandler(w http.ResponseWriter, r *http.Request, title string) {
+ body := r.FormValue("body")
+ p := &Page{Title: title, Body: []byte(body)}
+ err := p.save()
+ if err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ return
+ }
+ http.Redirect(w, r, "/view/"+title, http.StatusFound)
+}
+
+var templates = template.Must(template.ParseFiles("edit.html", "view.html"))
+
+func renderTemplate(w http.ResponseWriter, tmpl string, p *Page) {
+ err := templates.ExecuteTemplate(w, tmpl+".html", p)
+ if err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ }
+}
+
+var validPath = regexp.MustCompile("^/(edit|save|view)/([a-zA-Z0-9]+)$")
+
+func makeHandler(fn func(http.ResponseWriter, *http.Request, string)) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ m := validPath.FindStringSubmatch(r.URL.Path)
+ if m == nil {
+ http.NotFound(w, r)
+ return
+ }
+ fn(w, r, m[2])
+ }
+}
+
+func main() {
+ http.HandleFunc("/view/", makeHandler(viewHandler))
+ http.HandleFunc("/edit/", makeHandler(editHandler))
+ http.HandleFunc("/save/", makeHandler(saveHandler))
+
+ log.Fatal(http.ListenAndServe(":8080", nil))
+}
diff --git a/_content/doc/articles/wiki/final_test.go b/_content/doc/articles/wiki/final_test.go
new file mode 100644
index 0000000..7644699
--- /dev/null
+++ b/_content/doc/articles/wiki/final_test.go
@@ -0,0 +1,24 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+package main
+
+import (
+ "fmt"
+ "log"
+ "net"
+ "net/http"
+)
+
+func serve() error {
+ l, err := net.Listen("tcp", "127.0.0.1:0")
+ if err != nil {
+ log.Fatal(err)
+ }
+ fmt.Println(l.Addr().String())
+ s := &http.Server{}
+ return s.Serve(l)
+}
diff --git a/_content/doc/articles/wiki/http-sample.go b/_content/doc/articles/wiki/http-sample.go
new file mode 100644
index 0000000..803b88c
--- /dev/null
+++ b/_content/doc/articles/wiki/http-sample.go
@@ -0,0 +1,18 @@
+// +build ignore
+
+package main
+
+import (
+ "fmt"
+ "log"
+ "net/http"
+)
+
+func handler(w http.ResponseWriter, r *http.Request) {
+ fmt.Fprintf(w, "Hi there, I love %s!", r.URL.Path[1:])
+}
+
+func main() {
+ http.HandleFunc("/", handler)
+ log.Fatal(http.ListenAndServe(":8080", nil))
+}
diff --git a/_content/doc/articles/wiki/index.html b/_content/doc/articles/wiki/index.html
new file mode 100644
index 0000000..a74a58e
--- /dev/null
+++ b/_content/doc/articles/wiki/index.html
@@ -0,0 +1,741 @@
+<!--{
+ "Title": "Writing Web Applications",
+ "Template": true
+}-->
+
+<h2>Introduction</h2>
+
+<p>
+Covered in this tutorial:
+</p>
+<ul>
+<li>Creating a data structure with load and save methods</li>
+<li>Using the <code>net/http</code> package to build web applications
+<li>Using the <code>html/template</code> package to process HTML templates</li>
+<li>Using the <code>regexp</code> package to validate user input</li>
+<li>Using closures</li>
+</ul>
+
+<p>
+Assumed knowledge:
+</p>
+<ul>
+<li>Programming experience</li>
+<li>Understanding of basic web technologies (HTTP, HTML)</li>
+<li>Some UNIX/DOS command-line knowledge</li>
+</ul>
+
+<h2>Getting Started</h2>
+
+<p>
+At present, you need to have a FreeBSD, Linux, OS X, or Windows machine to run Go.
+We will use <code>$</code> to represent the command prompt.
+</p>
+
+<p>
+Install Go (see the <a href="/doc/install">Installation Instructions</a>).
+</p>
+
+<p>
+Make a new directory for this tutorial inside your <code>GOPATH</code> and cd to it:
+</p>
+
+<pre>
+$ mkdir gowiki
+$ cd gowiki
+</pre>
+
+<p>
+Create a file named <code>wiki.go</code>, open it in your favorite editor, and
+add the following lines:
+</p>
+
+<pre>
+package main
+
+import (
+ "fmt"
+ "io/ioutil"
+)
+</pre>
+
+<p>
+We import the <code>fmt</code> and <code>ioutil</code> packages from the Go
+standard library. Later, as we implement additional functionality, we will
+add more packages to this <code>import</code> declaration.
+</p>
+
+<h2>Data Structures</h2>
+
+<p>
+Let's start by defining the data structures. A wiki consists of a series of
+interconnected pages, each of which has a title and a body (the page content).
+Here, we define <code>Page</code> as a struct with two fields representing
+the title and body.
+</p>
+
+{{code "doc/articles/wiki/part1.go" `/^type Page/` `/}/`}}
+
+<p>
+The type <code>[]byte</code> means "a <code>byte</code> slice".
+(See <a href="/doc/articles/slices_usage_and_internals.html">Slices: usage and
+internals</a> for more on slices.)
+The <code>Body</code> element is a <code>[]byte</code> rather than
+<code>string</code> because that is the type expected by the <code>io</code>
+libraries we will use, as you'll see below.
+</p>
+
+<p>
+The <code>Page</code> struct describes how page data will be stored in memory.
+But what about persistent storage? We can address that by creating a
+<code>save</code> method on <code>Page</code>:
+</p>
+
+{{code "doc/articles/wiki/part1.go" `/^func.*Page.*save/` `/}/`}}
+
+<p>
+This method's signature reads: "This is a method named <code>save</code> that
+takes as its receiver <code>p</code>, a pointer to <code>Page</code> . It takes
+no parameters, and returns a value of type <code>error</code>."
+</p>
+
+<p>
+This method will save the <code>Page</code>'s <code>Body</code> to a text
+file. For simplicity, we will use the <code>Title</code> as the file name.
+</p>
+
+<p>
+The <code>save</code> method returns an <code>error</code> value because
+that is the return type of <code>WriteFile</code> (a standard library function
+that writes a byte slice to a file). The <code>save</code> method returns the
+error value, to let the application handle it should anything go wrong while
+writing the file. If all goes well, <code>Page.save()</code> will return
+<code>nil</code> (the zero-value for pointers, interfaces, and some other
+types).
+</p>
+
+<p>
+The octal integer literal <code>0600</code>, passed as the third parameter to
+<code>WriteFile</code>, indicates that the file should be created with
+read-write permissions for the current user only. (See the Unix man page
+<code>open(2)</code> for details.)
+</p>
+
+<p>
+In addition to saving pages, we will want to load pages, too:
+</p>
+
+{{code "doc/articles/wiki/part1-noerror.go" `/^func loadPage/` `/^}/`}}
+
+<p>
+The function <code>loadPage</code> constructs the file name from the title
+parameter, reads the file's contents into a new variable <code>body</code>, and
+returns a pointer to a <code>Page</code> literal constructed with the proper
+title and body values.
+</p>
+
+<p>
+Functions can return multiple values. The standard library function
+<code>io.ReadFile</code> returns <code>[]byte</code> and <code>error</code>.
+In <code>loadPage</code>, error isn't being handled yet; the "blank identifier"
+represented by the underscore (<code>_</code>) symbol is used to throw away the
+error return value (in essence, assigning the value to nothing).
+</p>
+
+<p>
+But what happens if <code>ReadFile</code> encounters an error? For example,
+the file might not exist. We should not ignore such errors. Let's modify the
+function to return <code>*Page</code> and <code>error</code>.
+</p>
+
+{{code "doc/articles/wiki/part1.go" `/^func loadPage/` `/^}/`}}
+
+<p>
+Callers of this function can now check the second parameter; if it is
+<code>nil</code> then it has successfully loaded a Page. If not, it will be an
+<code>error</code> that can be handled by the caller (see the
+<a href="/ref/spec#Errors">language specification</a> for details).
+</p>
+
+<p>
+At this point we have a simple data structure and the ability to save to and
+load from a file. Let's write a <code>main</code> function to test what we've
+written:
+</p>
+
+{{code "doc/articles/wiki/part1.go" `/^func main/` `/^}/`}}
+
+<p>
+After compiling and executing this code, a file named <code>TestPage.txt</code>
+would be created, containing the contents of <code>p1</code>. The file would
+then be read into the struct <code>p2</code>, and its <code>Body</code> element
+printed to the screen.
+</p>
+
+<p>
+You can compile and run the program like this:
+</p>
+
+<pre>
+$ go build wiki.go
+$ ./wiki
+This is a sample Page.
+</pre>
+
+<p>
+(If you're using Windows you must type "<code>wiki</code>" without the
+"<code>./</code>" to run the program.)
+</p>
+
+<p>
+<a href="part1.go">Click here to view the code we've written so far.</a>
+</p>
+
+<h2>Introducing the <code>net/http</code> package (an interlude)</h2>
+
+<p>
+Here's a full working example of a simple web server:
+</p>
+
+{{code "doc/articles/wiki/http-sample.go"}}
+
+<p>
+The <code>main</code> function begins with a call to
+<code>http.HandleFunc</code>, which tells the <code>http</code> package to
+handle all requests to the web root (<code>"/"</code>) with
+<code>handler</code>.
+</p>
+
+<p>
+It then calls <code>http.ListenAndServe</code>, specifying that it should
+listen on port 8080 on any interface (<code>":8080"</code>). (Don't
+worry about its second parameter, <code>nil</code>, for now.)
+This function will block until the program is terminated.
+</p>
+
+<p>
+<code>ListenAndServe</code> always returns an error, since it only returns when an
+unexpected error occurs.
+In order to log that error we wrap the function call with <code>log.Fatal</code>.
+</p>
+
+<p>
+The function <code>handler</code> is of the type <code>http.HandlerFunc</code>.
+It takes an <code>http.ResponseWriter</code> and an <code>http.Request</code> as
+its arguments.
+</p>
+
+<p>
+An <code>http.ResponseWriter</code> value assembles the HTTP server's response; by writing
+to it, we send data to the HTTP client.
+</p>
+
+<p>
+An <code>http.Request</code> is a data structure that represents the client
+HTTP request. <code>r.URL.Path</code> is the path component
+of the request URL. The trailing <code>[1:]</code> means
+"create a sub-slice of <code>Path</code> from the 1st character to the end."
+This drops the leading "/" from the path name.
+</p>
+
+<p>
+If you run this program and access the URL:
+</p>
+<pre>http://localhost:8080/monkeys</pre>
+<p>
+the program would present a page containing:
+</p>
+<pre>Hi there, I love monkeys!</pre>
+
+<h2>Using <code>net/http</code> to serve wiki pages</h2>
+
+<p>
+To use the <code>net/http</code> package, it must be imported:
+</p>
+
+<pre>
+import (
+ "fmt"
+ "io/ioutil"
+ "log"
+ <b>"net/http"</b>
+)
+</pre>
+
+<p>
+Let's create a handler, <code>viewHandler</code> that will allow users to
+view a wiki page. It will handle URLs prefixed with "/view/".
+</p>
+
+{{code "doc/articles/wiki/part2.go" `/^func viewHandler/` `/^}/`}}
+
+<p>
+Again, note the use of <code>_</code> to ignore the <code>error</code>
+return value from <code>loadPage</code>. This is done here for simplicity
+and generally considered bad practice. We will attend to this later.
+</p>
+
+<p>
+First, this function extracts the page title from <code>r.URL.Path</code>,
+the path component of the request URL.
+The <code>Path</code> is re-sliced with <code>[len("/view/"):]</code> to drop
+the leading <code>"/view/"</code> component of the request path.
+This is because the path will invariably begin with <code>"/view/"</code>,
+which is not part of the page's title.
+</p>
+
+<p>
+The function then loads the page data, formats the page with a string of simple
+HTML, and writes it to <code>w</code>, the <code>http.ResponseWriter</code>.
+</p>
+
+<p>
+To use this handler, we rewrite our <code>main</code> function to
+initialize <code>http</code> using the <code>viewHandler</code> to handle
+any requests under the path <code>/view/</code>.
+</p>
+
+{{code "doc/articles/wiki/part2.go" `/^func main/` `/^}/`}}
+
+<p>
+<a href="part2.go">Click here to view the code we've written so far.</a>
+</p>
+
+<p>
+Let's create some page data (as <code>test.txt</code>), compile our code, and
+try serving a wiki page.
+</p>
+
+<p>
+Open <code>test.txt</code> file in your editor, and save the string "Hello world" (without quotes)
+in it.
+</p>
+
+<pre>
+$ go build wiki.go
+$ ./wiki
+</pre>
+
+<p>
+(If you're using Windows you must type "<code>wiki</code>" without the
+"<code>./</code>" to run the program.)
+</p>
+
+<p>
+With this web server running, a visit to <code><a
+href="http://localhost:8080/view/test">http://localhost:8080/view/test</a></code>
+should show a page titled "test" containing the words "Hello world".
+</p>
+
+<h2>Editing Pages</h2>
+
+<p>
+A wiki is not a wiki without the ability to edit pages. Let's create two new
+handlers: one named <code>editHandler</code> to display an 'edit page' form,
+and the other named <code>saveHandler</code> to save the data entered via the
+form.
+</p>
+
+<p>
+First, we add them to <code>main()</code>:
+</p>
+
+{{code "doc/articles/wiki/final-noclosure.go" `/^func main/` `/^}/`}}
+
+<p>
+The function <code>editHandler</code> loads the page
+(or, if it doesn't exist, create an empty <code>Page</code> struct),
+and displays an HTML form.
+</p>
+
+{{code "doc/articles/wiki/notemplate.go" `/^func editHandler/` `/^}/`}}
+
+<p>
+This function will work fine, but all that hard-coded HTML is ugly.
+Of course, there is a better way.
+</p>
+
+<h2>The <code>html/template</code> package</h2>
+
+<p>
+The <code>html/template</code> package is part of the Go standard library.
+We can use <code>html/template</code> to keep the HTML in a separate file,
+allowing us to change the layout of our edit page without modifying the
+underlying Go code.
+</p>
+
+<p>
+First, we must add <code>html/template</code> to the list of imports. We
+also won't be using <code>fmt</code> anymore, so we have to remove that.
+</p>
+
+<pre>
+import (
+ <b>"html/template"</b>
+ "io/ioutil"
+ "net/http"
+)
+</pre>
+
+<p>
+Let's create a template file containing the HTML form.
+Open a new file named <code>edit.html</code>, and add the following lines:
+</p>
+
+{{code "doc/articles/wiki/edit.html"}}
+
+<p>
+Modify <code>editHandler</code> to use the template, instead of the hard-coded
+HTML:
+</p>
+
+{{code "doc/articles/wiki/final-noerror.go" `/^func editHandler/` `/^}/`}}
+
+<p>
+The function <code>template.ParseFiles</code> will read the contents of
+<code>edit.html</code> and return a <code>*template.Template</code>.
+</p>
+
+<p>
+The method <code>t.Execute</code> executes the template, writing the
+generated HTML to the <code>http.ResponseWriter</code>.
+The <code>.Title</code> and <code>.Body</code> dotted identifiers refer to
+<code>p.Title</code> and <code>p.Body</code>.
+</p>
+
+<p>
+Template directives are enclosed in double curly braces.
+The <code>printf "%s" .Body</code> instruction is a function call
+that outputs <code>.Body</code> as a string instead of a stream of bytes,
+the same as a call to <code>fmt.Printf</code>.
+The <code>html/template</code> package helps guarantee that only safe and
+correct-looking HTML is generated by template actions. For instance, it
+automatically escapes any greater than sign (<code>></code>), replacing it
+with <code>&gt;</code>, to make sure user data does not corrupt the form
+HTML.
+</p>
+
+<p>
+Since we're working with templates now, let's create a template for our
+<code>viewHandler</code> called <code>view.html</code>:
+</p>
+
+{{code "doc/articles/wiki/view.html"}}
+
+<p>
+Modify <code>viewHandler</code> accordingly:
+</p>
+
+{{code "doc/articles/wiki/final-noerror.go" `/^func viewHandler/` `/^}/`}}
+
+<p>
+Notice that we've used almost exactly the same templating code in both
+handlers. Let's remove this duplication by moving the templating code
+to its own function:
+</p>
+
+{{code "doc/articles/wiki/final-template.go" `/^func renderTemplate/` `/^}/`}}
+
+<p>
+And modify the handlers to use that function:
+</p>
+
+{{code "doc/articles/wiki/final-template.go" `/^func viewHandler/` `/^}/`}}
+{{code "doc/articles/wiki/final-template.go" `/^func editHandler/` `/^}/`}}
+
+<p>
+If we comment out the registration of our unimplemented save handler in
+<code>main</code>, we can once again build and test our program.
+<a href="part3.go">Click here to view the code we've written so far.</a>
+</p>
+
+<h2>Handling non-existent pages</h2>
+
+<p>
+What if you visit <a href="http://localhost:8080/view/APageThatDoesntExist">
+<code>/view/APageThatDoesntExist</code></a>? You'll see a page containing
+HTML. This is because it ignores the error return value from
+<code>loadPage</code> and continues to try and fill out the template
+with no data. Instead, if the requested Page doesn't exist, it should
+redirect the client to the edit Page so the content may be created:
+</p>
+
+{{code "doc/articles/wiki/part3-errorhandling.go" `/^func viewHandler/` `/^}/`}}
+
+<p>
+The <code>http.Redirect</code> function adds an HTTP status code of
+<code>http.StatusFound</code> (302) and a <code>Location</code>
+header to the HTTP response.
+</p>
+
+<h2>Saving Pages</h2>
+
+<p>
+The function <code>saveHandler</code> will handle the submission of forms
+located on the edit pages. After uncommenting the related line in
+<code>main</code>, let's implement the handler:
+</p>
+
+{{code "doc/articles/wiki/final-template.go" `/^func saveHandler/` `/^}/`}}
+
+<p>
+The page title (provided in the URL) and the form's only field,
+<code>Body</code>, are stored in a new <code>Page</code>.
+The <code>save()</code> method is then called to write the data to a file,
+and the client is redirected to the <code>/view/</code> page.
+</p>
+
+<p>
+The value returned by <code>FormValue</code> is of type <code>string</code>.
+We must convert that value to <code>[]byte</code> before it will fit into
+the <code>Page</code> struct. We use <code>[]byte(body)</code> to perform
+the conversion.
+</p>
+
+<h2>Error handling</h2>
+
+<p>
+There are several places in our program where errors are being ignored. This
+is bad practice, not least because when an error does occur the program will
+have unintended behavior. A better solution is to handle the errors and return
+an error message to the user. That way if something does go wrong, the server
+will function exactly how we want and the user can be notified.
+</p>
+
+<p>
+First, let's handle the errors in <code>renderTemplate</code>:
+</p>
+
+{{code "doc/articles/wiki/final-parsetemplate.go" `/^func renderTemplate/` `/^}/`}}
+
+<p>
+The <code>http.Error</code> function sends a specified HTTP response code
+(in this case "Internal Server Error") and error message.
+Already the decision to put this in a separate function is paying off.
+</p>
+
+<p>
+Now let's fix up <code>saveHandler</code>:
+</p>
+
+{{code "doc/articles/wiki/part3-errorhandling.go" `/^func saveHandler/` `/^}/`}}
+
+<p>
+Any errors that occur during <code>p.save()</code> will be reported
+to the user.
+</p>
+
+<h2>Template caching</h2>
+
+<p>
+There is an inefficiency in this code: <code>renderTemplate</code> calls
+<code>ParseFiles</code> every time a page is rendered.
+A better approach would be to call <code>ParseFiles</code> once at program
+initialization, parsing all templates into a single <code>*Template</code>.
+Then we can use the
+<a href="/pkg/html/template/#Template.ExecuteTemplate"><code>ExecuteTemplate</code></a>
+method to render a specific template.
+</p>
+
+<p>
+First we create a global variable named <code>templates</code>, and initialize
+it with <code>ParseFiles</code>.
+</p>
+
+{{code "doc/articles/wiki/final.go" `/var templates/`}}
+
+<p>
+The function <code>template.Must</code> is a convenience wrapper that panics
+when passed a non-nil <code>error</code> value, and otherwise returns the
+<code>*Template</code> unaltered. A panic is appropriate here; if the templates
+can't be loaded the only sensible thing to do is exit the program.
+</p>
+
+<p>
+The <code>ParseFiles</code> function takes any number of string arguments that
+identify our template files, and parses those files into templates that are
+named after the base file name. If we were to add more templates to our
+program, we would add their names to the <code>ParseFiles</code> call's
+arguments.
+</p>
+
+<p>
+We then modify the <code>renderTemplate</code> function to call the
+<code>templates.ExecuteTemplate</code> method with the name of the appropriate
+template:
+</p>
+
+{{code "doc/articles/wiki/final.go" `/func renderTemplate/` `/^}/`}}
+
+<p>
+Note that the template name is the template file name, so we must
+append <code>".html"</code> to the <code>tmpl</code> argument.
+</p>
+
+<h2>Validation</h2>
+
+<p>
+As you may have observed, this program has a serious security flaw: a user
+can supply an arbitrary path to be read/written on the server. To mitigate
+this, we can write a function to validate the title with a regular expression.
+</p>
+
+<p>
+First, add <code>"regexp"</code> to the <code>import</code> list.
+Then we can create a global variable to store our validation
+expression:
+</p>
+
+{{code "doc/articles/wiki/final-noclosure.go" `/^var validPath/`}}
+
+<p>
+The function <code>regexp.MustCompile</code> will parse and compile the
+regular expression, and return a <code>regexp.Regexp</code>.
+<code>MustCompile</code> is distinct from <code>Compile</code> in that it will
+panic if the expression compilation fails, while <code>Compile</code> returns
+an <code>error</code> as a second parameter.
+</p>
+
+<p>
+Now, let's write a function that uses the <code>validPath</code>
+expression to validate path and extract the page title:
+</p>
+
+{{code "doc/articles/wiki/final-noclosure.go" `/func getTitle/` `/^}/`}}
+
+<p>
+If the title is valid, it will be returned along with a <code>nil</code>
+error value. If the title is invalid, the function will write a
+"404 Not Found" error to the HTTP connection, and return an error to the
+handler. To create a new error, we have to import the <code>errors</code>
+package.
+</p>
+
+<p>
+Let's put a call to <code>getTitle</code> in each of the handlers:
+</p>
+
+{{code "doc/articles/wiki/final-noclosure.go" `/^func viewHandler/` `/^}/`}}
+{{code "doc/articles/wiki/final-noclosure.go" `/^func editHandler/` `/^}/`}}
+{{code "doc/articles/wiki/final-noclosure.go" `/^func saveHandler/` `/^}/`}}
+
+<h2>Introducing Function Literals and Closures</h2>
+
+<p>
+Catching the error condition in each handler introduces a lot of repeated code.
+What if we could wrap each of the handlers in a function that does this
+validation and error checking? Go's
+<a href="/ref/spec#Function_literals">function
+literals</a> provide a powerful means of abstracting functionality
+that can help us here.
+</p>
+
+<p>
+First, we re-write the function definition of each of the handlers to accept
+a title string:
+</p>
+
+<pre>
+func viewHandler(w http.ResponseWriter, r *http.Request, title string)
+func editHandler(w http.ResponseWriter, r *http.Request, title string)
+func saveHandler(w http.ResponseWriter, r *http.Request, title string)
+</pre>
+
+<p>
+Now let's define a wrapper function that <i>takes a function of the above
+type</i>, and returns a function of type <code>http.HandlerFunc</code>
+(suitable to be passed to the function <code>http.HandleFunc</code>):
+</p>
+
+<pre>
+func makeHandler(fn func (http.ResponseWriter, *http.Request, string)) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ // Here we will extract the page title from the Request,
+ // and call the provided handler 'fn'
+ }
+}
+</pre>
+
+<p>
+The returned function is called a closure because it encloses values defined
+outside of it. In this case, the variable <code>fn</code> (the single argument
+to <code>makeHandler</code>) is enclosed by the closure. The variable
+<code>fn</code> will be one of our save, edit, or view handlers.
+</p>
+
+<p>
+Now we can take the code from <code>getTitle</code> and use it here
+(with some minor modifications):
+</p>
+
+{{code "doc/articles/wiki/final.go" `/func makeHandler/` `/^}/`}}
+
+<p>
+The closure returned by <code>makeHandler</code> is a function that takes
+an <code>http.ResponseWriter</code> and <code>http.Request</code> (in other
+words, an <code>http.HandlerFunc</code>).
+The closure extracts the <code>title</code> from the request path, and
+validates it with the <code>validPath</code> regexp. If the
+<code>title</code> is invalid, an error will be written to the
+<code>ResponseWriter</code> using the <code>http.NotFound</code> function.
+If the <code>title</code> is valid, the enclosed handler function
+<code>fn</code> will be called with the <code>ResponseWriter</code>,
+<code>Request</code>, and <code>title</code> as arguments.
+</p>
+
+<p>
+Now we can wrap the handler functions with <code>makeHandler</code> in
+<code>main</code>, before they are registered with the <code>http</code>
+package:
+</p>
+
+{{code "doc/articles/wiki/final.go" `/func main/` `/^}/`}}
+
+<p>
+Finally we remove the calls to <code>getTitle</code> from the handler functions,
+making them much simpler:
+</p>
+
+{{code "doc/articles/wiki/final.go" `/^func viewHandler/` `/^}/`}}
+{{code "doc/articles/wiki/final.go" `/^func editHandler/` `/^}/`}}
+{{code "doc/articles/wiki/final.go" `/^func saveHandler/` `/^}/`}}
+
+<h2>Try it out!</h2>
+
+<p>
+<a href="final.go">Click here to view the final code listing.</a>
+</p>
+
+<p>
+Recompile the code, and run the app:
+</p>
+
+<pre>
+$ go build wiki.go
+$ ./wiki
+</pre>
+
+<p>
+Visiting <a href="http://localhost:8080/view/ANewPage">http://localhost:8080/view/ANewPage</a>
+should present you with the page edit form. You should then be able to
+enter some text, click 'Save', and be redirected to the newly created page.
+</p>
+
+<h2>Other tasks</h2>
+
+<p>
+Here are some simple tasks you might want to tackle on your own:
+</p>
+
+<ul>
+<li>Store templates in <code>tmpl/</code> and page data in <code>data/</code>.
+<li>Add a handler to make the web root redirect to
+ <code>/view/FrontPage</code>.</li>
+<li>Spruce up the page templates by making them valid HTML and adding some
+ CSS rules.</li>
+<li>Implement inter-page linking by converting instances of
+ <code>[PageName]</code> to <br>
+ <code><a href="/view/PageName">PageName</a></code>.
+ (hint: you could use <code>regexp.ReplaceAllFunc</code> to do this)
+ </li>
+</ul>
diff --git a/_content/doc/articles/wiki/notemplate.go b/_content/doc/articles/wiki/notemplate.go
new file mode 100644
index 0000000..4b358f2
--- /dev/null
+++ b/_content/doc/articles/wiki/notemplate.go
@@ -0,0 +1,59 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+package main
+
+import (
+ "fmt"
+ "io/ioutil"
+ "log"
+ "net/http"
+)
+
+type Page struct {
+ Title string
+ Body []byte
+}
+
+func (p *Page) save() error {
+ filename := p.Title + ".txt"
+ return ioutil.WriteFile(filename, p.Body, 0600)
+}
+
+func loadPage(title string) (*Page, error) {
+ filename := title + ".txt"
+ body, err := ioutil.ReadFile(filename)
+ if err != nil {
+ return nil, err
+ }
+ return &Page{Title: title, Body: body}, nil
+}
+
+func viewHandler(w http.ResponseWriter, r *http.Request) {
+ title := r.URL.Path[len("/view/"):]
+ p, _ := loadPage(title)
+ fmt.Fprintf(w, "<h1>%s</h1><div>%s</div>", p.Title, p.Body)
+}
+
+func editHandler(w http.ResponseWriter, r *http.Request) {
+ title := r.URL.Path[len("/edit/"):]
+ p, err := loadPage(title)
+ if err != nil {
+ p = &Page{Title: title}
+ }
+ fmt.Fprintf(w, "<h1>Editing %s</h1>"+
+ "<form action=\"/save/%s\" method=\"POST\">"+
+ "<textarea name=\"body\">%s</textarea><br>"+
+ "<input type=\"submit\" value=\"Save\">"+
+ "</form>",
+ p.Title, p.Title, p.Body)
+}
+
+func main() {
+ http.HandleFunc("/view/", viewHandler)
+ http.HandleFunc("/edit/", editHandler)
+ log.Fatal(http.ListenAndServe(":8080", nil))
+}
diff --git a/_content/doc/articles/wiki/part1-noerror.go b/_content/doc/articles/wiki/part1-noerror.go
new file mode 100644
index 0000000..913c6dc
--- /dev/null
+++ b/_content/doc/articles/wiki/part1-noerror.go
@@ -0,0 +1,35 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+package main
+
+import (
+ "fmt"
+ "io/ioutil"
+)
+
+type Page struct {
+ Title string
+ Body []byte
+}
+
+func (p *Page) save() error {
+ filename := p.Title + ".txt"
+ return ioutil.WriteFile(filename, p.Body, 0600)
+}
+
+func loadPage(title string) *Page {
+ filename := title + ".txt"
+ body, _ := ioutil.ReadFile(filename)
+ return &Page{Title: title, Body: body}
+}
+
+func main() {
+ p1 := &Page{Title: "TestPage", Body: []byte("This is a sample page.")}
+ p1.save()
+ p2 := loadPage("TestPage")
+ fmt.Println(string(p2.Body))
+}
diff --git a/_content/doc/articles/wiki/part1.go b/_content/doc/articles/wiki/part1.go
new file mode 100644
index 0000000..2ff1abd
--- /dev/null
+++ b/_content/doc/articles/wiki/part1.go
@@ -0,0 +1,38 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+package main
+
+import (
+ "fmt"
+ "io/ioutil"
+)
+
+type Page struct {
+ Title string
+ Body []byte
+}
+
+func (p *Page) save() error {
+ filename := p.Title + ".txt"
+ return ioutil.WriteFile(filename, p.Body, 0600)
+}
+
+func loadPage(title string) (*Page, error) {
+ filename := title + ".txt"
+ body, err := ioutil.ReadFile(filename)
+ if err != nil {
+ return nil, err
+ }
+ return &Page{Title: title, Body: body}, nil
+}
+
+func main() {
+ p1 := &Page{Title: "TestPage", Body: []byte("This is a sample Page.")}
+ p1.save()
+ p2, _ := loadPage("TestPage")
+ fmt.Println(string(p2.Body))
+}
diff --git a/_content/doc/articles/wiki/part2.go b/_content/doc/articles/wiki/part2.go
new file mode 100644
index 0000000..db92f4c
--- /dev/null
+++ b/_content/doc/articles/wiki/part2.go
@@ -0,0 +1,44 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+package main
+
+import (
+ "fmt"
+ "io/ioutil"
+ "log"
+ "net/http"
+)
+
+type Page struct {
+ Title string
+ Body []byte
+}
+
+func (p *Page) save() error {
+ filename := p.Title + ".txt"
+ return ioutil.WriteFile(filename, p.Body, 0600)
+}
+
+func loadPage(title string) (*Page, error) {
+ filename := title + ".txt"
+ body, err := ioutil.ReadFile(filename)
+ if err != nil {
+ return nil, err
+ }
+ return &Page{Title: title, Body: body}, nil
+}
+
+func viewHandler(w http.ResponseWriter, r *http.Request) {
+ title := r.URL.Path[len("/view/"):]
+ p, _ := loadPage(title)
+ fmt.Fprintf(w, "<h1>%s</h1><div>%s</div>", p.Title, p.Body)
+}
+
+func main() {
+ http.HandleFunc("/view/", viewHandler)
+ log.Fatal(http.ListenAndServe(":8080", nil))
+}
diff --git a/_content/doc/articles/wiki/part3-errorhandling.go b/_content/doc/articles/wiki/part3-errorhandling.go
new file mode 100644
index 0000000..2c8b42d
--- /dev/null
+++ b/_content/doc/articles/wiki/part3-errorhandling.go
@@ -0,0 +1,76 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+package main
+
+import (
+ "html/template"
+ "io/ioutil"
+ "log"
+ "net/http"
+)
+
+type Page struct {
+ Title string
+ Body []byte
+}
+
+func (p *Page) save() error {
+ filename := p.Title + ".txt"
+ return ioutil.WriteFile(filename, p.Body, 0600)
+}
+
+func loadPage(title string) (*Page, error) {
+ filename := title + ".txt"
+ body, err := ioutil.ReadFile(filename)
+ if err != nil {
+ return nil, err
+ }
+ return &Page{Title: title, Body: body}, nil
+}
+
+func renderTemplate(w http.ResponseWriter, tmpl string, p *Page) {
+ t, _ := template.ParseFiles(tmpl + ".html")
+ t.Execute(w, p)
+}
+
+func viewHandler(w http.ResponseWriter, r *http.Request) {
+ title := r.URL.Path[len("/view/"):]
+ p, err := loadPage(title)
+ if err != nil {
+ http.Redirect(w, r, "/edit/"+title, http.StatusFound)
+ return
+ }
+ renderTemplate(w, "view", p)
+}
+
+func editHandler(w http.ResponseWriter, r *http.Request) {
+ title := r.URL.Path[len("/edit/"):]
+ p, err := loadPage(title)
+ if err != nil {
+ p = &Page{Title: title}
+ }
+ renderTemplate(w, "edit", p)
+}
+
+func saveHandler(w http.ResponseWriter, r *http.Request) {
+ title := r.URL.Path[len("/save/"):]
+ body := r.FormValue("body")
+ p := &Page{Title: title, Body: []byte(body)}
+ err := p.save()
+ if err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ return
+ }
+ http.Redirect(w, r, "/view/"+title, http.StatusFound)
+}
+
+func main() {
+ http.HandleFunc("/view/", viewHandler)
+ http.HandleFunc("/edit/", editHandler)
+ http.HandleFunc("/save/", saveHandler)
+ log.Fatal(http.ListenAndServe(":8080", nil))
+}
diff --git a/_content/doc/articles/wiki/part3.go b/_content/doc/articles/wiki/part3.go
new file mode 100644
index 0000000..437ea33
--- /dev/null
+++ b/_content/doc/articles/wiki/part3.go
@@ -0,0 +1,60 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+package main
+
+import (
+ "html/template"
+ "io/ioutil"
+ "log"
+ "net/http"
+)
+
+type Page struct {
+ Title string
+ Body []byte
+}
+
+func (p *Page) save() error {
+ filename := p.Title + ".txt"
+ return ioutil.WriteFile(filename, p.Body, 0600)
+}
+
+func loadPage(title string) (*Page, error) {
+ filename := title + ".txt"
+ body, err := ioutil.ReadFile(filename)
+ if err != nil {
+ return nil, err
+ }
+ return &Page{Title: title, Body: body}, nil
+}
+
+func renderTemplate(w http.ResponseWriter, tmpl string, p *Page) {
+ t, _ := template.ParseFiles(tmpl + ".html")
+ t.Execute(w, p)
+}
+
+func viewHandler(w http.ResponseWriter, r *http.Request) {
+ title := r.URL.Path[len("/view/"):]
+ p, _ := loadPage(title)
+ renderTemplate(w, "view", p)
+}
+
+func editHandler(w http.ResponseWriter, r *http.Request) {
+ title := r.URL.Path[len("/edit/"):]
+ p, err := loadPage(title)
+ if err != nil {
+ p = &Page{Title: title}
+ }
+ renderTemplate(w, "edit", p)
+}
+
+func main() {
+ http.HandleFunc("/view/", viewHandler)
+ http.HandleFunc("/edit/", editHandler)
+ //http.HandleFunc("/save/", saveHandler)
+ log.Fatal(http.ListenAndServe(":8080", nil))
+}
diff --git a/_content/doc/articles/wiki/test_Test.txt.good b/_content/doc/articles/wiki/test_Test.txt.good
new file mode 100644
index 0000000..f0eec86
--- /dev/null
+++ b/_content/doc/articles/wiki/test_Test.txt.good
@@ -0,0 +1 @@
+some content
\ No newline at end of file
diff --git a/_content/doc/articles/wiki/test_edit.good b/_content/doc/articles/wiki/test_edit.good
new file mode 100644
index 0000000..36c6dbb
--- /dev/null
+++ b/_content/doc/articles/wiki/test_edit.good
@@ -0,0 +1,6 @@
+<h1>Editing Test</h1>
+
+<form action="/save/Test" method="POST">
+<div><textarea name="body" rows="20" cols="80"></textarea></div>
+<div><input type="submit" value="Save"></div>
+</form>
diff --git a/_content/doc/articles/wiki/test_view.good b/_content/doc/articles/wiki/test_view.good
new file mode 100644
index 0000000..07e8edb
--- /dev/null
+++ b/_content/doc/articles/wiki/test_view.good
@@ -0,0 +1,5 @@
+<h1>Test</h1>
+
+<p>[<a href="/edit/Test">edit</a>]</p>
+
+<div>some content</div>
diff --git a/_content/doc/articles/wiki/view.html b/_content/doc/articles/wiki/view.html
new file mode 100644
index 0000000..b1e87ef
--- /dev/null
+++ b/_content/doc/articles/wiki/view.html
@@ -0,0 +1,5 @@
+<h1>{{.Title}}</h1>
+
+<p>[<a href="/edit/{{.Title}}">edit</a>]</p>
+
+<div>{{printf "%s" .Body}}</div>
diff --git a/_content/doc/articles/wiki/wiki_test.go b/_content/doc/articles/wiki/wiki_test.go
new file mode 100644
index 0000000..1d976fd
--- /dev/null
+++ b/_content/doc/articles/wiki/wiki_test.go
@@ -0,0 +1,165 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main_test
+
+import (
+ "bytes"
+ "fmt"
+ "io/ioutil"
+ "net/http"
+ "os"
+ "os/exec"
+ "path/filepath"
+ "strings"
+ "testing"
+)
+
+func TestSnippetsCompile(t *testing.T) {
+ if testing.Short() {
+ t.Skip("skipping slow builds in short mode")
+ }
+
+ goFiles, err := filepath.Glob("*.go")
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ for _, f := range goFiles {
+ if strings.HasSuffix(f, "_test.go") {
+ continue
+ }
+ f := f
+ t.Run(f, func(t *testing.T) {
+ t.Parallel()
+
+ cmd := exec.Command("go", "build", "-o", os.DevNull, f)
+ out, err := cmd.CombinedOutput()
+ if err != nil {
+ t.Errorf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, out)
+ }
+ })
+ }
+}
+
+func TestWikiServer(t *testing.T) {
+ must := func(err error) {
+ if err != nil {
+ t.Helper()
+ t.Fatal(err)
+ }
+ }
+
+ dir, err := ioutil.TempDir("", t.Name())
+ must(err)
+ defer os.RemoveAll(dir)
+
+ // We're testing a walkthrough example of how to write a server.
+ //
+ // That server hard-codes a port number to make the walkthrough simpler, but
+ // we can't assume that the hard-coded port is available on an arbitrary
+ // builder. So we'll patch out the hard-coded port, and replace it with a
+ // function that writes the server's address to stdout
+ // so that we can read it and know where to send the test requests.
+
+ finalGo, err := ioutil.ReadFile("final.go")
+ must(err)
+ const patchOld = `log.Fatal(http.ListenAndServe(":8080", nil))`
+ patched := bytes.ReplaceAll(finalGo, []byte(patchOld), []byte(`log.Fatal(serve())`))
+ if bytes.Equal(patched, finalGo) {
+ t.Fatalf("Can't patch final.go: %q not found.", patchOld)
+ }
+ must(ioutil.WriteFile(filepath.Join(dir, "final_patched.go"), patched, 0644))
+
+ // Build the server binary from the patched sources.
+ // The 'go' command requires that they all be in the same directory.
+ // final_test.go provides the implemtation for our serve function.
+ must(copyFile(filepath.Join(dir, "final_srv.go"), "final_test.go"))
+ cmd := exec.Command("go", "build",
+ "-o", filepath.Join(dir, "final.exe"),
+ filepath.Join(dir, "final_patched.go"),
+ filepath.Join(dir, "final_srv.go"))
+ out, err := cmd.CombinedOutput()
+ if err != nil {
+ t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, out)
+ }
+
+ // Run the server in our temporary directory so that it can
+ // write its content there. It also needs a couple of template files,
+ // and looks for them in the same directory.
+ must(copyFile(filepath.Join(dir, "edit.html"), "edit.html"))
+ must(copyFile(filepath.Join(dir, "view.html"), "view.html"))
+ cmd = exec.Command(filepath.Join(dir, "final.exe"))
+ cmd.Dir = dir
+ stderr := bytes.NewBuffer(nil)
+ cmd.Stderr = stderr
+ stdout, err := cmd.StdoutPipe()
+ must(err)
+ must(cmd.Start())
+
+ defer func() {
+ cmd.Process.Kill()
+ err := cmd.Wait()
+ if stderr.Len() > 0 {
+ t.Logf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, stderr)
+ }
+ }()
+
+ var addr string
+ if _, err := fmt.Fscanln(stdout, &addr); err != nil || addr == "" {
+ t.Fatalf("Failed to read server address: %v", err)
+ }
+
+ // The server is up and has told us its address.
+ // Make sure that its HTTP API works as described in the article.
+
+ r, err := http.Get(fmt.Sprintf("http://%s/edit/Test", addr))
+ must(err)
+ responseMustMatchFile(t, r, "test_edit.good")
+
+ r, err = http.Post(fmt.Sprintf("http://%s/save/Test", addr),
+ "application/x-www-form-urlencoded",
+ strings.NewReader("body=some%20content"))
+ must(err)
+ responseMustMatchFile(t, r, "test_view.good")
+
+ gotTxt, err := ioutil.ReadFile(filepath.Join(dir, "Test.txt"))
+ must(err)
+ wantTxt, err := ioutil.ReadFile("test_Test.txt.good")
+ must(err)
+ if !bytes.Equal(wantTxt, gotTxt) {
+ t.Fatalf("Test.txt differs from expected after posting to /save.\ngot:\n%s\nwant:\n%s", gotTxt, wantTxt)
+ }
+
+ r, err = http.Get(fmt.Sprintf("http://%s/view/Test", addr))
+ must(err)
+ responseMustMatchFile(t, r, "test_view.good")
+}
+
+func responseMustMatchFile(t *testing.T, r *http.Response, filename string) {
+ t.Helper()
+
+ defer r.Body.Close()
+ body, err := ioutil.ReadAll(r.Body)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ wantBody, err := ioutil.ReadFile(filename)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if !bytes.Equal(body, wantBody) {
+ t.Fatalf("%v: body does not match %s.\ngot:\n%s\nwant:\n%s", r.Request.URL, filename, body, wantBody)
+ }
+}
+
+func copyFile(dst, src string) error {
+ buf, err := ioutil.ReadFile(src)
+ if err != nil {
+ return err
+ }
+ return ioutil.WriteFile(dst, buf, 0644)
+}
diff --git a/_content/doc/cmd.html b/_content/doc/cmd.html
new file mode 100644
index 0000000..e1f7e77
--- /dev/null
+++ b/_content/doc/cmd.html
@@ -0,0 +1,99 @@
+<!--{
+ "Title": "Command Documentation"
+}-->
+
+<p>
+There is a suite of programs to build and process Go source code.
+Instead of being run directly, programs in the suite are usually invoked
+by the <a href="/cmd/go/">go</a> program.
+</p>
+
+<p>
+The most common way to run these programs is as a subcommand of the go program,
+for instance as <code>go fmt</code>. Run like this, the command operates on
+complete packages of Go source code, with the go program invoking the
+underlying binary with arguments appropriate to package-level processing.
+</p>
+
+<p>
+The programs can also be run as stand-alone binaries, with unmodified arguments,
+using the go <code>tool</code> subcommand, such as <code>go tool cgo</code>.
+For most commands this is mainly useful for debugging.
+Some of the commands, such as <code>pprof</code>, are accessible only through
+the go <code>tool</code> subcommand.
+</p>
+
+<p>
+Finally the <code>fmt</code> and <code>godoc</code> commands are installed
+as regular binaries called <code>gofmt</code> and <code>godoc</code> because
+they are so often referenced.
+</p>
+
+<p>
+Click on the links for more documentation, invocation methods, and usage details.
+</p>
+
+<table class="dir">
+<tr>
+<th>Name</th>
+<th> </th>
+<th>Synopsis</th>
+</tr>
+
+<tr>
+<td><a href="/cmd/go/">go</a></td>
+<td> </td>
+<td>
+The <code>go</code> program manages Go source code and runs the other
+commands listed here.
+See the command docs for usage
+details.
+</td>
+</tr>
+
+<tr>
+<td><a href="/cmd/cgo/">cgo</a></td>
+<td> </td>
+<td>Cgo enables the creation of Go packages that call C code.</td>
+</tr>
+
+<tr>
+<td><a href="/cmd/cover/">cover</a></td>
+<td> </td>
+<td>Cover is a program for creating and analyzing the coverage profiles
+generated by <code>"go test -coverprofile"</code>.</td>
+</tr>
+
+<tr>
+<td><a href="/cmd/fix/">fix</a></td>
+<td> </td>
+<td>Fix finds Go programs that use old features of the language and libraries
+and rewrites them to use newer ones.</td>
+</tr>
+
+<tr>
+<td><a href="/cmd/gofmt/">fmt</a></td>
+<td> </td>
+<td>Fmt formats Go packages, it is also available as an independent <a href="/cmd/gofmt/">
+gofmt</a> command with more general options.</td>
+</tr>
+
+<tr>
+<td><a href="//godoc.org/golang.org/x/tools/cmd/godoc/">godoc</a></td>
+<td> </td>
+<td>Godoc extracts and generates documentation for Go packages.</td>
+</tr>
+
+<tr>
+<td><a href="/cmd/vet/">vet</a></td>
+<td> </td>
+<td>Vet examines Go source code and reports suspicious constructs, such as Printf
+calls whose arguments do not align with the format string.</td>
+</tr>
+
+</table>
+
+<p>
+This is an abridged list. See the <a href="/cmd/">full command reference</a>
+for documentation of the compilers and more.
+</p>
diff --git a/_content/doc/code.html b/_content/doc/code.html
new file mode 100644
index 0000000..99a1729
--- /dev/null
+++ b/_content/doc/code.html
@@ -0,0 +1,470 @@
+<!--{
+ "Title": "How to Write Go Code",
+ "Template": true
+}-->
+
+<h2 id="Introduction">Introduction</h2>
+
+<p>
+This document demonstrates the development of a simple Go package inside a
+module and introduces the <a href="/cmd/go/">go tool</a>, the standard way to
+fetch, build, and install Go modules, packages, and commands.
+</p>
+
+<p>
+Note: This document assumes that you are using Go 1.13 or later and the
+<code>GO111MODULE</code> environment variable is not set. If you are looking for
+the older, pre-modules version of this document, it is archived
+<a href="gopath_code.html">here</a>.
+</p>
+
+<h2 id="Organization">Code organization</h2>
+
+<p>
+Go programs are organized into packages. A <dfn>package</dfn> is a collection
+of source files in the same directory that are compiled together. Functions,
+types, variables, and constants defined in one source file are visible to all
+other source files within the same package.
+</p>
+
+<p>
+A repository contains one or more modules. A <dfn>module</dfn> is a collection
+of related Go packages that are released together. A Go repository typically
+contains only one module, located at the root of the repository. A file named
+<code>go.mod</code> there declares the <dfn>module path</dfn>: the import path
+prefix for all packages within the module. The module contains the packages in
+the directory containing its <code>go.mod</code> file as well as subdirectories
+of that directory, up to the next subdirectory containing another
+<code>go.mod</code> file (if any).
+</p>
+
+<p>
+Note that you don't need to publish your code to a remote repository before you
+can build it. A module can be defined locally without belonging to a repository.
+However, it's a good habit to organize your code as if you will publish it
+someday.
+</p>
+
+<p>
+Each module's path not only serves as an import path prefix for its packages,
+but also indicates where the <code>go</code> command should look to download it.
+For example, in order to download the module <code>golang.org/x/tools</code>,
+the <code>go</code> command would consult the repository indicated by
+<code>https://golang.org/x/tools</code> (described more <a href="https://golang.org/cmd/go/#hdr-Relative_import_paths">here</a>).
+</p>
+
+<p>
+An <dfn>import path</dfn> is a string used to import a package. A package's
+import path is its module path joined with its subdirectory within the module.
+For example, the module <code>github.com/google/go-cmp</code> contains a package
+in the directory <code>cmp/</code>. That package's import path is
+<code>github.com/google/go-cmp/cmp</code>. Packages in the standard library do
+not have a module path prefix.
+</p>
+
+<h2 id="Command">Your first program</h2>
+
+<p>
+To compile and run a simple program, first choose a module path (we'll use
+<code>example.com/user/hello</code>) and create a <code>go.mod</code> file that
+declares it:
+</p>
+
+<pre>
+$ mkdir hello # Alternatively, clone it if it already exists in version control.
+$ cd hello
+$ <b>go mod init example.com/user/hello</b>
+go: creating new go.mod: module example.com/user/hello
+$ cat go.mod
+module example.com/user/hello
+
+go 1.16
+$
+</pre>
+
+<p>
+The first statement in a Go source file must be
+<code>package <dfn>name</dfn></code>. Executable commands must always use
+<code>package main</code>.
+</p>
+
+<p>
+Next, create a file named <code>hello.go</code> inside that directory containing
+the following Go code:
+</p>
+
+<pre>
+package main
+
+import "fmt"
+
+func main() {
+ fmt.Println("Hello, world.")
+}
+</pre>
+
+<p>
+Now you can build and install that program with the <code>go</code> tool:
+</p>
+
+<pre>
+$ <b>go install example.com/user/hello</b>
+$
+</pre>
+
+<p>
+This command builds the <code>hello</code> command, producing an executable
+binary. It then installs that binary as <code>$HOME/go/bin/hello</code> (or,
+under Windows, <code>%USERPROFILE%\go\bin\hello.exe</code>).
+</p>
+
+<p>
+The install directory is controlled by the <code>GOPATH</code>
+and <code>GOBIN</code> <a href="/cmd/go/#hdr-Environment_variables">environment
+variables</a>. If <code>GOBIN</code> is set, binaries are installed to that
+directory. If <code>GOPATH</code> is set, binaries are installed to
+the <code>bin</code> subdirectory of the first directory in
+the <code>GOPATH</code> list. Otherwise, binaries are installed to
+the <code>bin</code> subdirectory of the default <code>GOPATH</code>
+(<code>$HOME/go</code> or <code>%USERPROFILE%\go</code>).
+</p>
+
+<p>
+You can use the <code>go env</code> command to portably set the default value
+for an environment variable for future <code>go</code> commands:
+</p>
+
+<pre>
+$ go env -w GOBIN=/somewhere/else/bin
+$
+</pre>
+
+<p>
+To unset a variable previously set by <code>go env -w</code>, use <code>go env -u</code>:
+</p>
+
+<pre>
+$ go env -u GOBIN
+$
+</pre>
+
+<p>
+Commands like <code>go install</code> apply within the context of the module
+containing the current working directory. If the working directory is not within
+the <code>example.com/user/hello</code> module, <code>go install</code> may fail.
+</p>
+
+<p>
+For convenience, <code>go</code> commands accept paths relative
+to the working directory, and default to the package in the
+current working directory if no other path is given.
+So in our working directory, the following commands are all equivalent:
+</p>
+
+<pre>
+$ go install example.com/user/hello
+</pre>
+
+<pre>
+$ go install .
+</pre>
+
+<pre>
+$ go install
+</pre>
+
+<p>
+Next, let's run the program to ensure it works. For added convenience, we'll
+add the install directory to our <code>PATH</code> to make running binaries
+easy:
+</p>
+
+<!-- Note: we can't use $(go env GOBIN) here until https://golang.org/issue/23439 is addressed. -->
+<pre>
+# Windows users should consult https://github.com/golang/go/wiki/SettingGOPATH
+# for setting %PATH%.
+$ <b>export PATH=$PATH:$(dirname $(go list -f '{{"{{"}}.Target{{"}}"}}' .))</b>
+$ <b>hello</b>
+Hello, world.
+$
+</pre>
+
+<p>
+If you're using a source control system, now would be a good time to initialize
+a repository, add the files, and commit your first change. Again, this step is
+optional: you do not need to use source control to write Go code.
+</p>
+
+<pre>
+$ <b>git init</b>
+Initialized empty Git repository in /home/user/hello/.git/
+$ <b>git add go.mod hello.go</b>
+$ <b>git commit -m "initial commit"</b>
+[master (root-commit) 0b4507d] initial commit
+ 1 file changed, 7 insertion(+)
+ create mode 100644 go.mod hello.go
+$
+</pre>
+
+<p>
+The <code>go</code> command locates the repository containing a given module path by requesting a corresponding HTTPS URL and reading metadata embedded in the HTML response (see
+<code><a href="/cmd/go/#hdr-Remote_import_paths">go help importpath</a></code>).
+Many hosting services already provide that metadata for repositories containing
+Go code, so the easiest way to make your module available for others to use is
+usually to make its module path match the URL for the repository.
+</p>
+
+<h3 id="ImportingLocal">Importing packages from your module</h3>
+
+<p>
+Let's write a <code>morestrings</code> package and use it from the <code>hello</code> program.
+First, create a directory for the package named
+<code>$HOME/hello/morestrings</code>, and then a file named
+<code>reverse.go</code> in that directory with the following contents:
+</p>
+
+<pre>
+// Package morestrings implements additional functions to manipulate UTF-8
+// encoded strings, beyond what is provided in the standard "strings" package.
+package morestrings
+
+// ReverseRunes returns its argument string reversed rune-wise left to right.
+func ReverseRunes(s string) string {
+ r := []rune(s)
+ for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {
+ r[i], r[j] = r[j], r[i]
+ }
+ return string(r)
+}
+</pre>
+
+<p>
+Because our <code>ReverseRunes</code> function begins with an upper-case
+letter, it is <a href="/ref/spec#Exported_identifiers"><dfn>exported</dfn></a>,
+and can be used in other packages that import our <code>morestrings</code>
+package.
+</p>
+
+<p>
+Let's test that the package compiles with <code>go build</code>:
+</p>
+
+<pre>
+$ cd $HOME/hello/morestrings
+$ <b>go build</b>
+$
+</pre>
+
+<p>
+This won't produce an output file. Instead it saves the compiled package in the
+local build cache.
+</p>
+
+<p>
+After confirming that the <code>morestrings</code> package builds, let's use it
+from the <code>hello</code> program. To do so, modify your original
+<code>$HOME/hello/hello.go</code> to use the morestrings package:
+</p>
+
+<pre>
+package main
+
+import (
+ "fmt"
+
+ <b>"example.com/user/hello/morestrings"</b>
+)
+
+func main() {
+ fmt.Println(morestrings.ReverseRunes("!oG ,olleH"))
+}
+</pre>
+
+<p>
+Install the <code>hello</code> program:
+</p>
+
+<pre>
+$ <b>go install example.com/user/hello</b>
+</pre>
+
+<p>
+Running the new version of the program, you should see a new, reversed message:
+</p>
+
+<pre>
+$ <b>hello</b>
+Hello, Go!
+</pre>
+
+<h3 id="ImportingRemote">Importing packages from remote modules</h3>
+
+<p>
+An import path can describe how to obtain the package source code using a
+revision control system such as Git or Mercurial. The <code>go</code> tool uses
+this property to automatically fetch packages from remote repositories.
+For instance, to use <code>github.com/google/go-cmp/cmp</code> in your program:
+</p>
+
+<pre>
+package main
+
+import (
+ "fmt"
+
+ "example.com/user/hello/morestrings"
+ "github.com/google/go-cmp/cmp"
+)
+
+func main() {
+ fmt.Println(morestrings.ReverseRunes("!oG ,olleH"))
+ fmt.Println(cmp.Diff("Hello World", "Hello Go"))
+}
+</pre>
+
+<p>
+Now that you have a dependency on an external module, you need to download that
+module and record its version in your <code>go.mod</code> file. The <code>go
+mod tidy</code> command adds missing module requirements for imported packages
+and removes requirements on modules that aren't used anymore.
+</p>
+
+<pre>
+$ go mod tidy
+go: finding module for package github.com/google/go-cmp/cmp
+go: found github.com/google/go-cmp/cmp in github.com/google/go-cmp v0.5.4
+$ go install example.com/user/hello
+$ hello
+Hello, Go!
+ string(
+- "Hello World",
++ "Hello Go",
+ )
+$ cat go.mod
+module example.com/user/hello
+
+go 1.16
+
+<b>require github.com/google/go-cmp v0.5.4</b>
+$
+</pre>
+
+<p>
+Module dependencies are automatically downloaded to the <code>pkg/mod</code>
+subdirectory of the directory indicated by the <code>GOPATH</code> environment
+variable. The downloaded contents for a given version of a module are shared
+among all other modules that <code>require</code> that version, so
+the <code>go</code> command marks those files and directories as read-only. To
+remove all downloaded modules, you can pass the <code>-modcache</code> flag
+to <code>go clean</code>:
+</p>
+
+<pre>
+$ go clean -modcache
+$
+</pre>
+
+<h2 id="Testing">Testing</h2>
+
+<p>
+Go has a lightweight test framework composed of the <code>go test</code>
+command and the <code>testing</code> package.
+</p>
+
+<p>
+You write a test by creating a file with a name ending in <code>_test.go</code>
+that contains functions named <code>TestXXX</code> with signature
+<code>func (t *testing.T)</code>.
+The test framework runs each such function;
+if the function calls a failure function such as <code>t.Error</code> or
+<code>t.Fail</code>, the test is considered to have failed.
+</p>
+
+<p>
+Add a test to the <code>morestrings</code> package by creating the file
+<code>$HOME/hello/morestrings/reverse_test.go</code> containing
+the following Go code.
+</p>
+
+<pre>
+package morestrings
+
+import "testing"
+
+func TestReverseRunes(t *testing.T) {
+ cases := []struct {
+ in, want string
+ }{
+ {"Hello, world", "dlrow ,olleH"},
+ {"Hello, 世界", "界世 ,olleH"},
+ {"", ""},
+ }
+ for _, c := range cases {
+ got := ReverseRunes(c.in)
+ if got != c.want {
+ t.Errorf("ReverseRunes(%q) == %q, want %q", c.in, got, c.want)
+ }
+ }
+}
+</pre>
+
+<p>
+Then run the test with <code>go test</code>:
+</p>
+
+<pre>
+$ <b>go test</b>
+PASS
+ok example.com/user/morestrings 0.165s
+$
+</pre>
+
+<p>
+Run <code><a href="/cmd/go/#hdr-Test_packages">go help test</a></code> and see the
+<a href="/pkg/testing/">testing package documentation</a> for more detail.
+</p>
+
+<h2 id="next">What's next</h2>
+
+<p>
+Subscribe to the
+<a href="//groups.google.com/group/golang-announce">golang-announce</a>
+mailing list to be notified when a new stable version of Go is released.
+</p>
+
+<p>
+See <a href="/doc/effective_go.html">Effective Go</a> for tips on writing
+clear, idiomatic Go code.
+</p>
+
+<p>
+Take {{if $.GoogleCN}}
+A Tour of Go
+{{else}}
+<a href="//tour.golang.org/">A Tour of Go</a>
+{{end}} to learn the language
+proper.
+</p>
+
+<p>
+Visit the <a href="/doc/#articles">documentation page</a> for a set of in-depth
+articles about the Go language and its libraries and tools.
+</p>
+
+<h2 id="help">Getting help</h2>
+
+<p>
+For real-time help, ask the helpful gophers in the community-run
+<a href="https://gophers.slack.com/messages/general/">gophers Slack server</a>
+(grab an invite <a href="https://invite.slack.golangbridge.org/">here</a>).
+</p>
+
+<p>
+The official mailing list for discussion of the Go language is
+<a href="//groups.google.com/group/golang-nuts">Go Nuts</a>.
+</p>
+
+<p>
+Report bugs using the
+<a href="//golang.org/issue">Go issue tracker</a>.
+</p>
diff --git a/_content/doc/codewalk/codewalk.css b/_content/doc/codewalk/codewalk.css
new file mode 100644
index 0000000..a0814e4
--- /dev/null
+++ b/_content/doc/codewalk/codewalk.css
@@ -0,0 +1,234 @@
+/*
+ Copyright 2010 The Go Authors. All rights reserved.
+ Use of this source code is governed by a BSD-style
+ license that can be found in the LICENSE file.
+*/
+
+#codewalk-main {
+ text-align: left;
+ width: 100%;
+ overflow: auto;
+}
+
+#code-display {
+ border: 0;
+ width: 100%;
+}
+
+.setting {
+ font-size: 8pt;
+ color: #888888;
+ padding: 5px;
+}
+
+.hotkey {
+ text-decoration: underline;
+}
+
+/* Style for Comments (the left-hand column) */
+
+#comment-column {
+ margin: 0pt;
+ width: 30%;
+}
+
+#comment-column.right {
+ float: right;
+}
+
+#comment-column.left {
+ float: left;
+}
+
+#comment-area {
+ overflow-x: hidden;
+ overflow-y: auto;
+}
+
+.comment {
+ cursor: pointer;
+ font-size: 16px;
+ border: 2px solid #ba9836;
+ margin-bottom: 10px;
+ margin-right: 10px; /* yes, for both .left and .right */
+}
+
+.comment:last-child {
+ margin-bottom: 0px;
+}
+
+.right .comment {
+ margin-left: 10px;
+}
+
+.right .comment.first {
+}
+
+.right .comment.last {
+}
+
+.left .comment.first {
+}
+
+.left .comment.last {
+}
+
+.comment.selected {
+ border-color: #99b2cb;
+}
+
+.right .comment.selected {
+ border-left-width: 12px;
+ margin-left: 0px;
+}
+
+.left .comment.selected {
+ border-right-width: 12px;
+ margin-right: 0px;
+}
+
+.comment-link {
+ display: none;
+}
+
+.comment-title {
+ font-size: small;
+ font-weight: bold;
+ background-color: #fffff0;
+ padding-right: 10px;
+ padding-left: 10px;
+ padding-top: 5px;
+ padding-bottom: 5px;
+}
+
+.right .comment-title {
+}
+
+.left .comment-title {
+}
+
+.comment.selected .comment-title {
+ background-color: #f8f8ff;
+}
+
+.comment-text {
+ overflow: auto;
+ padding-left: 10px;
+ padding-right: 10px;
+ padding-top: 10px;
+ padding-bottom: 5px;
+ font-size: small;
+ line-height: 1.3em;
+}
+
+.comment-text p {
+ margin-top: 0em;
+ margin-bottom: 0.5em;
+}
+
+.comment-text p:last-child {
+ margin-bottom: 0em;
+}
+
+.file-name {
+ font-size: x-small;
+ padding-top: 0px;
+ padding-bottom: 5px;
+}
+
+.hidden-filepaths .file-name {
+ display: none;
+}
+
+.path-dir {
+ color: #555;
+}
+
+.path-file {
+ color: #555;
+}
+
+
+/* Style for Code (the right-hand column) */
+
+/* Wrapper for the code column to make widths get calculated correctly */
+#code-column {
+ display: block;
+ position: relative;
+ margin: 0pt;
+ width: 70%;
+}
+
+#code-column.left {
+ float: left;
+}
+
+#code-column.right {
+ float: right;
+}
+
+#code-area {
+ background-color: #f8f8ff;
+ border: 2px solid #99b2cb;
+ padding: 5px;
+}
+
+.left #code-area {
+ margin-right: -1px;
+}
+
+.right #code-area {
+ margin-left: -1px;
+}
+
+#code-header {
+ margin-bottom: 5px;
+}
+
+#code {
+ background-color: white;
+}
+
+code {
+ font-size: 100%;
+}
+
+.codewalkhighlight {
+ font-weight: bold;
+ background-color: #f8f8ff;
+}
+
+#code-display {
+ margin-top: 0px;
+ margin-bottom: 0px;
+}
+
+#sizer {
+ position: absolute;
+ cursor: col-resize;
+ left: 0px;
+ top: 0px;
+ width: 8px;
+}
+
+/* Style for options (bottom strip) */
+
+#code-options {
+ display: none;
+}
+
+#code-options > span {
+ padding-right: 20px;
+}
+
+#code-options .selected {
+ border-bottom: 1px dotted;
+}
+
+#comment-options {
+ text-align: center;
+}
+
+div#content {
+ padding-bottom: 0em;
+}
diff --git a/_content/doc/codewalk/codewalk.js b/_content/doc/codewalk/codewalk.js
new file mode 100644
index 0000000..4f59a8f
--- /dev/null
+++ b/_content/doc/codewalk/codewalk.js
@@ -0,0 +1,305 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/**
+ * A class to hold information about the Codewalk Viewer.
+ * @param {jQuery} context The top element in whose context the viewer should
+ * operate. It will not touch any elements above this one.
+ * @constructor
+ */
+ var CodewalkViewer = function(context) {
+ this.context = context;
+
+ /**
+ * The div that contains all of the comments and their controls.
+ */
+ this.commentColumn = this.context.find('#comment-column');
+
+ /**
+ * The div that contains the comments proper.
+ */
+ this.commentArea = this.context.find('#comment-area');
+
+ /**
+ * The div that wraps the iframe with the code, as well as the drop down menu
+ * listing the different files.
+ * @type {jQuery}
+ */
+ this.codeColumn = this.context.find('#code-column');
+
+ /**
+ * The div that contains the code but excludes the options strip.
+ * @type {jQuery}
+ */
+ this.codeArea = this.context.find('#code-area');
+
+ /**
+ * The iframe that holds the code (from Sourcerer).
+ * @type {jQuery}
+ */
+ this.codeDisplay = this.context.find('#code-display');
+
+ /**
+ * The overlaid div used as a grab handle for sizing the code/comment panes.
+ * @type {jQuery}
+ */
+ this.sizer = this.context.find('#sizer');
+
+ /**
+ * The full-screen overlay that ensures we don't lose track of the mouse
+ * while dragging.
+ * @type {jQuery}
+ */
+ this.overlay = this.context.find('#overlay');
+
+ /**
+ * The hidden input field that we use to hold the focus so that we can detect
+ * shortcut keypresses.
+ * @type {jQuery}
+ */
+ this.shortcutInput = this.context.find('#shortcut-input');
+
+ /**
+ * The last comment that was selected.
+ * @type {jQuery}
+ */
+ this.lastSelected = null;
+};
+
+/**
+ * Minimum width of the comments or code pane, in pixels.
+ * @type {number}
+ */
+CodewalkViewer.MIN_PANE_WIDTH = 200;
+
+/**
+ * Navigate the code iframe to the given url and update the code popout link.
+ * @param {string} url The target URL.
+ * @param {Object} opt_window Window dependency injection for testing only.
+ */
+CodewalkViewer.prototype.navigateToCode = function(url, opt_window) {
+ if (!opt_window) opt_window = window;
+ // Each iframe is represented by two distinct objects in the DOM: an iframe
+ // object and a window object. These do not expose the same capabilities.
+ // Here we need to get the window representation to get the location member,
+ // so we access it directly through window[] since jQuery returns the iframe
+ // representation.
+ // We replace location rather than set so as not to create a history for code
+ // navigation.
+ opt_window['code-display'].location.replace(url);
+ var k = url.indexOf('&');
+ if (k != -1) url = url.slice(0, k);
+ k = url.indexOf('fileprint=');
+ if (k != -1) url = url.slice(k+10, url.length);
+ this.context.find('#code-popout-link').attr('href', url);
+};
+
+/**
+ * Selects the first comment from the list and forces a refresh of the code
+ * view.
+ */
+CodewalkViewer.prototype.selectFirstComment = function() {
+ // TODO(rsc): handle case where there are no comments
+ var firstSourcererLink = this.context.find('.comment:first');
+ this.changeSelectedComment(firstSourcererLink);
+};
+
+/**
+ * Sets the target on all links nested inside comments to be _blank.
+ */
+CodewalkViewer.prototype.targetCommentLinksAtBlank = function() {
+ this.context.find('.comment a[href], #description a[href]').each(function() {
+ if (!this.target) this.target = '_blank';
+ });
+};
+
+/**
+ * Installs event handlers for all the events we care about.
+ */
+CodewalkViewer.prototype.installEventHandlers = function() {
+ var self = this;
+
+ this.context.find('.comment')
+ .click(function(event) {
+ if (jQuery(event.target).is('a[href]')) return true;
+ self.changeSelectedComment(jQuery(this));
+ return false;
+ });
+
+ this.context.find('#code-selector')
+ .change(function() {self.navigateToCode(jQuery(this).val());});
+
+ this.context.find('#description-table .quote-feet.setting')
+ .click(function() {self.toggleDescription(jQuery(this)); return false;});
+
+ this.sizer
+ .mousedown(function(ev) {self.startSizerDrag(ev); return false;});
+ this.overlay
+ .mouseup(function(ev) {self.endSizerDrag(ev); return false;})
+ .mousemove(function(ev) {self.handleSizerDrag(ev); return false;});
+
+ this.context.find('#prev-comment')
+ .click(function() {
+ self.changeSelectedComment(self.lastSelected.prev()); return false;
+ });
+
+ this.context.find('#next-comment')
+ .click(function() {
+ self.changeSelectedComment(self.lastSelected.next()); return false;
+ });
+
+ // Workaround for Firefox 2 and 3, which steal focus from the main document
+ // whenever the iframe content is (re)loaded. The input field is not shown,
+ // but is a way for us to bring focus back to a place where we can detect
+ // keypresses.
+ this.context.find('#code-display')
+ .load(function(ev) {self.shortcutInput.focus();});
+
+ jQuery(document).keypress(function(ev) {
+ switch(ev.which) {
+ case 110: // 'n'
+ self.changeSelectedComment(self.lastSelected.next());
+ return false;
+ case 112: // 'p'
+ self.changeSelectedComment(self.lastSelected.prev());
+ return false;
+ default: // ignore
+ }
+ });
+
+ window.onresize = function() {self.updateHeight();};
+};
+
+/**
+ * Starts dragging the pane sizer.
+ * @param {Object} ev The mousedown event that started us dragging.
+ */
+CodewalkViewer.prototype.startSizerDrag = function(ev) {
+ this.initialCodeWidth = this.codeColumn.width();
+ this.initialCommentsWidth = this.commentColumn.width();
+ this.initialMouseX = ev.pageX;
+ this.overlay.show();
+};
+
+/**
+ * Handles dragging the pane sizer.
+ * @param {Object} ev The mousemove event updating dragging position.
+ */
+CodewalkViewer.prototype.handleSizerDrag = function(ev) {
+ var delta = ev.pageX - this.initialMouseX;
+ if (this.codeColumn.is('.right')) delta = -delta;
+ var proposedCodeWidth = this.initialCodeWidth + delta;
+ var proposedCommentWidth = this.initialCommentsWidth - delta;
+ var mw = CodewalkViewer.MIN_PANE_WIDTH;
+ if (proposedCodeWidth < mw) delta = mw - this.initialCodeWidth;
+ if (proposedCommentWidth < mw) delta = this.initialCommentsWidth - mw;
+ proposedCodeWidth = this.initialCodeWidth + delta;
+ proposedCommentWidth = this.initialCommentsWidth - delta;
+ // If window is too small, don't even try to resize.
+ if (proposedCodeWidth < mw || proposedCommentWidth < mw) return;
+ this.codeColumn.width(proposedCodeWidth);
+ this.commentColumn.width(proposedCommentWidth);
+ this.options.codeWidth = parseInt(
+ this.codeColumn.width() /
+ (this.codeColumn.width() + this.commentColumn.width()) * 100);
+ this.context.find('#code-column-width').text(this.options.codeWidth + '%');
+};
+
+/**
+ * Ends dragging the pane sizer.
+ * @param {Object} ev The mouseup event that caused us to stop dragging.
+ */
+CodewalkViewer.prototype.endSizerDrag = function(ev) {
+ this.overlay.hide();
+ this.updateHeight();
+};
+
+/**
+ * Toggles the Codewalk description between being shown and hidden.
+ * @param {jQuery} target The target that was clicked to trigger this function.
+ */
+CodewalkViewer.prototype.toggleDescription = function(target) {
+ var description = this.context.find('#description');
+ description.toggle();
+ target.find('span').text(description.is(':hidden') ? 'show' : 'hide');
+ this.updateHeight();
+};
+
+/**
+ * Changes the side of the window on which the code is shown and saves the
+ * setting in a cookie.
+ * @param {string?} codeSide The side on which the code should be, either
+ * 'left' or 'right'.
+ */
+CodewalkViewer.prototype.changeCodeSide = function(codeSide) {
+ var commentSide = codeSide == 'left' ? 'right' : 'left';
+ this.context.find('#set-code-' + codeSide).addClass('selected');
+ this.context.find('#set-code-' + commentSide).removeClass('selected');
+ // Remove previous side class and add new one.
+ this.codeColumn.addClass(codeSide).removeClass(commentSide);
+ this.commentColumn.addClass(commentSide).removeClass(codeSide);
+ this.sizer.css(codeSide, 'auto').css(commentSide, 0);
+ this.options.codeSide = codeSide;
+};
+
+/**
+ * Adds selected class to newly selected comment, removes selected style from
+ * previously selected comment, changes drop down options so that the correct
+ * file is selected, and updates the code popout link.
+ * @param {jQuery} target The target that was clicked to trigger this function.
+ */
+CodewalkViewer.prototype.changeSelectedComment = function(target) {
+ var currentFile = target.find('.comment-link').attr('href');
+ if (!currentFile) return;
+
+ if (!(this.lastSelected && this.lastSelected.get(0) === target.get(0))) {
+ if (this.lastSelected) this.lastSelected.removeClass('selected');
+ target.addClass('selected');
+ this.lastSelected = target;
+ var targetTop = target.position().top;
+ var parentTop = target.parent().position().top;
+ if (targetTop + target.height() > parentTop + target.parent().height() ||
+ targetTop < parentTop) {
+ var delta = targetTop - parentTop;
+ target.parent().animate(
+ {'scrollTop': target.parent().scrollTop() + delta},
+ Math.max(delta / 2, 200), 'swing');
+ }
+ var fname = currentFile.match(/(?:select=|fileprint=)\/[^&]+/)[0];
+ fname = fname.slice(fname.indexOf('=')+2, fname.length);
+ this.context.find('#code-selector').val(fname);
+ this.context.find('#prev-comment').toggleClass(
+ 'disabled', !target.prev().length);
+ this.context.find('#next-comment').toggleClass(
+ 'disabled', !target.next().length);
+ }
+
+ // Force original file even if user hasn't changed comments since they may
+ // have navigated away from it within the iframe without us knowing.
+ this.navigateToCode(currentFile);
+};
+
+/**
+ * Updates the viewer by changing the height of the comments and code so that
+ * they fit within the height of the window. The function is typically called
+ * after the user changes the window size.
+ */
+CodewalkViewer.prototype.updateHeight = function() {
+ var windowHeight = jQuery(window).height() - 5 // GOK
+ var areaHeight = windowHeight - this.codeArea.offset().top
+ var footerHeight = this.context.find('#footer').outerHeight(true)
+ this.commentArea.height(areaHeight - footerHeight - this.context.find('#comment-options').outerHeight(true))
+ var codeHeight = areaHeight - footerHeight - 15 // GOK
+ this.codeArea.height(codeHeight)
+ this.codeDisplay.height(codeHeight - this.codeDisplay.offset().top + this.codeArea.offset().top);
+ this.sizer.height(codeHeight);
+};
+
+window.initFuncs.push(function() {
+ var viewer = new CodewalkViewer(jQuery('#codewalk-main'));
+ viewer.selectFirstComment();
+ viewer.targetCommentLinksAtBlank();
+ viewer.installEventHandlers();
+ viewer.updateHeight();
+});
diff --git a/_content/doc/codewalk/codewalk.xml b/_content/doc/codewalk/codewalk.xml
new file mode 100644
index 0000000..34e6e91
--- /dev/null
+++ b/_content/doc/codewalk/codewalk.xml
@@ -0,0 +1,124 @@
+<codewalk title="How to Write a Codewalk">
+
+<step title="Introduction" src="doc/codewalk/codewalk.xml">
+ A codewalk is a guided tour through a piece of code.
+ It consists of a sequence of steps, each typically explaining
+ a highlighted section of code.
+ <br/><br/>
+
+ The <a href="/cmd/godoc">godoc</a> web server translates
+ an XML file like the one in the main window pane into the HTML
+ page that you're viewing now.
+ <br/><br/>
+
+ The codewalk with URL path <code>/doc/codewalk/</code><i>name</i>
+ is loaded from the input file <code>$GOROOT/doc/codewalk/</code><i>name</i><code>.xml</code>.
+ <br/><br/>
+
+ This codewalk explains how to write a codewalk by examining
+ its own source code,
+ <code><a href="/doc/codewalk/codewalk.xml">$GOROOT/doc/codewalk/codewalk.xml</a></code>,
+ shown in the main window pane to the left.
+</step>
+
+<step title="Title" src="doc/codewalk/codewalk.xml:/title=/">
+ The codewalk input file is an XML file containing a single
+ <code><codewalk></code> element.
+ That element's <code>title</code> attribute gives the title
+ that is used both on the codewalk page and in the codewalk list.
+</step>
+
+<step title="Steps" src="doc/codewalk/codewalk.xml:/<step/,/step>/">
+ Each step in the codewalk is a <code><step></code> element
+ nested inside the main <code><codewalk></code>.
+ The step element's <code>title</code> attribute gives the step's title,
+ which is shown in a shaded bar above the main step text.
+ The element's <code>src</code> attribute specifies the source
+ code to show in the main window pane and, optionally, a range of
+ lines to highlight.
+ <br/><br/>
+
+ The first step in this codewalk does not highlight any lines:
+ its <code>src</code> is just a file name.
+</step>
+
+<step title="Specifying a source line" src='doc/codewalk/codewalk.xml:/title="Title"/'>
+ The most complex part of the codewalk specification is
+ saying what lines to highlight.
+ Instead of ordinary line numbers,
+ the codewalk uses an address syntax that makes it possible
+ to describe the match by its content.
+ As the file gets edited, this descriptive address has a better
+ chance to continue to refer to the right section of the file.
+ <br/><br/>
+
+ To specify a source line, use a <code>src</code> attribute of the form
+ <i>filename</i><code>:</code><i>address</i>,
+ where <i>address</i> is an address in the syntax used by the text editors <i>sam</i> and <i>acme</i>.
+ <br/><br/>
+
+ The simplest address is a single regular expression.
+ The highlighted line in the main window pane shows that the
+ address for the “Title” step was <code>/title=/</code>,
+ which matches the first instance of that <a href="/pkg/regexp">regular expression</a> (<code>title=</code>) in the file.
+</step>
+
+<step title="Specifying a source range" src='doc/codewalk/codewalk.xml:/title="Steps"/'>
+ To highlight a range of source lines, the simplest address to use is
+ a pair of regular expressions
+ <code>/</code><i>regexp1</i><code>/,/</code><i>regexp2</i><code>/</code>.
+ The highlight begins with the line containing the first match for <i>regexp1</i>
+ and ends with the line containing the first match for <i>regexp2</i>
+ after the end of the match for <i>regexp1</i>.
+ Ignoring the HTML quoting,
+ The line containing the first match for <i>regexp1</i> will be the first one highlighted,
+ and the line containing the first match for <i>regexp2</i>.
+ <br/><br/>
+
+ The address <code>/<step/,/step>/</code> looks for the first instance of
+ <code><step</code> in the file, and then starting after that point,
+ looks for the first instance of <code>step></code>.
+ (Click on the “Steps” step above to see the highlight in action.)
+ Note that the <code><</code> and <code>></code> had to be written
+ using XML escapes in order to be valid XML.
+</step>
+
+<step title="Advanced addressing" src="doc/codewalk/codewalk.xml:/Advanced/,/step>/">
+ The <code>/</code><i>regexp</i><code>/</code>
+ and <code>/</code><i>regexp1</i><code>/,/</code><i>regexp2</i><code>/</code>
+ forms suffice for most highlighting.
+ <br/><br/>
+
+ The full address syntax is summarized in this table
+ (an excerpt of Table II from
+ <a href="https://9p.io/sys/doc/sam/sam.html">The text editor <code>sam</code></a>):
+ <br/><br/>
+
+ <table>
+ <tr><td colspan="2"><b>Simple addresses</b></td></tr>
+ <tr><td><code>#</code><i>n</i></td>
+ <td>The empty string after character <i>n</i></td></tr>
+ <tr><td><i>n</i></td>
+ <td>Line <i>n</i></td></tr>
+ <tr><td><code>/</code><i>regexp</i><code>/</code></td>
+ <td>The first following match of the regular expression</td></tr>
+ <!-- not supported (yet?)
+ <tr><td><code>–/</code><i>regexp</i><code>/</code></td>
+ <td>The first previous match of the regular expression</td></tr>
+ -->
+ <tr><td><code>$</code></td>
+ <td>The null string at the end of the file</td></tr>
+
+ <tr><td colspan="2"><b>Compound addresses</b></td></tr>
+ <tr><td><i>a1</i><code>+</code><i>a2</i></td>
+ <td>The address <i>a2</i> evaluated starting at the right of <i>a1</i></td></tr>
+ <tr><td><i>a1</i><code>-</code><i>a2</i></td>
+ <td>The address <i>a2</i> evaluated in the reverse direction starting at the left of <i>a1</i></td></tr>
+ <tr><td><i>a1</i><code>,</code><i>a2</i></td>
+ <td>From the left of <i>a1</i> to the right of <i>a2</i> (default <code>0,$</code>).</td></tr>
+ </table>
+</step>
+
+
+
+</codewalk>
diff --git a/_content/doc/codewalk/codewalk_test.go b/_content/doc/codewalk/codewalk_test.go
new file mode 100644
index 0000000..31f078a
--- /dev/null
+++ b/_content/doc/codewalk/codewalk_test.go
@@ -0,0 +1,52 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main_test
+
+import (
+ "bytes"
+ "os"
+ "os/exec"
+ "strings"
+ "testing"
+)
+
+// TestMarkov tests the code dependency of markov.xml.
+func TestMarkov(t *testing.T) {
+ cmd := exec.Command("go", "run", "markov.go")
+ cmd.Stdin = strings.NewReader("foo")
+ cmd.Stderr = bytes.NewBuffer(nil)
+ out, err := cmd.Output()
+ if err != nil {
+ t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, cmd.Stderr)
+ }
+
+ if !bytes.Equal(out, []byte("foo\n")) {
+ t.Fatalf(`%s with input "foo" did not output "foo":\n%s`, strings.Join(cmd.Args, " "), out)
+ }
+}
+
+// TestPig tests the code dependency of functions.xml.
+func TestPig(t *testing.T) {
+ cmd := exec.Command("go", "run", "pig.go")
+ cmd.Stderr = bytes.NewBuffer(nil)
+ out, err := cmd.Output()
+ if err != nil {
+ t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, cmd.Stderr)
+ }
+
+ const want = "Wins, losses staying at k = 100: 210/990 (21.2%), 780/990 (78.8%)\n"
+ if !bytes.Contains(out, []byte(want)) {
+ t.Fatalf(`%s: unexpected output\ngot:\n%s\nwant output containing:\n%s`, strings.Join(cmd.Args, " "), out, want)
+ }
+}
+
+// TestURLPoll tests the code dependency of sharemem.xml.
+func TestURLPoll(t *testing.T) {
+ cmd := exec.Command("go", "build", "-o", os.DevNull, "urlpoll.go")
+ out, err := cmd.CombinedOutput()
+ if err != nil {
+ t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, out)
+ }
+}
diff --git a/_content/doc/codewalk/functions.xml b/_content/doc/codewalk/functions.xml
new file mode 100644
index 0000000..db518dc
--- /dev/null
+++ b/_content/doc/codewalk/functions.xml
@@ -0,0 +1,105 @@
+<codewalk title="First-Class Functions in Go">
+
+<step title="Introduction" src="doc/codewalk/pig.go">
+ Go supports first class functions, higher-order functions, user-defined
+ function types, function literals, closures, and multiple return values.
+ <br/><br/>
+
+ This rich feature set supports a functional programming style in a strongly
+ typed language.
+ <br/><br/>
+
+ In this codewalk we will look at a simple program that simulates a dice game
+ called <a href="http://en.wikipedia.org/wiki/Pig_(dice)">Pig</a> and evaluates
+ basic strategies.
+</step>
+
+<step title="Game overview" src="doc/codewalk/pig.go:/\/\/ A score/,/thisTurn int\n}/">
+ Pig is a two-player game played with a 6-sided die. Each turn, you may roll or stay.
+ <ul>
+ <li> If you roll a 1, you lose all points for your turn and play passes to
+ your opponent. Any other roll adds its value to your turn score. </li>
+ <li> If you stay, your turn score is added to your total score, and play passes
+ to your opponent. </li>
+ </ul>
+
+ The first person to reach 100 total points wins.
+ <br/><br/>
+
+ The <code>score</code> type stores the scores of the current and opposing
+ players, in addition to the points accumulated during the current turn.
+</step>
+
+<step title="User-defined function types" src="doc/codewalk/pig.go:/\/\/ An action/,/bool\)/">
+ In Go, functions can be passed around just like any other value. A function's
+ type signature describes the types of its arguments and return values.
+ <br/><br/>
+
+ The <code>action</code> type is a function that takes a <code>score</code>
+ and returns the resulting <code>score</code> and whether the current turn is
+ over.
+ <br/><br/>
+
+ If the turn is over, the <code>player</code> and <code>opponent</code> fields
+ in the resulting <code>score</code> should be swapped, as it is now the other player's
+ turn.
+</step>
+
+<step title="Multiple return values" src="doc/codewalk/pig.go:/\/\/ roll returns/,/true\n}/">
+ Go functions can return multiple values.
+ <br/><br/>
+
+ The functions <code>roll</code> and <code>stay</code> each return a pair of
+ values. They also match the <code>action</code> type signature. These
+ <code>action</code> functions define the rules of Pig.
+</step>
+
+<step title="Higher-order functions" src="doc/codewalk/pig.go:/\/\/ A strategy/,/action\n/">
+ A function can use other functions as arguments and return values.
+ <br/><br/>
+
+ A <code>strategy</code> is a function that takes a <code>score</code> as input
+ and returns an <code>action</code> to perform. <br/>
+ (Remember, an <code>action</code> is itself a function.)
+</step>
+
+<step title="Function literals and closures" src="doc/codewalk/pig.go:/return func/,/return roll\n\t}/">
+ Anonymous functions can be declared in Go, as in this example. Function
+ literals are closures: they inherit the scope of the function in which they
+ are declared.
+ <br/><br/>
+
+ One basic strategy in Pig is to continue rolling until you have accumulated at
+ least k points in a turn, and then stay. The argument <code>k</code> is
+ enclosed by this function literal, which matches the <code>strategy</code> type
+ signature.
+</step>
+
+<step title="Simulating games" src="doc/codewalk/pig.go:/\/\/ play/,/currentPlayer\n}/">
+ We simulate a game of Pig by calling an <code>action</code> to update the
+ <code>score</code> until one player reaches 100 points. Each
+ <code>action</code> is selected by calling the <code>strategy</code> function
+ associated with the current player.
+</step>
+
+<step title="Simulating a tournament" src="doc/codewalk/pig.go:/\/\/ roundRobin/,/gamesPerStrategy\n}/">
+ The <code>roundRobin</code> function simulates a tournament and tallies wins.
+ Each strategy plays each other strategy <code>gamesPerSeries</code> times.
+</step>
+
+<step title="Variadic function declarations" src="doc/codewalk/pig.go:/\/\/ ratioS/,/string {/">
+ Variadic functions like <code>ratioString</code> take a variable number of
+ arguments. These arguments are available as a slice inside the function.
+</step>
+
+<step title="Simulation results" src="doc/codewalk/pig.go:/func main/,/\n}/">
+ The <code>main</code> function defines 100 basic strategies, simulates a round
+ robin tournament, and then prints the win/loss record of each strategy.
+ <br/><br/>
+
+ Among these strategies, staying at 25 is best, but the <a
+ href="http://www.google.com/search?q=optimal+play+pig">optimal strategy for
+ Pig</a> is much more complex.
+</step>
+
+</codewalk>
diff --git a/_content/doc/codewalk/markov.go b/_content/doc/codewalk/markov.go
new file mode 100644
index 0000000..5f62e05
--- /dev/null
+++ b/_content/doc/codewalk/markov.go
@@ -0,0 +1,130 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+Generating random text: a Markov chain algorithm
+
+Based on the program presented in the "Design and Implementation" chapter
+of The Practice of Programming (Kernighan and Pike, Addison-Wesley 1999).
+See also Computer Recreations, Scientific American 260, 122 - 125 (1989).
+
+A Markov chain algorithm generates text by creating a statistical model of
+potential textual suffixes for a given prefix. Consider this text:
+
+ I am not a number! I am a free man!
+
+Our Markov chain algorithm would arrange this text into this set of prefixes
+and suffixes, or "chain": (This table assumes a prefix length of two words.)
+
+ Prefix Suffix
+
+ "" "" I
+ "" I am
+ I am a
+ I am not
+ a free man!
+ am a free
+ am not a
+ a number! I
+ number! I am
+ not a number!
+
+To generate text using this table we select an initial prefix ("I am", for
+example), choose one of the suffixes associated with that prefix at random
+with probability determined by the input statistics ("a"),
+and then create a new prefix by removing the first word from the prefix
+and appending the suffix (making the new prefix is "am a"). Repeat this process
+until we can't find any suffixes for the current prefix or we exceed the word
+limit. (The word limit is necessary as the chain table may contain cycles.)
+
+Our version of this program reads text from standard input, parsing it into a
+Markov chain, and writes generated text to standard output.
+The prefix and output lengths can be specified using the -prefix and -words
+flags on the command-line.
+*/
+package main
+
+import (
+ "bufio"
+ "flag"
+ "fmt"
+ "io"
+ "math/rand"
+ "os"
+ "strings"
+ "time"
+)
+
+// Prefix is a Markov chain prefix of one or more words.
+type Prefix []string
+
+// String returns the Prefix as a string (for use as a map key).
+func (p Prefix) String() string {
+ return strings.Join(p, " ")
+}
+
+// Shift removes the first word from the Prefix and appends the given word.
+func (p Prefix) Shift(word string) {
+ copy(p, p[1:])
+ p[len(p)-1] = word
+}
+
+// Chain contains a map ("chain") of prefixes to a list of suffixes.
+// A prefix is a string of prefixLen words joined with spaces.
+// A suffix is a single word. A prefix can have multiple suffixes.
+type Chain struct {
+ chain map[string][]string
+ prefixLen int
+}
+
+// NewChain returns a new Chain with prefixes of prefixLen words.
+func NewChain(prefixLen int) *Chain {
+ return &Chain{make(map[string][]string), prefixLen}
+}
+
+// Build reads text from the provided Reader and
+// parses it into prefixes and suffixes that are stored in Chain.
+func (c *Chain) Build(r io.Reader) {
+ br := bufio.NewReader(r)
+ p := make(Prefix, c.prefixLen)
+ for {
+ var s string
+ if _, err := fmt.Fscan(br, &s); err != nil {
+ break
+ }
+ key := p.String()
+ c.chain[key] = append(c.chain[key], s)
+ p.Shift(s)
+ }
+}
+
+// Generate returns a string of at most n words generated from Chain.
+func (c *Chain) Generate(n int) string {
+ p := make(Prefix, c.prefixLen)
+ var words []string
+ for i := 0; i < n; i++ {
+ choices := c.chain[p.String()]
+ if len(choices) == 0 {
+ break
+ }
+ next := choices[rand.Intn(len(choices))]
+ words = append(words, next)
+ p.Shift(next)
+ }
+ return strings.Join(words, " ")
+}
+
+func main() {
+ // Register command-line flags.
+ numWords := flag.Int("words", 100, "maximum number of words to print")
+ prefixLen := flag.Int("prefix", 2, "prefix length in words")
+
+ flag.Parse() // Parse command-line flags.
+ rand.Seed(time.Now().UnixNano()) // Seed the random number generator.
+
+ c := NewChain(*prefixLen) // Initialize a new Chain.
+ c.Build(os.Stdin) // Build chains from standard input.
+ text := c.Generate(*numWords) // Generate text.
+ fmt.Println(text) // Write text to standard output.
+}
diff --git a/_content/doc/codewalk/markov.xml b/_content/doc/codewalk/markov.xml
new file mode 100644
index 0000000..7e44840
--- /dev/null
+++ b/_content/doc/codewalk/markov.xml
@@ -0,0 +1,307 @@
+<!--
+Copyright 2011 The Go Authors. All rights reserved.
+Use of this source code is governed by a BSD-style
+license that can be found in the LICENSE file.
+-->
+
+<codewalk title="Generating arbitrary text: a Markov chain algorithm">
+
+<step title="Introduction" src="doc/codewalk/markov.go:/Generating/,/line\./">
+ This codewalk describes a program that generates random text using
+ a Markov chain algorithm. The package comment describes the algorithm
+ and the operation of the program. Please read it before continuing.
+</step>
+
+<step title="Modeling Markov chains" src="doc/codewalk/markov.go:/ chain/">
+ A chain consists of a prefix and a suffix. Each prefix is a set
+ number of words, while a suffix is a single word.
+ A prefix can have an arbitrary number of suffixes.
+ To model this data, we use a <code>map[string][]string</code>.
+ Each map key is a prefix (a <code>string</code>) and its values are
+ lists of suffixes (a slice of strings, <code>[]string</code>).
+ <br/><br/>
+ Here is the example table from the package comment
+ as modeled by this data structure:
+ <pre>
+map[string][]string{
+ " ": {"I"},
+ " I": {"am"},
+ "I am": {"a", "not"},
+ "a free": {"man!"},
+ "am a": {"free"},
+ "am not": {"a"},
+ "a number!": {"I"},
+ "number! I": {"am"},
+ "not a": {"number!"},
+}</pre>
+ While each prefix consists of multiple words, we
+ store prefixes in the map as a single <code>string</code>.
+ It would seem more natural to store the prefix as a
+ <code>[]string</code>, but we can't do this with a map because the
+ key type of a map must implement equality (and slices do not).
+ <br/><br/>
+ Therefore, in most of our code we will model prefixes as a
+ <code>[]string</code> and join the strings together with a space
+ to generate the map key:
+ <pre>
+Prefix Map key
+
+[]string{"", ""} " "
+[]string{"", "I"} " I"
+[]string{"I", "am"} "I am"
+</pre>
+</step>
+
+<step title="The Chain struct" src="doc/codewalk/markov.go:/type Chain/,/}/">
+ The complete state of the chain table consists of the table itself and
+ the word length of the prefixes. The <code>Chain</code> struct stores
+ this data.
+</step>
+
+<step title="The NewChain constructor function" src="doc/codewalk/markov.go:/func New/,/\n}/">
+ The <code>Chain</code> struct has two unexported fields (those that
+ do not begin with an upper case character), and so we write a
+ <code>NewChain</code> constructor function that initializes the
+ <code>chain</code> map with <code>make</code> and sets the
+ <code>prefixLen</code> field.
+ <br/><br/>
+ This is constructor function is not strictly necessary as this entire
+ program is within a single package (<code>main</code>) and therefore
+ there is little practical difference between exported and unexported
+ fields. We could just as easily write out the contents of this function
+ when we want to construct a new Chain.
+ But using these unexported fields is good practice; it clearly denotes
+ that only methods of Chain and its constructor function should access
+ those fields. Also, structuring <code>Chain</code> like this means we
+ could easily move it into its own package at some later date.
+</step>
+
+<step title="The Prefix type" src="doc/codewalk/markov.go:/type Prefix/">
+ Since we'll be working with prefixes often, we define a
+ <code>Prefix</code> type with the concrete type <code>[]string</code>.
+ Defining a named type clearly allows us to be explicit when we are
+ working with a prefix instead of just a <code>[]string</code>.
+ Also, in Go we can define methods on any named type (not just structs),
+ so we can add methods that operate on <code>Prefix</code> if we need to.
+</step>
+
+<step title="The String method" src="doc/codewalk/markov.go:/func[^\n]+String/,/}/">
+ The first method we define on <code>Prefix</code> is
+ <code>String</code>. It returns a <code>string</code> representation
+ of a <code>Prefix</code> by joining the slice elements together with
+ spaces. We will use this method to generate keys when working with
+ the chain map.
+</step>
+
+<step title="Building the chain" src="doc/codewalk/markov.go:/func[^\n]+Build/,/\n}/">
+ The <code>Build</code> method reads text from an <code>io.Reader</code>
+ and parses it into prefixes and suffixes that are stored in the
+ <code>Chain</code>.
+ <br/><br/>
+ The <code><a href="/pkg/io/#Reader">io.Reader</a></code> is an
+ interface type that is widely used by the standard library and
+ other Go code. Our code uses the
+ <code><a href="/pkg/fmt/#Fscan">fmt.Fscan</a></code> function, which
+ reads space-separated values from an <code>io.Reader</code>.
+ <br/><br/>
+ The <code>Build</code> method returns once the <code>Reader</code>'s
+ <code>Read</code> method returns <code>io.EOF</code> (end of file)
+ or some other read error occurs.
+</step>
+
+<step title="Buffering the input" src="doc/codewalk/markov.go:/bufio\.NewReader/">
+ This function does many small reads, which can be inefficient for some
+ <code>Readers</code>. For efficiency we wrap the provided
+ <code>io.Reader</code> with
+ <code><a href="/pkg/bufio/">bufio.NewReader</a></code> to create a
+ new <code>io.Reader</code> that provides buffering.
+</step>
+
+<step title="The Prefix variable" src="doc/codewalk/markov.go:/make\(Prefix/">
+ At the top of the function we make a <code>Prefix</code> slice
+ <code>p</code> using the <code>Chain</code>'s <code>prefixLen</code>
+ field as its length.
+ We'll use this variable to hold the current prefix and mutate it with
+ each new word we encounter.
+</step>
+
+<step title="Scanning words" src="doc/codewalk/markov.go:/var s string/,/\n }/">
+ In our loop we read words from the <code>Reader</code> into a
+ <code>string</code> variable <code>s</code> using
+ <code>fmt.Fscan</code>. Since <code>Fscan</code> uses space to
+ separate each input value, each call will yield just one word
+ (including punctuation), which is exactly what we need.
+ <br/><br/>
+ <code>Fscan</code> returns an error if it encounters a read error
+ (<code>io.EOF</code>, for example) or if it can't scan the requested
+ value (in our case, a single string). In either case we just want to
+ stop scanning, so we <code>break</code> out of the loop.
+</step>
+
+<step title="Adding a prefix and suffix to the chain" src="doc/codewalk/markov.go:/ key/,/key\], s\)">
+ The word stored in <code>s</code> is a new suffix. We add the new
+ prefix/suffix combination to the <code>chain</code> map by computing
+ the map key with <code>p.String</code> and appending the suffix
+ to the slice stored under that key.
+ <br/><br/>
+ The built-in <code>append</code> function appends elements to a slice
+ and allocates new storage when necessary. When the provided slice is
+ <code>nil</code>, <code>append</code> allocates a new slice.
+ This behavior conveniently ties in with the semantics of our map:
+ retrieving an unset key returns the zero value of the value type and
+ the zero value of <code>[]string</code> is <code>nil</code>.
+ When our program encounters a new prefix (yielding a <code>nil</code>
+ value in the map) <code>append</code> will allocate a new slice.
+ <br/><br/>
+ For more information about the <code>append</code> function and slices
+ in general see the
+ <a href="/doc/articles/slices_usage_and_internals.html">Slices: usage and internals</a> article.
+</step>
+
+<step title="Pushing the suffix onto the prefix" src="doc/codewalk/markov.go:/p\.Shift/">
+ Before reading the next word our algorithm requires us to drop the
+ first word from the prefix and push the current suffix onto the prefix.
+ <br/><br/>
+ When in this state
+ <pre>
+p == Prefix{"I", "am"}
+s == "not" </pre>
+ the new value for <code>p</code> would be
+ <pre>
+p == Prefix{"am", "not"}</pre>
+ This operation is also required during text generation so we put
+ the code to perform this mutation of the slice inside a method on
+ <code>Prefix</code> named <code>Shift</code>.
+</step>
+
+<step title="The Shift method" src="doc/codewalk/markov.go:/func[^\n]+Shift/,/\n}/">
+ The <code>Shift</code> method uses the built-in <code>copy</code>
+ function to copy the last len(p)-1 elements of <code>p</code> to
+ the start of the slice, effectively moving the elements
+ one index to the left (if you consider zero as the leftmost index).
+ <pre>
+p := Prefix{"I", "am"}
+copy(p, p[1:])
+// p == Prefix{"am", "am"}</pre>
+ We then assign the provided <code>word</code> to the last index
+ of the slice:
+ <pre>
+// suffix == "not"
+p[len(p)-1] = suffix
+// p == Prefix{"am", "not"}</pre>
+</step>
+
+<step title="Generating text" src="doc/codewalk/markov.go:/func[^\n]+Generate/,/\n}/">
+ The <code>Generate</code> method is similar to <code>Build</code>
+ except that instead of reading words from a <code>Reader</code>
+ and storing them in a map, it reads words from the map and
+ appends them to a slice (<code>words</code>).
+ <br/><br/>
+ <code>Generate</code> uses a conditional for loop to generate
+ up to <code>n</code> words.
+</step>
+
+<step title="Getting potential suffixes" src="doc/codewalk/markov.go:/choices/,/}\n/">
+ At each iteration of the loop we retrieve a list of potential suffixes
+ for the current prefix. We access the <code>chain</code> map at key
+ <code>p.String()</code> and assign its contents to <code>choices</code>.
+ <br/><br/>
+ If <code>len(choices)</code> is zero we break out of the loop as there
+ are no potential suffixes for that prefix.
+ This test also works if the key isn't present in the map at all:
+ in that case, <code>choices</code> will be <code>nil</code> and the
+ length of a <code>nil</code> slice is zero.
+</step>
+
+<step title="Choosing a suffix at random" src="doc/codewalk/markov.go:/next := choices/,/Shift/">
+ To choose a suffix we use the
+ <code><a href="/pkg/math/rand/#Intn">rand.Intn</a></code> function.
+ It returns a random integer up to (but not including) the provided
+ value. Passing in <code>len(choices)</code> gives us a random index
+ into the full length of the list.
+ <br/><br/>
+ We use that index to pick our new suffix, assign it to
+ <code>next</code> and append it to the <code>words</code> slice.
+ <br/><br/>
+ Next, we <code>Shift</code> the new suffix onto the prefix just as
+ we did in the <code>Build</code> method.
+</step>
+
+<step title="Returning the generated text" src="doc/codewalk/markov.go:/Join\(words/">
+ Before returning the generated text as a string, we use the
+ <code>strings.Join</code> function to join the elements of
+ the <code>words</code> slice together, separated by spaces.
+</step>
+
+<step title="Command-line flags" src="doc/codewalk/markov.go:/Register command-line flags/,/prefixLen/">
+ To make it easy to tweak the prefix and generated text lengths we
+ use the <code><a href="/pkg/flag/">flag</a></code> package to parse
+ command-line flags.
+ <br/><br/>
+ These calls to <code>flag.Int</code> register new flags with the
+ <code>flag</code> package. The arguments to <code>Int</code> are the
+ flag name, its default value, and a description. The <code>Int</code>
+ function returns a pointer to an integer that will contain the
+ user-supplied value (or the default value if the flag was omitted on
+ the command-line).
+</step>
+
+<step title="Program set up" src="doc/codewalk/markov.go:/flag.Parse/,/rand.Seed/">
+ The <code>main</code> function begins by parsing the command-line
+ flags with <code>flag.Parse</code> and seeding the <code>rand</code>
+ package's random number generator with the current time.
+ <br/><br/>
+ If the command-line flags provided by the user are invalid the
+ <code>flag.Parse</code> function will print an informative usage
+ message and terminate the program.
+</step>
+
+<step title="Creating and building a new Chain" src="doc/codewalk/markov.go:/c := NewChain/,/c\.Build/">
+ To create the new <code>Chain</code> we call <code>NewChain</code>
+ with the value of the <code>prefix</code> flag.
+ <br/><br/>
+ To build the chain we call <code>Build</code> with
+ <code>os.Stdin</code> (which implements <code>io.Reader</code>) so
+ that it will read its input from standard input.
+</step>
+
+<step title="Generating and printing text" src="doc/codewalk/markov.go:/c\.Generate/,/fmt.Println/">
+ Finally, to generate text we call <code>Generate</code> with
+ the value of the <code>words</code> flag and assigning the result
+ to the variable <code>text</code>.
+ <br/><br/>
+ Then we call <code>fmt.Println</code> to write the text to standard
+ output, followed by a carriage return.
+</step>
+
+<step title="Using this program" src="doc/codewalk/markov.go">
+ To use this program, first build it with the
+ <a href="/cmd/go/">go</a> command:
+ <pre>
+$ go build markov.go</pre>
+ And then execute it while piping in some input text:
+ <pre>
+$ echo "a man a plan a canal panama" \
+ | ./markov -prefix=1
+a plan a man a plan a canal panama</pre>
+ Here's a transcript of generating some text using the Go distribution's
+ README file as source material:
+ <pre>
+$ ./markov -words=10 < $GOROOT/README
+This is the source code repository for the Go source
+$ ./markov -prefix=1 -words=10 < $GOROOT/README
+This is the go directory (the one containing this README).
+$ ./markov -prefix=1 -words=10 < $GOROOT/README
+This is the variable if you have just untarred a</pre>
+</step>
+
+<step title="An exercise for the reader" src="doc/codewalk/markov.go">
+ The <code>Generate</code> function does a lot of allocations when it
+ builds the <code>words</code> slice. As an exercise, modify it to
+ take an <code>io.Writer</code> to which it incrementally writes the
+ generated text with <code>Fprint</code>.
+ Aside from being more efficient this makes <code>Generate</code>
+ more symmetrical to <code>Build</code>.
+</step>
+
+</codewalk>
diff --git a/_content/doc/codewalk/pig.go b/_content/doc/codewalk/pig.go
new file mode 100644
index 0000000..941daae
--- /dev/null
+++ b/_content/doc/codewalk/pig.go
@@ -0,0 +1,121 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "fmt"
+ "math/rand"
+)
+
+const (
+ win = 100 // The winning score in a game of Pig
+ gamesPerSeries = 10 // The number of games per series to simulate
+)
+
+// A score includes scores accumulated in previous turns for each player,
+// as well as the points scored by the current player in this turn.
+type score struct {
+ player, opponent, thisTurn int
+}
+
+// An action transitions stochastically to a resulting score.
+type action func(current score) (result score, turnIsOver bool)
+
+// roll returns the (result, turnIsOver) outcome of simulating a die roll.
+// If the roll value is 1, then thisTurn score is abandoned, and the players'
+// roles swap. Otherwise, the roll value is added to thisTurn.
+func roll(s score) (score, bool) {
+ outcome := rand.Intn(6) + 1 // A random int in [1, 6]
+ if outcome == 1 {
+ return score{s.opponent, s.player, 0}, true
+ }
+ return score{s.player, s.opponent, outcome + s.thisTurn}, false
+}
+
+// stay returns the (result, turnIsOver) outcome of staying.
+// thisTurn score is added to the player's score, and the players' roles swap.
+func stay(s score) (score, bool) {
+ return score{s.opponent, s.player + s.thisTurn, 0}, true
+}
+
+// A strategy chooses an action for any given score.
+type strategy func(score) action
+
+// stayAtK returns a strategy that rolls until thisTurn is at least k, then stays.
+func stayAtK(k int) strategy {
+ return func(s score) action {
+ if s.thisTurn >= k {
+ return stay
+ }
+ return roll
+ }
+}
+
+// play simulates a Pig game and returns the winner (0 or 1).
+func play(strategy0, strategy1 strategy) int {
+ strategies := []strategy{strategy0, strategy1}
+ var s score
+ var turnIsOver bool
+ currentPlayer := rand.Intn(2) // Randomly decide who plays first
+ for s.player+s.thisTurn < win {
+ action := strategies[currentPlayer](s)
+ s, turnIsOver = action(s)
+ if turnIsOver {
+ currentPlayer = (currentPlayer + 1) % 2
+ }
+ }
+ return currentPlayer
+}
+
+// roundRobin simulates a series of games between every pair of strategies.
+func roundRobin(strategies []strategy) ([]int, int) {
+ wins := make([]int, len(strategies))
+ for i := 0; i < len(strategies); i++ {
+ for j := i + 1; j < len(strategies); j++ {
+ for k := 0; k < gamesPerSeries; k++ {
+ winner := play(strategies[i], strategies[j])
+ if winner == 0 {
+ wins[i]++
+ } else {
+ wins[j]++
+ }
+ }
+ }
+ }
+ gamesPerStrategy := gamesPerSeries * (len(strategies) - 1) // no self play
+ return wins, gamesPerStrategy
+}
+
+// ratioString takes a list of integer values and returns a string that lists
+// each value and its percentage of the sum of all values.
+// e.g., ratios(1, 2, 3) = "1/6 (16.7%), 2/6 (33.3%), 3/6 (50.0%)"
+func ratioString(vals ...int) string {
+ total := 0
+ for _, val := range vals {
+ total += val
+ }
+ s := ""
+ for _, val := range vals {
+ if s != "" {
+ s += ", "
+ }
+ pct := 100 * float64(val) / float64(total)
+ s += fmt.Sprintf("%d/%d (%0.1f%%)", val, total, pct)
+ }
+ return s
+}
+
+func main() {
+ strategies := make([]strategy, win)
+ for k := range strategies {
+ strategies[k] = stayAtK(k + 1)
+ }
+ wins, games := roundRobin(strategies)
+
+ for k := range strategies {
+ fmt.Printf("Wins, losses staying at k =% 4d: %s\n",
+ k+1, ratioString(wins[k], games-wins[k]))
+ }
+}
diff --git a/_content/doc/codewalk/popout.png b/_content/doc/codewalk/popout.png
new file mode 100644
index 0000000..9c0c236
--- /dev/null
+++ b/_content/doc/codewalk/popout.png
Binary files differ
diff --git a/_content/doc/codewalk/sharemem.xml b/_content/doc/codewalk/sharemem.xml
new file mode 100644
index 0000000..8b47f12
--- /dev/null
+++ b/_content/doc/codewalk/sharemem.xml
@@ -0,0 +1,181 @@
+<codewalk title="Share Memory By Communicating">
+
+<step title="Introduction" src="doc/codewalk/urlpoll.go">
+Go's approach to concurrency differs from the traditional use of
+threads and shared memory. Philosophically, it can be summarized:
+<br/><br/>
+<i>Don't communicate by sharing memory; share memory by communicating.</i>
+<br/><br/>
+Channels allow you to pass references to data structures between goroutines.
+If you consider this as passing around ownership of the data (the ability to
+read and write it), they become a powerful and expressive synchronization
+mechanism.
+<br/><br/>
+In this codewalk we will look at a simple program that polls a list of
+URLs, checking their HTTP response codes and periodically printing their state.
+</step>
+
+<step title="State type" src="doc/codewalk/urlpoll.go:/State/,/}/">
+The State type represents the state of a URL.
+<br/><br/>
+The Pollers send State values to the StateMonitor,
+which maintains a map of the current state of each URL.
+</step>
+
+<step title="Resource type" src="doc/codewalk/urlpoll.go:/Resource/,/}/">
+A Resource represents the state of a URL to be polled: the URL itself
+and the number of errors encountered since the last successful poll.
+<br/><br/>
+When the program starts, it allocates one Resource for each URL.
+The main goroutine and the Poller goroutines send the Resources to
+each other on channels.
+</step>
+
+<step title="Poller function" src="doc/codewalk/urlpoll.go:/func Poller/,/\n}/">
+Each Poller receives Resource pointers from an input channel.
+In this program, the convention is that sending a Resource pointer on
+a channel passes ownership of the underlying data from the sender
+to the receiver. Because of this convention, we know that
+no two goroutines will access this Resource at the same time.
+This means we don't have to worry about locking to prevent concurrent
+access to these data structures.
+<br/><br/>
+The Poller processes the Resource by calling its Poll method.
+<br/><br/>
+It sends a State value to the status channel, to inform the StateMonitor
+of the result of the Poll.
+<br/><br/>
+Finally, it sends the Resource pointer to the out channel. This can be
+interpreted as the Poller saying "I'm done with this Resource" and
+returning ownership of it to the main goroutine.
+<br/><br/>
+Several goroutines run Pollers, processing Resources in parallel.
+</step>
+
+<step title="The Poll method" src="doc/codewalk/urlpoll.go:/Poll executes/,/\n}/">
+The Poll method (of the Resource type) performs an HTTP HEAD request
+for the Resource's URL and returns the HTTP response's status code.
+If an error occurs, Poll logs the message to standard error and returns the
+error string instead.
+</step>
+
+<step title="main function" src="doc/codewalk/urlpoll.go:/func main/,/\n}/">
+The main function starts the Poller and StateMonitor goroutines
+and then loops passing completed Resources back to the pending
+channel after appropriate delays.
+</step>
+
+<step title="Creating channels" src="doc/codewalk/urlpoll.go:/Create our/,/complete/">
+First, main makes two channels of *Resource, pending and complete.
+<br/><br/>
+Inside main, a new goroutine sends one Resource per URL to pending
+and the main goroutine receives completed Resources from complete.
+<br/><br/>
+The pending and complete channels are passed to each of the Poller
+goroutines, within which they are known as in and out.
+</step>
+
+<step title="Initializing StateMonitor" src="doc/codewalk/urlpoll.go:/Launch the StateMonitor/,/statusInterval/">
+StateMonitor will initialize and launch a goroutine that stores the state
+of each Resource. We will look at this function in detail later.
+<br/><br/>
+For now, the important thing to note is that it returns a channel of State,
+which is saved as status and passed to the Poller goroutines.
+</step>
+
+<step title="Launching Poller goroutines" src="doc/codewalk/urlpoll.go:/Launch some Poller/,/}/">
+Now that it has the necessary channels, main launches a number of
+Poller goroutines, passing the channels as arguments.
+The channels provide the means of communication between the main, Poller, and
+StateMonitor goroutines.
+</step>
+
+<step title="Send Resources to pending" src="doc/codewalk/urlpoll.go:/Send some Resources/,/}\(\)/">
+To add the initial work to the system, main starts a new goroutine
+that allocates and sends one Resource per URL to pending.
+<br/><br/>
+The new goroutine is necessary because unbuffered channel sends and
+receives are synchronous. That means these channel sends will block until
+the Pollers are ready to read from pending.
+<br/><br/>
+Were these sends performed in the main goroutine with fewer Pollers than
+channel sends, the program would reach a deadlock situation, because
+main would not yet be receiving from complete.
+<br/><br/>
+Exercise for the reader: modify this part of the program to read a list of
+URLs from a file. (You may want to move this goroutine into its own
+named function.)
+</step>
+
+<step title="Main Event Loop" src="doc/codewalk/urlpoll.go:/range complete/,/\n }/">
+When a Poller is done with a Resource, it sends it on the complete channel.
+This loop receives those Resource pointers from complete.
+For each received Resource, it starts a new goroutine calling
+the Resource's Sleep method. Using a new goroutine for each
+ensures that the sleeps can happen in parallel.
+<br/><br/>
+Note that any single Resource pointer may only be sent on either pending or
+complete at any one time. This ensures that a Resource is either being
+handled by a Poller goroutine or sleeping, but never both simultaneously.
+In this way, we share our Resource data by communicating.
+</step>
+
+<step title="The Sleep method" src="doc/codewalk/urlpoll.go:/Sleep/,/\n}/">
+Sleep calls time.Sleep to pause before sending the Resource to done.
+The pause will either be of a fixed length (pollInterval) plus an
+additional delay proportional to the number of sequential errors (r.errCount).
+<br/><br/>
+This is an example of a typical Go idiom: a function intended to run inside
+a goroutine takes a channel, upon which it sends its return value
+(or other indication of completed state).
+</step>
+
+<step title="StateMonitor" src="doc/codewalk/urlpoll.go:/StateMonitor/,/\n}/">
+The StateMonitor receives State values on a channel and periodically
+outputs the state of all Resources being polled by the program.
+</step>
+
+<step title="The updates channel" src="doc/codewalk/urlpoll.go:/updates :=/">
+The variable updates is a channel of State, on which the Poller goroutines
+send State values.
+<br/><br/>
+This channel is returned by the function.
+</step>
+
+<step title="The urlStatus map" src="doc/codewalk/urlpoll.go:/urlStatus/">
+The variable urlStatus is a map of URLs to their most recent status.
+</step>
+
+<step title="The Ticker object" src="doc/codewalk/urlpoll.go:/ticker/">
+A time.Ticker is an object that repeatedly sends a value on a channel at a
+specified interval.
+<br/><br/>
+In this case, ticker triggers the printing of the current state to
+standard output every updateInterval nanoseconds.
+</step>
+
+<step title="The StateMonitor goroutine" src="doc/codewalk/urlpoll.go:/go func/,/}\(\)/">
+StateMonitor will loop forever, selecting on two channels:
+ticker.C and update. The select statement blocks until one of its
+communications is ready to proceed.
+<br/><br/>
+When StateMonitor receives a tick from ticker.C, it calls logState to
+print the current state. When it receives a State update from updates,
+it records the new status in the urlStatus map.
+<br/><br/>
+Notice that this goroutine owns the urlStatus data structure,
+ensuring that it can only be accessed sequentially.
+This prevents memory corruption issues that might arise from parallel reads
+and/or writes to a shared map.
+</step>
+
+<step title="Conclusion" src="doc/codewalk/urlpoll.go">
+In this codewalk we have explored a simple example of using Go's concurrency
+primitives to share memory through communication.
+<br/><br/>
+This should provide a starting point from which to explore the ways in which
+goroutines and channels can be used to write expressive and concise concurrent
+programs.
+</step>
+
+</codewalk>
diff --git a/_content/doc/codewalk/urlpoll.go b/_content/doc/codewalk/urlpoll.go
new file mode 100644
index 0000000..1fb9958
--- /dev/null
+++ b/_content/doc/codewalk/urlpoll.go
@@ -0,0 +1,116 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "log"
+ "net/http"
+ "time"
+)
+
+const (
+ numPollers = 2 // number of Poller goroutines to launch
+ pollInterval = 60 * time.Second // how often to poll each URL
+ statusInterval = 10 * time.Second // how often to log status to stdout
+ errTimeout = 10 * time.Second // back-off timeout on error
+)
+
+var urls = []string{
+ "http://www.google.com/",
+ "http://golang.org/",
+ "http://blog.golang.org/",
+}
+
+// State represents the last-known state of a URL.
+type State struct {
+ url string
+ status string
+}
+
+// StateMonitor maintains a map that stores the state of the URLs being
+// polled, and prints the current state every updateInterval nanoseconds.
+// It returns a chan State to which resource state should be sent.
+func StateMonitor(updateInterval time.Duration) chan<- State {
+ updates := make(chan State)
+ urlStatus := make(map[string]string)
+ ticker := time.NewTicker(updateInterval)
+ go func() {
+ for {
+ select {
+ case <-ticker.C:
+ logState(urlStatus)
+ case s := <-updates:
+ urlStatus[s.url] = s.status
+ }
+ }
+ }()
+ return updates
+}
+
+// logState prints a state map.
+func logState(s map[string]string) {
+ log.Println("Current state:")
+ for k, v := range s {
+ log.Printf(" %s %s", k, v)
+ }
+}
+
+// Resource represents an HTTP URL to be polled by this program.
+type Resource struct {
+ url string
+ errCount int
+}
+
+// Poll executes an HTTP HEAD request for url
+// and returns the HTTP status string or an error string.
+func (r *Resource) Poll() string {
+ resp, err := http.Head(r.url)
+ if err != nil {
+ log.Println("Error", r.url, err)
+ r.errCount++
+ return err.Error()
+ }
+ r.errCount = 0
+ return resp.Status
+}
+
+// Sleep sleeps for an appropriate interval (dependent on error state)
+// before sending the Resource to done.
+func (r *Resource) Sleep(done chan<- *Resource) {
+ time.Sleep(pollInterval + errTimeout*time.Duration(r.errCount))
+ done <- r
+}
+
+func Poller(in <-chan *Resource, out chan<- *Resource, status chan<- State) {
+ for r := range in {
+ s := r.Poll()
+ status <- State{r.url, s}
+ out <- r
+ }
+}
+
+func main() {
+ // Create our input and output channels.
+ pending, complete := make(chan *Resource), make(chan *Resource)
+
+ // Launch the StateMonitor.
+ status := StateMonitor(statusInterval)
+
+ // Launch some Poller goroutines.
+ for i := 0; i < numPollers; i++ {
+ go Poller(pending, complete, status)
+ }
+
+ // Send some Resources to the pending queue.
+ go func() {
+ for _, url := range urls {
+ pending <- &Resource{url: url}
+ }
+ }()
+
+ for r := range complete {
+ go r.Sleep(pending)
+ }
+}
diff --git a/_content/doc/conduct.html b/_content/doc/conduct.html
new file mode 100644
index 0000000..d959943
--- /dev/null
+++ b/_content/doc/conduct.html
@@ -0,0 +1,210 @@
+<!--{
+ "Title": "Go Community Code of Conduct",
+ "Path": "/conduct"
+}-->
+
+<style>
+ul {
+ max-width: 800px;
+}
+ul ul {
+ margin: 0 0 5px;
+}
+</style>
+
+<h2 id="about">About</h2>
+
+<p>
+Online communities include people from many different backgrounds.
+The Go contributors are committed to providing a friendly, safe and welcoming
+environment for all, regardless of gender identity and expression, sexual orientation,
+disabilities, neurodiversity, physical appearance, body size, ethnicity, nationality,
+race, age, religion, or similar personal characteristics.
+</p>
+
+<p>
+The first goal of the Code of Conduct is to specify a baseline standard
+of behavior so that people with different social values and communication
+styles can talk about Go effectively, productively, and respectfully.
+</p>
+
+<p>
+The second goal is to provide a mechanism for resolving conflicts in the
+community when they arise.
+</p>
+
+<p>
+The third goal of the Code of Conduct is to make our community welcoming to
+people from different backgrounds.
+Diversity is critical to the project; for Go to be successful, it needs
+contributors and users from all backgrounds.
+(See <a href="https://blog.golang.org/open-source">Go, Open Source, Community</a>.)
+</p>
+
+<p>
+We believe that healthy debate and disagreement are essential to a healthy project and community.
+However, it is never ok to be disrespectful.
+We value diverse opinions, but we value respectful behavior more.
+</p>
+
+<h2 id="values">Gopher values</h2>
+
+<p>
+These are the values to which people in the Go community (“Gophers”) should aspire.
+</p>
+
+<ul>
+<li>Be friendly and welcoming
+<li>Be patient
+ <ul>
+ <li>Remember that people have varying communication styles and that not
+ everyone is using their native language.
+ (Meaning and tone can be lost in translation.)
+ </ul>
+<li>Be thoughtful
+ <ul>
+ <li>Productive communication requires effort.
+ Think about how your words will be interpreted.
+ <li>Remember that sometimes it is best to refrain entirely from commenting.
+ </ul>
+<li>Be respectful
+ <ul>
+ <li>In particular, respect differences of opinion.
+ </ul>
+<li>Be charitable
+ <ul>
+ <li>Interpret the arguments of others in good faith, do not seek to disagree.
+ <li>When we do disagree, try to understand why.
+ </ul>
+<li>Avoid destructive behavior:
+ <ul>
+ <li>Derailing: stay on topic; if you want to talk about something else,
+ start a new conversation.
+ <li>Unconstructive criticism: don't merely decry the current state of affairs;
+ offer—or at least solicit—suggestions as to how things may be improved.
+ <li>Snarking (pithy, unproductive, sniping comments)
+ <li>Discussing potentially offensive or sensitive issues;
+ this all too often leads to unnecessary conflict.
+ <li>Microaggressions: brief and commonplace verbal, behavioral and
+ environmental indignities that communicate hostile, derogatory or negative
+ slights and insults to a person or group.
+ </ul>
+</ul>
+
+<p>
+People are complicated.
+You should expect to be misunderstood and to misunderstand others;
+when this inevitably occurs, resist the urge to be defensive or assign blame.
+Try not to take offense where no offense was intended.
+Give people the benefit of the doubt.
+Even if the intent was to provoke, do not rise to it.
+It is the responsibility of <i>all parties</i> to de-escalate conflict when it arises.
+</p>
+
+<h2 id="code">Code of Conduct</h2>
+
+<h3 id="our-pledge">Our Pledge</h3>
+
+<p>In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of
+experience, education, socio-economic status, nationality, personal appearance,
+race, religion, or sexual identity and orientation.</p>
+
+<h3 id="our-standards">Our Standards</h3>
+
+<p>Examples of behavior that contributes to creating a positive environment
+include:</p>
+
+<ul>
+<li>Using welcoming and inclusive language</li>
+<li>Being respectful of differing viewpoints and experiences</li>
+<li>Gracefully accepting constructive criticism</li>
+<li>Focusing on what is best for the community</li>
+<li>Showing empathy towards other community members</li>
+</ul>
+
+<p>Examples of unacceptable behavior by participants include:</p>
+
+<ul>
+<li>The use of sexualized language or imagery and unwelcome sexual attention or
+advances</li>
+<li>Trolling, insulting/derogatory comments, and personal or political attacks</li>
+<li>Public or private harassment</li>
+<li>Publishing others’ private information, such as a physical or electronic
+address, without explicit permission</li>
+<li>Other conduct which could reasonably be considered inappropriate in a
+professional setting</li>
+</ul>
+
+<h3 id="our-responsibilities">Our Responsibilities</h3>
+
+<p>Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.</p>
+
+<p>Project maintainers have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, or to ban temporarily or permanently any
+contributor for other behaviors that they deem inappropriate, threatening,
+offensive, or harmful.</p>
+
+<h3 id="scope">Scope</h3>
+
+<p>This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.</p>
+
+<p>This Code of Conduct also applies outside the project spaces when the Project
+Stewards have a reasonable belief that an individual’s behavior may have a
+negative impact on the project or its community.</p>
+
+<h3 id="conflict-resolution"></a>Conflict Resolution</h3>
+
+<p>We do not believe that all conflict is bad; healthy debate and disagreement
+often yield positive results. However, it is never okay to be disrespectful or
+to engage in behavior that violates the project’s code of conduct.</p>
+
+<p>If you see someone violating the code of conduct, you are encouraged to address
+the behavior directly with those involved. Many issues can be resolved quickly
+and easily, and this gives people more control over the outcome of their
+dispute. If you are unable to resolve the matter for any reason, or if the
+behavior is threatening or harassing, report it. We are dedicated to providing
+an environment where participants feel welcome and safe.</p>
+
+<p id="reporting">Reports should be directed to Carmen Andoh and Van Riper, the
+Go Project Stewards, at <i>conduct@golang.org</i>.
+It is the Project Stewards’ duty to
+receive and address reported violations of the code of conduct. They will then
+work with a committee consisting of representatives from the Open Source
+Programs Office and the Google Open Source Strategy team. If for any reason you
+are uncomfortable reaching out to the Project Stewards, please email
+the Google Open Source Programs Office at <i>opensource@google.com</i>.</p>
+
+<p>We will investigate every complaint, but you may not receive a direct response.
+We will use our discretion in determining when and how to follow up on reported
+incidents, which may range from not taking action to permanent expulsion from
+the project and project-sponsored spaces. We will notify the accused of the
+report and provide them an opportunity to discuss it before any action is taken.
+The identity of the reporter will be omitted from the details of the report
+supplied to the accused. In potentially harmful situations, such as ongoing
+harassment or threats to anyone’s safety, we may take action without notice.</p>
+
+<h3 id="attribution">Attribution</h3>
+
+<p>This Code of Conduct is adapted from the Contributor Covenant, version 1.4,
+available at
+<a href="https://www.contributor-covenant.org/version/1/4/code-of-conduct.html">https://www.contributor-covenant.org/version/1/4/code-of-conduct.html</a></p>
+
+<h2 id="summary">Summary</h2>
+
+<ul>
+<li>Treat everyone with respect and kindness.
+<li>Be thoughtful in how you communicate.
+<li>Don’t be destructive or inflammatory.
+<li>If you encounter an issue, please mail <a href="mailto:conduct@golang.org">conduct@golang.org</a>.
+</ul>
diff --git a/_content/doc/contrib.html b/_content/doc/contrib.html
new file mode 100644
index 0000000..5d129df
--- /dev/null
+++ b/_content/doc/contrib.html
@@ -0,0 +1,122 @@
+<!--{
+ "Title": "The Go Project",
+ "Path": "/project/",
+ "Template": true
+}-->
+
+<img class="gopher" src="/doc/gopher/project.png" alt="" />
+
+<div id="manual-nav"></div>
+
+<p>
+Go is an open source project developed by a team at
+<a href="//google.com/">Google</a> and many
+<a href="/CONTRIBUTORS">contributors</a> from the open source community.
+</p>
+
+<p>
+Go is distributed under a <a href="/LICENSE">BSD-style license</a>.
+</p>
+
+<h3 id="announce"><a href="//groups.google.com/group/golang-announce">Announcements Mailing List</a></h3>
+<p>
+A low traffic mailing list for important announcements, such as new releases.
+</p>
+<p>
+We encourage all Go users to subscribe to
+<a href="//groups.google.com/group/golang-announce">golang-announce</a>.
+</p>
+
+
+<h2 id="go1">Version history</h2>
+
+<h3 id="release"><a href="/doc/devel/release.html">Release History</a></h3>
+
+<p>A <a href="/doc/devel/release.html">summary</a> of the changes between Go releases. Notes for the major releases:</p>
+
+<ul>
+ {{range releases -}}
+ <li><a href="/doc/go{{.Version}}">Go {{.Version}}</a> <small>({{.Date.Format "January 2006"}})</small></li>
+ {{end -}}
+</ul>
+
+<h3 id="go1compat"><a href="/doc/go1compat">Go 1 and the Future of Go Programs</a></h3>
+<p>
+What Go 1 defines and the backwards-compatibility guarantees one can expect as
+Go 1 matures.
+</p>
+
+
+<h2 id="resources">Developer Resources</h2>
+
+<h3 id="source"><a href="https://golang.org/change">Source Code</a></h3>
+<p>Check out the Go source code.</p>
+
+<h3 id="discuss"><a href="//groups.google.com/group/golang-nuts">Discussion Mailing List</a></h3>
+<p>
+A mailing list for general discussion of Go programming.
+</p>
+<p>
+Questions about using Go or announcements relevant to other Go users should be sent to
+<a href="//groups.google.com/group/golang-nuts">golang-nuts</a>.
+</p>
+
+<h3 id="golang-dev"><a href="https://groups.google.com/group/golang-dev">Developer</a> and
+<a href="https://groups.google.com/group/golang-codereviews">Code Review Mailing List</a></h3>
+<p>The <a href="https://groups.google.com/group/golang-dev">golang-dev</a>
+mailing list is for discussing code changes to the Go project.
+The <a href="https://groups.google.com/group/golang-codereviews">golang-codereviews</a>
+mailing list is for actual reviewing of the code changes (CLs).</p>
+
+<h3 id="golang-checkins"><a href="https://groups.google.com/group/golang-checkins">Checkins Mailing List</a></h3>
+<p>A mailing list that receives a message summarizing each checkin to the Go repository.</p>
+
+<h3 id="build_status"><a href="//build.golang.org/">Build Status</a></h3>
+<p>View the status of Go builds across the supported operating
+systems and architectures.</p>
+
+
+<h2 id="howto">How you can help</h2>
+
+<h3><a href="//golang.org/issue">Reporting issues</a></h3>
+
+<p>
+If you spot bugs, mistakes, or inconsistencies in the Go project's code or
+documentation, please let us know by
+<a href="//golang.org/issue/new">filing a ticket</a>
+on our <a href="//golang.org/issue">issue tracker</a>.
+(Of course, you should check it's not an existing issue before creating
+a new one.)
+</p>
+
+<p>
+We pride ourselves on being meticulous; no issue is too small.
+</p>
+
+<p>
+Security-related issues should be reported to
+<a href="mailto:security@golang.org">security@golang.org</a>.<br>
+See the <a href="/security">security policy</a> for more details.
+</p>
+
+<p>
+Community-related issues should be reported to
+<a href="mailto:conduct@golang.org">conduct@golang.org</a>.<br>
+See the <a href="/conduct">Code of Conduct</a> for more details.
+</p>
+
+<h3><a href="/doc/contribute.html">Contributing code & documentation</a></h3>
+
+<p>
+Go is an open source project and we welcome contributions from the community.
+</p>
+<p>
+To get started, read these <a href="/doc/contribute.html">contribution
+guidelines</a> for information on design, testing, and our code review process.
+</p>
+<p>
+Check <a href="//golang.org/issue">the tracker</a> for
+open issues that interest you. Those labeled
+<a href="https://github.com/golang/go/issues?q=is%3Aopen+is%3Aissue+label%3A%22help+wanted%22">help wanted</a>
+are particularly in need of outside help.
+</p>
diff --git a/_content/doc/contribute.html b/_content/doc/contribute.html
new file mode 100644
index 0000000..94f2233
--- /dev/null
+++ b/_content/doc/contribute.html
@@ -0,0 +1,1294 @@
+<!--{
+ "Title": "Contribution Guide"
+}-->
+
+<p>
+The Go project welcomes all contributors.
+</p>
+
+<p>
+This document is a guide to help you through the process
+of contributing to the Go project, which is a little different
+from that used by other open source projects.
+We assume you have a basic understanding of Git and Go.
+</p>
+
+<p>
+In addition to the information here, the Go community maintains a
+<a href="https://golang.org/wiki/CodeReview">CodeReview</a> wiki page.
+Feel free to contribute to the wiki as you learn the review process.
+</p>
+
+<p>
+Note that the <code>gccgo</code> front end lives elsewhere;
+see <a href="gccgo_contribute.html">Contributing to gccgo</a>.
+</p>
+
+<h2 id="contributor">Becoming a contributor</h2>
+
+<h3 id="contrib_overview">Overview</h3>
+
+<p>
+The first step is registering as a Go contributor and configuring your environment.
+Here is a checklist of the required steps to follow:
+</p>
+
+<ul>
+<li>
+<b>Step 0</b>: Decide on a single Google Account you will be using to contribute to Go.
+Use that account for all the following steps and make sure that <code>git</code>
+is configured to create commits with that account's e-mail address.
+</li>
+<li>
+<b>Step 1</b>: <a href="https://cla.developers.google.com/clas">Sign and submit</a> a
+CLA (Contributor License Agreement).
+</li>
+<li>
+<b>Step 2</b>: Configure authentication credentials for the Go Git repository.
+Visit <a href="https://go.googlesource.com">go.googlesource.com</a>, click
+"Generate Password" in the page's top right menu bar, and follow the
+instructions.
+</li>
+<li>
+<b>Step 3</b>: Register for Gerrit, the code review tool used by the Go team,
+by <a href="https://go-review.googlesource.com/login/">visiting this page</a>.
+The CLA and the registration need to be done only once for your account.
+</li>
+<li>
+<b>Step 4</b>: Install <code>git-codereview</code> by running
+<code>go get -u golang.org/x/review/git-codereview</code>
+</li>
+</ul>
+
+<p>
+If you prefer, there is an automated tool that walks through these steps.
+Just run:
+</p>
+
+<pre>
+$ go get -u golang.org/x/tools/cmd/go-contrib-init
+$ cd /code/to/edit
+$ go-contrib-init
+</pre>
+
+<p>
+The rest of this chapter elaborates on these instructions.
+If you have completed the steps above (either manually or through the tool), jump to
+<a href="#before_contributing">Before contributing code</a>.
+</p>
+
+<h3 id="google_account">Step 0: Select a Google Account</h3>
+
+<p>
+A contribution to Go is made through a Google account with a specific
+e-mail address.
+Make sure to use the same account throughout the process and
+for all your subsequent contributions.
+You may need to decide whether to use a personal address or a corporate address.
+The choice will depend on who
+will own the copyright for the code that you will be writing
+and submitting.
+You might want to discuss this topic with your employer before deciding which
+account to use.
+</p>
+
+<p>
+Google accounts can either be Gmail e-mail accounts, G Suite organization accounts, or
+accounts associated with an external e-mail address.
+For instance, if you need to use
+an existing corporate e-mail that is not managed through G Suite, you can create
+an account associated
+<a href="https://accounts.google.com/SignUpWithoutGmail">with your existing
+e-mail address</a>.
+</p>
+
+<p>
+You also need to make sure that your Git tool is configured to create commits
+using your chosen e-mail address.
+You can either configure Git globally
+(as a default for all projects), or locally (for a single specific project).
+You can check the current configuration with this command:
+</p>
+
+<pre>
+$ git config --global user.email # check current global config
+$ git config user.email # check current local config
+</pre>
+
+<p>
+To change the configured address:
+</p>
+
+<pre>
+$ git config --global user.email name@example.com # change global config
+$ git config user.email name@example.com # change local config
+</pre>
+
+
+<h3 id="cla">Step 1: Contributor License Agreement</h3>
+
+<p>
+Before sending your first change to the Go project
+you must have completed one of the following two CLAs.
+Which CLA you should sign depends on who owns the copyright to your work.
+</p>
+
+<ul>
+<li>
+If you are the copyright holder, you will need to agree to the
+<a href="https://developers.google.com/open-source/cla/individual">individual
+contributor license agreement</a>, which can be completed online.
+</li>
+<li>
+If your organization is the copyright holder, the organization
+will need to agree to the
+<a href="https://developers.google.com/open-source/cla/corporate">corporate
+contributor license agreement</a>.<br>
+</li>
+</ul>
+
+<p>
+You can check your currently signed agreements and sign new ones at
+the <a href="https://cla.developers.google.com/clas?pli=1&authuser=1">Google Developers
+Contributor License Agreements</a> website.
+If the copyright holder for your contribution has already completed the
+agreement in connection with another Google open source project,
+it does not need to be completed again.
+</p>
+
+<p>
+If the copyright holder for the code you are submitting changes—for example,
+if you start contributing code on behalf of a new company—please send mail
+to the <a href="mailto:golang-dev@googlegroups.com"><code>golang-dev</code>
+mailing list</a>.
+This will let us know the situation so we can make sure an appropriate agreement is
+completed and update the <code>AUTHORS</code> file.
+</p>
+
+
+<h3 id="config_git_auth">Step 2: Configure git authentication</h3>
+
+<p>
+The main Go repository is located at
+<a href="https://go.googlesource.com">go.googlesource.com</a>,
+a Git server hosted by Google.
+Authentication on the web server is made through your Google account, but
+you also need to configure <code>git</code> on your computer to access it.
+Follow these steps:
+</p>
+
+<ol>
+<li>
+Visit <a href="https://go.googlesource.com">go.googlesource.com</a>
+and click on "Generate Password" in the page's top right menu bar.
+You will be redirected to accounts.google.com to sign in.
+</li>
+<li>
+After signing in, you will be taken to a page with the title "Configure Git".
+This page contains a personalized script that when run locally will configure Git
+to hold your unique authentication key.
+This key is paired with one that is generated and stored on the server,
+analogous to how SSH keys work.
+</li>
+<li>
+Copy and run this script locally in your terminal to store your secret
+authentication token in a <code>.gitcookies</code> file.
+If you are using a Windows computer and running <code>cmd</code>,
+you should instead follow the instructions in the yellow box to run the command;
+otherwise run the regular script.
+</li>
+</ol>
+
+<h3 id="auth">Step 3: Create a Gerrit account </h3>
+
+<p>
+Gerrit is an open-source tool used by Go maintainers to discuss and review
+code submissions.
+</p>
+
+<p>
+To register your account, visit <a href="https://go-review.googlesource.com/login/">
+go-review.googlesource.com/login/</a> and sign in once using the same Google Account you used above.
+</p>
+
+<h3 id="git-codereview_install">Step 4: Install the git-codereview command</h3>
+
+<p>
+Changes to Go must be reviewed before they are accepted, no matter who makes the change.
+A custom <code>git</code> command called <code>git-codereview</code>
+simplifies sending changes to Gerrit.
+</p>
+
+<p>
+Install the <code>git-codereview</code> command by running,
+</p>
+
+<pre>
+$ go get -u golang.org/x/review/git-codereview
+</pre>
+
+<p>
+Make sure <code>git-codereview</code> is installed in your shell path, so that the
+<code>git</code> command can find it.
+Check that
+</p>
+
+<pre>
+$ git codereview help
+</pre>
+
+<p>
+prints help text, not an error. If it prints an error, make sure that
+<code>$GOPATH/bin</code> is in your <code>$PATH</code>.
+</p>
+
+<p>
+On Windows, when using git-bash you must make sure that
+<code>git-codereview.exe</code> is in your <code>git</code> exec-path.
+Run <code>git --exec-path</code> to discover the right location then create a
+symbolic link or just copy the executable from <code>$GOPATH/bin</code> to this
+directory.
+</p>
+
+
+<h2 id="before_contributing">Before contributing code</h2>
+
+<p>
+The project welcomes code patches, but to make sure things are well
+coordinated you should discuss any significant change before starting
+the work.
+It's recommended that you signal your intention to contribute in the
+issue tracker, either by <a href="https://golang.org/issue/new">filing
+a new issue</a> or by claiming
+an <a href="https://golang.org/issues">existing one</a>.
+</p>
+
+<h3 id="where">Where to contribute</h3>
+
+<p>
+The Go project consists of the main
+<a href="https://go.googlesource.com/go">go</a> repository, which contains the
+source code for the Go language, as well as many golang.org/x/... repositories.
+These contain the various tools and infrastructure that support Go. For
+example, <a href="https://go.googlesource.com/pkgsite">golang.org/x/pkgsite</a>
+is for <a href="https://pkg.go.dev">pkg.go.dev</a>,
+<a href="https://go.googlesource.com/playground">golang.org/x/playground</a>
+is for the Go playground, and
+<a href="https://go.googlesource.com/tools">golang.org/x/tools</a> contains
+a variety of Go tools, including the Go language server,
+<a href="https://golang.org/s/gopls">gopls</a>. You can see a
+list of all the golang.org/x/... repositories on
+<a href="https://go.googlesource.com">go.googlesource.com</a>.
+</p>
+
+<h3 id="check_tracker">Check the issue tracker</h3>
+
+<p>
+Whether you already know what contribution to make, or you are searching for
+an idea, the <a href="https://github.com/golang/go/issues">issue tracker</a> is
+always the first place to go.
+Issues are triaged to categorize them and manage the workflow.
+</p>
+
+<p>
+The majority of the golang.org/x/... repos also use the main Go
+issue tracker. However, a few of these repositories manage their issues
+separately, so please be sure to check the right tracker for the repository to
+which you would like to contribute.
+</p>
+
+<p>
+Most issues will be marked with one of the following workflow labels:
+</p>
+
+<ul>
+ <li>
+ <b>NeedsInvestigation</b>: The issue is not fully understood
+ and requires analysis to understand the root cause.
+ </li>
+ <li>
+ <b>NeedsDecision</b>: the issue is relatively well understood, but the
+ Go team hasn't yet decided the best way to address it.
+ It would be better to wait for a decision before writing code.
+ If you are interested in working on an issue in this state,
+ feel free to "ping" maintainers in the issue's comments
+ if some time has passed without a decision.
+ </li>
+ <li>
+ <b>NeedsFix</b>: the issue is fully understood and code can be written
+ to fix it.
+ </li>
+</ul>
+
+<p>
+You can use GitHub's search functionality to find issues to help out with. Examples:
+</p>
+
+<ul>
+ <li>
+ Issues that need investigation: <a href="https://github.com/golang/go/issues?q=is%3Aissue+is%3Aopen+label%3ANeedsInvestigation"><code>is:issue is:open label:NeedsInvestigation</code></a>
+ </li>
+ <li>
+ Issues that need a fix: <a href="https://github.com/golang/go/issues?q=is%3Aissue+is%3Aopen+label%3ANeedsFix"><code>is:issue is:open label:NeedsFix</code></a>
+ </li>
+ <li>
+ Issues that need a fix and have a CL: <a href="https://github.com/golang/go/issues?q=is%3Aissue+is%3Aopen+label%3ANeedsFix+%22golang.org%2Fcl%22"><code>is:issue is:open label:NeedsFix "golang.org/cl"</code></a>
+ </li>
+ <li>
+ Issues that need a fix and do not have a CL: <a href="https://github.com/golang/go/issues?q=is%3Aissue+is%3Aopen+label%3ANeedsFix+NOT+%22golang.org%2Fcl%22"><code>is:issue is:open label:NeedsFix NOT "golang.org/cl"</code></a>
+ </li>
+</ul>
+
+<h3 id="design">Open an issue for any new problem</h3>
+
+<p>
+Excluding very trivial changes, all contributions should be connected
+to an existing issue.
+Feel free to open one and discuss your plans.
+This process gives everyone a chance to validate the design,
+helps prevent duplication of effort,
+and ensures that the idea fits inside the goals for the language and tools.
+It also checks that the design is sound before code is written;
+the code review tool is not the place for high-level discussions.
+</p>
+
+<p>
+When planning work, please note that the Go project follows a <a
+href="https://golang.org/wiki/Go-Release-Cycle">six-month development cycle</a>
+for the main Go repository. The latter half of each cycle is a three-month
+feature freeze during which only bug fixes and documentation updates are
+accepted. New contributions can be sent during a feature freeze, but they will
+not be merged until the freeze is over. The freeze applies to the entire main
+repository as well as to the code in golang.org/x/... repositories that is
+needed to build the binaries included in the release. See the lists of packages
+vendored into
+<a href="https://github.com/golang/go/blob/master/src/vendor/modules.txt">the standard library</a>
+and the <a href="https://github.com/golang/go/blob/master/src/cmd/vendor/modules.txt"><code>go</code> command</a>.
+</p>
+
+<p>
+Significant changes to the language, libraries, or tools must go
+through the
+<a href="https://golang.org/s/proposal-process">change proposal process</a>
+before they can be accepted.
+</p>
+
+<p>
+Sensitive security-related issues (only!) should be reported to <a href="mailto:security@golang.org">security@golang.org</a>.
+</p>
+
+<h2 id="sending_a_change_github">Sending a change via GitHub</h2>
+
+<p>
+First-time contributors that are already familiar with the
+<a href="https://guides.github.com/introduction/flow/">GitHub flow</a>
+are encouraged to use the same process for Go contributions.
+Even though Go
+maintainers use Gerrit for code review, a bot called Gopherbot has been created to sync
+GitHub pull requests to Gerrit.
+</p>
+
+<p>
+Open a pull request as you normally would.
+Gopherbot will create a corresponding Gerrit change and post a link to
+it on your GitHub pull request; updates to the pull request will also
+get reflected in the Gerrit change.
+When somebody comments on the change, their comment will be also
+posted in your pull request, so you will get a notification.
+</p>
+
+<p>
+Some things to keep in mind:
+</p>
+
+<ul>
+<li>
+To update the pull request with new code, just push it to the branch; you can either
+add more commits, or rebase and force-push (both styles are accepted).
+</li>
+<li>
+If the request is accepted, all commits will be squashed, and the final
+commit description will be composed by concatenating the pull request's
+title and description.
+The individual commits' descriptions will be discarded.
+See <a href="#commit_messages">Writing good commit messages</a> for some
+suggestions.
+</li>
+<li>
+Gopherbot is unable to sync line-by-line codereview into GitHub: only the
+contents of the overall comment on the request will be synced.
+Remember you can always visit Gerrit to see the fine-grained review.
+</li>
+</ul>
+
+<h2 id="sending_a_change_gerrit">Sending a change via Gerrit</h2>
+
+<p>
+It is not possible to fully sync Gerrit and GitHub, at least at the moment,
+so we recommend learning Gerrit.
+It's different but powerful and familiarity with it will help you understand
+the flow.
+</p>
+
+<h3 id="gerrit_overview">Overview</h3>
+
+<p>
+This is an overview of the overall process:
+</p>
+
+<ul>
+<li>
+<b>Step 1:</b> Clone the source code from <code>go.googlesource.com</code> and
+make sure it's stable by compiling and testing it once.
+
+<p>If you're making a change to the
+<a href="https://go.googlesource.com/go">main Go repository</a>:</p>
+
+<pre>
+$ git clone https://go.googlesource.com/go
+$ cd go/src
+$ ./all.bash # compile and test
+</pre>
+
+<p>
+If you're making a change to one of the golang.org/x/... repositories
+(<a href="https://go.googlesource.com/tools">golang.org/x/tools</a>,
+in this example):
+</p>
+
+<pre>
+$ git clone https://go.googlesource.com/tools
+$ cd tools
+$ go test ./... # compile and test
+</pre>
+</li>
+
+<li>
+<b>Step 2:</b> Prepare changes in a new branch, created from the master branch.
+To commit the changes, use <code>git</code> <code>codereview</code> <code>change</code>; that
+will create or amend a single commit in the branch.
+<pre>
+$ git checkout -b mybranch
+$ [edit files...]
+$ git add [files...]
+$ git codereview change # create commit in the branch
+$ [edit again...]
+$ git add [files...]
+$ git codereview change # amend the existing commit with new changes
+$ [etc.]
+</pre>
+</li>
+
+<li>
+<b>Step 3:</b> Test your changes, either by running the tests in the package
+you edited or by re-running <code>all.bash</code>.
+
+<p>In the main Go repository:</p>
+<pre>
+$ ./all.bash # recompile and test
+</pre>
+
+<p>In a golang.org/x/... repository:</p>
+<pre>
+$ go test ./... # recompile and test
+</pre>
+</li>
+
+<li>
+<b>Step 4:</b> Send the changes for review to Gerrit using <code>git</code>
+<code>codereview</code> <code>mail</code> (which doesn't use e-mail, despite the name).
+<pre>
+$ git codereview mail # send changes to Gerrit
+</pre>
+</li>
+
+<li>
+<b>Step 5:</b> After a review, apply changes to the same single commit
+and mail them to Gerrit again:
+<pre>
+$ [edit files...]
+$ git add [files...]
+$ git codereview change # update same commit
+$ git codereview mail # send to Gerrit again
+</pre>
+</li>
+</ul>
+
+<p>
+The rest of this section describes these steps in more detail.
+</p>
+
+
+<h3 id="checkout_go">Step 1: Clone the source code</h3>
+
+<p>
+In addition to a recent Go installation, you need to have a local copy of the source
+checked out from the correct repository.
+You can check out the Go source repo onto your local file system anywhere
+you want as long as it's outside your <code>GOPATH</code>.
+Clone from <code>go.googlesource.com</code> (not GitHub):
+</p>
+
+<p>Main Go repository:</p>
+<pre>
+$ git clone https://go.googlesource.com/go
+$ cd go
+</pre>
+
+<p>golang.org/x/... repository</p>
+(<a href="https://go.googlesource.com/tools">golang.org/x/tools</a> in this example):
+<pre>
+$ git clone https://go.googlesource.com/tools
+$ cd tools
+</pre>
+
+<h3 id="make_branch">Step 2: Prepare changes in a new branch</h3>
+
+<p>
+Each Go change must be made in a separate branch, created from the master branch.
+You can use
+the normal <code>git</code> commands to create a branch and add changes to the
+staging area:
+</p>
+
+<pre>
+$ git checkout -b mybranch
+$ [edit files...]
+$ git add [files...]
+</pre>
+
+<p>
+To commit changes, instead of <code>git commit</code>, use <code>git codereview change</code>.
+</p>
+
+<pre>
+$ git codereview change
+(open $EDITOR)
+</pre>
+
+<p>
+You can edit the commit description in your favorite editor as usual.
+The <code>git</code> <code>codereview</code> <code>change</code> command
+will automatically add a unique Change-Id line near the bottom.
+That line is used by Gerrit to match successive uploads of the same change.
+Do not edit or delete it.
+A Change-Id looks like this:
+</p>
+
+<pre>
+Change-Id: I2fbdbffb3aab626c4b6f56348861b7909e3e8990
+</pre>
+
+<p>
+The tool also checks that you've
+run <code>go</code> <code>fmt</code> over the source code, and that
+the commit message follows the <a href="#commit_messages">suggested format</a>.
+</p>
+
+<p>
+If you need to edit the files again, you can stage the new changes and
+re-run <code>git</code> <code>codereview</code> <code>change</code>: each subsequent
+run will amend the existing commit while preserving the Change-Id.
+</p>
+
+<p>
+Make sure that you always keep a single commit in each branch.
+If you add more
+commits by mistake, you can use <code>git</code> <code>rebase</code> to
+<a href="https://stackoverflow.com/questions/31668794/squash-all-your-commits-in-one-before-a-pull-request-in-github">squash them together</a>
+into a single one.
+</p>
+
+
+<h3 id="testing">Step 3: Test your changes</h3>
+
+<p>
+You've <a href="code.html">written and tested your code</a>, but
+before sending code out for review, run <i>all the tests for the whole
+tree</i> to make sure the changes don't break other packages or programs.
+</p>
+
+<h4 id="test-gorepo">In the main Go repository</h4>
+
+<p>This can be done by running <code>all.bash</code>:</p>
+
+<pre>
+$ cd go/src
+$ ./all.bash
+</pre>
+
+<p>
+(To build under Windows use <code>all.bat</code>)
+</p>
+
+<p>
+After running for a while and printing a lot of testing output, the command should finish
+by printing,
+</p>
+
+<pre>
+ALL TESTS PASSED
+</pre>
+
+<p>
+You can use <code>make.bash</code> instead of <code>all.bash</code>
+to just build the compiler and the standard library without running the test suite.
+Once the <code>go</code> tool is built, it will be installed as <code>bin/go</code>
+under the directory in which you cloned the Go repository, and you can
+run it directly from there.
+See also
+the section on how to <a href="#quick_test">test your changes quickly</a>.
+</p>
+
+<h4 id="test-xrepo">In the golang.org/x/... repositories</h4>
+
+<p>
+Run the tests for the entire repository
+(<a href="https://go.googlesource.com/tools">golang.org/x/tools</a>,
+in this example):
+</p>
+
+<pre>
+$ cd tools
+$ go test ./...
+</pre>
+
+<p>
+If you're concerned about the build status,
+you can check the <a href="https://build.golang.org">Build Dashboard</a>.
+Test failures may also be caught by the TryBots in code review.
+</p>
+
+<p>
+Some repositories, like
+<a href="https://go.googlesource.com/vscode-go">golang.org/x/vscode-go</a> will
+have different testing infrastructures, so always check the documentation
+for the repository in which you are working. The README file in the root of the
+repository will usually have this information.
+</p>
+
+<h3 id="mail">Step 4: Send changes for review</h3>
+
+<p>
+Once the change is ready and tested over the whole tree, send it for review.
+This is done with the <code>mail</code> sub-command which, despite its name, doesn't
+directly mail anything; it just sends the change to Gerrit:
+</p>
+
+<pre>
+$ git codereview mail
+</pre>
+
+<p>
+Gerrit assigns your change a number and URL, which <code>git</code> <code>codereview</code> <code>mail</code> will print, something like:
+</p>
+
+<pre>
+remote: New Changes:
+remote: https://go-review.googlesource.com/99999 math: improved Sin, Cos and Tan precision for very large arguments
+</pre>
+
+<p>
+If you get an error instead, check the
+<a href="#troubleshooting_mail">Troubleshooting mail errors</a> section.
+</p>
+
+<p>
+If your change relates to an open GitHub issue and you have followed the <a href="#commit_messages">
+suggested commit message format</a>, the issue will be updated in a few minutes by a bot,
+linking your Gerrit change to it in the comments.
+</p>
+
+
+<h3 id="revise">Step 5: Revise changes after a review</h3>
+
+<p>
+Go maintainers will review your code on Gerrit, and you will get notifications via e-mail.
+You can see the review on Gerrit and comment on them there.
+You can also reply
+<a href="https://gerrit-review.googlesource.com/Documentation/intro-user.html#reply-by-email">using e-mail</a>
+if you prefer.
+</p>
+
+<p>
+If you need to revise your change after the review, edit the files in
+the same branch you previously created, add them to the Git staging
+area, and then amend the commit with
+<code>git</code> <code>codereview</code> <code>change</code>:
+</p>
+
+<pre>
+$ git codereview change # amend current commit
+(open $EDITOR)
+$ git codereview mail # send new changes to Gerrit
+</pre>
+
+<p>
+If you don't need to change the commit description, just save and exit from the editor.
+Remember not to touch the special Change-Id line.
+</p>
+
+<p>
+Again, make sure that you always keep a single commit in each branch.
+If you add more
+commits by mistake, you can use <code>git rebase</code> to
+<a href="https://stackoverflow.com/questions/31668794/squash-all-your-commits-in-one-before-a-pull-request-in-github">squash them together</a>
+into a single one.
+</p>
+
+<h2 id="commit_messages">Good commit messages</h2>
+
+<p>
+Commit messages in Go follow a specific set of conventions,
+which we discuss in this section.
+</p>
+
+<p>
+Here is an example of a good one:
+</p>
+
+<pre>
+math: improve Sin, Cos and Tan precision for very large arguments
+
+The existing implementation has poor numerical properties for
+large arguments, so use the McGillicutty algorithm to improve
+accuracy above 1e10.
+
+The algorithm is described at https://wikipedia.org/wiki/McGillicutty_Algorithm
+
+Fixes #159
+</pre>
+
+<h3 id="first_line">First line</h3>
+
+<p>
+The first line of the change description is conventionally a short one-line
+summary of the change, prefixed by the primary affected package.
+</p>
+
+<p>
+A rule of thumb is that it should be written so to complete the sentence
+"This change modifies Go to _____."
+That means it does not start with a capital letter, is not a complete sentence,
+and actually summarizes the result of the change.
+</p>
+
+<p>
+Follow the first line by a blank line.
+</p>
+
+<h3 id="main_content">Main content</h3>
+
+<p>
+The rest of the description elaborates and should provide context for the
+change and explain what it does.
+Write in complete sentences with correct punctuation, just like
+for your comments in Go.
+Don't use HTML, Markdown, or any other markup language.
+</p>
+
+<p>
+Add any relevant information, such as benchmark data if the change
+affects performance.
+The <a href="https://godoc.org/golang.org/x/perf/cmd/benchstat">benchstat</a>
+tool is conventionally used to format
+benchmark data for change descriptions.
+</p>
+
+<h3 id="ref_issues">Referencing issues</h3>
+
+<p>
+The special notation "Fixes #12345" associates the change with issue 12345 in the
+<a href="https://golang.org/issue/12345">Go issue tracker</a>.
+When this change is eventually applied, the issue
+tracker will automatically mark the issue as fixed.
+</p>
+
+<p>
+If the change is a partial step towards the resolution of the issue,
+write "Updates #12345" instead.
+This will leave a comment in the issue linking back to the change in
+Gerrit, but it will not close the issue when the change is applied.
+</p>
+
+<p>
+If you are sending a change against a golang.org/x/... repository, you must use
+the fully-qualified syntax supported by GitHub to make sure the change is
+linked to the issue in the main repository, not the x/ repository.
+Most issues are tracked in the main repository's issue tracker.
+The correct form is "Fixes golang/go#159".
+</p>
+
+
+<h2 id="review">The review process</h2>
+
+<p>
+This section explains the review process in detail and how to approach
+reviews after a change has been mailed.
+</p>
+
+
+<h3 id="mistakes">Common beginner mistakes</h3>
+
+<p>
+When a change is sent to Gerrit, it is usually triaged within a few days.
+A maintainer will have a look and provide some initial review that for first-time
+contributors usually focuses on basic cosmetics and common mistakes.
+These include things like:
+</p>
+
+<ul>
+<li>
+Commit message not following the <a href="#commit_messages">suggested
+format</a>.
+</li>
+
+<li>
+The lack of a linked GitHub issue.
+The vast majority of changes
+require a linked issue that describes the bug or the feature that the change
+fixes or implements, and consensus should have been reached on the tracker
+before proceeding with it.
+Gerrit reviews do not discuss the merit of the change,
+just its implementation.
+<br>
+Only trivial or cosmetic changes will be accepted without an associated issue.
+</li>
+
+<li>
+Change sent during the freeze phase of the development cycle, when the tree
+is closed for general changes.
+In this case,
+a maintainer might review the code with a line such as <code>R=go1.12</code>,
+which means that it will be reviewed later when the tree opens for a new
+development window.
+You can add <code>R=go1.XX</code> as a comment yourself
+if you know that it's not the correct time frame for the change.
+</li>
+</ul>
+
+<h3 id="trybots">Trybots</h3>
+
+<p>
+After an initial reading of your change, maintainers will trigger trybots,
+a cluster of servers that will run the full test suite on several different
+architectures.
+Most trybots complete in a few minutes, at which point a link will
+be posted in Gerrit where you can see the results.
+</p>
+
+<p>
+If the trybot run fails, follow the link and check the full logs of the
+platforms on which the tests failed.
+Try to understand what broke, update your patch to fix it, and upload again.
+Maintainers will trigger a new trybot run to see
+if the problem was fixed.
+</p>
+
+<p>
+Sometimes, the tree can be broken on some platforms for a few hours; if
+the failure reported by the trybot doesn't seem related to your patch, go to the
+<a href="https://build.golang.org">Build Dashboard</a> and check if the same
+failure appears in other recent commits on the same platform.
+In this case,
+feel free to write a comment in Gerrit to mention that the failure is
+unrelated to your change, to help maintainers understand the situation.
+</p>
+
+<h3 id="reviews">Reviews</h3>
+
+<p>
+The Go community values very thorough reviews.
+Think of each review comment like a ticket: you are expected to somehow "close" it
+by acting on it, either by implementing the suggestion or convincing the
+reviewer otherwise.
+</p>
+
+<p>
+After you update the change, go through the review comments and make sure
+to reply to every one.
+You can click the "Done" button to reply
+indicating that you've implemented the reviewer's suggestion; otherwise,
+click on "Reply" and explain why you have not, or what you have done instead.
+</p>
+
+<p>
+It is perfectly normal for changes to go through several round of reviews,
+with one or more reviewers making new comments every time
+and then waiting for an updated change before reviewing again.
+This cycle happens even for experienced contributors, so
+don't be discouraged by it.
+</p>
+
+<h3 id="votes">Voting conventions</h3>
+
+<p>
+As they near a decision, reviewers will make a "vote" on your change.
+The Gerrit voting system involves an integer in the range -2 to +2:
+</p>
+
+<ul>
+ <li>
+ <b>+2</b> The change is approved for being merged.
+ Only Go maintainers can cast a +2 vote.
+ </li>
+ <li>
+ <b>+1</b> The change looks good, but either the reviewer is requesting
+ minor changes before approving it, or they are not a maintainer and cannot
+ approve it, but would like to encourage an approval.
+ </li>
+ <li>
+ <b>-1</b> The change is not good the way it is but might be fixable.
+ A -1 vote will always have a comment explaining why the change is unacceptable.
+ </li>
+ <li>
+ <b>-2</b> The change is blocked by a maintainer and cannot be approved.
+ Again, there will be a comment explaining the decision.
+ </li>
+</ul>
+
+<p>
+At least two maintainers must approve of the change, and at least one
+of those maintainers must +2 the change.
+The second maintainer may cast a vote of Trust+1, meaning that the
+change looks basically OK, but that the maintainer hasn't done the
+detailed review required for a +2 vote.
+</p>
+
+<h3 id="submit">Submitting an approved change</h3>
+
+<p>
+After the code has been +2'ed and Trust+1'ed, an approver will
+apply it to the master branch using the Gerrit user interface.
+This is called "submitting the change".
+</p>
+
+<p>
+The two steps (approving and submitting) are separate because in some cases maintainers
+may want to approve it but not to submit it right away (for instance,
+the tree could be temporarily frozen).
+</p>
+
+<p>
+Submitting a change checks it into the repository.
+The change description will include a link to the code review,
+which will be updated with a link to the change
+in the repository.
+Since the method used to integrate the changes is Git's "Cherry Pick",
+the commit hashes in the repository will be changed by
+the submit operation.
+</p>
+
+<p>
+If your change has been approved for a few days without being
+submitted, feel free to write a comment in Gerrit requesting
+submission.
+</p>
+
+
+<h3 id="more_information">More information</h3>
+
+<p>
+In addition to the information here, the Go community maintains a <a
+href="https://golang.org/wiki/CodeReview">CodeReview</a> wiki page.
+Feel free to contribute to this page as you learn more about the review process.
+</p>
+
+
+
+<h2 id="advanced_topics">Miscellaneous topics</h2>
+
+<p>
+This section collects a number of other comments that are
+outside the issue/edit/code review/submit process itself.
+</p>
+
+
+<h3 id="copyright">Copyright headers</h3>
+
+<p>
+Files in the Go repository don't list author names, both to avoid clutter
+and to avoid having to keep the lists up to date.
+Instead, your name will appear in the
+<a href="https://golang.org/change">change log</a> and in the <a
+href="/CONTRIBUTORS"><code>CONTRIBUTORS</code></a> file and perhaps the <a
+href="/AUTHORS"><code>AUTHORS</code></a> file.
+These files are automatically generated from the commit logs periodically.
+The <a href="/AUTHORS"><code>AUTHORS</code></a> file defines who “The Go
+Authors”—the copyright holders—are.
+</p>
+
+<p>
+New files that you contribute should use the standard copyright header:
+</p>
+
+<pre>
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+</pre>
+
+<p>
+(Use the current year if you're reading this in 2022 or beyond.)
+Files in the repository are copyrighted the year they are added.
+Do not update the copyright year on files that you change.
+</p>
+
+
+
+
+<h3 id="troubleshooting_mail">Troubleshooting mail errors</h3>
+
+<p>
+The most common way that the <code>git</code> <code>codereview</code> <code>mail</code>
+command fails is because the e-mail address in the commit does not match the one
+that you used during <a href="#google_account">the registration process</a>.
+
+<br>
+If you see something like...
+</p>
+
+<pre>
+remote: Processing changes: refs: 1, done
+remote:
+remote: ERROR: In commit ab13517fa29487dcf8b0d48916c51639426c5ee9
+remote: ERROR: author email address XXXXXXXXXXXXXXXXXXX
+remote: ERROR: does not match your user account.
+</pre>
+
+<p>
+you need to configure Git for this repository to use the
+e-mail address that you registered with.
+To change the e-mail address to ensure this doesn't happen again, run:
+</p>
+
+<pre>
+$ git config user.email email@address.com
+</pre>
+
+<p>
+Then change the commit to use this alternative e-mail address with this command:
+</p>
+
+<pre>
+$ git commit --amend --author="Author Name <email@address.com>"
+</pre>
+
+<p>
+Then retry by running:
+</p>
+
+<pre>
+$ git codereview mail
+</pre>
+
+
+<h3 id="quick_test">Quickly testing your changes</h3>
+
+<p>
+Running <code>all.bash</code> for every single change to the code tree
+is burdensome.
+Even though it is strongly suggested to run it before
+sending a change, during the normal development cycle you may want
+to compile and test only the package you are developing.
+</p>
+
+<ul>
+<li>
+In general, you can run <code>make.bash</code> instead of <code>all.bash</code>
+to only rebuild the Go tool chain without running the whole test suite.
+Or you
+can run <code>run.bash</code> to only run the whole test suite without rebuilding
+the tool chain.
+You can think of <code>all.bash</code> as <code>make.bash</code>
+followed by <code>run.bash</code>.
+</li>
+
+<li>
+In this section, we'll call the directory into which you cloned the Go repository <code>$GODIR</code>.
+The <code>go</code> tool built by <code>$GODIR/src/make.bash</code> will be installed
+in <code>$GODIR/bin/go</code> and you
+can invoke it to test your code.
+For instance, if you
+have modified the compiler and you want to test how it affects the
+test suite of your own project, just run <code>go</code> <code>test</code>
+using it:
+
+<pre>
+$ cd <MYPROJECTDIR>
+$ $GODIR/bin/go test
+</pre>
+</li>
+
+<li>
+If you're changing the standard library, you probably don't need to rebuild
+the compiler: you can just run the tests for the package you've changed.
+You can do that either with the Go version you normally use, or
+with the Go compiler built from your clone (which is
+sometimes required because the standard library code you're modifying
+might require a newer version than the stable one you have installed).
+
+<pre>
+$ cd $GODIR/src/crypto/sha1
+$ [make changes...]
+$ $GODIR/bin/go test .
+</pre>
+</li>
+
+<li>
+If you're modifying the compiler itself, you can just recompile
+the <code>compile</code> tool (which is the internal binary invoked
+by <code>go</code> <code>build</code> to compile each single package).
+After that, you will want to test it by compiling or running something.
+
+<pre>
+$ cd $GODIR/src
+$ [make changes...]
+$ $GODIR/bin/go install cmd/compile
+$ $GODIR/bin/go build [something...] # test the new compiler
+$ $GODIR/bin/go run [something...] # test the new compiler
+$ $GODIR/bin/go test [something...] # test the new compiler
+</pre>
+
+The same applies to other internal tools of the Go tool chain,
+such as <code>asm</code>, <code>cover</code>, <code>link</code>, and so on.
+Just recompile and install the tool using <code>go</code>
+<code>install</code> <code>cmd/<TOOL></code> and then use
+the built Go binary to test it.
+</li>
+
+<li>
+In addition to the standard per-package tests, there is a top-level
+test suite in <code>$GODIR/test</code> that contains
+several black-box and regression tests.
+The test suite is run
+by <code>all.bash</code> but you can also run it manually:
+
+<pre>
+$ cd $GODIR/test
+$ $GODIR/bin/go run run.go
+</pre>
+</ul>
+
+
+<h3 id="cc">Specifying a reviewer / CCing others</h3>
+
+<p>
+Unless explicitly told otherwise, such as in the discussion leading
+up to sending in the change, it's better not to specify a reviewer.
+All changes are automatically CC'ed to the
+<a href="https://groups.google.com/group/golang-codereviews">golang-codereviews@googlegroups.com</a>
+mailing list.
+If this is your first ever change, there may be a moderation
+delay before it appears on the mailing list, to prevent spam.
+</p>
+
+<p>
+You can specify a reviewer or CC interested parties
+using the <code>-r</code> or <code>-cc</code> options.
+Both accept a comma-separated list of e-mail addresses:
+</p>
+
+<pre>
+$ git codereview mail -r joe@golang.org -cc mabel@example.com,math-nuts@swtch.com
+</pre>
+
+
+<h3 id="sync">Synchronize your client</h3>
+
+<p>
+While you were working, others might have submitted changes to the repository.
+To update your local branch, run
+</p>
+
+<pre>
+$ git codereview sync
+</pre>
+
+<p>
+(Under the covers this runs
+<code>git</code> <code>pull</code> <code>-r</code>.)
+</p>
+
+
+<h3 id="download">Reviewing code by others</h3>
+
+<p>
+As part of the review process reviewers can propose changes directly (in the
+GitHub workflow this would be someone else attaching commits to a pull request).
+
+You can import these changes proposed by someone else into your local Git repository.
+On the Gerrit review page, click the "Download ▼" link in the upper right
+corner, copy the "Checkout" command and run it from your local Git repo.
+It will look something like this:
+</p>
+
+<pre>
+$ git fetch https://go.googlesource.com/review refs/changes/21/13245/1 && git checkout FETCH_HEAD
+</pre>
+
+<p>
+To revert, change back to the branch you were working in.
+</p>
+
+
+<h3 id="git-config">Set up git aliases</h3>
+
+<p>
+The <code>git-codereview</code> command can be run directly from the shell
+by typing, for instance,
+</p>
+
+<pre>
+$ git codereview sync
+</pre>
+
+<p>
+but it is more convenient to set up aliases for <code>git-codereview</code>'s own
+subcommands, so that the above becomes,
+</p>
+
+<pre>
+$ git sync
+</pre>
+
+<p>
+The <code>git-codereview</code> subcommands have been chosen to be distinct from
+Git's own, so it's safe to define these aliases.
+To install them, copy this text into your
+Git configuration file (usually <code>.gitconfig</code> in your home directory):
+</p>
+
+<pre>
+[alias]
+ change = codereview change
+ gofmt = codereview gofmt
+ mail = codereview mail
+ pending = codereview pending
+ submit = codereview submit
+ sync = codereview sync
+</pre>
+
+
+<h3 id="multiple_changes">Sending multiple dependent changes</h3>
+
+<p>
+Advanced users may want to stack up related commits in a single branch.
+Gerrit allows for changes to be dependent on each other, forming such a dependency chain.
+Each change will need to be approved and submitted separately but the dependency
+will be visible to reviewers.
+</p>
+
+<p>
+To send out a group of dependent changes, keep each change as a different commit under
+the same branch, and then run:
+</p>
+
+<pre>
+$ git codereview mail HEAD
+</pre>
+
+<p>
+Make sure to explicitly specify <code>HEAD</code>, which is usually not required when sending
+single changes. More details can be found in the <a href="https://pkg.go.dev/golang.org/x/review/git-codereview?tab=doc#hdr-Multiple_Commit_Work_Branches">git-codereview documentation</a>.
+</p>
diff --git a/_content/doc/copyright.html b/_content/doc/copyright.html
new file mode 100644
index 0000000..86b45bb
--- /dev/null
+++ b/_content/doc/copyright.html
@@ -0,0 +1,11 @@
+<!--{
+ "Title": "Copyright"
+}-->
+
+<p>
+ Except as
+ <a href="https://developers.google.com/site-policies#restrictions">noted</a>, the contents of this
+ site are licensed under the
+ <a href="https://creativecommons.org/licenses/by/3.0/">Creative Commons Attribution 3.0 License</a>,
+ and code is licensed under a <a href="/LICENSE">BSD license</a>.
+</p>
diff --git a/_content/doc/debugging_with_gdb.html b/_content/doc/debugging_with_gdb.html
new file mode 100644
index 0000000..98b70fb
--- /dev/null
+++ b/_content/doc/debugging_with_gdb.html
@@ -0,0 +1,554 @@
+<!--{
+ "Title": "Debugging Go Code with GDB",
+ "Path": "/doc/gdb"
+}-->
+
+<!--
+NOTE: In this document and others in this directory, the convention is to
+set fixed-width phrases with non-fixed-width spaces, as in
+<code>hello</code> <code>world</code>.
+Do not send CLs removing the interior tags from such phrases.
+-->
+
+<i>
+<p>
+The following instructions apply to the standard toolchain
+(the <code>gc</code> Go compiler and tools).
+Gccgo has native gdb support.
+</p>
+<p>
+Note that
+<a href="https://github.com/go-delve/delve">Delve</a> is a better
+alternative to GDB when debugging Go programs built with the standard
+toolchain. It understands the Go runtime, data structures, and
+expressions better than GDB. Delve currently supports Linux, OSX,
+and Windows on <code>amd64</code>.
+For the most up-to-date list of supported platforms, please see
+<a href="https://github.com/go-delve/delve/tree/master/Documentation/installation">
+ the Delve documentation</a>.
+</p>
+</i>
+
+<p>
+GDB does not understand Go programs well.
+The stack management, threading, and runtime contain aspects that differ
+enough from the execution model GDB expects that they can confuse
+the debugger and cause incorrect results even when the program is
+compiled with gccgo.
+As a consequence, although GDB can be useful in some situations (e.g.,
+debugging Cgo code, or debugging the runtime itself), it is not
+a reliable debugger for Go programs, particularly heavily concurrent
+ones. Moreover, it is not a priority for the Go project to address
+these issues, which are difficult.
+</p>
+
+<p>
+In short, the instructions below should be taken only as a guide to how
+to use GDB when it works, not as a guarantee of success.
+
+Besides this overview you might want to consult the
+<a href="https://sourceware.org/gdb/current/onlinedocs/gdb/">GDB manual</a>.
+</p>
+
+<p>
+</p>
+
+<h2 id="Introduction">Introduction</h2>
+
+<p>
+When you compile and link your Go programs with the <code>gc</code> toolchain
+on Linux, macOS, FreeBSD or NetBSD, the resulting binaries contain DWARFv4
+debugging information that recent versions (≥7.5) of the GDB debugger can
+use to inspect a live process or a core dump.
+</p>
+
+<p>
+Pass the <code>'-w'</code> flag to the linker to omit the debug information
+(for example, <code>go</code> <code>build</code> <code>-ldflags=-w</code> <code>prog.go</code>).
+</p>
+
+<p>
+The code generated by the <code>gc</code> compiler includes inlining of
+function invocations and registerization of variables. These optimizations
+can sometimes make debugging with <code>gdb</code> harder.
+If you find that you need to disable these optimizations,
+build your program using <code>go</code> <code>build</code> <code>-gcflags=all="-N -l"</code>.
+</p>
+
+<p>
+If you want to use gdb to inspect a core dump, you can trigger a dump
+on a program crash, on systems that permit it, by setting
+<code>GOTRACEBACK=crash</code> in the environment (see the
+<a href="/pkg/runtime/#hdr-Environment_Variables"> runtime package
+documentation</a> for more info).
+</p>
+
+<h3 id="Common_Operations">Common Operations</h3>
+
+<ul>
+<li>
+Show file and line number for code, set breakpoints and disassemble:
+<pre>(gdb) <b>list</b>
+(gdb) <b>list <i>line</i></b>
+(gdb) <b>list <i>file.go</i>:<i>line</i></b>
+(gdb) <b>break <i>line</i></b>
+(gdb) <b>break <i>file.go</i>:<i>line</i></b>
+(gdb) <b>disas</b></pre>
+</li>
+<li>
+Show backtraces and unwind stack frames:
+<pre>(gdb) <b>bt</b>
+(gdb) <b>frame <i>n</i></b></pre>
+</li>
+<li>
+Show the name, type and location on the stack frame of local variables,
+arguments and return values:
+<pre>(gdb) <b>info locals</b>
+(gdb) <b>info args</b>
+(gdb) <b>p variable</b>
+(gdb) <b>whatis variable</b></pre>
+</li>
+<li>
+Show the name, type and location of global variables:
+<pre>(gdb) <b>info variables <i>regexp</i></b></pre>
+</li>
+</ul>
+
+
+<h3 id="Go_Extensions">Go Extensions</h3>
+
+<p>
+A recent extension mechanism to GDB allows it to load extension scripts for a
+given binary. The toolchain uses this to extend GDB with a handful of
+commands to inspect internals of the runtime code (such as goroutines) and to
+pretty print the built-in map, slice and channel types.
+</p>
+
+<ul>
+<li>
+Pretty printing a string, slice, map, channel or interface:
+<pre>(gdb) <b>p <i>var</i></b></pre>
+</li>
+<li>
+A $len() and $cap() function for strings, slices and maps:
+<pre>(gdb) <b>p $len(<i>var</i>)</b></pre>
+</li>
+<li>
+A function to cast interfaces to their dynamic types:
+<pre>(gdb) <b>p $dtype(<i>var</i>)</b>
+(gdb) <b>iface <i>var</i></b></pre>
+<p class="detail"><b>Known issue:</b> GDB can’t automatically find the dynamic
+type of an interface value if its long name differs from its short name
+(annoying when printing stacktraces, the pretty printer falls back to printing
+the short type name and a pointer).</p>
+</li>
+<li>
+Inspecting goroutines:
+<pre>(gdb) <b>info goroutines</b>
+(gdb) <b>goroutine <i>n</i> <i>cmd</i></b>
+(gdb) <b>help goroutine</b></pre>
+For example:
+<pre>(gdb) <b>goroutine 12 bt</b></pre>
+You can inspect all goroutines by passing <code>all</code> instead of a specific goroutine's ID.
+For example:
+<pre>(gdb) <b>goroutine all bt</b></pre>
+</li>
+</ul>
+
+<p>
+If you'd like to see how this works, or want to extend it, take a look at <a
+href="/src/runtime/runtime-gdb.py">src/runtime/runtime-gdb.py</a> in
+the Go source distribution. It depends on some special magic types
+(<code>hash<T,U></code>) and variables (<code>runtime.m</code> and
+<code>runtime.g</code>) that the linker
+(<a href="/src/cmd/link/internal/ld/dwarf.go">src/cmd/link/internal/ld/dwarf.go</a>) ensures are described in
+the DWARF code.
+</p>
+
+<p>
+If you're interested in what the debugging information looks like, run
+<code>objdump</code> <code>-W</code> <code>a.out</code> and browse through the <code>.debug_*</code>
+sections.
+</p>
+
+
+<h3 id="Known_Issues">Known Issues</h3>
+
+<ol>
+<li>String pretty printing only triggers for type string, not for types derived
+from it.</li>
+<li>Type information is missing for the C parts of the runtime library.</li>
+<li>GDB does not understand Go’s name qualifications and treats
+<code>"fmt.Print"</code> as an unstructured literal with a <code>"."</code>
+that needs to be quoted. It objects even more strongly to method names of
+the form <code>pkg.(*MyType).Meth</code>.
+<li>As of Go 1.11, debug information is compressed by default.
+Older versions of gdb, such as the one available by default on MacOS,
+do not understand the compression.
+You can generate uncompressed debug information by using <code>go
+build -ldflags=-compressdwarf=false</code>.
+(For convenience you can put the <code>-ldflags</code> option in
+the <a href="/cmd/go/#hdr-Environment_variables"><code>GOFLAGS</code>
+environment variable</a> so that you don't have to specify it each time.)
+</li>
+</ol>
+
+<h2 id="Tutorial">Tutorial</h2>
+
+<p>
+In this tutorial we will inspect the binary of the
+<a href="/pkg/regexp/">regexp</a> package's unit tests. To build the binary,
+change to <code>$GOROOT/src/regexp</code> and run <code>go</code> <code>test</code> <code>-c</code>.
+This should produce an executable file named <code>regexp.test</code>.
+</p>
+
+
+<h3 id="Getting_Started">Getting Started</h3>
+
+<p>
+Launch GDB, debugging <code>regexp.test</code>:
+</p>
+
+<pre>
+$ <b>gdb regexp.test</b>
+GNU gdb (GDB) 7.2-gg8
+Copyright (C) 2010 Free Software Foundation, Inc.
+License GPLv 3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
+Type "show copying" and "show warranty" for licensing/warranty details.
+This GDB was configured as "x86_64-linux".
+
+Reading symbols from /home/user/go/src/regexp/regexp.test...
+done.
+Loading Go Runtime support.
+(gdb)
+</pre>
+
+<p>
+The message "Loading Go Runtime support" means that GDB loaded the
+extension from <code>$GOROOT/src/runtime/runtime-gdb.py</code>.
+</p>
+
+<p>
+To help GDB find the Go runtime sources and the accompanying support script,
+pass your <code>$GOROOT</code> with the <code>'-d'</code> flag:
+</p>
+
+<pre>
+$ <b>gdb regexp.test -d $GOROOT</b>
+</pre>
+
+<p>
+If for some reason GDB still can't find that directory or that script, you can load
+it by hand by telling gdb (assuming you have the go sources in
+<code>~/go/</code>):
+</p>
+
+<pre>
+(gdb) <b>source ~/go/src/runtime/runtime-gdb.py</b>
+Loading Go Runtime support.
+</pre>
+
+<h3 id="Inspecting_the_source">Inspecting the source</h3>
+
+<p>
+Use the <code>"l"</code> or <code>"list"</code> command to inspect source code.
+</p>
+
+<pre>
+(gdb) <b>l</b>
+</pre>
+
+<p>
+List a specific part of the source parameterizing <code>"list"</code> with a
+function name (it must be qualified with its package name).
+</p>
+
+<pre>
+(gdb) <b>l main.main</b>
+</pre>
+
+<p>
+List a specific file and line number:
+</p>
+
+<pre>
+(gdb) <b>l regexp.go:1</b>
+(gdb) <i># Hit enter to repeat last command. Here, this lists next 10 lines.</i>
+</pre>
+
+
+<h3 id="Naming">Naming</h3>
+
+<p>
+Variable and function names must be qualified with the name of the packages
+they belong to. The <code>Compile</code> function from the <code>regexp</code>
+package is known to GDB as <code>'regexp.Compile'</code>.
+</p>
+
+<p>
+Methods must be qualified with the name of their receiver types. For example,
+the <code>*Regexp</code> type’s <code>String</code> method is known as
+<code>'regexp.(*Regexp).String'</code>.
+</p>
+
+<p>
+Variables that shadow other variables are magically suffixed with a number in the debug info.
+Variables referenced by closures will appear as pointers magically prefixed with '&'.
+</p>
+
+<h3 id="Setting_breakpoints">Setting breakpoints</h3>
+
+<p>
+Set a breakpoint at the <code>TestFind</code> function:
+</p>
+
+<pre>
+(gdb) <b>b 'regexp.TestFind'</b>
+Breakpoint 1 at 0x424908: file /home/user/go/src/regexp/find_test.go, line 148.
+</pre>
+
+<p>
+Run the program:
+</p>
+
+<pre>
+(gdb) <b>run</b>
+Starting program: /home/user/go/src/regexp/regexp.test
+
+Breakpoint 1, regexp.TestFind (t=0xf8404a89c0) at /home/user/go/src/regexp/find_test.go:148
+148 func TestFind(t *testing.T) {
+</pre>
+
+<p>
+Execution has paused at the breakpoint.
+See which goroutines are running, and what they're doing:
+</p>
+
+<pre>
+(gdb) <b>info goroutines</b>
+ 1 waiting runtime.gosched
+* 13 running runtime.goexit
+</pre>
+
+<p>
+the one marked with the <code>*</code> is the current goroutine.
+</p>
+
+<h3 id="Inspecting_the_stack">Inspecting the stack</h3>
+
+<p>
+Look at the stack trace for where we’ve paused the program:
+</p>
+
+<pre>
+(gdb) <b>bt</b> <i># backtrace</i>
+#0 regexp.TestFind (t=0xf8404a89c0) at /home/user/go/src/regexp/find_test.go:148
+#1 0x000000000042f60b in testing.tRunner (t=0xf8404a89c0, test=0x573720) at /home/user/go/src/testing/testing.go:156
+#2 0x000000000040df64 in runtime.initdone () at /home/user/go/src/runtime/proc.c:242
+#3 0x000000f8404a89c0 in ?? ()
+#4 0x0000000000573720 in ?? ()
+#5 0x0000000000000000 in ?? ()
+</pre>
+
+<p>
+The other goroutine, number 1, is stuck in <code>runtime.gosched</code>, blocked on a channel receive:
+</p>
+
+<pre>
+(gdb) <b>goroutine 1 bt</b>
+#0 0x000000000040facb in runtime.gosched () at /home/user/go/src/runtime/proc.c:873
+#1 0x00000000004031c9 in runtime.chanrecv (c=void, ep=void, selected=void, received=void)
+ at /home/user/go/src/runtime/chan.c:342
+#2 0x0000000000403299 in runtime.chanrecv1 (t=void, c=void) at/home/user/go/src/runtime/chan.c:423
+#3 0x000000000043075b in testing.RunTests (matchString={void (struct string, struct string, bool *, error *)}
+ 0x7ffff7f9ef60, tests= []testing.InternalTest = {...}) at /home/user/go/src/testing/testing.go:201
+#4 0x00000000004302b1 in testing.Main (matchString={void (struct string, struct string, bool *, error *)}
+ 0x7ffff7f9ef80, tests= []testing.InternalTest = {...}, benchmarks= []testing.InternalBenchmark = {...})
+at /home/user/go/src/testing/testing.go:168
+#5 0x0000000000400dc1 in main.main () at /home/user/go/src/regexp/_testmain.go:98
+#6 0x00000000004022e7 in runtime.mainstart () at /home/user/go/src/runtime/amd64/asm.s:78
+#7 0x000000000040ea6f in runtime.initdone () at /home/user/go/src/runtime/proc.c:243
+#8 0x0000000000000000 in ?? ()
+</pre>
+
+<p>
+The stack frame shows we’re currently executing the <code>regexp.TestFind</code> function, as expected.
+</p>
+
+<pre>
+(gdb) <b>info frame</b>
+Stack level 0, frame at 0x7ffff7f9ff88:
+ rip = 0x425530 in regexp.TestFind (/home/user/go/src/regexp/find_test.go:148);
+ saved rip 0x430233
+ called by frame at 0x7ffff7f9ffa8
+ source language minimal.
+ Arglist at 0x7ffff7f9ff78, args: t=0xf840688b60
+ Locals at 0x7ffff7f9ff78, Previous frame's sp is 0x7ffff7f9ff88
+ Saved registers:
+ rip at 0x7ffff7f9ff80
+</pre>
+
+<p>
+The command <code>info</code> <code>locals</code> lists all variables local to the function and their values, but is a bit
+dangerous to use, since it will also try to print uninitialized variables. Uninitialized slices may cause gdb to try
+to print arbitrary large arrays.
+</p>
+
+<p>
+The function’s arguments:
+</p>
+
+<pre>
+(gdb) <b>info args</b>
+t = 0xf840688b60
+</pre>
+
+<p>
+When printing the argument, notice that it’s a pointer to a
+<code>Regexp</code> value. Note that GDB has incorrectly put the <code>*</code>
+on the right-hand side of the type name and made up a 'struct' keyword, in traditional C style.
+</p>
+
+<pre>
+(gdb) <b>p re</b>
+(gdb) p t
+$1 = (struct testing.T *) 0xf840688b60
+(gdb) p t
+$1 = (struct testing.T *) 0xf840688b60
+(gdb) p *t
+$2 = {errors = "", failed = false, ch = 0xf8406f5690}
+(gdb) p *t->ch
+$3 = struct hchan<*testing.T>
+</pre>
+
+<p>
+That <code>struct</code> <code>hchan<*testing.T></code> is the
+runtime-internal representation of a channel. It is currently empty,
+or gdb would have pretty-printed its contents.
+</p>
+
+<p>
+Stepping forward:
+</p>
+
+<pre>
+(gdb) <b>n</b> <i># execute next line</i>
+149 for _, test := range findTests {
+(gdb) <i># enter is repeat</i>
+150 re := MustCompile(test.pat)
+(gdb) <b>p test.pat</b>
+$4 = ""
+(gdb) <b>p re</b>
+$5 = (struct regexp.Regexp *) 0xf84068d070
+(gdb) <b>p *re</b>
+$6 = {expr = "", prog = 0xf840688b80, prefix = "", prefixBytes = []uint8, prefixComplete = true,
+ prefixRune = 0, cond = 0 '\000', numSubexp = 0, longest = false, mu = {state = 0, sema = 0},
+ machine = []*regexp.machine}
+(gdb) <b>p *re->prog</b>
+$7 = {Inst = []regexp/syntax.Inst = {{Op = 5 '\005', Out = 0, Arg = 0, Rune = []int}, {Op =
+ 6 '\006', Out = 2, Arg = 0, Rune = []int}, {Op = 4 '\004', Out = 0, Arg = 0, Rune = []int}},
+ Start = 1, NumCap = 2}
+</pre>
+
+
+<p>
+We can step into the <code>String</code>function call with <code>"s"</code>:
+</p>
+
+<pre>
+(gdb) <b>s</b>
+regexp.(*Regexp).String (re=0xf84068d070, noname=void) at /home/user/go/src/regexp/regexp.go:97
+97 func (re *Regexp) String() string {
+</pre>
+
+<p>
+Get a stack trace to see where we are:
+</p>
+
+<pre>
+(gdb) <b>bt</b>
+#0 regexp.(*Regexp).String (re=0xf84068d070, noname=void)
+ at /home/user/go/src/regexp/regexp.go:97
+#1 0x0000000000425615 in regexp.TestFind (t=0xf840688b60)
+ at /home/user/go/src/regexp/find_test.go:151
+#2 0x0000000000430233 in testing.tRunner (t=0xf840688b60, test=0x5747b8)
+ at /home/user/go/src/testing/testing.go:156
+#3 0x000000000040ea6f in runtime.initdone () at /home/user/go/src/runtime/proc.c:243
+....
+</pre>
+
+<p>
+Look at the source code:
+</p>
+
+<pre>
+(gdb) <b>l</b>
+92 mu sync.Mutex
+93 machine []*machine
+94 }
+95
+96 // String returns the source text used to compile the regular expression.
+97 func (re *Regexp) String() string {
+98 return re.expr
+99 }
+100
+101 // Compile parses a regular expression and returns, if successful,
+</pre>
+
+<h3 id="Pretty_Printing">Pretty Printing</h3>
+
+<p>
+GDB's pretty printing mechanism is triggered by regexp matches on type names. An example for slices:
+</p>
+
+<pre>
+(gdb) <b>p utf</b>
+$22 = []uint8 = {0 '\000', 0 '\000', 0 '\000', 0 '\000'}
+</pre>
+
+<p>
+Since slices, arrays and strings are not C pointers, GDB can't interpret the subscripting operation for you, but
+you can look inside the runtime representation to do that (tab completion helps here):
+</p>
+<pre>
+
+(gdb) <b>p slc</b>
+$11 = []int = {0, 0}
+(gdb) <b>p slc-></b><i><TAB></i>
+array slc len
+(gdb) <b>p slc->array</b>
+$12 = (int *) 0xf84057af00
+(gdb) <b>p slc->array[1]</b>
+$13 = 0</pre>
+
+
+
+<p>
+The extension functions $len and $cap work on strings, arrays and slices:
+</p>
+
+<pre>
+(gdb) <b>p $len(utf)</b>
+$23 = 4
+(gdb) <b>p $cap(utf)</b>
+$24 = 4
+</pre>
+
+<p>
+Channels and maps are 'reference' types, which gdb shows as pointers to C++-like types <code>hash<int,string>*</code>. Dereferencing will trigger prettyprinting
+</p>
+
+<p>
+Interfaces are represented in the runtime as a pointer to a type descriptor and a pointer to a value. The Go GDB runtime extension decodes this and automatically triggers pretty printing for the runtime type. The extension function <code>$dtype</code> decodes the dynamic type for you (examples are taken from a breakpoint at <code>regexp.go</code> line 293.)
+</p>
+
+<pre>
+(gdb) <b>p i</b>
+$4 = {str = "cbb"}
+(gdb) <b>whatis i</b>
+type = regexp.input
+(gdb) <b>p $dtype(i)</b>
+$26 = (struct regexp.inputBytes *) 0xf8400b4930
+(gdb) <b>iface i</b>
+regexp.input: struct regexp.inputBytes *
+</pre>
diff --git a/_content/doc/devel/pre_go1.html b/_content/doc/devel/pre_go1.html
new file mode 100644
index 0000000..7f1ad7b
--- /dev/null
+++ b/_content/doc/devel/pre_go1.html
@@ -0,0 +1,455 @@
+<!--{
+ "Title": "Pre-Go 1 Release History"
+}-->
+
+<p>
+This page summarizes the changes between stable releases of Go prior to Go 1.
+See the <a href="release.html">Release History</a> page for notes on recent releases.
+</p>
+
+<h2 id="r60">r60 (released 2011/09/07)</h2>
+
+<p>
+The r60 release corresponds to
+<code><a href="weekly.html#2011-08-17">weekly.2011-08-17</a></code>.
+This section highlights the most significant changes in this release.
+For a more detailed summary, see the
+<a href="weekly.html#2011-08-17">weekly release notes</a>.
+For complete information, see the
+<a href="//code.google.com/p/go/source/list?r=release-branch.r60">Mercurial change list</a>.
+</p>
+
+<h3 id="r60.lang">Language</h3>
+
+<p>
+An "else" block is now required to have braces except if the body of the "else"
+is another "if". Since gofmt always puts those braces in anyway,
+gofmt-formatted programs will not be affected.
+To fix other programs, run gofmt.
+</p>
+
+<h3 id="r60.pkg">Packages</h3>
+
+<p>
+<a href="/pkg/http/">Package http</a>'s URL parsing and query escaping code
+(such as <code>ParseURL</code> and <code>URLEscape</code>) has been moved to
+the new <a href="/pkg/url/">url package</a>, with several simplifications to
+the names. Client code can be updated automatically with gofix.
+</p>
+
+<p>
+<a href="/pkg/image/">Package image</a> has had significant changes made to the
+<code>Pix</code> field of struct types such as
+<a href="/pkg/image/#RGBA">image.RGBA</a> and
+<a href="/pkg/image/#NRGBA">image.NRGBA</a>.
+The <a href="/pkg/image/#Image">image.Image</a> interface type has not changed,
+though, and you should not need to change your code if you don't explicitly
+refer to <code>Pix</code> fields. For example, if you decode a number of images
+using the <a href="/pkg/image/jpeg/">image/jpeg</a> package, compose them using
+<a href="/pkg/image/draw/">image/draw</a>, and then encode the result using
+<a href="/pkg/img/png">image/png</a>, then your code should still work as
+before.
+If your code <i>does</i> refer to <code>Pix</code> fields see the
+<a href="/doc/devel/weekly.html#2011-07-19">weekly.2011-07-19</a>
+snapshot notes for how to update your code.
+</p>
+
+<p>
+<a href="/pkg/template/">Package template</a> has been replaced with a new
+templating package (formerly <code>exp/template</code>). The original template
+package is still available as <a href="/pkg/old/template/">old/template</a>.
+The <code>old/template</code> package is deprecated and will be removed.
+The Go tree has been updated to use the new template package. We encourage
+users of the old template package to switch to the new one. Code that uses
+<code>template</code> or <code>exp/template</code> will need to change its
+import lines to <code>"old/template"</code> or <code>"template"</code>,
+respectively.
+</p>
+
+<h3 id="r60.cmd">Tools</h3>
+
+<p>
+<a href="/cmd/goinstall/">Goinstall</a> now uses a new tag selection scheme.
+When downloading or updating, goinstall looks for a tag or branch with the
+<code>"go."</code> prefix that corresponds to the local Go version. For Go
+<code>release.r58</code> it looks for <code>go.r58</code>. For
+<code>weekly.2011-06-03</code> it looks for <code>go.weekly.2011-06-03</code>.
+If the specific <code>go.X</code> tag or branch is not found, it chooses the
+closest earlier version. If an appropriate tag or branch is found, goinstall
+uses that version of the code. Otherwise it uses the default version selected
+by the version control system. Library authors are encouraged to use the
+appropriate tag or branch names in their repositories to make their libraries
+more accessible.
+</p>
+
+<h3 id="r60.minor">Minor revisions</h3>
+
+<p>
+r60.1 includes a
+<a href="//golang.org/change/1824581bf62d">linker
+fix</a>, a pair of
+<a href="//golang.org/change/9ef4429c2c64">goplay</a>
+<a href="//golang.org/change/d42ed8c3098e">fixes</a>,
+and a <code>json</code> package
+<a href="//golang.org/change/d5e97874fe84">fix</a> and
+a new
+<a href="//golang.org/change/4f0e6269213f">struct tag
+option</a>.
+</p>
+
+<p>
+r60.2
+<a href="//golang.org/change/ff19536042ac">fixes</a>
+a memory leak involving maps.
+</p>
+
+<p>
+r60.3 fixes a
+<a href="//golang.org/change/01fa62f5e4e5">reflect bug</a>.
+</p>
+
+<h2 id="r59">r59 (released 2011/08/01)</h2>
+
+<p>
+The r59 release corresponds to
+<code><a href="weekly.html#2011-07-07">weekly.2011-07-07</a></code>.
+This section highlights the most significant changes in this release.
+For a more detailed summary, see the
+<a href="weekly.html#2011-07-07">weekly release notes</a>.
+For complete information, see the
+<a href="//code.google.com/p/go/source/list?r=release-branch.r59">Mercurial change list</a>.
+</p>
+
+<h3 id="r59.lang">Language</h3>
+
+<p>
+This release includes a language change that restricts the use of
+<code>goto</code>. In essence, a <code>goto</code> statement outside a block
+cannot jump to a label inside that block. Your code may require changes if it
+uses <code>goto</code>.
+See <a href="//golang.org/change/dc6d3cf9279d">this
+changeset</a> for how the new rule affected the Go tree.
+</p>
+
+<h3 id="r59.pkg">Packages</h3>
+
+<p>
+As usual, <a href="/cmd/gofix/">gofix</a> will handle the bulk of the rewrites
+necessary for these changes to package APIs.
+</p>
+
+<p>
+<a href="/pkg/http">Package http</a> has a new
+<a href="/pkg/http/#FileSystem">FileSystem</a> interface that provides access
+to files. The <a href="/pkg/http/#FileServer">FileServer</a> helper now takes a
+<code>FileSystem</code> argument instead of an explicit file system root. By
+implementing your own <code>FileSystem</code> you can use the
+<code>FileServer</code> to serve arbitrary data.
+</p>
+
+<p>
+<a href="/pkg/os/">Package os</a>'s <code>ErrorString</code> type has been
+hidden. Most uses of <code>os.ErrorString</code> can be replaced with
+<a href="/pkg/os/#NewError">os.NewError</a>.
+</p>
+
+<p>
+<a href="/pkg/reflect/">Package reflect</a> supports a new struct tag scheme
+that enables sharing of struct tags between multiple packages.
+In this scheme, the tags must be of the form:
+</p>
+<pre>
+ `key:"value" key2:"value2"`
+</pre>
+<p>
+The <a href="/pkg/reflect/#StructField">StructField</a> type's Tag field now
+has type <a href="/pkg/reflect/#StructTag">StructTag</a>, which has a
+<code>Get</code> method. Clients of <a href="/pkg/json">json</a> and
+<a href="/pkg/xml">xml</a> will need to be updated. Code that says
+</p>
+<pre>
+ type T struct {
+ X int "name"
+ }
+</pre>
+<p>
+should become
+</p>
+<pre>
+ type T struct {
+ X int `json:"name"` // or `xml:"name"`
+ }
+</pre>
+<p>
+Use <a href="/cmd/govet/">govet</a> to identify struct tags that need to be
+changed to use the new syntax.
+</p>
+
+<p>
+<a href="/pkg/sort/">Package sort</a>'s <code>IntArray</code> type has been
+renamed to <a href="/pkg/sort/#IntSlice">IntSlice</a>, and similarly for
+<a href="/pkg/sort/#Float64Slice">Float64Slice</a> and
+<a href="/pkg/sort/#StringSlice">StringSlice</a>.
+</p>
+
+<p>
+<a href="/pkg/strings/">Package strings</a>'s <code>Split</code> function has
+itself been split into <a href="/pkg/strings/#Split">Split</a> and
+<a href="/pkg/strings/#SplitN">SplitN</a>.
+<code>SplitN</code> is the same as the old <code>Split</code>.
+The new <code>Split</code> is equivalent to <code>SplitN</code> with a final
+argument of -1.
+</p>
+
+<a href="/pkg/image/draw/">Package image/draw</a>'s
+<a href="/pkg/image/draw/#Draw">Draw</a> function now takes an additional
+argument, a compositing operator.
+If in doubt, use <a href="/pkg/image/draw/#Op">draw.Over</a>.
+</p>
+
+<h3 id="r59.cmd">Tools</h3>
+
+<p>
+<a href="/cmd/goinstall/">Goinstall</a> now installs packages and commands from
+arbitrary remote repositories (not just Google Code, Github, and so on).
+See the <a href="/cmd/goinstall/">goinstall documentation</a> for details.
+</p>
+
+<h2 id="r58">r58 (released 2011/06/29)</h2>
+
+<p>
+The r58 release corresponds to
+<code><a href="weekly.html#2011-06-09">weekly.2011-06-09</a></code>
+with additional bug fixes.
+This section highlights the most significant changes in this release.
+For a more detailed summary, see the
+<a href="weekly.html#2011-06-09">weekly release notes</a>.
+For complete information, see the
+<a href="//code.google.com/p/go/source/list?r=release-branch.r58">Mercurial change list</a>.
+</p>
+
+<h3 id="r58.lang">Language</h3>
+
+<p>
+This release fixes a <a href="//golang.org/change/b720749486e1">use of uninitialized memory in programs that misuse <code>goto</code></a>.
+</p>
+
+<h3 id="r58.pkg">Packages</h3>
+
+<p>
+As usual, <a href="/cmd/gofix/">gofix</a> will handle the bulk of the rewrites
+necessary for these changes to package APIs.
+</p>
+
+<p>
+<a href="/pkg/http/">Package http</a> drops the <code>finalURL</code> return
+value from the <a href="/pkg/http/#Client.Get">Client.Get</a> method. The value
+is now available via the new <code>Request</code> field on <a
+href="/pkg/http/#Response">http.Response</a>.
+Most instances of the type map[string][]string in have been
+replaced with the new <a href="/pkg/http/#Values">Values</a> type.
+</p>
+
+<p>
+<a href="/pkg/exec/">Package exec</a> has been redesigned with a more
+convenient and succinct API.
+</p>
+
+<p>
+<a href="/pkg/strconv/">Package strconv</a>'s <a href="/pkg/strconv/#Quote">Quote</a>
+function now escapes only those Unicode code points not classified as printable
+by <a href="/pkg/unicode/#IsPrint">unicode.IsPrint</a>.
+Previously Quote would escape all non-ASCII characters.
+This also affects the <a href="/pkg/fmt/">fmt</a> package's <code>"%q"</code>
+formatting directive. The previous quoting behavior is still available via
+strconv's new <a href="/pkg/strconv/#QuoteToASCII">QuoteToASCII</a> function.
+</p>
+
+<p>
+<a href="/pkg/os/signal/">Package os/signal</a>'s
+<a href="/pkg/os/#Signal">Signal</a> and
+<a href="/pkg/os/#UnixSignal">UnixSignal</a> types have been moved to the
+<a href="/pkg/os/">os</a> package.
+</p>
+
+<p>
+<a href="/pkg/image/draw/">Package image/draw</a> is the new name for
+<code>exp/draw</code>. The GUI-related code from <code>exp/draw</code> is now
+located in the <a href="/pkg/exp/gui/">exp/gui</a> package.
+</p>
+
+<h3 id="r58.cmd">Tools</h3>
+
+<p>
+<a href="/cmd/goinstall/">Goinstall</a> now observes the GOPATH environment
+variable to build and install your own code and external libraries outside of
+the Go tree (and avoid writing Makefiles).
+</p>
+
+
+<h3 id="r58.minor">Minor revisions</h3>
+
+<p>r58.1 adds
+<a href="//golang.org/change/293c25943586">build</a> and
+<a href="//golang.org/change/bf17e96b6582">runtime</a>
+changes to make Go run on OS X 10.7 Lion.
+</p>
+
+<h2 id="r57">r57 (released 2011/05/03)</h2>
+
+<p>
+The r57 release corresponds to
+<code><a href="weekly.html#2011-04-27">weekly.2011-04-27</a></code>
+with additional bug fixes.
+This section highlights the most significant changes in this release.
+For a more detailed summary, see the
+<a href="weekly.html#2011-04-27">weekly release notes</a>.
+For complete information, see the
+<a href="//code.google.com/p/go/source/list?r=release-branch.r57">Mercurial change list</a>.
+</p>
+
+<p>The new <a href="/cmd/gofix">gofix</a> tool finds Go programs that use old APIs and rewrites them to use
+newer ones. After you update to a new Go release, gofix helps make the
+necessary changes to your programs. Gofix will handle the http, os, and syscall
+package changes described below, and we will update the program to keep up with
+future changes to the libraries.
+Gofix can’t
+handle all situations perfectly, so read and test the changes it makes before
+committing them.
+See <a href="//blog.golang.org/2011/04/introducing-gofix.html">the gofix blog post</a> for more
+information.</p>
+
+<h3 id="r57.lang">Language</h3>
+
+<p>
+<a href="/doc/go_spec.html#Receive_operator">Multiple assignment syntax</a> replaces the <code>closed</code> function.
+The syntax for channel
+receives allows an optional second assigned value, a boolean value
+indicating whether the channel is closed. This code:
+</p>
+
+<pre>
+ v := <-ch
+ if closed(ch) {
+ // channel is closed
+ }
+</pre>
+
+<p>should now be written as:</p>
+
+<pre>
+ v, ok := <-ch
+ if !ok {
+ // channel is closed
+ }
+</pre>
+
+<p><a href="/doc/go_spec.html#Label_scopes">Unused labels are now illegal</a>, just as unused local variables are.</p>
+
+<h3 id="r57.pkg">Packages</h3>
+
+<p>
+<a href="/pkg/gob/">Package gob</a> will now encode and decode values of types that implement the
+<a href="/pkg/gob/#GobEncoder">GobEncoder</a> and
+<a href="/pkg/gob/#GobDecoder">GobDecoder</a> interfaces. This allows types with unexported
+fields to transmit self-consistent descriptions; examples include
+<a href="/pkg/big/#Int.GobDecode">big.Int</a> and <a href="/pkg/big/#Rat.GobDecode">big.Rat</a>.
+</p>
+
+<p>
+<a href="/pkg/http/">Package http</a> has been redesigned.
+For clients, there are new
+<a href="/pkg/http/#Client">Client</a> and <a href="/pkg/http/#Transport">Transport</a>
+abstractions that give more control over HTTP details such as headers sent
+and redirections followed. These abstractions make it easy to implement
+custom clients that add functionality such as <a href="//code.google.com/p/goauth2/source/browse/oauth/oauth.go">OAuth2</a>.
+For servers, <a href="/pkg/http/#ResponseWriter">ResponseWriter</a>
+has dropped its non-essential methods.
+The Hijack and Flush methods are no longer required;
+code can test for them by checking whether a specific value implements
+<a href="/pkg/http/#Hijacker">Hijacker</a> or <a href="/pkg/http/#Flusher">Flusher</a>.
+The RemoteAddr and UsingTLS methods are replaced by <a href="/pkg/http/#Request">Request</a>'s
+RemoteAddr and TLS fields.
+The SetHeader method is replaced by a Header method;
+its result, of type <a href="/pkg/http/#Header">Header</a>,
+implements Set and other methods.
+</p>
+
+<p>
+<a href="/pkg/net/">Package net</a>
+drops the <code>laddr</code> argument from <a href="/pkg/net/#Conn.Dial">Dial</a>
+and drops the <code>cname</code> return value
+from <a href="/pkg/net/#LookupHost">LookupHost</a>.
+The implementation now uses <a href="/cmd/cgo/">cgo</a> to implement
+network name lookups using the C library getaddrinfo(3)
+function when possible. This ensures that Go and C programs
+resolve names the same way and also avoids the OS X
+application-level firewall.
+</p>
+
+<p>
+<a href="/pkg/os/">Package os</a>
+introduces simplified <a href="/pkg/os/#File.Open">Open</a>
+and <a href="/pkg/os/#File.Create">Create</a> functions.
+The original Open is now available as <a href="/pkg/os/#File.OpenFile">OpenFile</a>.
+The final three arguments to <a href="/pkg/os/#Process.StartProcess">StartProcess</a>
+have been replaced by a pointer to a <a href="/pkg/os/#ProcAttr">ProcAttr</a>.
+</p>
+
+<p>
+<a href="/pkg/reflect/">Package reflect</a> has been redesigned.
+<a href="/pkg/reflect/#Type">Type</a> is now an interface that implements
+all the possible type methods.
+Instead of a type switch on a Type <code>t</code>, switch on <code>t.Kind()</code>.
+<a href="/pkg/reflect/#Value">Value</a> is now a struct value that
+implements all the possible value methods.
+Instead of a type switch on a Value <code>v</code>, switch on <code>v.Kind()</code>.
+Typeof and NewValue are now called <a href="/pkg/reflect/#Type.TypeOf">TypeOf</a> and <a href="/pkg/reflect/#Value.ValueOf">ValueOf</a>
+To create a writable Value, use <code>New(t).Elem()</code> instead of <code>Zero(t)</code>.
+See <a href="//golang.org/change/843855f3c026">the change description</a>
+for the full details.
+The new API allows a more efficient implementation of Value
+that avoids many of the allocations required by the previous API.
+</p>
+
+<p>
+Remember that gofix will handle the bulk of the rewrites
+necessary for these changes to package APIs.
+</p>
+
+<h3 id="r57.cmd">Tools</h3>
+
+<p><a href="/cmd/gofix/">Gofix</a>, a new command, is described above.</p>
+
+<p>
+<a href="/cmd/gotest/">Gotest</a> is now a Go program instead of a shell script.
+The new <code>-test.short</code> flag in combination with package testing's Short function
+allows you to write tests that can be run in normal or “short” mode;
+all.bash runs tests in short mode to reduce installation time.
+The Makefiles know about the flag: use <code>make testshort</code>.
+</p>
+
+<p>
+The run-time support now implements CPU and memory profiling.
+Gotest's new
+<a href="/cmd/gotest/"><code>-test.cpuprofile</code> and
+<code>-test.memprofile</code> flags</a> make it easy to
+profile tests.
+To add profiling to your web server, see the <a href="/pkg/http/pprof/">http/pprof</a>
+documentation.
+For other uses, see the <a href="/pkg/runtime/pprof/">runtime/pprof</a> documentation.
+</p>
+
+<h3 id="r57.minor">Minor revisions</h3>
+
+<p>r57.1 fixes a <a href="//golang.org/change/ff2bc62726e7145eb2ecc1e0f076998e4a8f86f0">nil pointer dereference in http.FormFile</a>.</p>
+<p>r57.2 fixes a <a href="//golang.org/change/063b0ff67d8277df03c956208abc068076818dae">use of uninitialized memory in programs that misuse <code>goto</code></a>.</p>
+
+<h2 id="r56">r56 (released 2011/03/16)</h2>
+
+<p>
+The r56 release was the first stable release and corresponds to
+<code><a href="weekly.html#2011-03-07">weekly.2011-03-07.1</a></code>.
+The numbering starts at 56 because before this release,
+what we now consider weekly snapshots were called releases.
+</p>
diff --git a/_content/doc/devel/release.html b/_content/doc/devel/release.html
new file mode 100644
index 0000000..3e887f6
--- /dev/null
+++ b/_content/doc/devel/release.html
@@ -0,0 +1,402 @@
+<!--{
+ "Title": "Release History",
+ "Template": true
+}-->
+
+<p>This page summarizes the changes between official stable releases of Go.
+The <a href="//golang.org/change">change log</a> has the full details.</p>
+
+<p>To update to a specific release, use:</p>
+
+<pre>
+git fetch --tags
+git checkout <i>goX.Y.Z</i>
+</pre>
+
+<h2 id="policy">Release Policy</h2>
+
+<p>
+Each major Go release is supported until there are two newer major releases.
+For example, Go 1.5 was supported until the Go 1.7 release, and Go 1.6 was
+supported until the Go 1.8 release.
+We fix critical problems, including <a href="/security">critical security problems</a>,
+in supported releases as needed by issuing minor revisions
+(for example, Go 1.6.1, Go 1.6.2, and so on).
+</p>
+
+{{range releases}}
+{{if ge .Version.Y 9}}
+ <h2 id="go{{.Version}}">go{{.Version}} (released {{.Date}})</h2>
+
+ <p>
+ Go {{.Version}} is a major release of Go.
+ Read the <a href="/doc/go{{.Version}}">Go {{.Version}} Release Notes</a> for more information.
+ </p>
+
+ {{if .Minor}}<h3 id="go{{.Version}}.minor">Minor revisions</h3>{{end}}
+
+ {{range .Minor}}
+ <p>
+ go{{.Version}}
+ ({{if .Future}}planned for{{else}}released{{end}} {{.Date}})
+ {{with .CustomSummary}}
+ {{.}}
+ {{else}}
+ {{if .Future}}will include{{else}}includes{{end}}
+ {{.Quantifier}}
+ {{if .Security}}security{{end}}
+ {{if eq .Quantifier "a"}}fix{{else}}fixes{{end -}}
+ {{with .ComponentsAndPackages}} to {{.}}{{end}}.
+ {{.More}}
+
+ {{if not .Future}}
+ See the
+ <a href="https://github.com/golang/go/issues?q=milestone%3AGo{{.Version}}+label%3ACherryPickApproved">Go {{.Version}} milestone</a>
+ on our issue tracker for details.
+ {{end}}
+ {{end}}
+ </p>
+ {{end}}
+{{end}}
+{{end}}
+
+{{/* Entries for Go 1.9 and newer are generated using data in the internal/history package. */}}
+{{/* Entries for Go 1.8.7 and older are hand-written as raw HTML below. */}}
+
+<h2 id="go1.8">go1.8 (released 2017-02-16)</h2>
+
+<p>
+Go 1.8 is a major release of Go.
+Read the <a href="/doc/go1.8">Go 1.8 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.8.minor">Minor revisions</h3>
+
+<p>
+go1.8.1 (released 2017-04-07) includes fixes to the compiler, linker, runtime,
+documentation, <code>go</code> command and the <code>crypto/tls</code>,
+<code>encoding/xml</code>, <code>image/png</code>, <code>net</code>,
+<code>net/http</code>, <code>reflect</code>, <code>text/template</code>,
+and <code>time</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.1">Go
+1.8.1 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.8.2 (released 2017-05-23) includes a security fix to the
+<code>crypto/elliptic</code> package.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.2">Go
+1.8.2 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.8.3 (released 2017-05-24) includes fixes to the compiler, runtime,
+documentation, and the <code>database/sql</code> package.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.3">Go
+1.8.3 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.8.4 (released 2017-10-04) includes two security fixes.
+It contains the same fixes as Go 1.9.1 and was released at the same time.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.4">Go
+1.8.4 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.8.5 (released 2017-10-25) includes fixes to the compiler, linker, runtime,
+documentation, <code>go</code> command,
+and the <code>crypto/x509</code> and <code>net/smtp</code> packages.
+It includes a fix to a bug introduced in Go 1.8.4 that broke <code>go</code> <code>get</code>
+of non-Git repositories under certain conditions.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.5">Go
+1.8.5 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.8.6 (released 2018-01-22) includes the same fix in <code>math/big</code>
+as Go 1.9.3 and was released at the same time.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.6">Go
+1.8.6 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.8.7 (released 2018-02-07) includes a security fix to "go get".
+It contains the same fix as Go 1.9.4 and was released at the same time.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.7">Go
+1.8.7</a> milestone on our issue tracker for details.
+</p>
+
+<h2 id="go1.7">go1.7 (released 2016-08-15)</h2>
+
+<p>
+Go 1.7 is a major release of Go.
+Read the <a href="/doc/go1.7">Go 1.7 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.7.minor">Minor revisions</h3>
+
+<p>
+go1.7.1 (released 2016-09-07) includes fixes to the compiler, runtime,
+documentation, and the <code>compress/flate</code>, <code>hash/crc32</code>,
+<code>io</code>, <code>net</code>, <code>net/http</code>,
+<code>path/filepath</code>, <code>reflect</code>, and <code>syscall</code>
+packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.7.1">Go
+1.7.1 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.7.2 should not be used. It was tagged but not fully released.
+The release was deferred due to a last minute bug report.
+Use go1.7.3 instead, and refer to the summary of changes below.
+</p>
+
+<p>
+go1.7.3 (released 2016-10-19) includes fixes to the compiler, runtime,
+and the <code>crypto/cipher</code>, <code>crypto/tls</code>,
+<code>net/http</code>, and <code>strings</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.7.3">Go
+1.7.3 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.7.4 (released 2016-12-01) includes two security fixes.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.7.4">Go
+1.7.4 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.7.5 (released 2017-01-26) includes fixes to the compiler, runtime,
+and the <code>crypto/x509</code> and <code>time</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.7.5">Go
+1.7.5 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.7.6 (released 2017-05-23) includes the same security fix as Go 1.8.2 and
+was released at the same time.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.2">Go
+1.8.2 milestone</a> on our issue tracker for details.
+</p>
+
+<h2 id="go1.6">go1.6 (released 2016-02-17)</h2>
+
+<p>
+Go 1.6 is a major release of Go.
+Read the <a href="/doc/go1.6">Go 1.6 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.6.minor">Minor revisions</h3>
+
+<p>
+go1.6.1 (released 2016-04-12) includes two security fixes.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.6.1">Go
+1.6.1 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.6.2 (released 2016-04-20) includes fixes to the compiler, runtime, tools,
+documentation, and the <code>mime/multipart</code>, <code>net/http</code>, and
+<code>sort</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.6.2">Go
+1.6.2 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.6.3 (released 2016-07-17) includes security fixes to the
+<code>net/http/cgi</code> package and <code>net/http</code> package when used in
+a CGI environment.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.6.3">Go
+1.6.3 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.6.4 (released 2016-12-01) includes two security fixes.
+It contains the same fixes as Go 1.7.4 and was released at the same time.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.7.4">Go
+1.7.4 milestone</a> on our issue tracker for details.
+</p>
+
+<h2 id="go1.5">go1.5 (released 2015-08-19)</h2>
+
+<p>
+Go 1.5 is a major release of Go.
+Read the <a href="/doc/go1.5">Go 1.5 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.5.minor">Minor revisions</h3>
+
+<p>
+go1.5.1 (released 2015-09-08) includes bug fixes to the compiler, assembler, and
+the <code>fmt</code>, <code>net/textproto</code>, <code>net/http</code>, and
+<code>runtime</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.5.1">Go
+1.5.1 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.5.2 (released 2015-12-02) includes bug fixes to the compiler, linker, and
+the <code>mime/multipart</code>, <code>net</code>, and <code>runtime</code>
+packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.5.2">Go
+1.5.2 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.5.3 (released 2016-01-13) includes a security fix to the <code>math/big</code> package
+affecting the <code>crypto/tls</code> package.
+See the <a href="https://golang.org/s/go153announce">release announcement</a> for details.
+</p>
+
+<p>
+go1.5.4 (released 2016-04-12) includes two security fixes.
+It contains the same fixes as Go 1.6.1 and was released at the same time.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.6.1">Go
+1.6.1 milestone</a> on our issue tracker for details.
+</p>
+
+<h2 id="go1.4">go1.4 (released 2014-12-10)</h2>
+
+<p>
+Go 1.4 is a major release of Go.
+Read the <a href="/doc/go1.4">Go 1.4 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.4.minor">Minor revisions</h3>
+
+<p>
+go1.4.1 (released 2015-01-15) includes bug fixes to the linker and the <code>log</code>, <code>syscall</code>, and <code>runtime</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.4.1">Go 1.4.1 milestone on our issue tracker</a> for details.
+</p>
+
+<p>
+go1.4.2 (released 2015-02-17) includes bug fixes to the <code>go</code> command, the compiler and linker, and the <code>runtime</code>, <code>syscall</code>, <code>reflect</code>, and <code>math/big</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.4.2">Go 1.4.2 milestone on our issue tracker</a> for details.
+</p>
+
+<p>
+go1.4.3 (released 2015-09-22) includes security fixes to the <code>net/http</code> package and bug fixes to the <code>runtime</code> package.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.4.3">Go 1.4.3 milestone on our issue tracker</a> for details.
+</p>
+
+<h2 id="go1.3">go1.3 (released 2014-06-18)</h2>
+
+<p>
+Go 1.3 is a major release of Go.
+Read the <a href="/doc/go1.3">Go 1.3 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.3.minor">Minor revisions</h3>
+
+<p>
+go1.3.1 (released 2014-08-13) includes bug fixes to the compiler and the <code>runtime</code>, <code>net</code>, and <code>crypto/rsa</code> packages.
+See the <a href="https://github.com/golang/go/commits/go1.3.1">change history</a> for details.
+</p>
+
+<p>
+go1.3.2 (released 2014-09-25) includes bug fixes to cgo and the crypto/tls packages.
+See the <a href="https://github.com/golang/go/commits/go1.3.2">change history</a> for details.
+</p>
+
+<p>
+go1.3.3 (released 2014-09-30) includes further bug fixes to cgo, the runtime package, and the nacl port.
+See the <a href="https://github.com/golang/go/commits/go1.3.3">change history</a> for details.
+</p>
+
+<h2 id="go1.2">go1.2 (released 2013-12-01)</h2>
+
+<p>
+Go 1.2 is a major release of Go.
+Read the <a href="/doc/go1.2">Go 1.2 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.2.minor">Minor revisions</h3>
+
+<p>
+go1.2.1 (released 2014-03-02) includes bug fixes to the <code>runtime</code>, <code>net</code>, and <code>database/sql</code> packages.
+See the <a href="https://github.com/golang/go/commits/go1.2.1">change history</a> for details.
+</p>
+
+<p>
+go1.2.2 (released 2014-05-05) includes a
+<a href="https://github.com/golang/go/commits/go1.2.2">security fix</a>
+that affects the tour binary included in the binary distributions (thanks to Guillaume T).
+</p>
+
+<h2 id="go1.1">go1.1 (released 2013-05-13)</h2>
+
+<p>
+Go 1.1 is a major release of Go.
+Read the <a href="/doc/go1.1">Go 1.1 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.1.minor">Minor revisions</h3>
+
+<p>
+go1.1.1 (released 2013-06-13) includes several compiler and runtime bug fixes.
+See the <a href="https://github.com/golang/go/commits/go1.1.1">change history</a> for details.
+</p>
+
+<p>
+go1.1.2 (released 2013-08-13) includes fixes to the <code>gc</code> compiler
+and <code>cgo</code>, and the <code>bufio</code>, <code>runtime</code>,
+<code>syscall</code>, and <code>time</code> packages.
+See the <a href="https://github.com/golang/go/commits/go1.1.2">change history</a> for details.
+If you use package syscall's <code>Getrlimit</code> and <code>Setrlimit</code>
+functions under Linux on the ARM or 386 architectures, please note change
+<a href="//golang.org/cl/11803043">11803043</a>
+that fixes <a href="//golang.org/issue/5949">issue 5949</a>.
+</p>
+
+<h2 id="go1">go1 (released 2012-03-28)</h2>
+
+<p>
+Go 1 is a major release of Go that will be stable in the long term.
+Read the <a href="/doc/go1.html">Go 1 Release Notes</a> for more information.
+</p>
+
+<p>
+It is intended that programs written for Go 1 will continue to compile and run
+correctly, unchanged, under future versions of Go 1.
+Read the <a href="/doc/go1compat.html">Go 1 compatibility document</a> for more
+about the future of Go 1.
+</p>
+
+<p>
+The go1 release corresponds to
+<code><a href="weekly.html#2012-03-27">weekly.2012-03-27</a></code>.
+</p>
+
+<h3 id="go1.minor">Minor revisions</h3>
+
+<p>
+go1.0.1 (released 2012-04-25) was issued to
+<a href="//golang.org/cl/6061043">fix</a> an
+<a href="//golang.org/issue/3545">escape analysis bug</a>
+that can lead to memory corruption.
+It also includes several minor code and documentation fixes.
+</p>
+
+<p>
+go1.0.2 (released 2012-06-13) was issued to fix two bugs in the implementation
+of maps using struct or array keys:
+<a href="//golang.org/issue/3695">issue 3695</a> and
+<a href="//golang.org/issue/3573">issue 3573</a>.
+It also includes many minor code and documentation fixes.
+</p>
+
+<p>
+go1.0.3 (released 2012-09-21) includes minor code and documentation fixes.
+</p>
+
+<p>
+See the <a href="https://github.com/golang/go/commits/release-branch.go1">go1 release branch history</a> for the complete list of changes.
+</p>
+
+<h2 id="pre.go1">Older releases</h2>
+
+<p>
+See the <a href="pre_go1.html">Pre-Go 1 Release History</a> page for notes
+on earlier releases.
+</p>
diff --git a/_content/doc/devel/weekly.html b/_content/doc/devel/weekly.html
new file mode 100644
index 0000000..cf3ea59
--- /dev/null
+++ b/_content/doc/devel/weekly.html
@@ -0,0 +1,6200 @@
+<!--{
+ "Title": "Weekly Snapshot History"
+}-->
+
+<p>This page summarizes the changes between tagged weekly snapshots of Go.
+Such snapshots are no longer created. This page remains as a historical reference only.</p>
+
+<p>For recent information, see the <a href="//golang.org/change">change log</a> and <a href="//groups.google.com/group/golang-dev/">development mailing list</a>.</p>
+
+<h2 id="2012-03-27">2012-03-27 (<a href="release.html#go1">Go 1</a>)</h2>
+
+<pre>
+* cmd/dist: fix detection of go1 version.
+* cmd/go: add missing error check (thanks Evan Shaw),
+ allow underscores in tool name (thanks Shenghou Ma),
+ bug fixes,
+ copy tag_test.go from goinstall,
+ explain versions better,
+ respect $GOBIN always,
+ update for go1 tag format.
+* cmd/godoc: canonicalize custom path redirects,
+ fix app engine version,
+ use virtual filesystem to implement -templates flag.
+* codewalk/sharemem.xml: fix references to files.
+* crypto/tls: don't select ECC ciphersuites with no mutual curve.
+* doc: add JSON-RPC: a tale of interfaces article (thanks Francisco Souza),
+ describe the Windows MSI installer as experimental,
+ link to Go Project Dashboard from package list,
+ update wiki tutorial templates and template discussion,
+ and many minor fixes.
+* exp/types: generalized GCImporter API.
+* go/build: cgoEnabled is not known to cmd/dist anymore (thanks Shenghou Ma),
+ fix import check.
+* godoc: make 'Overview' section collapsible.
+* misc/dist: many fixes and tweaks.
+* misc/emacs: fix indentation bug.
+* misc/goplay: fix error on IE8 (thanks Yasuhiro Matsumoto).
+* net: ignore ECONNABORTED from syscall.Accept (thanks Devon H. O'Dell).
+* os: add missing byte to FileMode buffer (thanks Stefan Nilsson).
+* path/filepath: convert drive letter to upper case in windows EvalSymlinks (thanks Alex Brainman),
+ correct comment in EvalSymlinks (thanks Alex Brainman),
+ use windows GetShortPathName api to force GetLongPathName to do its work (thanks Alex Brainman),
+ windows drive letter cannot be a digit (thanks Alex Brainman).
+* run.bash: compile the codewalks.
+* runtime: restore deadlock detection in the simplest case (thanks Rémy Oudompheng),
+ work around false negative in deadlock detection.
+* text/template: fix typo in package comment.
+* windows: installer fixes (thanks Joe Poirier).
+</pre>
+
+<h2 id="2012-03-22">2012-03-22 (Go 1 Release Candidate 2)</h2>
+
+<pre>
+As with last week's snapshot, this snapshot is another Go 1 release candidate.
+A notable change in this snapshot are Windows installer fixes.
+
+Changes in this snapshot:
+* 5l, 6l, 8l: fix stack split logic for stacks near default segment size.
+* archive/zip: move r.zip off disk, into reader_test.go.
+* build: catch API changes during build,
+ do more during windows build (thanks Alex Brainman),
+ lengthen timeout for the lengthy runtime test (thanks Shenghou Ma),
+ unset GOPATH before tests (thanks Shenghou Ma).
+* cmd/cgo: add support for function export for gccgo (thanks Rémy Oudompheng),
+ fix handling of errno for gccgo.
+* cmd/go: add -fno-common by default on Darwin (thanks Shenghou Ma),
+ don't add detail to errPrintedOutput,
+ fix directory->import path conversion,
+ make build errors more visible,
+ use .o, not .{5,6,8}, for gccgo created object files,
+ work around occasional ETXTBSY running cgo.
+* cmd/godoc: add toys, tour button to playground,
+ inform users that the playground doesn't work via local godoc,
+ style example headings like links,
+ use *goroot as base path in zip file,
+ use FormatText for formating code in html template,
+ use shorter titles for tabs.
+* cmd/gofmt: show ascii in usage (thanks Yasuhiro Matsumoto).
+* cmd/pack: also recognize '\\' as path separator in filenames (thanks Shenghou Ma).
+* crypto/tls: always send a Certificate message if one was requested.
+* doc/install: remove reference to "Go Tutorial" (thanks Shenghou Ma).
+* doc/play: use []rune instead of []int (thanks Yasuhiro Matsumoto).
+* doc: add Go Concurrency Patterns: Timing out, moving on article (thanks Francisco Souza),
+ add Go image/draw package article and convert code snippets to Go1,
+ add Gobs of data article (thanks Francisco Souza),
+ add Godoc: documenting Go code article (thanks Francisco Souza),
+ add JSON and Go article (thanks Francisco Souza),
+ general update of gccgo installation instructions,
+ minor updates to most docs.
+* flag: add examples.
+* gc: fix struct and array comparisons for new bool rules (thanks Anthony Martin),
+ use quoted string format in import error,
+ when expanding append inline, preserve arguments.
+* go/build: clarify why we exclude files starting with '_' or '.' (thanks Shenghou Ma),
+ clearer argument name for Import (src -> srcDir),
+ do not report Target for local imports,
+ fix match.
+* go/printer, gofmt: fix multi-line logic.
+* html/template: add Templates and XXXEscape functions,
+ fix nil pointer bug,
+ fix panic on Clone.
+* io/ioutil: fix crash when Stat fails.
+* make.bat: fix for old files (thanks Christopher Redden),
+ don't show error message if old generated files do not exist (thanks Shenghou Ma),
+ properly handle directories with spaces (thanks Alex Brainman).
+* misc/cgo/gmp: update for Go 1 (thanks Shenghou Ma).
+* misc/dashboard: remove old python package dashboard.
+* misc/dist: don't ship cmd/cov or cmd/prof,
+ force modes to 0755 or 0644 in tarballs,
+ remove exp and old before building.
+* misc/vim: restore fileencodings (thanks Yasuhiro Matsumoto).
+* net/http: couple more triv.go modernizations,
+ ensure triv.go compiles and runs (thanks Robert Hencke).
+* net: drop unnecessary type assertions and fix leak in test (thanks Mikio Hara).
+* os: IsNotExist() should also consider ERROR_PATH_NOT_FOUND on Windows (thanks Shenghou Ma),
+ do not assume syscall.Write will write everything,
+ remove document duplication in error predicate functions (thanks Shenghou Ma),
+ return some invented data from Stat(DevNull) on windows (thanks Alex Brainman).
+* path/filepath: implement Match and Glob on windows (thanks Alex Brainman).
+* reflect: document PkgPath, Method, StructField,
+ panic if MakeSlice is given bad len/cap arguments.
+* run.bat: disable test in test\bench\go1 to fix build (thanks Alex Brainman).
+* runtime/cgo: darwin signal masking (thanks Mikio Hara),
+ linux signal masking (thanks Mikio Hara).
+* runtime: do not handle signals before configuring handler,
+ manage stack by ourselves for badcallback on windows/amd64 (thanks Shenghou Ma),
+ remove unused goc2c.c (thanks Shenghou Ma).
+* sort: add time complexity to doc (thanks Stefan Nilsson),
+ fix computation of maxDepth to avoid infinite loop (thanks Stefan Nilsson).
+* spec: delete references to unsafe.Reflect,Typeof,Unreflect.
+* syscall: Test SCM_CREDENTIALS, SO_PASSCRED on Linux (thanks Albert Strasheim),
+ add a test for passing an fd over a unix socket,
+ delete passfd_test.go.
+* test: use testlib in a few more cases (thanks Shenghou Ma).
+* text/template: fix a couple of parse bugs around identifiers,
+ variables do not take arguments.
+</pre>
+
+<h2 id="2012-03-13">2012-03-13 (Go 1 Release Candidate 1)</h2>
+
+<pre>
+This weekly snapshot is very close to what we expect will be the contents of
+the Go 1 release. There are still a few minor documentation issues to resolve,
+and a handful of bugs that should be addressed before the release, but the vast
+majority of Go programs should be completely unaffected by any changes we make
+between now and the full release.
+
+If you're interested in helping us test, eager to try out Go 1, or just
+curious, this weekly snapshot is the one to try. We'll issue a new App Engine
+Go 1 beta SDK very soon, so if you're an App Engine user you can try it there
+too.
+
+To help us focus on any remaining bugs and avoid introducing new ones, we will
+restrict our attention to critical fixes and issues marked Go1-Must in the
+issue tracker. Everything non-essential will be held until after the Go 1
+release is cut and in the field for a while.
+
+Changes in this snapshot:
+* archive/zip: verify CRC32s in non-streamed files,
+ write data descriptor signature for OS X; fix bugs reading it.
+* build: build correct cmd/dist matching GOHOSTARCH (thanks Shenghou Ma),
+ re-enable some broken tests in run.bash (thanks Shenghou Ma),
+ remove some references to Make.inc etc.
+ use run.go for running tests.
+* builder: use short test for subrepos (thanks Shenghou Ma).
+* cgo, runtime: diagnose callback on non-Go thread.
+* cmd/api: set compiler for all build contexts,
+ work on Windows again, and make gccgo files work a bit more.
+* cmd/cgo: document CGO_LDFLAGS and CGO_CFLAGS,
+ silence const warnings.
+* cmd/dist, cmd/go: move CGO_ENABLED from 'go tool dist env' to 'go env' (thanks Shenghou Ma).
+* cmd/dist: fix build for Linux/ARM (thanks Shenghou Ma),
+ use correct hg tag for go version (thanks Alex Brainman).
+* cmd/fix: add rules for net/http -> net/http/httputil renames.
+* cmd/gc: allow ~ in import paths,
+ delete old map delete in walk,
+ do not confuse unexported methods of same name,
+ if $GOROOT_FINAL is set, rewrite file names in object files,
+ implement len(array) / cap(array) rule,
+ import path cannot start with slash on Windows (thanks Shenghou Ma),
+ must not inline panic, recover,
+ show duplicate key in error,
+ unnamed struct types can have methods.
+* cmd/go: add -compiler,
+ add env command, use to fix misc/cgo/testso,
+ allow go get with arbitrary URLs,
+ allow ssh tunnelled bzr, git and svn (thanks Ingo Oeser),
+ always provide .exe suffix on windows (thanks Shenghou Ma),
+ document import path meta tag discovery in go help remote,
+ honor buildflags in run, test (thanks Rémy Oudompheng),
+ local import fixes,
+ make go get new.code/... work,
+ rebuild external test package dependencies,
+ respect $GOBIN always,
+ support -compiler for go list, fix isStale for gccgo (thanks Rémy Oudompheng).
+* cmd/godoc: add support for serving templates.
+ fix codewalk handler (thanks Francisco Souza).
+ remove extra / in paths (thanks Ugorji Nwoke),
+ support $GOPATH, simplify file system code,
+ switch on +1 buttons.
+* cmd/gofmt: fix race in long test (thanks Mikio Hara).
+* codereview: fix for Mercurial 2.1.
+* crypto/x509: allow server gated crypto in windows systemVerify (thanks Mikkel Krautz),
+ do not forget to free cert context (thanks Alex Brainman),
+ don't include empty additional primes in PKCS#1 private key,
+ enforce path length constraint,
+ new home for root fetchers; build chains using Windows API (thanks Mikkel Krautz).
+* csv: clarify what a negative FieldsPerRecord means.
+* database/sql: add docs about connection state, pooling,
+ ensure Stmts are correctly closed (thanks Gwenael Treguier),
+ fix double connection free on Stmt.Query error,
+ fix typo bug resulting in double-Prepare.
+* database/sql: add ErrBadConn.
+* doc/go1: template packages have changed since r60.
+* doc/go_mem: init-created goroutine behavior changes for Go 1 (thanks Shenghou Ma).
+* doc/gopher: flip frontpage gopher's eyes.
+* doc: add "About the go command" article,
+ add C? Go? Cgo! article (thanks Francisco Souza),
+ add Go's declaration syntax article (thanks Francisco Souza),
+ add more gophers,
+ add note about import . to Go 1 compatibility notes,
+ several doc fixes and improvements,
+ update Effective Go init section,
+ update progs/run (thanks Shenghou Ma),
+ update reference gopher,
+ web site tweaks.
+* encoding/asn1: handle UTCTime before the year 2000.
+* encoding/binary: improve package comment (thanks Stefan Nilsson).
+* encoding/gob: fix memory corruption.
+* encoding/json: document that nil slice encodes as `null`.
+* exp/wingui: moved to code.google.com/p/gowingui.
+* expvar: add locking to String, and use RWMutex properly throughout,
+ add missing locking in String methods.
+* fmt, log: stop using unicode.
+* fmt: minor tweak of package doc to show headings in godoc (thanks Volker Dobler).
+* go/build, cmd/go: add support for .syso files.
+* go/build: add NoGoError,
+ add dependency test,
+ do not parse .syso files (thanks Alex Brainman).
+* go/parser: avoid endless loop in case of internal error,
+ better error synchronization.
+* go/printer, gofmt: nicer formatting of multi-line returns.
+* go/printer: example for Fprint.
+* go/scanner: better panic diagnostic.
+* go spec: no known implementation differences anymore,
+ fix inaccuracy in type identity definition.
+* io: better document WriterAt.
+* misc/dashboard: remove obsolete package builder code.
+* misc/dist: add source archive support,
+ add windows installer and zip support,
+ minimum target requirement is 10.6 for Darwin (thanks Shenghou Ma).
+* misc/emacs: fix extra indentation after comments that end with a period.
+* misc/xcode: example install of language spec for Xcode 4.x (thanks Emil Hessman).
+* net, net/rpc, reflect, time: document concurrency guarantees.
+* net/http: fix crash with Transport.CloseIdleConnections,
+ return appropriate errors from ReadRequest.
+* net: add skip message to test (thanks Mikio Hara),
+ disable use of external listen along with other external network uses,
+ do not use reflect for DNS messages (thanks Rémy Oudompheng),
+ document ReadMsgUnix, WriteMsgUnix,
+ fix TestDialTimeout on windows builder,
+ improve server and file tests (thanks Mikio Hara),
+ make Dial and Listen behavior consistent across over platforms (thanks Mikio Hara),
+ remove dependence on bytes, fmt, strconv,
+ silence another epoll print,
+ use IANA reserved port to test dial timeout (thanks Mikio Hara).
+* os: document FileInfo.Size as system-dependent for irregular files,
+ fix SameFile to work for directories on windows (thanks Alex Brainman).
+* path/filepath/path_test.go: repair and enable TestAbs.
+* path/filepath: disable AbsTest on windows,
+ retrieve real file name in windows EvalSymlinks (thanks Alex Brainman).
+* runtime/pprof: disable test on Leopard 64-bit.
+* runtime: add Compiler,
+ fix windows/amd64 exception handler (thanks Alex Brainman),
+ inline calls to notok,
+ move runtime.write back to C,
+ print error on receipt of signal on non-Go thread,
+ remove unused runtime·signame and runtime·newError,
+ try extending arena size in 32-bit allocator (thanks Rémy Oudompheng),
+ wait for main goroutine before setting GOMAXPROCS (thanks Rémy Oudompheng).
+* strconv: add table-based isPrint, remove dependence on bytes, unicode, and strings.
+* sync/atomic: disable store and load test on a single processor machine (thanks Mikio Hara).
+* syscall: fix mkall.sh, mksyscall_linux.pl, and regen for Linux/ARM (thanks Shenghou Ma).
+* test/run: use all available cores on ARM system (thanks Shenghou Ma).
+* test: actually run them on windows (thanks Alex Brainman),
+ add inherited interface test to ddd.go,
+ enable method expression tests in ddd.go,
+ invoke go command in run.go,
+ match gccgo error messages for bug388.go,
+ skip . files in directory.
+* testing: do not print 'no tests' when there are examples.
+* time: during short test, do not bother tickers take longer than expected (thanks Shenghou Ma),
+ mention receiver in Unix, UnixNano docs.
+* unicode/utf16: remove dependence on package unicode.
+* unicode/utf8: remove dependence on unicode.
+* windows: make background of gopher icon transparent (thanks Volker Dobler).
+</pre>
+
+<h2 id="2012-03-04">2012-03-04</h2>
+
+<pre>
+This snapshot includes a major re-design of the go/build package.
+Its FindTree, ScanDir, Tree, and DirInfo types have been replaced with the
+Import and Package types. There is no gofix. Code that uses go/build will need
+to be updated manually to use the package's new interface.
+
+Other changes:
+* 6a/6l: add IMUL3Q and SHLDL.
+* all: remove unused unexported functions and constants (thanks Rémy Oudompheng).
+* build: add GO_ prefix to LDFLAGS and GCFLAGS (thanks Gustavo Niemeyer).
+* cmd/cc: fix an out of bounds array access (thanks Anthony Martin),
+ grow some global arrays.
+* cmd/dist: force line-buffering stdout/stderr on Unix (thanks Shenghou Ma),
+ recognize CC="ccache clang" as clang.
+* cmd/go: avoid repeated include dirs (thanks Rémy Oudompheng),
+ fix -I flag for gc command (thanks Gustavo Niemeyer),
+ fix verbose command displaying (thanks Gustavo Niemeyer),
+ fixes for gccgo (thanks Rémy Oudompheng),
+ many fixes,
+ test -i should not disable -c (thanks Shenghou Ma).
+* cmd/vet: don't give error for Printf("%+5.2e", x) (thanks Shenghou Ma).
+* cmd/yacc/units.y: update comment, give better error messages when $GOROOT not set (thanks Shenghou Ma).
+* crypto/tls: force OS X target version to 10.6 for API compatibility (thanks Mikkel Krautz).
+* crypto/x509: fix typo in Verify documentation (thanks Mikkel Krautz).
+* dist: treat CC as one unit (thanks Scott Lawrence).
+* doc/go1: add justification discussions to major changes,
+ minor corrections and updates.
+* doc: describe API changes to go/build,
+ elaborate available checks for cmd/vet (thanks Shenghou Ma),
+ expand code.html to discuss the go tool in more depth,
+ instruct FreeBSD/Linux users to rm the old version first,
+ remove Go for C++ Programmers,
+ remove roadmap document,
+ remove tutorial,
+ update codelab/wiki to Go 1 (thanks Shenghou Ma),
+* encoding/gob: fix "// +build" comment for debug.go (thanks Shenghou Ma),
+ more hardening for lengths of input strings.
+* encoding/json: drop MarshalForHTML; gofix calls to Marshal,
+ escape output from Marshalers.
+* encoding/xml: fix anonymous field Unmarshal example (thanks Gustavo Niemeyer),
+ fix xml test tag usage (thanks Gustavo Niemeyer).
+* gc: disallow absolute import paths,
+ fix escape analysis + inlining + closure bug,
+ fix string comparisons for new bool rules (thanks Anthony Martin),
+ reject import paths containing special characters (thanks Anthony Martin).
+* go/ast: examples for ast.Print, ast.Inspect.
+* go/doc, godoc: fix range of type declarations.
+* go/parser: check import path restrictions,
+ expand test cases for bad import.
+* go/printer, gofmt: improved comment placement.
+* go/printer: fix printing of variadic function calls (thanks Anthony Martin),
+ fix test for new import path restrictions (thanks Anthony Martin),
+ replace multiline logic,
+ simpler exprList code, more tests.
+* godoc: add Examples link to top-level index,
+ bring back highlighting, selections, and alerts,
+ consistent placement of documentation sections,
+ don't show directories w/o packages in flat dir mode,
+ don't show testdata directories,
+ fix codewalks.
+* gotype: provide -comments flag.
+* html/template: make doctype check case-insensitive (thanks Scott Lawrence),
+ use correct method signature in introduction example (thanks Mike Rosset).
+* io: document that I/O is not necessarily safe for parallel access.
+* ld: allow more -L options (thanks Shenghou Ma),
+ fix alignment of rodata section.
+* misc: add zsh completion for go tool (thanks Rémy Oudompheng).
+* misc/bash: Completion for go tool (thanks Yissakhar Z. Beck).
+* misc/dashboard: fix bug in UI template,
+ record install counts for external packages.
+* misc/dist: implement binary distribution scripts in go.
+* misc/gobuilder: send commit time in RFC3339 format.
+* misc/xcode: move Xcode3 specific files into sub directory.
+* net/http/cgi: add an empty response test,
+ fix empty response.
+* net/http/httptest: make Server.Close wait for outstanding requests to finish.
+* net/http/httputil: fix DumpRequestOut on https URLs,
+ make https DumpRequestOut less racy.
+* net/http: add overlooked 418 status code, per RFC 2324,
+ fix ProxyFromEnvironment bug, docs, add tests,
+ make a test more paranoid & reliable on Windows.
+* net/rpc: silence read error on closing connection.
+* net: add stubs for NetBSD (thanks Benny Siegert),
+ make -external flag for tests default to true (thanks Mikio Hara),
+ reorganize test files (thanks Mikio Hara).
+* os: diagnose chdir error during StartProcess,
+ implement UserTime/SystemTime on windows (thanks Alex Brainman),
+ implement sameFile on windows (thanks Alex Brainman),
+ release process handle at the end of windows (*Process).Wait (thanks Alex Brainman),
+ sleep 5ms after process has exited on windows (thanks Alex Brainman).
+* path/filepath: note that SplitList is different from strings.Split,
+ steer people away from HasPrefix.
+* reflect: don't panic comparing functions in DeepEqual.
+ make Value.Interface return immutable data.
+* runtime/pprof: support OS X CPU profiling.
+* runtime: add sanity checks to the runtime-gdb.py prettyprinters,
+ check for ARM syscall failures (thanks Shenghou Ma),
+ darwin and linux signal masking,
+ run init on main thread,
+ size arena to fit in virtual address space limit.
+* spec: allow disallow of \uFFFD in import path,
+ apply method sets, embedding to all types, not just named types,
+ clarifications around exports, uniqueness of identifiers,
+ import path implementation restriction,
+ inside functions, variables must be evaluated,
+ use the term "lexical token" (rather then "lexical symbol").
+* sync: add Once example, remove old WaitGroup example.
+* test/bench/shootout: update post-Makefile.
+* test: add documentation, misc fixes.
+* testing: add -test.example flag to control execution of examples.
+* text/template: add example showing use of custom function,
+ add examples that use multiple templates,
+ fix redefinition bugs.
+* time: add a comment about how to use the Duration constants.
+</pre>
+
+<h2 id="2012-02-22">2012-02-22</h2>
+
+<pre>
+This weekly snapshot includes changes to the os and runtime packages.
+
+This should be the last of the significant incompatible changes before Go 1.
+
+There are no longer error constants such as EINVAL in the os package, since the
+set of values varied with the underlying operating system. There are new
+portable functions like IsPermission to test common error properties, plus a
+few new error values with more Go-like names, such as ErrPermission and
+ErrNoEnv.
+
+The os.Getenverror function has been removed. To distinguish between a
+non-existent environment variable and an empty string, use os.Environ or
+syscall.Getenv.
+
+The Process.Wait method has dropped its option argument and the associated
+constants are gone from the package. Also, the function Wait is gone; only the
+method of the Process type persists.
+
+The non-portable Waitmsg type has been replaced with the portable ProcessState.
+
+Much of the API exported by package runtime has been removed in favor of
+functionality provided by other packages. Code using the runtime.Type
+interface or its specific concrete type implementations should now use package
+reflect. Code using runtime.Semacquire or runtime.Semrelease should use
+channels or the abstractions in package sync.
+
+The runtime.Alloc, runtime.Free, and runtime.Lookup functions, an unsafe API
+created for debugging the memory allocator, have no replacement.
+
+The runtime.Cgocalls and runtime.Goroutines functions have been renamed to
+runtime.NumCgoCall and runtime.NumGoroutine.
+
+The "go fix" command will update code to accommodate most of these changes.
+
+Other changes:
+* 5c, 6c, 8c, 6g, 8g: correct boundary checking (thanks Shenghou Ma).
+* 5g, 6g, 8g: flush modified globals aggressively.
+* 8a, 8l: add EMMS instruction (thanks Evan Shaw).
+* bufio: don't return errors from good Peeks.
+* build: add make.bash --no-clean option,
+ improve Windows support.
+* builder: reuse existing workspace if possible (thanks Shenghou Ma),
+ update for os.Wait changes.
+* bytes: document Compare/Equal semantics for nil arguments, and add tests.
+* cgo: fix definition of opaque types (thanks Gustavo Niemeyer).
+* cmd/api: record return type of functions for variable typecheck (thanks Rémy Oudompheng).
+* cmd/cgo: bug fixes.
+* cmd/dist: add clang specific -Wno options (thanks Bobby Powers),
+ fix install cmd/5g on non-arm system,
+ fix pprof permissions (thanks Bobby Powers),
+ make dir check in defaulttarg() more robust (thanks Shenghou Ma),
+ use correct package target when cross-compiling (thanks Alex Brainman).
+* cmd/gc: correctly typecheck expression lists in returns (thanks Rémy Oudompheng),
+ don't believe that variables mentioned 256 times are unused (thanks Rémy Oudompheng),
+ error on constant shift overflows (thanks Rémy Oudompheng),
+ fix comparison of struct with _ field.
+ fix error for floating-point constant %,
+ new, less strict bool rules.
+* cmd/go: add tool -n flag,
+ go test -i correctly handle cgo packages (thanks Shenghou Ma).
+* codereview: fix submit message for new clone URL (thanks Shenghou Ma).
+* database/sql/driver: API cleanups.
+* doc: many fixes and adjustments.
+* encoding/gob: cache engine for user type, not base type,
+ catch internal error when it happens,
+ fix mutually recursive slices of structs.
+* encoding/json: ignore anonymous fields.
+* go/doc: return Examples in name order.
+* go/parser: imaginary constants and ! may start an expression.
+* go/printer, gofmt: improved comma placement.
+* go/printer: don't lose relevant parentheses when rewriting selector expressions.
+* godoc: adjust line height in pre blocks,
+ don't print spurious suggestion when running "go doc foo",
+ fix absolute->relative mapping,
+ fix tag mismatch validation errors (thanks Scott Lawrence),
+ import example code support,
+ support flat directory view again.
+* html/template: add Clone and AddParseTree,
+ don't indirect past a Stringer,
+ minor tweak to docs to improve HTML typography.
+* image: add Decode example.
+* ld: add NOPTRBSS for large, pointer-free uninitialized data.
+* math/rand: Intn etc. should panic if their argument is <= 0.
+* misc/dist/windows: distro builder updates (thanks Joe Poirier).
+* misc/goplay: remain in work directory, build in temp directory.
+* net, os, syscall: delete os.EPLAN9 (thanks Mikio Hara).
+* net/http: add optional Server.TLSConfig field.
+* net/smtp: use EHLO then HELO.
+* net/textproto: accept bad MIME headers as browsers do.
+* net/url: regularise receiver names.
+* net: make LocalAddr on multicast return group address (thanks Mikio Hara),
+ make parseProcNetIGMP more robust (thanks Mikio Hara),
+ more selfConnect debugging: panic if ra == nil in internetSocket,
+ panic if sockaddrToTCP returns nil incorrectly,
+ other miscellaneous fixes.
+* path, path/filepath: polish documentation (thanks Rémy Oudompheng).
+* pprof: add Profile type.
+* runtime: avoid malloc during malloc,
+ define NSIG to fix plan 9 build (thanks David du Colombier),
+ fix FreeBSD signal handling around thread creation (thanks Devon H. O'Dell),
+ goroutine profile, stack dumps,
+ implement runtime.osyield on FreeBSD 386, amd64 (thanks Devon H. O'Dell),
+ permit default behavior of SIGTSTP, SIGTTIN, SIGTTOU,
+ release unused memory to the OS (thanks Sébastien Paolacci),
+ remove an obsolete file (thanks Mikio Hara).
+* spec: make all comparison results untyped bool,
+ refine the wording about variables in type switches,
+ struct comparison only compares non-blank fields.
+* syscall: Make Pdeathsig type Signal in SysProcAttr on Linux (thanks Albert Strasheim),
+ fix bounds check in Error,
+ force Windows to always use US English error messages (thanks Shenghou Ma).
+* test: migrated to new go-based testing framework.
+* text/template: evaluate function fields.
+* time: use Go distribution zoneinfo if system copy not found.
+</pre>
+
+<h2 id="2012-02-14">2012-02-14</h2>
+
+<pre>
+This release includes some package changes that require changes to client code.
+
+The flate, gzip and zlib's NewWriterXxx functions no longer return an error.
+The compiler will flag all affected code which must then be updated by hand.
+
+The os package's Exec and Time functions were removed. Callers should use
+syscall.Exec and time.Now instead. The ShellExpand function was renamed to
+ExpandEnv. The NewFile function now takes a uintptr and the *File.Fd method
+returns a uintptr.
+
+The runtime package's Type type and its methods have been removed.
+Use the reflect package instead.
+
+Other changes:
+* 8a, 8l: add LFENCE, MFENCE, SFENCE (thanks Darren Elwood).
+* all.bat: report error code back to the gobuilder (thanks Alex Brainman).
+* archive/zip: hide Write method from *Writer type.
+* build: create the correct $GOTOOLDIR,
+ get rid of deps.bash (thanks Anthony Martin),
+ reject make.bash on Windows.
+* builder: set $GOBUILDEXIT for Windows (thanks Alex Brainman),
+* bytes: add Reader,
+ return error in WriteTo if buffer is not drained.
+* cgo: add support for returning errno with gccgo (thanks Rémy Oudompheng).
+* cmd/api: follow constant references.
+* cmd/cgo: omit //line in -godefs, -cdefs output.
+* cmd/dist: fixes (thanks Alex Brainman, Gustavo Niemeyer, Mikio Hara, Shenghou Ma).
+* cmd/fix: warn about exp, old, deleted packages.
+* cmd/gc: suspend safemode during typecheck of inlined bodies.
+* cmd/go: a raft of fixes,
+ connect os.Stdin for go run and go tool,
+ go get scheme detection (thanks Daniel Krech),
+ respect test -timeout flag.
+* cmd/vet: warn for construct 'Println(os.Stderr, ...)' (thanks Shenghou Ma).
+* compress/gzip: remove dead code (thanks Alex Brainman).
+* container/heap: add example.
+* dashboard: add gobuilder -fail mode.
+* database/sql: more tests,
+ remove Into from ScannerInto/ScanInto,
+ rename ErrTransactionFinished to ErrTxDone,
+ support ErrSkip in Tx.Exec (thanks Andrew Balholm),
+ treat pointers as nullable types as with encoding/json (thanks Andrew Pritchard).
+* debug/macho: drop terrifyingly monstrous URL from package comment.
+* dist: prevent recusive loop on windows when fatal() is called (thanks Daniel Theophanes).
+* doc: add App Engine docs to 'learn' and 'reference' pages,
+ add playground.js,
+ new document about compatibility of releases,
+ update install.html for binary distros, add install-source.html.
+* effective_go: use new map deletion syntax.
+* encoding/binary: add Size, to replace the functionality of the old TotalSize,
+ another attempt to describe the type of Read and Write's data,
+ slices are allowed; say so.
+* encoding/json: document buffering.
+* encoding/xml: add support for the omitempty flag (thanks Gustavo Niemeyer).
+* exp/norm: merged charinfo and decomposition tables.
+* exp/types: use build.FindTree in GcImporter (thanks James Whitehead).
+* flate: delete WrongValueError type.
+* fmt: diagnose invalid verb applied to pointer,
+ scan FALSE correctly.
+* gc: bug fixes, better error messages.
+* go/doc: handle recursive embedded types (thanks Gary Burd),
+ don't lose exported consts/vars with unexported type,
+ treat predeclared error interface like an exported type.
+* go/printer: implement SourcePos mode.
+* godoc: list examples in index,
+ new design,
+ regard lone examples as "whole file" examples.
+* html/template: added more words about examples and doc (thanks Bjorn Tipling).
+* log/syslog: return length of data provided by the user, not length of header.
+* make.bat: remove double quotes (thanks Alex Brainman).
+* math: fix gamma doc, link to OEIS.
+* mime: unexport some internal details.
+* misc/dist: add binary distribution packaging script for linux,
+ new hierarchy for binary distribution packaging scripts.
+* net/http: add ServeContent,
+ don't spin on temporary accept failure,
+ fix client goroutine leak with persistent connections,
+ fix reference to URL.RawPath in docs (thanks Bjorn Tipling),
+ panic on duplicate registrations,
+ use mtime < t+1s to check for unmodified (thanks Hong Ruiqi).
+* net: avoid Shutdown during Close,
+ avoid TCP self-connect,
+ disable TestDialTimeout on Windows,
+ disable multicast test on Alpha GNU/Linux,
+ disable wild use of SO_REUSEPORT on BSD variants (thanks Mikio Hara),
+ enable flags on stream for multicast listeners (thanks Mikio Hara),
+ make use of listenerBacklog (thanks Mikio Hara),
+ prefer an IPv4 listen if no address given (thanks Mikio Hara).
+* os/exec: add Cmd.Waitmsg.
+* os/signal: revive this package.
+* regexp/syntax: add package and Parse commentary.
+* regexp: allow substitutions in Replace, ReplaceString.
+* runtime, pprof: add profiling of thread creation.
+* runtime, time: accelerate tests in short mode (thanks Rémy Oudompheng).
+* runtime: exit early on OABI systems (thanks Shenghou Ma),
+ drop to 32 bit malloc if 64 bit will not work,
+ fix "SysReserve returned unaligned address" bug on 32-bit systems (thanks Shenghou Ma),
+ fix grsec support (thanks Gustavo Niemeyer),
+ on 386, fix FP control word on all threads, not just initial thread,
+ put lockorder before pollorder in Select memory block,
+ use startpanic so that only one thread handles an incoming SIGQUIT.
+* spec: add forward links from 'method set' to where it gets used,
+ clarify implementation restrictions on untyped floats,
+ disallow recursive embedded interfaces,
+ method names must be unique,
+ send on closed channel counts as "proceeding",
+ strings are more slices than arrays.
+* strconv: handle very large inputs.
+* strings: add Seek and ReadAt methods to Reader.
+* sync/atomic: disable hammer pointer tests on wrong size system.
+* testing: let runtime catch the panic.
+* text/template: refer HTML users to html/template.
+* text/template/parse: deep Copy method for nodes.
+* time: clean up MarshalJSON, add RFC3339 method,
+ use "2006-01-02 15:04:05.999999999 -0700 MST" as String format.
+</pre>
+
+<h2 id="2012-02-07">2012-02-07</h2>
+
+<pre>
+This weekly snapshot includes a re-organization of the Go tools.
+
+Only the go, godoc, and gofmt tools are installed to $GOROOT/bin (or $GOBIN).
+The remainder are installed to $GOROOT/bin/tool.
+This puts the lesser-used tools (6g, cgo, govet, etc.) outside the user PATH.
+Instead these tools may be called through the go tool with 'go tool command'.
+For example, to vet hello.go you would type 'go tool vet hello.go'.
+Type 'go tool' see the list of available tools.
+
+With the move, some tools were given simpler names:
+ 6cov -> cov
+ 6nm -> nm
+ goapi -> api
+ gofix -> fix
+ gopack -> pack
+ gopprof -> pprof
+ govet -> vet
+ goyacc -> yacc
+
+The os/signal package has been moved to exp/signal.
+
+A new tool named 'dist' has been introduced to handle building the gc tool
+chain and to bootstrap the go tool. The old build scripts and make files
+have been removed.
+
+Other changes:
+* 5a, 6a, 8a, cc: check in y.tab.[ch].
+* 5l, 6l, 8l, ld: remove memory leaks (thanks Shenghou Ma).
+* 5l, 6l, 8l: implement -X flag.
+* 5l: make -v option output less nonessential clutter (thanks Shenghou Ma),
+ optimize the common case in patch() (thanks Shenghou Ma).
+* 8a, 8l: implement support for RDTSC instruction (thanks Shenghou Ma).
+* 8g: use uintptr for local pc.
+* archive/zip: support full range of FileMode flags (thanks Gustavo Niemeyer).
+* bufio: remove special error type, update docs.
+* build: move the "-c" flag into HOST_CFLAGS (thanks Anthony Martin),
+ remove unnecessary pragmas (thanks Anthony Martin).
+* builder: drop recover blocks.
+* bytes: API tweaks.
+* cgo: accept null pointers in gccgo flavour of C.GoString (thanks Rémy Oudompheng),
+ print line numbers in fatal errors when relevant (thanks Rémy Oudompheng).
+* cmd/dist: add GOBIN to env's output (thanks Gustavo Niemeyer),
+ fix bug in bsubst (thanks Alex Brainman),
+ fix build on openbsd (thanks Mikio Hara),
+ generate files for package runtime,
+ ignore file names beginning with . or _,
+ prevent race on VERSION creation (thanks Gustavo Niemeyer).
+* cmd/gc: another special (%hhS) case for method names,
+ describe debugging flags (thanks Anthony Martin),
+ diagnose \ in import path,
+ disallow switch _ := v.(type),
+ don't print implicit type on struct literal in export,
+ fix codegen reordering for expressions involving && and ||,
+ use octal escapes in mkopnames (thanks Anthony Martin).
+ use original constant expression in error messages (thanks Rémy Oudompheng).
+* cmd/go: add support for release tags via git branches (thanks Gustavo Niemeyer),
+ build: print import errors when invoked on files (thanks Kyle Lemons),
+ clean test directories as they complete,
+ fix error message on non-existing tools (thanks Rémy Oudompheng),
+ fix handling of gccgo standard library (thanks Rémy Oudompheng),
+ fixed panic on `go clean -n` and `go clean -x` (thanks Sanjay Menakuru),
+ introduce support for "go build" with gccgo (thanks Rémy Oudompheng),
+ make vcs command actually gather output (thanks Roger Peppe),
+ pass env CGO_CFLAGS to cgo (thanks Jeff Hodges),
+ record location of failed imports for error reporting (thanks Rémy Oudompheng).
+* cmd/goapi: expand embedded interfaces.
+* cmd/goinstall: remove now that 'go get' works (thanks Gustavo Niemeyer).
+* cmd/ld: fix gdbscript (thanks Wei Guangjing).
+* cmd/pack: change gopack to pack in error messages.
+* codereview: miscellaneous fixes and improvements.
+* crypto/elliptic: p224Contract could produce a non-minimal representation.
+* crypto/tls: better error message when connecting to SSLv3 servers.
+* crypto/x509: use case-insensitive hostname matching.
+* dashboard: support for sub-repositories, update to go1beta.
+* database/sql: permit scanning into interface{}.
+* doc: update go1.html for recent changes.
+* encoding/base32: add DecodeString and EncodeToString helper methods,
+ ignore new line characters during decode.
+* encoding/base64: ignore new line characters during decode.
+* encoding/gob: document CommonType.
+* encoding/hex: canonicalize error type names.
+* encoding/json: call (*T).MarshalJSON for addressable T values.
+* encoding/xml: fix decoding of xml.Name with sub-elements (thanks Gustavo Niemeyer),
+ fix documentation for Decoder.Skip.
+* exp/norm: Added some benchmarks for form-specific performance measurements,
+ a few minor changes in prepration for a table format change.
+* expvar: revise API.
+* fix: add image/{bmp,tiff} to go1pkgrename.
+* flag: allow a FlagSet to not write to os.Stderr,
+ describe valid input for Duration flags.
+* fmt: add test of NaN map keys,
+ fix caching bug in Scan.
+* go/build: put a space between 'generated by make' and package statement,
+ update syslist.go package comment.
+* go/doc: fix URL linking in ToHTML (thanks Gary Burd),
+ added error, rune to list of predeclared types,
+ don't lose factory functions of non-exported types,
+ don't show methods of exported anonymous fields,
+ enable AllMethods flag (and fix logic).
+* go/printer: don't print incorrect programs.
+* go/scanner: idiomatic receiver names.
+* go/spec: update language on map types.
+* go/token: remove dependency on encoding/gob.
+* gob: fuzz testing, plus a fix for very large type names.
+* gobuilder: use go tool to build and test sub-repositories.
+* godoc: add URL mode m=methods,
+ diagnostic for empty FS tree,
+ fix identifier search,
+ fix redirect loop for URL "/",
+ provide link to subdirectories, if any,
+ sort list of "other packages",
+ update metadata in appinit.go.
+* gophertool: fix link to the build status dashboard (thanks Jongmin Kim).
+* hgignore: add VERSION.cache (thanks Gustavo Niemeyer),
+ delete dregs, ignore tmpltohtml.
+* html: add package doc.
+* image: add package docs, rename s/UnknownFormatError/ErrFormat/ and,
+ delete the image.Repeated type,
+ remove image/bmp and image/tiff from std.
+* io/ioutil: document EOF behavior in ReadFile and ReadAll.
+* io: API tweaks.
+* libmach: add stubs for Plan 9 (thanks Anthony Martin).
+* make.bash: don't remove hgpatch.
+* math/big: add raw access to Int bits,
+ API and documentation cleanup.
+* misc/goplay: use go tool "run" (thanks Olivier Duperray).
+* misc/osx: don't set GOROOT or modify profile files,
+ update for dist tool, drop image.bash, update readme.
+* net, syscall: add IPv4 multicast helpers for windows (thanks Mikio Hara).
+* net/http/httputil: fix race in DumpRequestOut,
+ preserve query params in reverse proxy.
+* net/http: don't set Content-Type header for HEAD requests by default (thanks Patrick Mylund Nielsen),
+ fix nil pointer dereference in error case (thanks Volker Dobler),
+ close client fd sooner on response read error,
+ set cookies in client jar on POST requests (thanks Volker Dobler).
+* net/rpc: fix data race on Call.Error.
+* net: ListenMulticastUDP to listen concurrently across multiple listeners (thanks Mikio Hara),
+ disable normal multicast testing on linux/arm (thanks Mikio Hara),
+ fix Plan 9 build (thanks Anthony Martin),
+ fix windows build (thanks Alex Brainman),
+ move DNSConfigError to a portable file,
+ remove types InvalidConnError and UnknownSocketError,
+ replace error variable name e, errno with err (thanks Mikio Hara),
+ run TestDialTimeout on windows (thanks Alex Brainman),
+ update comments to remove redundant "net" prefix (thanks Mikio Hara).
+* os/exec: TestExtraFiles - close any leaked file descriptors,
+ make sure file is not closed early in leaked fd test.
+* os/signal: move to exp/signal.
+* os/user: windows implementation (thanks Alex Brainman).
+* os: Process.handle use syscall.Handle (thanks Wei Guangjing),
+ file windows use syscall.InvalidHandle instead of -1 (thanks Wei Guangjing),
+ remove SIGXXX signals variables,
+ turn FileStat.Sys into a method on FileInfo (thanks Gustavo Niemeyer).
+* path/filepath: repair and simplify the symlink test.
+* reflect: add comment about Type.Field allocation,
+ test that PtrTo returns types that match program types.
+* runtime: add runtime.cputicks() and seed fastrand with it (thanks Damian Gryski),
+ delete UpdateMemStats, replace with ReadMemStats(&stats) (thanks Rémy Oudompheng),
+ fix float64 hash,
+ use GOTRACEBACK to decide whether to show runtime frames,
+ use per-map hash seeds (thanks Damian Gryski).
+* spec: add number to the fibonacci sequence.
+* std: add struct field tags to untagged literals.
+* strings: add Fields example.
+* syscall: add Timeval.Nano, Timespec.Nano, for conversion to Duration,
+ cache environment variables on Plan 9 (thanks Anthony Martin),
+ fix // +build comments in types_*.go,
+ fix build directive in types_linux.go,
+ update bootstrap scripts to sync with new go command (thanks Mikio Hara).
+* test: add import test that caused an incorrect gccgo error,
+ add test for receiver named _,
+ add test of NaN in map,
+ add test which crashed gccgo compiler,
+ don't use package main for files without a main function,
+ fix bug headers,
+ float to integer test case,
+ make map nan timing test more robust,
+ match gccgo error messages,
+ test append with two different named types with same element type,
+ test method expressions with parameters, and with import,
+ test slice beyond len,
+ test that x := <-c accepts a general expression.
+* testing: capture panics, present them, and mark the test as a failure.
+* unicode: document large var blocks and the SpecialCase vars.
+* vet: add a check for untagged struct literals.
+</pre>
+
+<h2 id="2012-01-27">2012-01-27</h2>
+
+<pre>
+This weekly snapshot renamed the html package to exp/html. The package will not
+be present in the Go 1 distribution, but will be installable from source.
+
+Error variables in the archive/tar, archive/zip, compress/gzip, compress/zlib,
+and crypto/bcrypt packages have been renamed from FooError to ErrFoo.
+There is no gofix, but the compiler will flag code that needs updating.
+
+This weekly snapshot relocates many packages to sub-repositories of the main
+Go repository. These are the old and new import paths:
+
+ crypto/bcrypt code.google.com/p/go.crypto/bcrypt
+ crypto/blowfish code.google.com/p/go.crypto/blowfish
+ crypto/cast5 code.google.com/p/go.crypto/cast5
+ crypto/md4 code.google.com/p/go.crypto/md4
+ crypto/ocsp code.google.com/p/go.crypto/ocsp
+ crypto/openpgp code.google.com/p/go.crypto/openpgp
+ crypto/openpgp/armor code.google.com/p/go.crypto/openpgp/armor
+ crypto/openpgp/elgamal code.google.com/p/go.crypto/openpgp/elgamal
+ crypto/openpgp/errors code.google.com/p/go.crypto/openpgp/errors
+ crypto/openpgp/packet code.google.com/p/go.crypto/openpgp/packet
+ crypto/openpgp/s2k code.google.com/p/go.crypto/openpgp/s2k
+ crypto/ripemd160 code.google.com/p/go.crypto/ripemd160
+ crypto/twofish code.google.com/p/go.crypto/twofish
+ crypto/xtea code.google.com/p/go.crypto/xtea
+ exp/ssh code.google.com/p/go.crypto/ssh
+ net/dict code.google.com/p/go.net/dict
+ net/websocket code.google.com/p/go.net/websocket
+ exp/spdy code.google.com/p/go.net/spdy
+ encoding/git85 code.google.com/p/go.codereview/git85
+ patch code.google.com/p/go.codereview/patch
+
+Gofix will update imports of these packages to use the new import paths.
+Installations that depend on these packages will need to install them using a
+'go get' command.
+
+Other changes:
+* 6c, 8c: make floating point code NaN-safe.
+* 6l, 8l: remove unused macro definition (thanks Shenghou Ma).
+* archive/tar: fix race in TestNonSeekable.
+* archive/zip: add functions to convert between os.FileInfo & FileHeader.
+* build: do not build all C compilers (thanks Shenghou Ma),
+ remove code now in subrepositories.
+* bytes: remove dead code, complete documentation,
+ restore panic on out-of-memory,
+ turn buffer size overflows into errors.
+* cgo: -cdefs should translate unsafe.Pointer to void * (thanks Shenghou Ma).
+* cmd/gc: forgotten recursion on ninit itself in order.c.
+* cmd/go: bug fixes, implement go get,
+ correctly handle -n and -x flags for 'go run' (thanks Shenghou Ma),
+ solve ambiguity of get lp.net/project/foo (thanks Gustavo Niemeyer),
+ update doc.go with text generated from the usage strings.
+* cmd/goapi: new tool for tracking exported API over time.
+* codereview: support for subrepositories.
+* compress/flate: fix a typo, improve compression rate by 3-4%,
+ increase the length of hash table from 1<<15 to 1<<17. 0%-16% speedup,
+ make lazy matching work,
+ reduce memory pressure at cost of additional arithmetic operation,
+ use append instead of slice+counter.
+* crypto: rename some FooError to ErrFoo.
+* dashboard: fix -commit for new xml package.
+* database/sql: add NullInt64, NullFloat64, NullBool (thanks James P. Cooper),
+ convert SQL null values to []byte as nil (thanks James P. Cooper),
+ fix Tx.Query (thanks Blake Mizerany).
+* doc: expand FAQ on GOMAXPROCS, update to Go 1.
+* doc/go1: add encoding/xml and net/url changes (thanks Gustavo Niemeyer),
+ add more info about hash and net changes, delete reference to html,
+ add flag, runtime, testing, image , mime, filepath.Walk,
+ document sub-repositories.
+* encoding/binary: document that PutVarint, PutUvarint may panic.
+* encoding/varint: deleted WriteXvarint.
+* encoding/xml: add docs for ignoring tag (thanks Gustavo Niemeyer),
+ bring API closer to other packages (thanks Gustavo Niemeyer),
+ improve []byte handling (thanks Gustavo Niemeyer),
+ remove Marshaler support (thanks Gustavo Niemeyer),
+ support ignoring fields with "-" (thanks Gustavo Niemeyer).
+* exp/ebnflint: test spec during 'go test'.
+* exp/norm: fixes a subtle bug introduced by change 10087: random offset.
+* gc, runtime: handle floating point map keys.
+* gc: avoid DOT in error messages,
+ do not try to add a key with incorrect type to a hash (thanks Jeff R. Allen),
+ fix order of evaluation,
+ fix recursion loop in interface comparison,
+ handle function calls in arguments to builtin complex operations,
+ missed typecheck in subscripting a const string,
+ permit unsafe.Pointer for inlined functions,
+ softer criteria for inlinability,
+ static implements check on typeswitches only applies to concrete case types,
+ test case for recursive interface bug.
+* go/ast: respect ImportSpec.EndPos (thanks Scott Lawrence).
+* go/build: add BuildTags to Context, allow !tag.
+* go/doc: rewrite and add lots of tests.
+* go/parser: use explicit parser.Mode type.
+* go/printer, gofmt: respect line breaks in signatures.
+* go/scanner: use explicit scanner.Mode type.
+* gob: annotate debug.go so it's not normally built,
+ reduce the maximum message size.
+* godoc: log node printing error,
+ move overview before API TOC,
+ update metadata upon launch.
+* gofix: add -debug flag for quicker diagnosis of internal errors,
+ handle xml.Unmarshal in xmlapi fix (thanks Gustavo Niemeyer),
+ update go1pkgrename for subrepositories.
+* goyacc: fix indexing bug when yydebug >= 2.
+* ld: fix Mach-O code signing for non-cgo binaries (thanks Mikkel Krautz).
+* libmach: cross compiling support (thanks Shenghou Ma).
+* math/big: assembly versions of bitLen for x86-64, 386, and ARM (thanks David G. Andersen),
+ return type of bitLen is an int; use MOVL on amd64 (thanks David G. Andersen),
+ add examples for Rat and Int's SetString and Scan methods,
+ slight improvement to algorithm used for internal bitLen function (thanks David G. Andersen),
+ test both bitLen and bitLen_g.
+* net/http: add Request.RequestURI field,
+ disabled test for Transport race / deadlock bug,
+ fix Transport deadlock (thanks Yoshiyuki Kanno),
+ make ParseForm ignore unknown content types (thanks Roger Peppe),
+ parse CONNECT requests (thanks Andrew Balholm).
+* net/rpc: fix data race in benchmark,
+ fix race in TestClientWriteError test,
+ log Call reply discard.
+* net: Dial, ListenPacket with "ip:protocol" network for raw IP sockets (thanks Mikio Hara),
+ actually reset deadline when time is zero,
+ consistent OpError message (thanks Mikio Hara),
+ fix dialing google test (thanks Mikio Hara),
+ make WriteTo fail when UDPConn is already connected (thanks Mikio Hara).
+* regexp: remove vestigial Error type.
+* runtime: add type algorithms for zero-sized types,
+ move NumCPU declaration into debug.go.
+* spec: function invocation, panic on *nil.
+* syscall: add NOTE_* constants on OS X (thanks Robert Figueiredo).
+* test: explicitly use variables to avoid gccgo "not used" error.
+* text/template: add example for Template.
+</pre>
+
+<h2 id="2012-01-20">2012-01-20</h2>
+
+<pre>
+This weekly snapshot renamed the exp/sql package to database/sql, and moved
+utf8.String from unicode/utf8 to exp/utf8string.
+
+Package net's SetTimeout methods were changed to SetDeadline.
+
+Many functions in package os now take a os.FileMode argument instead of a
+plain uint32. An os.ModeSticky constant is also now defined.
+
+The meaning of the first buffer element for image.YCbCr has changed to match
+the semantics of the other image types like image.RGBA.
+
+The NewMD5, NewSHA1 and NewSHA256 functions in crypto/hmac have been
+deprecated. Use New instead, explicitly passing the hash function.
+
+Other changes:
+* buildscripts: move to buildscript directory (thanks Shenghou Ma).
+* bytes: add the usual copyright notice to example_test.go (thanks Olivier Duperray).
+* cmd/go: remove mentions of 'gotest' from the documentation,
+ skip _obj directories in package scans.
+* container/heap: better package documentation.
+* crypto/elliptic: add constant-time P224.
+* crypto/hmac: Add HMAC-SHA224 and HMAC-SHA384/512 (thanks Luit van Drongelen),
+* crypto/tls: add FreeBSD root certificate location (thanks Shenghou Ma).
+* crypto/x509: remove explicit uses of rsa.
+* doc: various updates (thanks Jongmin Kim, Scott Lawrence, Shenghou Ma, Stefan Nilsson).
+* encoding/json: allow / and % in tag names,
+ document angle bracket escaping,
+ fix comments, tweak tests for tag names (thanks Mikio Hara).
+* encoding/xml: marshal/unmarshal xml.Name in field (thanks Gustavo Niemeyer).
+* exp/inotify: fix data race in linux tests.
+* exp/proxy: fix build after URL changes (thanks Gustavo Niemeyer).
+* exp/sql: copy when scanning into []byte by default,
+ rename NullableString to NullString and allow its use as a parameter.
+* exp/ssh: add marshal functions for uint32 and uint64 types,
+ handle versions with just '\n',
+ rename (some) fields (thanks Christopher Wedgwood).
+* exp/terminal: fix build on non-Linux using Makefiles.
+* fmt: enable and fix malloc test,
+* gc: don't emit pkgpath for error type,
+ don't fault on return outside function (thanks Scott Lawrence),
+ fieldnames in structliterals in exported inlines should not be qualified if they're embedded builtin types,
+ fix infinite recursion for embedded interfaces,
+ give esc.c's sink an orig so -mm diagnostics work again,
+ handle printing of string/arrayrune conversions.
+ remove redundant code (thanks Shenghou Ma).
+* go/build: no back slash in FindTree returned pkg name (thanks Alex Brainman).
+* go/doc: collect imports,
+ don't shadow receiver.
+ rewrote and completed test framework.
+ print only one newline between paragraphs
+* go/parser: expressions may have comments.
+* go/scanner: fix example (thanks Olivier Duperray).
+* go/token: replaced Files() with Iterate().
+* godoc: add anchors to cmd documentation headings,
+ remove "need more packages?" link,
+ specify HTML page metadata with a JSON blob,
+ support canonical Paths in HTML metadata.
+* html/template: fix docs after API changes (thanks Gustavo Niemeyer).
+* html: in foreign content, check for HTML integration points in breakout.
+* image/color: rename modelYCbCr to yCbCrModel (thanks Benny Siegert),
+ simplify documentation (thanks David Crawshaw).
+* image: add PixOffset methods.
+* math/rand: decrease test duration in short mode,
+ document default initial seed for global generator (thanks Scott Lawrence).
+* mime: make FormatMediaType take full type for consistency.
+* misc/cgo/test: make tests run on windows (thanks Alex Brainman).
+* net/http/cgi: increase a flaky test timeout.
+* net/http: change test to use override param instead of chan,
+ log handler panic before closing HTTP connection,
+ send cookies in jar on redirect (thanks Jeff Hodges),
+ the documentation should call NewRequest with the right signature (thanks Christoph Hack),
+ update the Client docs a bit.
+* net/url: cleaned up URL interface (v2) (thanks Gustavo Niemeyer).
+* net: consistent log format in test (thanks Mikio Hara),
+ various build fixes (thanks Mikio Hara),
+ use NewTimer, not NewTicker, in fd_windows.go.
+* old/netchan: fix data race on client hashmap.
+* os/exec: trivial allocation removal in LookPath (thanks Gustavo Niemeyer).
+* os: remove old note about NewSyscallError being special (thanks Alex Brainman),
+* path: added examples (thanks Sanjay Menakuru).
+* pkg: Add and fix Copyright of "hand generated" files (thanks Olivier Duperray),
+ add missing godoc comments to windows versions (thanks Alex Brainman).
+* regexp: add SubexpNames.
+* runtime: implement runtime.usleep for FreeBSD/386 and amd64 (thanks Shenghou Ma),
+ madvise and SysUnused for Darwin (thanks Dave Cheney).
+* sync/atomic: fix data race in tests.
+* syscall: add Unix method to TimeSpec, TimeVal,
+ fix plan9 build (thanks Mikio Hara).
+* test: change several tests to not print,
+ fix bug364 to actually run,
+ match gccgo error messages for bug345,
+ split golden.out into expected output per test.
+* testing: do not recover example's panic (thanks Shenghou Ma),
+ document examples.
+* text/template/parse: use human error prints.
+* text/template: fix nil error on redefinition.
+* time: add Since, which returns the time elapsed since some past time t.
+</pre>
+
+<h2 id="2012-01-15">2012-01-15</h2>
+
+<pre>
+This weekly snapshot includes two package changes that may require changes to
+client code.
+
+The image package's Tiled type has been renamed to Repeated.
+
+The encoding/xml package has been changed to make more idiomatic use of struct
+tags, among other things. If you use the xml package please read the change
+description to see if your code is affected:
+ http://code.google.com/p/go/source/detail?r=70e914beb409
+
+Function inlining is now enabled by default in the gc compiler.
+
+Other changes:
+* bytes: Buffer read of 0 bytes at EOF shouldn't be an EOF.
+* cgo: if value for constant did not parse, get it from DWARF info,
+ write _cgo_export.h to object directory, not source dir.
+* cmd/go: add -p flag for parallelism (like make -j),
+ add -v flag to build and install,
+ add ... patterns in import path arguments,
+ fix data race during build,
+ fix import directory list for compilation,
+ fix linker arguments,
+ handle cgo pkg-config pragmas,
+ handle path to cmd directory,
+ include test files in fmt, vet, and fix (thanks Sanjay Menakuru),
+ kill test processes after 10 minutes,
+ pass arguments to command for run (thanks Eric Eisner),
+ rely on exit code to tell if test passed,
+ use relative paths in go fix, go fmt, go vet output.
+* cmd/gofmt: fix simplify.go by running gofmt on cmd/gofmt (thanks Olivier Duperray).
+* crypto/openpgp: assorted cleanups,
+ truncate hashes before checking DSA signatures.
+* crypto/tls: improve TLS Client Authentication (thanks Jeff R. Allen),
+ update generate_cert.go for new time package.
+* dashboard: better caching, bug fixes.
+* doc: update "How to Write Go Code" to use the go tool.
+ fix broken function codewalk examples.
+* encoding/asn1: document support for *big.Int (thanks Florian Weimer).
+* encoding/gob: fix panic when decoding []byte to incompatible slice types (thanks Alexey Borzenkov).
+* encoding/json: don't marshal special float values (thanks Evan Shaw).
+* encoding/xml: major Go 1 fixup (thanks Gustavo Niemeyer).
+* exp/proxy: new package.
+* exp/sql: add time.Time support,
+ close Rows on EOF,
+ fix potential corruption in QueryRow.Scan into a *[]byte.
+* exp/ssh: various small fixes (thanks Dave Cheney).
+* exp/terminal: add SetPrompt and handle large pastes,
+ add to level Makefile for the (non-Linux?) systems that need it.
+* flag: add Duration flag type,
+ change Set method Value interface to return error instead of bool.
+* gc: better errors messages,
+ avoid false positives when using scalar struct fields (thanks Rémy Oudompheng),
+ closure code gen improvements,
+ disallow declaration of variables outside package,
+ fix switch on interface values (thanks Rémy Oudompheng),
+ inlining bug fixes,
+ improve unsafe.Pointer type-check error messages (thanks Ryan Hitchman),
+ put limit on size of exported recursive interface (thanks Lorenzo Stoakes),
+* go-mode.el: fix syntax highlighting of backticks (thanks Florian Weimer).
+* go/ast: remove unnecessary result value from ast.Fprint/Print.
+* go/build: allow colon in #cgo flags,
+ pass CgoLDFLAGS at end of link command.
+* go/doc: new API, don't ignore anonymous non-exported fields, initial testing support.
+* go/parser: remove unused Parse* functions. Simplified ParseExpr signature.
+* go/printer: don't crash if AST contains BadXXX nodes.
+* go/scanner: 17% faster scanning, remove InsertSemis mode.
+* goinstall: use correct checkout URL for Google Code svn repos.
+* gotest: make _testmain.go conform to gofmt rules (thanks Benny Siegert).
+* goyacc: fix units.y build breakage (thanks Shenghou Ma).
+* html/template: reenable testcases and fix mis-escaped sequences (thanks Mike Samuel).
+* html: "in select in table" insertion mode (thanks Andrew Balholm),
+ adjust foreign attributes,
+ foreign element HTML integration points, tag name adjustment,
+ parse <frameset> inside body (thanks Andrew Balholm),
+ propagate foreign namespaces only when adding foreign content.
+* json: better error messages when the ,string option is misused.
+* ld: parse but do not implement -X flag.
+* log/syslog: add Alert method (thanks Vadim Vygonets).
+* make.bash: remove old dregs (thanks Alex Brainman).
+* math/big: simplify fast string conversion.
+* math: fix typo in all_test.go (thanks Charles L. Dorian).
+* misc/windows: add src/pkg/runtime/z* files to installation script (thanks Alex Brainman).
+* net/http: don't ignore Request.Write's Flush error,
+ allow cookies with negative Max-Age attribute as these are (thanks Volker Dobler).
+* net/textproto: avoid corruption when reading a single header.
+* net: add IP-level socket option helpers for Unix variants (thanks Mikio Hara),
+ fix incorrect mode on ListenIP, ListenUDP (thanks Mikio Hara),
+ make use of the kernel state to listen on TCP, Unix (thanks Mikio Hara),
+ platform-dependent default socket options (thanks Mikio Hara).
+* os: add ModeCharDevice.
+* runtime: add NumCPU,
+ delete duplicate implementation of pcln walker,
+ distinct panic message for call of nil func value,
+ enable runtime.ncpu on FreeBSD (thanks Devon H. O'Dell),
+ make garbage collector faster by deleting code,
+ regenerate defs_darwin_{386,amd64}.h (thanks Dave Cheney),
+ runtime.usleep() bugfix on darwin/amd64 and linux/arm (thanks Shenghou Ma).
+* spec: pointer comparison for pointers to 0-sized variables,
+ change the wording regarding select statement choice.
+* strconv: fix round up corner case,
+ faster FormatFloat(x, *, -1, 64) using Grisu3 algorithm (thanks Rémy Oudompheng),
+ implement fast path for rounding already short numbers (thanks Rémy Oudompheng),
+ return ErrSyntax when unquoting illegal octal sequences.
+* syscall: linux-only support for parent death signal (thanks Albert Strasheim),
+ make Environ return original order.
+* testing: fix defer race,
+ use flag.Duration for -timeout flag.
+* text/template: handle panic values that are not errors (thanks Rémy Oudompheng),
+ for range on a map, sort the keys if feasible.
+* time: add ParseDuration,
+ fix docs for After and NewTicker.
+* windows: use ArbitraryUserPointer as TLS slot (thanks Wei Guangjing).
+</pre>
+
+<h2 id="2011-12-22">2011-12-22</h2>
+
+<pre>
+This snapshot includes changes to the images/ycbcr and testing packages, and
+changes to the build system.
+
+The types for managing Y'CbCr images in the image/ycbcr have been moved to the
+image and image/color packages. A gofix module will rewrite affected code.
+
+The testing package's B type (used when running benchmarks) now has the same
+methods as T (used in tests), such as Print, Error, and Fatal.
+
+This weekly adds a new command named 'go' for building and testing go programs.
+For Go 1, the go command will replace the makefile-based approach that we have
+been using. It is not yet ready for general use, but all.bash does use it to
+build the tree. If you have problems building the weekly, you can 'export
+USE_GO_TOOL=false' before running all.bash to fall back to the makefiles.
+
+Other changes:
+* archive/zip: add SetModTime method to FileHeader.
+* build: make use of env (thanks Mikio Hara),
+ fixes to make "go install" work on windows (thanks Alex Brainman).
+* bytes: add two Buffer examples.
+* cgo: support export for built-in types (thanks Maxim Pimenov).
+* cmd/go: avoid infinite loop with package specific flags (thanks Mikio Hara),
+ fixes to build standard library,
+ implement test command,
+ make sure use of pthread for gcc-4.5 and beyond (thanks Mikio Hara),
+ respect $GCFLAGS,
+ use spaces consistently in help message (thanks Roger Peppe),
+ many other improvements.
+* codereview: initialize "found" in codereview.py (thanks Miki Tebeka).
+* crypto/mime/net/time: add netbsd to +build tags (thanks Joel Sing).
+* crypto/tls: don't assume an RSA private key in the API.
+* crypto/x509: don't crash with nil receiver in accessor method.
+* doc/effective_go: discuss redeclaration.
+* doc: delete go course notes,
+ refer to http://build.golang.org/ where applicable (thanks Robert Hencke),
+ suggest code.google.com/p/go instead of go.googlecode.com/hg.
+* encoding/binary: add Write and Read examples,
+ add more benchmarks (thanks Roger Peppe).
+* encoding/gob: arrays are zero only if their elements are zero.
+* encoding/json: cleanup leftover variables in array decoding (thanks Rémy Oudompheng),
+ examples for Marshal and Unmarshal.
+* exp/ssh: rename ClientAuthPublicKey helper ClientAuthKeyring (thanks Dave Cheney),
+ simplify Stdin/out/errPipe methods (thanks Dave Cheney).
+* fmt: speed up floating point print, clean up some code,
+ make the malloc test check its counts.
+* gc: allow use of unsafe.Pointer in generated code,
+ avoid unsafe in defn of package runtime,
+ better linenumbers for inlined functions,
+ better loopdepth analysis for labels,
+ implement and test \r in raw strings,
+ inlining, allow empty bodies, fix _ arguments,
+ omit argument names from function types in error messages.
+* go/ast, parser: remember short variable decls. w/ correspoding ident objects.
+* go/build: add new +build tags 'cgo' and 'nocgo'.
+* go/doc, godoc: move export filtering into go/doc
+* go/printer, gofmt: fine tuning of line spacing.
+* go/scanner: strip CRs from raw literals.
+* gob: isZero for struct values.
+* godoc: allow examples for methods (thanks Volker Dobler),
+ show methods of anonymous fields.
+* goinstall: only suggest -fix for bad imports when appropriate.
+* govet: add checking for printf verbs,
+ divide the program into one file per vetting suite.
+* html: more parser improvements (thanks Andrew Balholm).
+* json: some tests to demonstrate bad error messages,
+ use strconv.Append variants to avoid allocations in encoding.
+* ld: add support for netbsd signature note section (thanks Joel Sing),
+ allow for IMAGE_REL_AMD64_ADDR32NB relocation type (thanks Alex Brainman).
+* math/big: Rand shouldn't hang if argument is also receiver.
+* misc/builder: set default builder host to build.golang.org.
+* misc/dashboard: delete old build dashboard code ,
+ improvements and fixes for the go implementation.
+* misc/vim: fix go filetype detection (thanks Paul Sbarra).
+* net, syscall, os: set CLOEXEC flag on epoll/kqueue descriptor.
+* net, syscall: interface address and mask (thanks Mikio Hara).
+* net/http: added interface for a cookie jar (thanks Volker Dobler),
+ test fixes (thanks Alex Brainman).
+* net: add DialTimeout,
+ sort Makefile entries (thanks Mikio Hara).
+* os, syscall: beginnings of NetBSD support (thanks Christopher Nielsen).
+* os/exec: add test to verify net package's epoll fd doesn't go to child,
+ disable the ExtraFiles test on darwin.
+* os: don't trust O_CLOEXEC on OS X,
+ make sure Remove returns correct error on windows (thanks Alex Brainman).
+* path, path/filepath: add Dir to complement Base.
+* path/filepath.Rel: document that the returned path is always relative.
+* runtime: don't panic on SIGILL, just crash.
+* spec: be precise about newlines.
+* sql: add Rows.Columns.
+* strconv: fix bug in extended-float based conversion,
+ implement faster parsing of decimal numbers, and
+ reduce buffer size for multi-precision decimals (thanks Rémy Oudompheng).
+* syscall: regenerate z-files for linux/arm (thanks Mikio Hara),
+ sort Makefile, mkall.sh and mkerrors.sh entries (thanks Mikio Hara).
+* test/bench/go1: first draft of Go 1 benchmark suite.
+* testing: compare Log to Println (thanks Robert Hencke),
+ make signalling safer for parallel tests.
+* text/template: better error message for empty templates,
+ fix handing of nil arguments to functions (thanks Gustavo Niemeyer).
+* time: add JSON marshaler for Time (thanks Robert Hencke),
+ new AddDate method (thanks Roger Peppe).
+* various: use $GCFLAGS and $GCIMPORTS like Make does (thanks Maxim Pimenov).
+</pre>
+
+<h2 id="2011-12-14">2011-12-14</h2>
+
+<pre>
+This snapshot includes language changes and changes to goinstall and gofmt.
+
+Equality and inequality (== and !=) are now defined for struct and array
+values, respectively, provided the elements of the data structures can
+themselves be compared. See the Go 1 release notes for the details:
+ http://weekly.golang.org/doc/go1.html#equality
+
+The rune type is now an alias for int32 and character literals have the default
+type of rune. Code that uses int where it should use rune will break.
+See the Go 1 release notes for the details:
+ http://weekly.golang.org/doc/go1.html#rune
+
+Goinstall now expects Google Code import paths to be of the form:
+ "code.google.com/p/go-tour/tree"
+It will reject imports in the old style "go-tour.googlecode.com/hg/tree".
+There is a gofix module to rename such imports.
+Use goinstall -fix to update broken packages.
+
+Gofmt's flags have been modified slightly.
+The -tabintent flag has been renamed -tabs.
+The -spaces flag has been removed.
+
+Other changes:
+* 5c, 6c, 8c: support 64-bit switch value (thanks Anthony Martin).
+* 8c: handle 64-bit switch value.
+* archive/tar: use struct comparison not DeepEqual (thanks Christopher Wedgwood).
+* archive/zip: make zip understand os.FileMode (thanks Roger Peppe).
+* bufio: make the minimum read buffer size 16 bytes.
+* build: disable cgo on Windows/amd64,
+ regularize packages so they may be built without Makefiles.
+* bytes: faster Count, Index, Equal.
+* cgo: add basic gccgo support (thanks Rémy Oudompheng).
+* codereview: fix path slash issue (thanks Yasuhiro Matsumoto).
+* compress/flate: fix out of bounds error.
+* contribute.html: do not fill in the reviewer field (thanks Florian Weimer).
+* crypto/aes: made faster by eliminating some indirection (thanks Taru Karttunen).
+* crypto/dsa: don't truncate input hashes.
+* doc/go_tutorial: make clear the file example is Unix-specific.
+* doc: add Defer, Panic, and Recover article,
+ add Error Handling article,
+ add Go 1 release notes document.
+* encoding/gob: better error messages when types mismatch.
+* env.bash: export CGO_ENABLED so cgo tests run (thanks Alex Brainman).
+* exp/sql: simplify some string conversions.
+* exp/ssh: Wait returns an *ExitError (thanks Gustav Paul).
+* exp/ssh: improve client channel close behavior (thanks Dave Cheney).
+* fmt: don't recur if String method (etc.) misbehaves.
+* gc: better error messages,
+ inlining (disabled without -l),
+ many bug fixes (thanks Lucio De Re and Rémy Oudompheng).
+* go/printer, godoc: print comments in example code.
+* go: implement doc, fmt, fix, list, vet, build, and install.
+* gobuilder: goinstall packages after building go tree.
+* godoc: <pre> must not occur inside <p> (thanks Olivier Duperray),
+ added an opensearch description document (thanks Christoph Hack),
+ text wrapping.
+* gofix: add httputil fix (thanks Yasuhiro Matsumoto).
+* gotest: use go/build more (thanks Robert Hencke).
+* gzip: convert between Latin-1 and Unicode (thanks Vadim Vygonets).
+* html/template: define the FuncMap type locally.
+* html: a first step at parsing foreign content (MathML, SVG),
+ more parser improvements (thanks Andrew Balholm).
+* http: close connection after printing panic stack trace (thanks Roger Peppe),
+ fix failing Transport HEAD request with gzip-looking response.
+* json: treat renamed byte slices the same as []byte.
+* ld: first pass at linker support for NetBSD binaries (thanks Christopher Nielsen),
+ fix memory leaks (thanks Scott Lawrence),
+ increase default stack size on Windows for cgo.
+* math: delete non-Sqrt-based Hypot,
+ implement, document, and fix special cases (thanks Charles L. Dorian),
+* misc/benchcmp: don't require "Benchmark" at beginning of line.
+* misc/osx: rename profile.go to profile_go (thanks Scott Lawrence).
+* net/http: fix trivial example server (thanks Olivier Duperray),
+ net/http: make test remove temporary file and directory.
+* net/smtp: add CRAM-MD5 authentication (thanks Vadim Vygonets).
+* reflect: fix Slice cap (thanks Gustavo Niemeyer).
+* regexp: performance improvements; avoid allocation of input interface.
+* runtime: bump gc 'extra bytes' check (thanks Christopher Wedgwood),
+ madvise and SysUnused for Linux (thanks Sébastien Paolacci),
+ make gc_test test extra allocated space, not total space,
+ support for NetBSD (thanks Christopher Nielsen).
+* spec: adjust complex constant example (thanks Robert Hencke),
+ values of underlying type uintptr can be converted to unsafe.Pointer,
+ var x = 'a' defaults to type rune.
+* strconv: include package and function name in error strings,
+ make QuoteRune etc. take a rune argument,
+ some performance improvements.
+* syscall: add constants for flock() system call under Linux,
+ regenerate z-files for darwin, freebsd (thanks Mikio Hara),
+ regenerate z-files for openbsd,
+ return error, not uintptr, when function returns error (thanks Alex Brainman).
+* test/bench: move to test/bench/shootout.
+* test/garbage: move to test/bench/garbage.
+* test: make array smaller in nilptr test.
+* time: allow sleep tests to run for 200% too long,
+ fix Time.Add (thanks Hector Chu),
+ fix daysIn for December (thanks Peter Mundy),
+ gob marshaler for Time (thanks Robert Hencke),
+ use Duration for AfterFunc.
+* various: a grab-bag of time.Duration cleanups.
+</pre>
+
+<h2 id="2011-12-06">2011-12-06</h2>
+
+<pre>
+This snapshot includes a language change and changes to the strconv and go/doc
+packages. The package changes require changes to client code.
+The language change is backwards-compatible.
+
+Type elision in arrays, slices, or maps of composite literals has been
+extended to include pointers to composite literals. Code like this
+ var t = []*T{&T{}, &T{}}
+may now be written as
+ var t = []*T{{}, {}}
+You can use gofmt -s to simplify such code.
+
+The strconv package has been given a more idiomatic and efficient interface.
+Client code can be updated with gofix. See the docs for the details:
+ http://weekly.golang.org/pkg/strconv/
+
+The go/doc package's ToHTML function now takes a []byte argument instead of a
+string.
+
+Other changes:
+* crypto/aes: eliminate some bounds checking and truncation (thanks Rémy Oudompheng).
+* crypto/x509: if a parent cert has a raw subject, use it.
+* encoding/gob: don't send type info for unexported fields.
+* exp/ssh: allow for msgUserAuthBanner during authentication (thanks Gustav Paul).
+* fmt: benchmark floating point,
+ only use Stringer or Error for strings.
+* gc: changes in export format in preparation of inlining,
+ disallow map/func equality via interface comparison,
+ use gofmt spacing when printing map type.
+* go/doc: exclude lines ending in ':' from possible headings.
+* gobuilder: -commit mode for packages,
+ cripple -package mode temporarily,
+ use new dashboard protocol.
+* godoc: improved output of examples in html (thanks Volker Dobler).
+* gofmt: handle &T in composite literal simplify.
+* goinstall: honour -install=false flag when -make=true.
+* hash: rewrite comment on Hash.Sum method.
+* html: more parser improvements (thanks Andrew Balholm).
+* image: avoid func comparison during ColorModel comparison.
+* math: add special-cases comments to Sinh and Tanh (thanks Charles L. Dorian).
+* misc/dashboard: further implementation work.
+* net, syscall: remove BindToDevice from UDPConn, IPConn (thanks Mikio Hara).
+* net/mail: correctly compare parsed times in the test.
+* os/exec: make LookPath always search CWD under Windows (thanks Benny Siegert).
+* runtime: prep for type-specific algorithms.
+* strconv: 34% to 63% faster conversions.
+</pre>
+
+<h2 id="2011-12-02">2011-12-02</h2>
+
+<pre>
+This weekly snapshot includes changes to the hash package and a gofix for the
+time and os.FileInfo changes in the last snapshot.
+
+The hash.Hash's Sum method has been given a []byte argument,
+permitting the user to append the hash to an existing byte slice.
+Existing code that uses Sum can pass nil as the argument.
+Gofix will make this change automatically.
+
+Other changes:
+* crypto/tls: cleanup certificate load on windows (thanks Alex Brainman).
+* exp/ssh: add Std{in,out,err}Pipe methods to Session (thanks Dave Cheney).
+* dashboard: don't choke on weird builder names.
+* exp/ssh: export type signal, now Signal (thanks Gustav Paul).
+* os: add ModeType constant to mask file type bits (thanks Gustavo Niemeyer).
+* text/template: replace Add with AddParseTree.
+* go/doc: detect headings and format them in html (thanks Volker Dobler).
+</pre>
+
+<h2 id="2011-12-01">2011-12-01</h2>
+
+<pre>
+This weekly snapshot includes changes to the time, os, and text/template
+packages. The changes to the time and os packages are significant and related.
+Code that uses package time, package text/template, or package os's FileInfo
+type will require changes.
+
+In package time, there is now one type - time.Time - to represent times.
+Note that time.Time should be used as a value, in contrast to old code
+which typically used a *time.Time, a pointer to a large struct. (Drop the *.)
+Any function that previously accepted a *time.Time, an int64
+number of seconds since 1970, or an int64 number of nanoseconds
+since 1970 should now accept a time.Time. Especially as a replacement
+for the int64s, the type is good documentation about the meaning of
+its value.
+
+Whether you were previously calling time.Seconds, time.Nanoseconds,
+time.LocalTime, or time.UTC, the replacement is the new function
+time.Now.
+
+If you previously wrote code like:
+
+ t0 := time.Nanoseconds()
+ myFunction()
+ t1 := time.Nanoseconds()
+ delta := t1 - t0
+ fmt.Printf("That took %.2f seconds\n", float64(t1-t0)/1e9)
+
+you can now write:
+
+ t0 := time.Now()
+ myFunction()
+ t1 := time.Now()
+ delta := t1.Sub(t0)
+ fmt.Printf("That took %s\n", delta)
+
+In this snippet, the variable delta is of the new type time.Duration, the
+replacement for the many int64 parameters that were nanosecond
+counts (but not since 1970).
+
+Gofix can do the above conversions and some others, but it does not
+rewrite explicit int64 types as time.Time. It is very likely that you will
+need to edit your program to change these types after running gofix.
+As always, be sure to read the changes that gofix makes using your
+version control system's diff feature.
+
+See http://weekly.golang.org/pkg/time/ for details.
+
+In package os, the FileInfo struct is replaced by a FileInfo interface,
+admitting implementations by code beyond the operating system.
+Code that refers to *os.FileInfo (a pointer to the old struct) should
+instead refer to os.FileInfo (the new interface).
+The interface has just a few methods:
+
+ type FileInfo interface {
+ Name() string // base name of the file
+ Size() int64 // length in bytes
+ Mode() FileMode // file mode bits
+ ModTime() time.Time // modification time
+ IsDir() bool // abbreviation for Mode().IsDir()
+ }
+
+If you need access to the underlying stat_t provided by the operating
+system kernel, you can access it by assuming that the FileInfo you are
+holding is actually an *os.FileStat, and that it's Sys field is actually a
+*syscall.Stat_t, as in:
+
+ dev := fi.(*os.FileStat).Sys.(*syscall.Stat_t).Dev
+
+Of course, this is not necessarily portable across different operating
+systems.
+
+Gofix will take care of rewriting *os.FileInfo to os.FileInfo for you,
+and it will also rewrite expressions like fi.Name into calls like fi.Name().
+
+See http://weekly.golang.org/pkg/os/#FileInfo for details.
+
+The template package has been changed to export a new, simpler API.
+The Set type is gone. Instead, templates are automatically associated by
+being parsed together; nested definitions implicitly create associations.
+Only associated templates can invoke one another.
+This approach dramatically reduces the breadth of the construction API.
+The html/template package has been updated also.
+There's a gofix for the simplest and most common uses of the old API.
+Code that doesn't mention the Set type is likely to work after running gofix;
+code that uses Set will need to be updated by hand.
+The template definition language itself is unchanged.
+
+See http://weekly.golang.org/pkg/text/template/ for details.
+
+
+Other changes:
+* cgo: add support for callbacks from dynamic libraries.
+* codereview: gofmt check for non-src/ files (thanks David Crawshaw).
+* crypto/openpgp/packet: fix private key checksum.
+* crypto/tls: add openbsd root certificate location,
+ don't rely on map iteration order.
+* crypto/x509, crypto/tls: support PKCS#8 private keys.
+* dashboard: start of reimplementation in Go for App Engine.
+* encoding/xml: fix copy bug.
+* exp/gui: move exp/gui and exp/gui/x11 to http://code.google.com/p/x-go-binding
+* exp/ssh: various improvements (thanks Dave Cheney and Gustav Paul).
+* filepath/path: fix Rel buffer sizing (thanks Gustavo Niemeyer).
+* gc: fix Nconv bug (thanks Rémy Oudompheng) and other fixes.
+* go/printer, gofmt: performance improvements.
+* gofix: test and fix missorted renames.
+* goinstall: add -fix flag to run gofix on packages on build failure,
+ better error reporting,
+ don't hit network unless a checkout or update is required,
+ support Google Code sub-repositories.
+* html: parser improvements (thanks Andrew Balholm).
+* http: fix sniffing bug causing short writes.
+* json: speed up encoding, caching reflect calls.
+* ld: align ELF data sections.
+* math/big: fix destination leak into result value (thanks Roger Peppe),
+ use recursive subdivision for significant speedup.
+* math: faster Cbrt and Sincos (thanks Charles L. Dorian).
+* misc/osx: scripts to make OS X package and disk image (thanks Scott Lawrence).
+* os: fail if Open("") is called on windows (thanks Alex Brainman).
+* runtime: make sure stack is 16-byte aligned on syscall (thanks Alex Brainman).
+* spec, gc: allow direct conversion between string and named []byte, []rune.
+* sql: add Tx.Stmt to use an existing prepared stmt in a transaction,
+ more driver docs & tests; no functional changes.
+* strings: add ContainsAny and ContainsRune (thanks Scott Lawrence).
+* syscall: add SUSv3 RLIMIT/RUSAGE constants (thanks Sébastien Paolacci),
+ fix openbsd sysctl hostname/domainname workaround,
+ implement Syscall15 (thanks Alex Brainman).
+* time: fix Timer stop.
+</pre>
+
+<h2 id="2011-11-18">2011-11-18</h2>
+
+<pre>
+This snapshot includes some language changes.
+
+Map and function value comparisons are now disallowed (except for comparison
+with nil) as per the Go 1 plan. Function equality was problematic in some
+contexts and map equality compares pointers, not the maps' content.
+
+As an experiment, structs are now allowed to be copied even if they contain
+unexported fields. This gives packages the ability to return opaque values in
+their APIs.
+
+Other changes:
+* 6a, 8a: allow $(-1) for consistency with $1, $(1), $-1.
+* 6l: code generation fixes (thanks Michał Derkacz).
+* build: fix check for selinux allow_execstack on Fedora (thanks Bobby Powers).
+* builtin: document delete.
+* cgo: don't panic on undeclared enums/structs (thanks Rémy Oudompheng),
+ fix g0 stack guard.
+* crypto/tls: fix handshake message test.
+* crypto: update incorrect references to Cipher interface; should be Block.
+* doc: clean ups, additions, and fixes to several documents.
+* doc/install: add openbsd (thanks Joel Sing!).
+* doc: link to Chinese translation of A Tour of Go.
+* encoding/json: add marshal/unmarshal benchmark,
+ decode [] as empty slice, not nil slice,
+ make BenchmarkSkipValue more consistent.
+* env.bash: check for presence of make/gmake (thanks Scott Lawrence).
+* exp/sql: NumInput() allow -1 to ignore checking (thanks Yasuhiro Matsumoto),
+ add DB.Close, fix bugs, remove Execer on Driver (only Conn),
+ document that for drivers, io.EOF means no more rows,
+ add client side support for publickey auth (thanks Dave Cheney),
+ add direct-tcpip client support (thanks Dave Cheney),
+ change test listen address, also exit test if fails,
+ other fixes and improvements (thanks Dave Cheney).
+* exp/terminal: rename shell to terminal and add SetSize.
+* fcgi: fix server capability discovery.
+* fmt: distinguish empty vs nil slice/map in %#v.
+* gc: better error, type checks, and many fixes,
+ remove m[k] = x, false syntax (use delete(m, k) instead),
+ support for building with Plan 9 yacc (thanks Anthony Martin).
+* go/printer: make //line formatting idempotent.
+* godefs: delete, replaced by cgo -godefs.
+* godoc: document -templates flag, fix remote search,
+ provide mode for flat (non-indented) directory listings.
+* gofmt: leave nil nodes of the AST unchanged (thanks Rémy Oudompheng).
+* html/template: indirect top-level values before printing.
+* html: more parser improvements (thanks Andrew Balholm).
+* http: fix serving from CWD with http.ServeFile,
+ make Dir("") equivalent to Dir(".").
+* ld: fix .bss for ldpe (thanks Wei Guangjing).
+* math/big: replace nat{} -> nat(nil).
+* math: faster Lgamma (thanks Charles L. Dorian).
+* mime: implement TypeByExtension for windows.
+* misc/bbedit: error and rune support (thanks Anthony Starks).
+* misc/benchcmp: benchmark comparison script.
+* misc/emacs: add delete builtin (thanks Bobby Powers).
+* misc/kate: add error and rune (thanks Evan Shaw).
+* misc/notepadplus: error and rune support (thanks Anthony Starks).
+* misc/windows: Windows installer in MSI format (thanks Joe Poirier).
+* net, io/ioutil: remove use of os.Time (thanks Anthony Martin).
+* net/http: fix EOF handling on response body (thanks Gustavo Niemeyer),
+ fix sniffing when using ReadFrom,
+ use t.Errorf from alternate goroutine in test.
+* os: remove undocumented Envs (use os.Environ instead).
+* reflect: empty slice/map is not DeepEqual to nil,
+ make Value an opaque struct.
+* runtime, syscall: convert from godefs to cgo.
+* runtime: add nanotime for Plan 9 (thanks Anthony Martin),
+ add timer support, use for package time,
+ avoid allocation for make([]T, 0).
+* strconv: add Ftoa benchmarks, make Ftoa faster.
+* syscall: delete syscall.Sleep, take over env implementation, use error.
+* testing: add file:line stamps to messages, print results to standard output.
+* text/template: refactor set parsing.
+* time: add ISOWeek method to Time (thanks Volker Dobler).
+* various: avoid func compare, reduce overuse of os.EINVAL + others.
+</pre>
+
+<h2 id="2011-11-09">2011-11-09</h2>
+
+<pre>
+This weekly snapshot renames various Go packages as described in the Go 1 plan.
+Import statements in client code can be updated automatically with gofix.
+
+The changes are:
+ asn1 -> encoding/asn1
+ big -> math/big
+ cmath -> math/cmplx
+ csv -> encoding/csv
+ exec -> os/exec
+ exp/template/html -> html/template
+ gob -> encoding/gob
+ http -> net/http
+ http/cgi -> net/http/cgi
+ http/fcgi -> net/http/fcgi
+ http/httptest -> net/http/httptest
+ http/pprof -> net/http/pprof
+ json -> encoding/json
+ mail -> net/mail
+ rpc -> net/rpc
+ rpc/jsonrpc -> net/rpc/jsonrpc
+ scanner -> text/scanner
+ smtp -> net/smtp
+ syslog -> log/syslog
+ tabwriter -> text/tabwriter
+ template -> text/template
+ template/parse -> text/template/parse
+ rand -> math/rand
+ url -> net/url
+ utf16 -> unicode/utf16
+ utf8 -> unicode/utf8
+ xml -> encoding/xml
+</pre>
+
+<h2 id="2011-11-08">2011-11-08</h2>
+
+<pre>
+This weekly snapshot includes some package changes.
+
+In preparation for the Go 1 package reorganziation the sources for various
+packages have been moved, but the import paths remain unchanged. This
+inconsistency breaks goinstall at this snapshot. If you use goinstall, please
+stay synced to the previous weekly snapshot until the next one is tagged.
+
+The Error methods in the html, bzip2, and sql packages that return error values
+have been renamed to Err.
+
+Some non-core parts of the http package have been moved to net/http/httputil.
+The Dump* and NewChunked* functions and ClientConn, ServerConn, and
+ReverseProxy types have been moved from http to httputil.
+
+The API for html/template is now a direct copy of the template API, instead of
+exposing a single Escape function. For HTML templates, use the
+html/template package as you would the template package.
+
+Other changes:
+* all: rename os.EOF to io.EOF in non-code contexts (thanks Vincent Vanackere),
+ sort imports with gofix.
+* archive/zip: close file opened with OpenReader (thanks Dmitry Chestnykh).
+* bufio: return nil line from ReadLine on error, as documented.
+* builtin: document basic types and the built-in error type.
+* bytes: add Contains function.
+* exp/sql: finish implementation of transactions, flesh out types, docs.
+* exp/ssh: improved client authentication support (thanks Dave Cheney).
+* gc: better error message for range over non-receive channel,
+ bug fixes and clean-ups,
+ detect type switch variable not used cases,
+ fix escaping of package paths in symbol names,
+ helpful error message on method call on pointer to pointer,
+ portably read archive headers (thanks Ron Minnich).
+* gob: fix bug when registering the same type multiple times.
+* gofix: avoid panic on body-less functions in netudpgroup,
+ make fix order implicit by date.
+* gofmt, gofix: sort imports.
+* goinstall: support launchpad.net/~user branches (thanks Jani Monoses).
+* gopack: do not look for Go metadata in non-Go objects.
+* gotest: don't run examples that have no expected output.
+* html: the parser bug fixing campaign continues (thanks Andrew Balholm).
+* http: fix whitespace handling in sniffer,
+ only recognize application/x-www-form-urlencoded in ParseForm,
+ support Trailers in ReadRequest.
+* lib9: add ctime.
+* math: faster Gamma (thanks Charles L. Dorian),
+ improved accuracy for Tan (thanks Charles L. Dorian),
+ improved high-angle test for Cos, Sin and Tan (thanks Charles L. Dorian).
+* net: implement LookupTXT for windows (thanks Alex Brainman).
+* os,text,unicode: renamings.
+* runtime/cgo: fix data declaration to be extern.
+* runtime: add timespec definition for freebsd,
+ add windows callback tests (thanks Alex Brainman),
+ fix prototype for openbsd thrsleep,
+ fix set and not used,
+ unify mutex code across OSes,
+ windows_386 sighandler to use correct g (thanks Alex Brainman).
+* template: format error with pointer receiver,
+ make redefinition of a template in a set more consistent.
+* test: clear execute bit from source file (thanks Mikio Hara),
+ make closedchan.go exit with failure if something fails.
+* time: faster Nanoseconds call.
+* websocket: return an error HTTP response for bad websocket request.
+* xml: allow parsing of <_> </_>. (thanks David Crawshaw).
+</pre>
+
+<h2 id="2011-11-02">2011-11-02 (new error type)</h2>
+
+<pre>
+This snapshot introduces the built-in error type, defined as
+
+ type error interface {
+ Error() string
+ }
+
+The error type replaces os.Error. Notice that the method name has changed from
+String to Error. Package fmt's Print formats both Stringers and errors:
+in general there is no need to implement both String and Error methods.
+
+Gofix can update most code. If you have split your package across many files,
+it may help to use the -force=error command-line option, which forces gofix to
+apply the error fix even if it is not obvious that a particular file needs it.
+As always, it is a good idea to read and test the changes that gofix made
+before committing them to your version control system.
+</pre>
+
+<h2 id="2011-11-01">2011-11-01</h2>
+
+<pre>
+* 6l: remove mention of -e flag - it does nothing.
+* cc: change cas to newcase (thanks Ron Minnich).
+* crypto/openpgp/error: use Error in names of error impl types.
+* crypto/rsa: change public exponent from 3 to 65537.
+* crypto/tls: add Error method to alert.
+* doc: add link to A Tour of Go in Japanese,
+ add 'all' make rule to build all docs,
+ refer to tour.golang.org instead of go-tour.appspot.com.
+* exp/norm: fixed bug that crept in with moving to the new regexp.
+* exp/ssh: fix length header leaking into channel data (thanks Dave Cheney).
+* fmt: handle os.Error values explicity (as distinct from Stringer).
+* gc: clean up printing,
+ fix [568]g -V crash (thanks Mikio Hara),
+ test + fix escape analysis bug.
+* go/build: avoid os.Error in tests.
+* go/doc: remove os.NewError anti-heuristic.
+* go/parser: test and fix := scoping bug.
+* gob: split uses of gobError, remove unnecessary embedding.
+* gofix: test import insertion, deletion.
+* goinstall: intelligent vcs selection for common sites (thanks Julian Phillips).
+* gopack: change archive file name length back to 16.
+* html: fix print argument in test,
+ more parser improvements (thanks Andrew Balholm).
+* json: properly handle nil slices (thanks Alexander Reece).
+* math: improved accuracy for Sin and Cos (thanks Charles L. Dorian).
+* misc/emacs: fix restoration of windows after gofmt (thanks Jan Newmarch).
+* misc/vim: add rune keyword (thanks Jongmin Kim).
+* misc/windows: can be used for amd64 (thanks Alex Brainman).
+* net: document why we do not use SO_REUSEADDR on windows (thanks Alex Brainman).
+* os: do not interpret 0-length read as EOF.
+* pkg: remove .String() from some print arguments.
+* rpc: avoid infinite loop on input error.
+* runtime/pprof: document OS X being broken.
+* runtime: lock the main goroutine to the main OS thread during init.
+* spec: define that initialization is sequential.
+* strconv: use better errors than os.EINVAL, os.ERANGE.
+* syscall: fix Await msg on Plan 9 (thanks Andrey Mirtchovski).
+* template: do not use error as stringer,
+ fix error checking on execute without parse (thanks Scott Lawrence).
+* test/alias.go: additional tests.
+* test: error-related fixes.
+* textproto: prevent long lines in HTTP headers from causing HTTP 400 responses.
+* time: add RFC1123 with numeric timezone format (thanks Scott Lawrence).
+</pre>
+
+<h2 id="2011-10-26">2011-10-26 (new rune type)</h2>
+
+<pre>
+This snapshot introduces the rune type, an alias for int that
+should be used for Unicode code points.
+
+A future release of Go (after Go 1) will change rune to be an
+alias for int32 instead of int. Using rune consistently is the way
+to make your code build both before and after this change.
+
+To test your code for rune safety, you can rebuild the Go tree with
+
+ GOEXPERIMENT=rune32 ./all.bash
+
+which builds a compiler in which rune is an alias for int32 instead of int.
+
+Also, run govet on your code to identify methods that might need to have their
+signatures updated.
+</pre>
+
+<h2 id="2011-10-25">2011-10-25</h2>
+
+<pre>
+* big: make SetString return nil if an error occurs,
+ new Rat.Inv method,
+ usable zero Rat values without need for explicit initialization.
+* codereview: show LGTMs in hg p.
+* crypto/x509: fix names in certificate generation.
+* exp/ssh: add experimental ssh client,
+ introduce Session to replace Cmd for interactive commands,
+ server cleanups (thanks Dave Cheney).
+* exp/types: fix crash in parseBasicType on unknown type.
+* fmt: don't panic formatting nil interfaces (thanks Gustavo Niemeyer).
+* go/ast, go/token: actually run tests; fix go/ast test.
+* gotest: explicit -help flag, use $GCFLAGS like make does.
+* govet: check canonical dynamic method signatures.
+* html: improved parsing (thanks Andrew Balholm),
+ parse <select> tags, parse and render comment nodes,
+ remove the Tokenizer.ReturnComments option.
+* http: Transport: with TLS InsecureSkipVerify, skip hostname check.
+* misc/vim: add highlighting for delete (thanks Dave Cheney).
+* net: do not set SO_REUSEADDR for windows (thanks Alex Brainman).
+* os/inotify: move to exp/inotify (thanks Mikio Hara).
+* runtime: include bootstrap m in mcpu accounting (thanks Hector Chu).
+* syscall: use uintptr for Mount flags.
+</pre>
+
+<h2 id="2011-10-18">2011-10-18</h2>
+
+<pre>
+This weekly snapshot includes some language and package changes that may
+require code changes. Please read these notes carefully, as there are many
+changes and your code will likely be affected.
+
+The syntax for map deletion has been changed. Code that looks like:
+ m[x] = 0, false
+should be written as:
+ delete(m, x)
+The compiler still accepts m[x] = 0, false for now; even so, you can use gofix
+to rewrite such assignments into delete(m, x).
+
+The Go compiler will reject a return statement without arguments when any of
+the result variables has been shadowed. Code rejected as a result of this
+change is likely to be buggy.
+
+Receive-only channels (<-chan T) cannot be closed.
+The compiler will diagnose such attempts.
+
+The first element of a map iteration is chosen at random. Code that depends on
+iteration order will need to be updated.
+
+Goroutines may be run during program initialization.
+
+A string may be appended to a byte slice. This code is now legal:
+ var b []byte
+ var s string
+ b = append(b, s...)
+
+The gotry command and its associated try package have been deleted.
+It was a fun experiment that - in the end - didn't carry its weight.
+
+The gotype tool has been moved to exp/gotype and its associated go/types
+package has been moved to exp/types. The deprecated go/typechecker package has
+been deleted.
+
+The enbflint tool has been moved to pkg/exp/ebnflint and its associated ebnf
+package has been moved to pkg/exp/ebnf.
+
+The netchan package has been moved to old/netchan.
+
+The http/spdy package has been moved to exp/spdy.
+
+The exp/datafmt package has been deleted.
+
+The container/vector package has been deleted. Slices are better:
+ http://code.google.com/p/go-wiki/wiki/SliceTricks
+
+Other changes:
+* 5l/6l/8l: correct ELFRESERVE diagnostic (thanks Anthony Martin).
+* 6l/8l: support OS X code signing (thanks Mikkel Krautz).
+* asn1: accept UTF8 strings as ASN.1 ANY values.
+* big: handle aliasing correctly for Rat.SetFrac.
+* build: add missing nuke target (thanks Anthony Martin),
+ catch future accidental dependencies to exp or old packages,
+ more robustly detect gold 2.20 (thanks Christopher Wedgwood),
+ pass $GCFLAGS to compiler,
+ stop on failed deps.bash.
+* crypto/tls: add 3DES ciphersuites,
+ add server side SNI support,
+ fetch root CA from Windows store (thanks Mikkel Krautz),
+ fetch root certificates using Mac OS API (thanks Mikkel Krautz),
+ fix broken looping code in windows root CA fetcher (thanks Mikkel Krautz),
+ more Unix root certificate locations.
+* crypto/x509: add code for dealing with PKIX public keys,
+ keep the raw Subject and Issuer.
+* csv: fix overly aggressive TrimLeadingSpace.
+* exp/ssh: general cleanups for client support (thanks Dave Cheney).
+* exp/template/html: fix bug in cssEscaper.
+* exp/terminal: split terminal handling from exp/ssh.
+* exp/winfsnotify: filesystem watcher for Windows (thanks Hector Chu).
+* fmt: fix test relying on map iteration order.
+* gc: changes to export format in preparation for inlining,
+ pass FlagNoPointers to runtime.new,
+ preserve uint8 and byte distinction in errors and import data,
+ stricter multiple assignment + test,
+ treat uintptr as potentially containing a pointer.
+* go/scanner: remove AllowIllegalChars mode.
+* go/token: document deserialization property.
+* gob: avoid one copy for every message written.
+* godefs: add enum/const testdata (thanks Dave Cheney).
+* godoc: generate package toc in template, not in JavaScript,
+ show "unexported" declarations when executing "godoc builtin",
+ show correct source name with -path.
+* gofix: make fix order explicit, add mapdelete.
+* gofmt: fix //line handling,
+ disallow rewrites for incomplete programs.
+* gotest: avoid conflicts with the name of the tested package (thanks Esko Luontola),
+ test example code.
+* goyacc: clean up after units (thanks Anthony Martin),
+ make more gofmt-compliant.
+* html: add a Render function, various bug fixes and improvements,
+ parser improvements (thanks Andrew Balholm).
+* http: DoS protection: cap non-Handler Request.Body reads,
+ RoundTrippers shouldn't mutate Request,
+ avoid panic caused by nil URL (thanks Anthony Martin),
+ fix read timeouts and closing,
+ remove Request.RawURL.
+* image/tiff: implement PackBits decoding (thanks Benny Siegert).
+* ld: fix "cannot create 8.out.exe" (thanks Jaroslavas Počepko).
+* misc/emacs: add a "godoc" command, like M-x man (thanks Evan Martin).
+* misc/swig: delete binaries (thanks Anthony Martin).
+* misc/windows: automated toolchain packager (thanks Joe Poirier).
+* net/windows: implement ip protocol name to number resolver (thanks Alex Brainman).
+* net: add File method to IPConn (thanks Mikio Hara),
+ allow LookupSRV on non-standard DNS names,
+ fix "unexpected socket family" error from WriteToUDP (thanks Albert Strasheim),
+ fix socket leak in case of Dial failure (thanks Chris Farmiloe),
+ remove duplicate error information in Dial (thanks Andrey Mirtchovski),
+ return error from CloseRead and CloseWrite (thanks Albert Strasheim),
+ skip ICMP test on Windows too unless uid 0.
+* reflect: disallow Interface method on Value obtained via unexported name,
+ make unsafe use of SliceHeader gc-friendly.
+* rpc: don't panic on write error.
+* runtime: faster strings,
+ fix crash if user sets MemProfileRate=0,
+ fix crash when returning from syscall during gc (thanks Hector Chu),
+ fix memory leak in parallel garbage collector.
+* scanner: invalidate scanner.Position when no token is present.
+* spec: define order of multiple assignment.
+* syscall/windows: dll function load and calling changes (thanks Alex Brainman).
+* syscall: add #ifdefs to fix the manual corrections in ztypes_linux_arm.go (thanks Dave Cheney),
+ adjust Mount to accommodate stricter FS implementations.
+* testing: fix time reported for failing tests.
+* utf8: add Valid and ValidString.
+* websocket: tweak hybi ReadHandshake to support Firefox (thanks Luca Greco).
+* xml: match Marshal's XMLName behavior in Unmarshal (thanks Chris Farmiloe).
+</pre>
+
+<h2 id="2011-10-06">2011-10-06</h2>
+
+<pre>
+This weekly snapshot includes changes to the io, image, and math packages that
+may require changes to client code.
+
+The io package's Copyn function has been renamed to CopyN.
+
+The math package's Fabs, Fdim, Fmax, Fmin and Fmod functions
+have been renamed to Abs, Dim, Max, Min, and Mod.
+
+Parts of the image package have been moved to the new image/color package.
+The spin-off renames some types. The new names are simply better:
+ image.Color -> color.Color
+ image.ColorModel -> color.Model
+ image.ColorModelFunc -> color.ModelFunc
+ image.PalettedColorModel -> color.Palette
+ image.RGBAColor -> color.RGBA
+ image.RGBAColorModel -> color.RGBAModel
+ image.RGBA64Color -> color.RGBA64
+ image.RGBA64ColorModel -> color.RGBA64Model
+(similarly for NRGBAColor, GrayColorModel, etc)
+The image.ColorImage type stays in the image package, but is renamed:
+ image.ColorImage -> image.Uniform
+The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
+image.Alpha, etc) do not change their name, and gain a nice symmetry:
+an image.RGBA is an image of color.RGBA, etc.
+The image.Black, image.Opaque uniform images remain unchanged (although their
+type is renamed from image.ColorImage to image.Uniform).
+The corresponding color types (color.Black, color.Opaque, etc) are new.
+Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
+ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and image.YCbCr,
+at a later date.
+
+* 5g/6g/8g: fix loop finding bug, fix -f(), registerize variables again.
+* 5l/6l/8l: add a DT_DEBUG dynamic tag to a dynamic ELF binary.
+* archive/zip: read and write unix file modes (thanks Gustavo Niemeyer).
+* build: clear execute bit from source files (thanks Mikio Hara).
+* bytes: add EqualFold.
+* cgo: allow Windows path characters in flag directives (thanks Joe Poirier),
+ support for mingw-w64 4.5.1 and newer (thanks Wei Guangjing).
+* codereview: extra repo sanity check,
+ fix for Mercurial 1.9.2,
+ fix hg change in Windows console (thanks Yasuhiro Matsumoto).
+* crypto/elliptic: use %x consistently in error print.
+* doc/spec: remove notes about gccgo limitations, now fixed.
+* doc: add 'Debugging Go code with GDB' tutorial,
+ fix memory model read visibility bug.
+* encoding/binary: PutX functions require buffer of sufficient size,
+ added benchmarks, support for varint encoding.
+* exec: add Command.ExtraFiles.
+* exp/sql{,/driver}: new database packages.
+* exp/ssh: move common code to common.go (thanks Dave Cheney).
+* exp/template/html: work continues.
+* fmt: replace channel cache with slice.
+* gc: limit helper threads based on ncpu.
+* go/doc, godoc, gotest: support for reading example documentation.
+* go: documentation and skeleton implementation of new command.
+* gob: protect against invalid message length,
+ allow sequential decoders on the same input stream.
+* hgpatch: do not use hg exit status (thanks Yasuhiro Matsumoto).
+* http: add Location method to Response,
+ don't send a 400 Bad Request after a client shutdown.
+* index/suffixarray: 4.5x faster index serialization (to memory).
+* io/ioutil: add a comment on why devNull is a ReaderFrom.
+* json: use strings.EqualFold instead of strings.ToLower.
+* misc/emacs: fix indent bug.
+* net: add shutdown: TCPConn.CloseWrite and CloseRead.
+* net: use AF_UNSPEC instead of individual address family (thanks Mikio Hara).
+* path/filepath: added Rel as the complement of Abs (thanks Gustavo Niemeyer).
+* pkg/syscall: add Mkfifo for linux platforms.
+* regexp: move to old/regexp, replace with exp/regexp, speedups.
+* runtime/gdb: fix pretty printing of channels,
+ gracefully handle not being able to find types.
+* runtime: check for nil value pointer in select syncsend case,
+ faster finalizers,
+ fix malloc sampling bug,
+ fix map memory leak,
+ fix spurious deadlock reporting,
+ fix usleep on linux/386 and re-enable parallel gc (thanks Hector Chu),
+ parallelize garbage collector mark + sweep.
+* strconv: faster Unquote in common case.
+* strings: add EqualFold, Replacer, NewReplacer.
+* suffixarray: add benchmarks for construction (thanks Eric Eisner).
+* syscall: add GetsockoptByte, SetsockoptByte for openbsd (thanks Mikio Hara),
+ add IPv4 ancillary data for linux (thanks Mikio Hara),
+ mark stdin, stdout, stderr non-inheritable by child processes (thanks Alex Brainman),
+ mksyscall_windows.pl creates non-syscall packages (thanks Jaroslavas Počepko),
+ update multicast socket options (thanks Mikio Hara).
+* testing: support for running tests in parallel (thanks Miki Tebeka).
+* time: make month/day name comparisons case insenstive.
+* unicode: fix make tables.
+* vim: Send GoFmt errors to a location list (thanks Paul Sbarra).
+* websocket: add hybi-13 support, add mutex to make websocket full-duplex.
+</pre>
+
+<h2 id="2011-09-21">2011-09-21</h2>
+
+<pre>
+This weekly contains several improvements, bug fixes, and new packages.
+
+* archive/tar: document Header fields and Type flags (thanks Mike Rosset).
+* bytes: fix Replace so it actually copies (thanks Gustavo Niemeyer).
+* cgo: use GOARCH from the environment (thanks Jaroslavas Počepko).
+* codereview: save CL messages in $(hg root)/last-change.
+* crypto/bcrypt: new package (thanks Jeff Hodges).
+* crypto/blowfish: exposing the blowfish key schedule (thanks Jeff Hodges).
+* doc: link to golang-france.
+* doc: when configuring gold for gccgo, use --enable-gold=default.
+* exp/norm: changed trie to produce smaller tables.
+* exp/ssh: new package,
+ refactor halfConnection to transport (thanks Dave Cheney).
+* exp/template/html: more fixes and improvements.
+* filepath: fix Glob to return no error on nonmatching patterns.
+* gc: disallow invalid map keys,
+ handle complex CONVNOP.
+* gob: allocation fixes.
+* godoc: simplify internal FileSystem interface.
+* http/cgi: clean up environment (thanks Yasuhiro Matsumoto).
+* http: always include Content-Length header, even for 0 (thanks Dave Grijalva),
+ check explicit wrong Request.ContentLength values,
+ fix TLS handshake blocking server accept loop,
+ prevent DumpRequest from adding implicit headers.
+* httptest: add NewUnstartedServer.
+* json: clearer Unmarshal doc,
+ skip nil in UnmarshalJSON and (for symmetry) MarshalJSON.
+* net: use /etc/hosts first when looking up IP addresses (thanks Andrey Mirtchovski).
+* reflect: add comment about the doubled semantics of Value.String.
+* runtime: implement pprof support for windows (thanks Hector Chu),
+ increase stack system space on windows/amd64 (thanks Hector Chu).
+* suffixarray: generate less garbage during construction (thanks Eric Eisner),
+ improved serialization code using gob instead of encoding/binary.
+* sync/atomic: replace MFENCE with LOCK XADD.
+</pre>
+
+<h2 id="2011-09-16">2011-09-16</h2>
+
+<pre>
+This weekly snapshot includes changes to the image, path/filepath, and time
+packages. Code that uses these packages may need to be updated.
+
+The image package's NewX functions (NewRGBA, NewNRGBA, etc) have been changed
+to take a Rectangle argument instead of a width and height.
+Gofix can make these changes automatically.
+
+The path/filepath package's Walk function has been changed to take a WalkFunc
+function value instead of a Visitor interface value. WalkFunc is like the
+Visitor's VisitDir and VisitFile methods except it handles both files and
+directories:
+ func(path string, info *os.FileInfo, err os.Error) os.Error
+To skip walking a directory (like returning false from VisitDir) the WalkFunc
+must return SkipDir.
+
+The time package's Time struct's Weekday field has been changed to a method.
+The value is calculated on demand, avoiding the need to re-parse
+programmatically-constructed Time values to find the correct weekday.
+
+There are no gofixes for the filepath or time API changes, but instances of the
+old APIs will be caught by the compiler. The Weekday one is easy to update by
+hand. The Walk one may take more consideration, but will have fewer instances
+to fix.
+
+* build: add build comments to core packages.
+* codereview: Mercurial 1.9 fix for hg diff @nnn.
+* crypto/tls: handle non-TLS more robustly,
+ support SSLv3.
+* debug/elf: permit another case of SHT_NOBITS section overlap in test.
+* exm/template/html: more work on this auto-escaping HTML template package.
+* exp/norm: added regression test tool for the standard Unicode test set.
+* exp/regexp/syntax: fix invalid input parser crash,
+ import all RE2 parse tests + fix bugs.
+* exp/regexp: add MustCompilePOSIX, CompilePOSIX, leftmost-longest matching.
+* flag: make zero FlagSet useful.
+* gc: clean up if grammar.
+* go/build: handle cgo, // +build comments.
+* go/printer: use panic/defer instead of goroutine for handling errors.
+* go/token: support to serialize file sets.
+* godoc, suffixarray: switch to exp/regexp.
+* godoc: show packages matching a query at the top,
+ support for complete index serialization,
+ use go/build to find files in a package.
+* gofmt: accept program fragments on standard input, add else test.
+* http/cgi: add openbsd environment configuration.
+* http: document that Response.Body is non-nil.
+* image/png: don't use a goroutine to decode, to permit decode during init.
+* json: if a field's tag is "-", ignore the field for encoding and decoding.
+* ld: grow dwarf includestack on demand.
+* net, syscall: implement SetsockoptIPMReq(), and
+ move to winsock v2.2 for multicast support (thanks Paul Lalonde).
+* net: add a LookupTXT function.
+* os: os.RemoveAll to check for wboth error codes on Windows (thanks Jaroslavas Počepko).
+* path/filepath: fix Visitor doc (thanks Gustavo Niemeyer),
+ make UNC file names work (thanks Yasuhiro Matsumoto).
+* runtime: optimizations to channels on Windows (thanks Hector Chu),
+ syscall to return both AX and DX for windows/386 (thanks Alex Brainman).
+* sync/atomic: add 64-bit Load and Store.
+* syscall: add route flags for linux (thanks Mikio Hara).
+* test: add test for inheriting private method from anonymous field.
+* websocket: fix infinite recursion in Addr.String() (thanks Tarmigan Casebolt),
+ rename websocket.WebSocketAddr to *websocket.Addr.
+</pre>
+
+<h2 id="2011-09-07">2011-09-07</h2>
+
+<pre>
+This weekly snapshot consists of improvements and bug fixes, including fixes
+for issues introduced by escape analysis changes in the gc compiler.
+
+* build: clear execute bit from Go files (thanks Mike Rosset),
+ error out if problem with sudo.bash /usr/local/bin (thanks Mike Rosset).
+* exp/norm: add Reader and Writer,
+ performance improvements of quickSpan.
+* exp/regexp: bug fixes and RE2 tests.
+* exp/template/html: string replacement refactoring,
+ tweaks to js{,_test}.go.
+* gc: add -p flag to catch import cycles earlier,
+ fix label recursion bugs,
+ fix zero-length struct eval,
+ zero stack-allocated slice backing arrays,
+* gc, ld: fix Windows file paths (thanks Hector Chu).
+* go/parser: accept corner cases of signature syntax.
+* gobuilder: ignore _test.go files when looking for docs, more logging.
+* godoc: minor tweaks for App Engine use.
+* gofix: do not convert url in field names (thanks Gustavo Niemeyer).
+* gofmt: indent multi-line signatures.
+* gopprof: regexp fixes (thanks Hector Chu).
+* image/png: check zlib checksum during Decode.
+* libmach: fix incorrect use of memset (thanks Dave Cheney).
+* misc/goplay: fix template output.
+* net: ParseCIDR returns IPNet instead of IPMask (thanks Mikio Hara),
+ sync CIDRMask code, doc.
+* os: use GetFileAttributesEx to implement Stat on windows (thanks Alex Brainman).
+* runtime: fix openbsd 386 raisesigpipe,
+ implement exception handling on windows/amd64 (thanks Hector Chu),
+ test for concurrent channel consumers (thanks Christopher Wedgwood).
+* sort: use heapsort to bail out quicksort (thanks Ziad Hatahet).
+* sync/atomic: add LoadUintptr, add Store functions.
+* syscall: update routing message attributes handling (thanks Mikio Hara).
+* template: fix deadlock,
+ indirect or dereference function arguments if necessary,
+ slightly simplify the test for assignability of arguments.
+* url: handle ; in ParseQuery.
+* websocket: fix incorrect prints found by govet (thanks Robert Hencke).
+</pre>
+
+<h2 id="2011-09-01">2011-09-01</h2>
+
+<pre>
+This weekly contains performance improvements and bug fixes.
+
+The gc compiler now does escape analysis, which improves program performance
+by placing variables on the call stack instead of the heap when it is safe to
+do so.
+
+The container/vector package is deprecated and will be removed at some point
+in the future.
+
+Other changes:
+* archive/tar: support symlinks. (thanks Mike Rosset)
+* big: fix nat.scan bug. (thanks Evan Shaw)
+* bufio: handle a "\r\n" that straddles the buffer.
+ add openbsd.
+ avoid redundant bss declarations.
+ fix unused parameters.
+ fix windows/amd64 build with newest mingw-w64. (thanks Hector Chu)
+* bytes: clarify that NewBuffer is not for beginners.
+* cgo: explain how to free something.
+ fix GoBytes. (thanks Gustavo Niemeyer)
+ fixes callback for windows amd64. (thanks Wei Guangjing)
+ note that CString result must be freed. (thanks Gustavo Niemeyer)
+* cov: remove tautological #defines. (thanks Lucio De Re)
+* dashboard: yet another utf-8 fix.
+* doc/codelab/wiki: fix Makefile.
+* doc/progs: fix windows/amd64. (thanks Jaroslavas Počepko)
+* doc/tmpltohtml: update to new template package.
+* doc: emphasize that environment variables are optional.
+* effective_go: convert to use tmpltohtml.
+* exp/norm: reduced the size of the byte buffer used by reorderBuffer by half by reusing space when combining.
+ a few minor fixes to support the implementation of norm.
+ added implementation for []byte versions of methods.
+* exp/template/html: add some tests for ">" attributes.
+ added handling for URL attributes.
+ differentiate URL-valued attributes (such as href).
+ reworked escapeText to recognize attr boundaries.
+* exp/wingui: made compatible with windows/amd64. (thanks Jaroslavas Počepko)
+* flag: add Parsed, restore Usage.
+* gc: add openbsd.
+ escape analysis.
+ fix build on Plan 9. (thanks Lucio De Re)
+ fix div bug.
+ fix pc/line table. (thanks Julian Phillips)
+ fix some spurious leaks.
+ make static initialization more static.
+ remove JCXZ; add JCXZW, JCXZL, and JCXZQ instructions. (thanks Jaroslavas Počepko)
+ shuffle #includes.
+ simplify escape analysis recursion.
+ tweak and enable escape analysis.
+* go/ast cleanup: base File/PackageExports on FilterFile/FilterPackage code.
+ adjustments to filter function.
+ fix ast.MergePackageFiles to collect infos about imports. (thanks Sebastien Binet)
+ generalize ast.FilterFile.
+* go/build: add test support & use in gotest.
+ separate test imports out when scanning. (thanks Gustavo Niemeyer)
+* go/parser: fix type switch scoping.
+ fix type switch scoping.
+* gob: explain that Debug isn't useful unless it's compiled in.
+* gobuilder: increase log limit.
+* godashboard: fix utf-8 in user names.
+* godoc: first step towards reducing index size.
+ add dummy playground.js to silence godoc warning at start-up.
+ added systematic throttling to indexing goroutine.
+ fix bug in zip.go.
+ support for reading/writing (splitted) index files.
+ use virtual file system when generating package synopses.
+* gofix: forgot to rename the URL type.
+ osopen: fixed=true when changing O_CREAT. (thanks Tarmigan Casebolt)
+* goinstall: error out with paths that end with '/'. (thanks Tarmigan Casebolt)
+ report lack of $GOPATH on errors. (thanks Gustavo Niemeyer)
+ select the tag that is closest to runtime.Version.
+* gotry: add missing $. (thanks Tarmigan Casebolt)
+* http: add MaxBytesReader to limit request body size.
+ add file protocol transport.
+ adjust test threshold for larger suse buffers.
+ delete error kludge.
+ on invalid request, send 400 response.
+ return 413 instead of 400 when the request body is too large. (thanks Dave Cheney)
+ support setting Transport's TLS client config.
+* image/tiff: add a decode benchmark. (thanks Benny Siegert)
+ decoder optimization. (thanks Benny Siegert)
+* image: add PalettedImage interface, and make image/png recognize it. (thanks Jaroslavas Počepko)
+* io: add TeeReader. (thanks Hector Chu)
+* json: add struct tag option to wrap literals in strings.
+ calculate Offset for Indent correctly. (thanks Jeff Hodges)
+ fix decode bug with struct tag names with ,opts being ignored.
+* ld: handle Plan 9 ar format. (thanks Lucio De Re)
+ remove duplicate bss definitions.
+* libmach: support reading symbols from Windows .exe for nm. (thanks Mateusz Czapliński)
+* math: fix Pow10 loop. (thanks Volker Dobler)
+* mime: ParseMediaType returns os.Error now, not a nil map.
+ media type formatter. (thanks Pascal S. de Kloe)
+ text charset defaults. (thanks Pascal S. de Kloe)
+* misc/dashboard: remove limit for json package list.
+* misc/emacs: refine label detection.
+* net: add ParseMAC function. (thanks Paul Borman)
+ change the internal form of IPMask for IPv4. (thanks Mikio Hara)
+ disable "tcp" test on openbsd.
+ fix windows build. (thanks Alex Brainman)
+ join and leave a IPv6 group address, on a specific interface. (thanks Mikio Hara)
+ make use of IPv4len, IPv6len. (thanks Mikio Hara)
+ move internal string manipulation routines to parse.go. (thanks Mikio Hara)
+* os: disable Hostname test on OpenBSD.
+ fix WNOHANG Waitmsg. (thanks Gustavo Niemeyer)
+* reflect: add Value.Bytes, Value.SetBytes methods.
+* rpc: add benchmark for async rpc calls.
+* runtime: add openbsd 386 defs.h.
+ add runtime support for openbsd 386.
+ add runtime· prefix to showframe.
+ ctrlhandler for windows amd64. (thanks Wei Guangjing)
+ fix stack cleanup on windows/amd64. (thanks Hector Chu)
+ fix void warnings.
+ go interface to cdecl calbacks. (thanks Jaroslavas Počepko)
+ handle string + char literals in goc2c.
+ make arm work on Ubuntu Natty qemu.
+ openbsd thread tweaks.
+ simplify stack traces.
+ speed up cgo calls. (thanks Alex Brainman)
+ use cgo runtime functions to call windows syscalls. (thanks Alex Brainman)
+ windows/amd64 callbacks fixed and syscall fixed to allow using it in callbacks. (thanks Jaroslavas Počepko)
+* strconv: put decimal on stack.
+* spec: update section on Implementation Differences.
+* syscall: SOMAXCONN should be 0x7fffffff at winsock2. (thanks Yasuhiro Matsumoto)
+ add openbsd 386.
+ handle RTM_NEWROUTE in ParseNetlinkRouteAttr on Linux. (thanks Albert Strasheim)
+ handle routing entry in ParseRoutingSockaddr on BSD variants. (thanks Mikio Hara)
+ openbsd amd64 syscall support.
+ use the vdso page on linux x86 for faster syscalls instead of int $0x80. (thanks Yuval Pavel Zholkover)
+* template/parse: give if, range, and with a common representation.
+* template: grammar fix for template documentation. (thanks Bill Neubauer)
+ range over channel.
+ remove else and end nodes from public view.
+* test: put GOROOT/bin before all others in run.
+* time: fix Plan 9 build. (thanks Fazlul Shahriar)
+ fix zone during windows test.
+* type switches: test for pathological case.
+* version.bash: update VERSION on -save if already present. (thanks Gustavo Niemeyer)
+* websocket: implements new version of WebSocket protocol. (thanks Fumitoshi Ukai)
+* windows/386: clean stack after syscall. (thanks Jaroslavas Počepko)
+* xml: marshal "parent>child" tags correctly. (thanks Ross Light)
+</pre>
+
+<h2 id="2011-08-17">2011-08-17 (<a href="release.html#r60">base for r60</a>)</h2>
+
+<pre>
+This weekly contains some package re-shuffling. Users of the http and
+template packages may be affected.
+
+This weekly replaces the template package with exp/template.
+The original template package is still available as old/template.
+The old/template package is deprecated and will be removed at some point
+in the future. The Go tree has been updated to use the new template package.
+We encourage users of the old template package to switch to the new one.
+Code that uses template or exp/template will need to change
+its import lines to "old/template" or "template", respectively.
+
+The http package's URL parsing and query escaping code (such as ParseURL and
+URLEscape) has been moved to the new url package, with several simplifications
+to the names. Client code can be updated automatically with gofix.
+
+* asn1: support unmarshaling structs with int32 members (thanks Dave Cheney).
+* build: allow builds without cgo or hg,
+ support versioning without hg (thanks Gustavo Niemeyer).
+* builtin: add documentation for builtins.
+* cgo: omit duplicate symbols in writeDefs (thanks Julian Phillips).
+* misc: add support for OpenBSD.
+* doc/codewalk: new Markov chain codewalk.
+* exp/norm: added trie lookup code and associated tests,
+ generate trie struct in triegen.go for better encapsulation,
+ implementation of decomposition and composing functionality.
+* exp/template/html: new experimental package for auto-escaping HTML templates.
+* exp/template: don't panic on range of nil interface,
+ rename Parse*File and Parse*Files for clarity,
+ support field syntax on maps (thanks Gustavo Niemeyer), and
+ many other fixes and changes.
+* gc: implement nil chan and nil map support.
+* go/parser: range clause and type literal fixes.
+* godoc: show all top-level decls for (fake) package builtin.
+* goinstall: really report all newly-installed public packages.
+* html: parse more malformed tags.
+* http: fix ParseMultipartForm after MultipartReader error,
+ fix side effects in DefaultTransport's RoundTrip method (thanks Dave Grijalva).
+* json: fix []unmarshaler case.
+* ld: make addaddrplus4 static (thanks Lucio De Re).
+* syscall: move multicast address handling to the net package.
+* net: Plan 9 support (thanks Fazlul Shahriar),
+ add SetTimeout to Listener interface (thanks Aleksandar Dezelin),
+ add multicast stubs for OpenBSD,
+ return correct local address for an accepted TCP connection (thanks Mikio Hara).
+* reflect: panic on Invalid Interface call (thanks Gustavo Niemeyer).
+* rpc: implement ServeRequest to synchronously serve a single request,
+ make Server.Mutex unexported.
+* runtime: better checks for syscall.NewCallback parameter (thanks Alex Brainman),
+ correct SEH installation during callbacks (thanks Alex Brainman),
+ fix GC bitmap corruption,
+ fix pseudo-randomness on some selects (thanks Gustavo Niemeyer).
+* syscall: make LazyDLL/LazyProc.Mutex unexported.
+* test: allow multiple patterns in errchk,
+ new nil semantics.
+* time: take fractional seconds even if not in the format string.
+* url: new package.
+* utf8: rename some internal constants to remove leading underscores.
+* xml: escape string chardata in xml.Marshal.
+</pre>
+
+<h2 id="2011-08-10">2011-08-10</h2>
+
+<pre>
+This weekly contains performance improvements and bug fixes.
+
+There are no outward-facing changes, but imports of the old-style
+container/vector package have also been removed from the core library (thanks
+John Asmuth, Kyle Consalus).
+
+Other changes:
+
+* 5g: fix set but not used error (thanks Dave Cheney).
+* cmd/ld: Corrected mismatched print formats and variables (thanks Lucio De Re).
+* errchk: add -0 flag.
+* exp/norm: fix build by adding a test placeholder,
+ maketables tool for generating tables for normalization.
+* exp/template: bug fixes,
+ ensure that a valid Set is returned even on error (thanks Roger Peppe),
+ make index on maps return zero when key not present (thanks Roger Peppe),
+ split the parse tree into a separate package exp/template/parse,
+ add url query formatting filter.
+* faq: lots of small tweaks plus a couple of new discussions,
+ variant types, unions.
+* fmt: call UpdateMemStats in malloc counter.
+* go/build: use GOBIN as binary path for GOROOT.
+* gob: add UpdateMemStats calls to malloc counter,
+ avoid a couple of init-time allocations,
+ don't invoke GobEncoder on zero values.
+* gofmt: update test script so 'make test' succeeds.
+* html: parse doctype tokens; merge adjacent text nodes.
+* http: add more MPEG-4 MIME types to sniffer, and disable MP4 sniffing,
+ add test to serve content in index.html (thanks Yasuhiro Matsumoto),
+ configurable and default request header size limit,
+ correct format flags when printing errors in tests (thanks Alex Brainman),
+ correct path to serve index.html (thanks Yasuhiro Matsumoto),
+* ld: add one empty symbol into pe to make dumpbin works (thanks Wei Guangjing),
+ fail linking if the top-level package is not main.
+* misc/vim: godoc command (thanks Yasuhiro Matsumoto).
+* net: add support for openbsd (thanks Joel Sing),
+ fix /proc/net/igmp,igmp6 reading bug on linux (thanks Mikio Hara),
+ implement windows LookupMX and LookupAddr (thanks Mikio Hara),
+ sort SRV records before returning from LookupSRV (thanks Alex Brainman),
+* os: add support for openbsd (thanks Joel Sing).
+* runtime: add more specialized type algorithms,
+ correct Note documentation,
+ faster chan creation on Linux/FreeBSD/Plan9,
+ openbsd amd64 runtime support (thanks Joel Sing),
+ remove unnecessary locking (thanks Hector Chu).
+* scanner: correct error position for illegal UTF-8 encodings.
+* syscall: delay load of dll functions on Windows (thanks Alex Brainman),
+ move BSD mmap syscall (thanks Joel Sing),
+ update routing message support for BSD variants (thanks Mikio Hara).
+* test/bench: note changes after recent improvements to locking and runtime.
+* time: add nanoseconds to the Time structure,
+ parse and format fractional seconds.
+</pre>
+
+<h2 id="2011-07-29">2011-07-29</h2>
+
+<pre>
+This weekly contains performance improvements and many bug fixes.
+
+* 6l: OpenBSD support.
+* archive/zip: handle zip files with more than 65535 files,
+ more efficient reader and bug fix.
+* big: refine printf formatting and optimize string conversion.
+* build: fixes for mingw-w64 (thanks Wei Guangjing),
+ miscellaneous fixes.
+* cgo: add GoBytes, fix gmp example.
+* exp/norm: API for normalization library.
+* exp/regexp: implement regexp API using exp/regexp/syntax.
+* exp/template: more tweaks and fixes, convert the tree to use exp/template.
+* fmt: handle precision 0 format strings in standard way.
+* gc: a raft of bug fixes.
+* go/parser: report illegal label declarations at ':'.
+* gob: send empty but non-nil maps.
+* godoc: allow form feed in text files,
+ app engine configuration and updated documentation.
+* goinstall: abort and warn when using any url scheme, not just 'http://',
+ write to goinstall.log in respective GOPATH.
+* html: handle character entities without semicolons (thanks Andrew Balholm),
+ parse misnested formatting tags according to the HTML5 spec,
+ sync html/testdata/webkit with upstream WebKit.
+* http: content-type sniffing,
+ make serveFile redirects relative (thanks Andrew Balholm),
+ other fixes.
+* image/tiff: Do not panic when RowsPerStrip is missing (thanks Benny Siegert).
+* io/ioutil: improve performance of ioutil.Discard (thanks Mike Solomon).
+* ld: detect all import cycles,
+ ldpe fixes (thanks Wei Guangjing),
+ remove cseekend and redo pe writing (thanks Alex Brainman),
+ remove overlap of ELF sections on dynamic binaries (thanks Gustavo Niemeyer).
+* net/textproto: avoid 1 copy in ReadLine, ReadContinuedLine.
+* net: fix memory corruption in windows *netFD.ReadFrom (thanks Alex Brainman).
+* runtime: faster entersyscall/exitsyscall,
+ fix scheduler races (thanks Hector Chu),
+ higher goroutine arg limit, clearer error,
+ parallelism-related performance optimizations and fixes,
+ replace byte-at-a-time zeroing loop with memclr (thanks Quan Yong Zhai).
+* sort: fix Float64Slice sort; NaN smallest value (thanks Florian Uekermann).
+* src: removed some uses of container/vector (thanks John Asmuth).
+* sync: improve Once fast path.
+* unicode: fix case-mapping for roman numerals.
+</pre>
+
+<h2 id="2011-07-19">2011-07-19</h2>
+
+<pre>
+This weekly snapshot includes a language change and a change to the image
+package that may require changes to client code.
+
+The language change is that an "else" block is now required to have braces
+except if the body of the "else" is another "if". Since gofmt always puts those
+braces in anyway, programs will not be affected unless they contain "else for",
+"else switch", or "else select". Run gofmt to fix any such programs.
+
+The image package has had significant changes made to the Pix field of struct
+types such as image.RGBA and image.NRGBA. The image.Image interface type has
+not changed, though, and you should not need to change your code if you don't
+explicitly refer to Pix fields. For example, if you decode a number of images
+using the image/jpeg package, compose them using image/draw, and then encode
+the result using image/png, then your code should still work as before.
+
+If you do explicitly refer to Pix fields, there are two changes. First, Pix[0]
+now refers to the pixel at Bounds().Min instead of the pixel at (0, 0). Second,
+the element type of the Pix slice is now uint8 instead of image.FooColor. For
+example, for an image.RGBA, the channel values will be packed R, G, B, A, R, G,
+B, A, etc. For 16-bits-per-channel color types, the pixel data will be stored
+as big-endian uint8s.
+
+Most Pix field types have changed, and so if your code still compiles after
+this change, then you probably don't need to make any further changes (unless
+you use an image.Paletted's Pix field). If you do get compiler errors, code
+that used to look like this:
+
+ // Get the R, G, B, A values for the pixel at (x, y).
+ var m *image.RGBA = loadAnImage()
+ c := m.Pix[y*m.Stride + x]
+ r, g, b, a := c.R, c.G, c.B, c.A
+
+should now look like this:
+
+ // Get the R, G, B, A values for the pixel at (x, y).
+ var m *image.RGBA = loadAnImage()
+ i := (y-m.Rect.Min.Y)*m.Stride + (x-m.Rect.Min.X)*4
+ r := m.Pix[i+0]
+ g := m.Pix[i+1]
+ b := m.Pix[i+2]
+ a := m.Pix[i+3]
+
+This image package change will not be fixed by gofix: how best to translate
+code into something efficient and idiomatic depends on the surrounding context,
+and is not easily automatable. Examples of what to do can be found in the
+changes to image/draw/draw.go in http://codereview.appspot.com/4675076/
+
+Other changes:
+* 6l: change default output name to 6.out.exe on windows (thanks Alex Brainman).
+* archive/zip: add Writer,
+ add Mtime_ns function to get modified time in sensible format.
+* cc, ld, gc: fixes for Plan 9 build (thanks Lucio De Re).
+* cgi: close stdout reader pipe when finished.
+* cgo: add missing semicolon in generated struct,
+ windows amd64 port (thanks Wei Guangjing).
+* codereview: fix for Mercurial 1.9.
+* dashboard: list "most installed this week" with rolling count.
+* debug/elf: read ELF Program headers (thanks Matthew Horsnell).
+* debug/pe: fixes ImportedSymbols for Win64 (thanks Wei Guangjing).
+* debug/proc: remove unused package.
+* doc/talks/io2010: update with gofix and handle the errors.
+* exp/eval, exp/ogle: remove packages eval and ogle.
+* exp/regexp/syntax: add Prog.NumCap.
+* exp/template: API changes, bug fixes, and tweaks.
+* flag: make -help nicer.
+* fmt: Scan(&int) was mishandling a lone digit.
+* gc: fix closure bug,
+ fix to build with clang (thanks Dave Cheney),
+ make size of struct{} and [0]byte 0 bytes (thanks Robert Hencke),
+ some enhancements to printing debug info.
+* gif: fix local color map and coordinates.
+* go/build: fixes for windows (thanks Alex Brainman),
+ include processing of .c files for cgo packages (thanks Alex Brainman),
+ less aggressive failure when GOROOT not found.
+* go/printer: changed max. number of newlines from 3 to 2.
+* gob: register more slice types (thanks Bobby Powers).
+* godoc: support for file systems stored in .zip files.
+* goinstall, dashboard: Google Code now supports git (thanks Tarmigan Casebolt).
+* hash/crc32: add SSE4.2 support.
+* html: update section references in comments to the latest HTML5 spec.
+* http: drain the pipe output in TestHandlerPanic to avoid logging deadlock,
+ fix Content-Type of file extension (thanks Yasuhiro Matsumoto),
+ implement http.FileSystem for zip files,
+ let FileServer work when path doesn't begin with a slash,
+ support for periodic flushing in ReverseProxy.
+* image/draw: add benchmarks.
+* json: add omitempty struct tag option,
+ allow using '$' and '-' as the struct field's tag (thanks Mikio Hara),
+ encode \r and \n in strings as e.g. "\n", not "\u000A" (thanks Evan Martin),
+ escape < and > in any JSON string for XSS prevention.
+* ld: allow seek within write buffer<
+ add a PT_LOAD PHDR entry for the PHDR (thanks David Anderson).
+* net: windows/amd64 port (thanks Wei Guangjing).
+* os: plan9: add Process.Signal as a way to send notes (thanks Yuval Pavel Zholkover).
+* os: don't permit Process.Signal after a successful Wait.
+* path/filepath: fixes for windows paths (thanks Alex Brainman).
+* reflect: add Value.NumMethod,
+ panic if Method index is out of range for a type.
+* runtime: faster entersyscall, exitsyscall,
+ fix panic for make(chan [0]byte),
+ fix subtle select bug (thanks Hector Chu),
+ make goc2c build on Plan 9 (thanks Lucio De Re),
+ make TestSideEffectOrder work twice,
+ several parallelism-related optimizations and fixes,
+ stdcall_raw stack 16byte align for Win64 (thanks Wei Guangjing),
+ string-related optimizations (thanks Quan Yong Zhai),
+ track running goroutine count.
+* strconv: handle [-+]Infinity in atof.
+* sync: add fast paths to WaitGroup,
+ improve RWMutex performance.
+* syscall: add Flock on Linux,
+ parse and encode SCM_RIGHTS and SCM_CREDENTIALS (thanks Albert Strasheim).
+</pre>
+
+<h2 id="2011-07-07">2011-07-07 (<a href="release.html#r59">base for r59</a>)</h2>
+
+<pre>
+This weekly snapshot includes changes to the strings, http, reflect, json, and
+xml packages. Code that uses these packages will need changes. Most of these
+changes can be made automatically with gofix.
+
+The strings package's Split function has itself been split into Split and
+SplitN. SplitN is the same as the old Split. The new Split is equivalent to
+SplitN with a final argument of -1.
+
+The http package has a new FileSystem interface that provides access to files.
+The FileServer helper now takes a FileSystem argument instead of an explicit
+file system root. By implementing your own FileSystem you can use the
+FileServer to serve arbitrary data.
+
+The reflect package supports a new struct tag scheme that enables sharing of
+struct tags between multiple packages.
+In this scheme, the tags must be of the form:
+ key:"value" key2:"value2"
+reflect.StructField's Tag field now has type StructTag (a string type), which
+has method Get(key string) string that returns the associated value.
+Clients of json and xml will need to be updated. Code that says
+ type T struct {
+ X int "name"
+ }
+should become
+ type T struct {
+ X int `json:"name"` // or `xml:"name"`
+ }
+Use govet to identify struct tags that need to be changed to use the new syntax.
+
+Other changes:
+* 5l, 6l, 8l: drop use of ed during build.
+* asn1: support T61 and UTF8 string.
+* bufio: do not cache Read errors (thanks Graham Miller).
+* build: make version.bash aware of branches.
+* cgi: don't depend on CGI.pm for tests.
+* codereview: make --ignore_hgpatch_failure work again,
+ restrict sync to default branch.
+* crypto/openpgp: add ability to reserialize keys,
+ bug fix (thanks Gideon Jan-Wessel Redelinghuys).
+* crypto/tls: fix generate_cert.go.
+* crypto/x509: prevent chain cycles in Verify.
+* csv: new package.
+* doc: remove ed from apt-get package list.
+* docs: fold the prog.sh scripting from makehtml into htmlgen itself.
+* ebnflint: better handling of stdin.
+* exp/regexp/syntax: new experimental RE2-based regexp implementation.
+* exp/template: a new experimental templating package.
+* fmt: add SkipSpace to fmt's ScanState interface.
+* fmt: rename errno and error to err for doc consistency.
+* gc: avoid package name ambiguity in error messages,
+ fix package quoting logic,
+ fixes for Plan 9 (thanks Lucio De Re).
+* go/build: evaluate symlinks before comparing path to GOPATH.
+* gob: use exported fields in structs in the package documentation.
+* godoc: ignore directories that begin with '.',
+ search GOPATH for documentation.
+* gofix: os/signal, path/filepath, and sort fixes (thanks Robert Hencke),
+* goinstall: add support for generic hosts (thanks Julian Phillips),
+ only report successfully-installed packages to the dashboard,
+ try to access via https (thanks Yasuhiro Matsumoto).
+* gotest: add -test.benchtime and -test.cpu flags.
+* html: fixes and improvements (thanks Yasuhiro Matsumoto).
+* http/cgi: add Handler.Dir to specify working directory (thanks Yasuhiro Matsumoto).
+* http: add StripPrefix handler wrapper,
+ assume ContentLength 0 on GET requests,
+ better handling of 0-length Request.Body,
+ do TLS handshake explicitly before copying TLS state,
+ document that ServerConn and ClientConn are low-level,
+ make NewChunkedReader public (thanks Andrew Balholm),
+ respect Handlers setting Connection: close in their response.
+* image: more tests, Paletted.Opaque optimization.
+* io.WriteString: if the object has a WriteString method, use it (thanks Evan Shaw).
+* ld: elide the Go symbol table when using -s (thanks Anthony Martin).
+* ld: fix ELF strip by removing overlap of sections (thanks Gustavo Niemeyer).
+* mime/multipart: parse LF-delimited messages, not just CRLF.
+* mime: permit lower-case media type parameters (thanks Pascal S. de Kloe).
+* misc/dashboard: new features and improvements (not yet deployed).
+* misc/emacs: update list of builtins (thanks Quan Yong Zhai).
+* misc/vim: allow only utf-8 for file encoding (thanks Yasuhiro Matsumoto).
+* os: fix documentation for FileInfo.Name,
+ simplify WriteString,
+ use a different symbol from syscall in mkunixsignals.sh.
+* path/filepath: enable TestWalk to run on windows (thanks Alex Brainman).
+* reflect: add MethodByName,
+ allow Len on String values.
+* regexp: document that Regexp is thread-safe.
+* runtime/cgo: check for errors from pthread_create (thanks Albert Strasheim).
+* runtime: add Semacquire/Semrelease benchmarks,
+ improved Semacquire/Semrelease implementation,
+ windows/amd64 port (thanks Wei Guangjing).
+* sync: add fast path to Once,
+ improve Mutex to allow successive acquisitions,
+ new and improved benchmarks.
+* syscall: regenerate zerrors for darwin/linux/freebsd,
+ support for tty options in StartProcess (thanks Ken Rockot).
+* testing: make ResetTimer not start/stop the timer,
+ scale benchmark precision to 0.01ns if needed.
+* time: zero-pad two-digit years.
+* unicode/maketables: update debugging data.
+* windows: define and use syscall.Handle (thanks Wei Guangjing).
+* xml: add Marshal and MarshalIndent.
+</pre>
+
+<h2 id="2011-06-23">2011-06-23</h2>
+
+<pre>
+This snapshot includes a language change that restricts the use of goto.
+In essence, a "goto" statement outside a block cannot jump to a label inside
+that block. Your code may require changes if it uses goto.
+This changeset shows how the new rule affected the Go tree:
+ http://code.google.com/p/go/source/detail?r=dc6d3cf9279d
+
+The os.ErrorString type has been hidden. If your code uses os.ErrorString it
+must be changed. Most uses of os.ErrorString can be replaced with os.NewError.
+
+Other changes:
+* 5c: do not use R9 and R10.
+* 8l: more fixes for Plan 9 (thanks Lucio De Re).
+* build: Make.ccmd: link with mach lib (thanks Joe Poirier).
+* build: exclude packages that fail on Plan 9 (thanks Anthony Martin).
+* cc: nit: silence comment warnings (thanks Dave Cheney).
+* codereview.py: note that hg change -d abandons a change list (thanks Robert Hencke).
+* crypto/openpgp: add ElGamal support.
+* doc/faq: add question about converting from []T to []interface{}.
+* doc: Effective Go: fix variadic function example (thanks Ben Lynn).
+* exec: LookPath should not search %PATH% for files like c:cmd.exe (thanks Alex Brainman),
+ add support for Plan 9 (thanks Anthony Martin),
+ better error message for windows LookPath (thanks Alex Brainman).
+* fmt: catch panics from calls to String etc.
+* gc: descriptive panic for nil pointer -> value method call,
+ implement goto restriction,
+ unsafe.Alignof, unsafe.Offsetof, unsafe.Sizeof now return uintptr.
+* go/build: include Import objects in Script Inputs.
+* godefs: rudimentary tests (thanks Robert Hencke).
+* goinstall: refactor and generalize repo handling code (thanks Julian Phillips),
+ temporarily use Makefiles by default (override with -make=false).
+* gopprof: update list of memory allocators.
+* http: add Server.ListenAndServeTLS,
+ buffer request.Write,
+ fix req.Cookie(name) with cookies in one header,
+ permit handlers to explicitly remove the Date header,
+ write Header keys with empty values.
+* image: basic test for the 16-bits-per-color-channel types.
+* io: clarify Read, ReadAt, Copy, Copyn EOF behavior.
+* ld: don't attempt to build dynamic sections unnecessarily (thanks Gustavo Niemeyer).
+* libmach: fix disassembly of FCMOVcc and FCOMI (thanks Anthony Martin),
+ fix tracing on linux (for cov) (thanks Anthony Martin).
+* mime: fix RFC references (thanks Pascal S. de Kloe).
+* misc/gobuilder: run make single-threaded on windows (thanks Alex Brainman).
+* misc/godashboard: Accept sub-directories for goinstall's report (thanks Yasuhiro Matsumoto).
+* nacl, tiny: remove vestiges (thanks Robert Hencke).
+* net, syscall: interface for windows (thanks Yasuhiro Matsumoto).
+* os: change Waitmsg String method to use pointer receiver (thanks Graham Miller).
+* runtime: don't use twice the memory with grsec-like kernels (thanks Gustavo Niemeyer),
+* spec: disallow goto into blocks.
+* sync: restore GOMAXPROCS during benchmarks.
+* syscall: add LSF support for linux (thanks Mikio Hara),
+ add socket control message support for darwin, freebsd, linux (thanks Mikio Hara),
+ add tty support to StartProcess (thanks Ken Rockot),
+ fix build for Sizeof change.
+* test: test of goto restrictions.
+* time: add support for Plan 9 (thanks Anthony Martin).
+</pre>
+
+<h2 id="2011-06-16">2011-06-16</h2>
+
+<pre>
+This snapshot includes changes to the sort and image/draw packages that will
+require changes to client code.
+
+The sort.IntArray type has been renamed to IntSlice, and similarly for
+StringArray and Float64Array.
+
+The image/draw package's Draw function now takes an additional argument,
+a compositing operator. If in doubt, use draw.Over.
+
+Other changes:
+* build: fix header files for Plan 9 (thanks Lucio De Re).
+* cgo: handle new Apple LLVM-based gcc from Xcode 4.2.
+* crypto/openpgp: add ability to encrypt and sign messages.
+* doc/gopher: add goggled gopher logo for App Engine.
+* doc: Update notes for 3-day Go course.
+* exec: make LookPath work when PATHEXT var not set on Windows (thanks Alex Brainman).
+* exp/regexp/syntax: syntax data structures, parser, escapes, character classes.
+* exp/template: lexical scanner for new template package.
+* fmt: debugging formats for characters: %+q %#U.
+* gc: frame compaction for arm,
+ handle go print() and go println(),
+ work around goto bug.
+* go/build: fixes, self-contained tests.
+* go/printer, gofmt: print "select {}" on one line.
+* godoc: replace OS file system accesses in favor of a FileSystem interface.
+* gofix: fix inconsistent indentation in help output (thanks Scott Lawrence).
+* goinstall: use go/build package to scan and build packages.
+* http/spdy: improve error handling (thanks William Chan).
+* http: use runtime/debug.Stack() to dump stack trace on panic.
+* ld: dwarf emit filenames in debug_line header instead of as extended opcodes,
+ fix link Windows PE __declspec(dllimport) symbol (thanks Wei Guangjing),
+ make .rodata section read-only (thanks Gustavo Niemeyer).
+* mail: decode RFC 2047 "B" encoding.
+* mime/multipart: remove temp files after tests on Windows (thanks Alex Brainman).
+* net: export all fields in Interface (thanks Mikio Hara),
+ rearrange source to run more tests on Windows (thanks Alex Brainman),
+ sendfile for win32 (thanks Yasuhiro Matsumoto).
+* os: Plan 9, fix OpenFile & Chmod, add Process.Kill (thanks Yuval Pavel Zholkover).
+* runtime: fix Plan 9 "lingering goroutines bug" (thanks Yuval Pavel Zholkover).
+* spec: clarify rules for append, scope rules for :=,
+ specify constant conversions,
+ unsafe.Alignof/Offsetof/Sizeof return uintptr.
+* syscall, os, exec: add *syscall.SysProcAttr field to os.ProcAttr and exec.Cmd.
+* syscall: add ptrace on darwin (thanks Jeff Hodges),
+ mksyscall_windows.pl should output unix newline (thanks Yasuhiro Matsumoto).
+ update BPF support for BSD variants (thanks Mikio Hara),
+ use strict in perl scripts (thanks Yasuhiro Matsumoto).
+* xml: handle non-string attribute fields (thanks Maxim Ushakov).
+</pre>
+
+<h2 id="2011-06-09">2011-06-09 (<a href="release.html#r58">base for r58</a>)</h2>
+
+<pre>
+This snapshot includes changes to the strconv, http, and exp/draw packages.
+Client code that uses the http or exp/draw packages will need to be changed,
+and code that uses strconv or fmt's "%q" formatting directive merits checking.
+
+The strconv package's Quote function now escapes only those Unicode code points
+not classified as printable by unicode.IsPrint. Previously Quote would escape
+all non-ASCII characters. This also affects the fmt package's "%q" formatting
+directive. The previous quoting behavior is still available via strconv's new
+QuoteToASCII function.
+
+Most instances of the type map[string][]string in the http package have been
+replaced with the new Values type. The http.Values type has the Get, Set, Add,
+and Del helper methods to make working with query parameters and form values
+more convenient.
+
+The exp/draw package has been split into the image/draw and exp/gui packages.
+
+Other changes:
+* 8l, ld: initial adjustments for Plan 9 native compilation of 8l (thanks Lucio De Re).
+* arm: floating point improvements (thanks Fan Hongjian).
+* big: Improved speed of nat-to-string conversion (thanks Michael T. Jones),
+ Rat outputs the requested precision from FloatString (thanks Graham Miller),
+ gobs for big.Rats.
+* cgo: support non intel gcc machine flags (thanks Dave Cheney).
+* compress/lzw: do not use background goroutines,
+ reduce decoder buffer size from 3*4096 to 2*4096.
+* crypto/twofish: fix Reset index overflow bug.
+* crypto: reorg, cleanup and add function for generating CRLs.
+* exec: export the underlying *os.Process in Cmd.
+* gc: enable building under clang/2.9 (thanks Dave Cheney),
+ preparatory work toward escape analysis, compact stack frames.
+* go/build: new incomplete package for building go programs.
+* godefs: do not assume forward type references are enums (thanks Robert Hencke).
+* gofix, gofmt: fix diff regression from exec change.
+* html: improve attribute parsing, note package status.
+* http: don't fail on accept hitting EMFILE,
+ fix handling of 0-length HTTP requests.
+* image/draw: fix clipping bug where sp/mp were not shifted when r.Min was.
+* image/gif: fix buglet in graphics extension.
+* image/tiff: support for bit depths other than 8 (thanks Benny Siegert).
+* ld: fix and simplify ELF symbol generation (thanks Anthony Martin)
+* libmach: use the standardized format for designated initializers (thanks Jeff Hodges)
+* mail: address list parsing.
+* net: add network interface identification API (thanks Mikio Hara),
+ fix bug in net.Interfaces: handle elastic sdl_data size correctly (thanks Mikio Hara).
+* netchan: added drain method to importer (thanks David Jakob Fritz).
+* os: add Process.Kill and Process.Signal (thanks Evan Shaw),
+ fix Getenv for Plan 9 (thanks Yuval Pavel Zholkover).
+* runtime: improve memmove by checking memory overlap (thanks Quan Yong Zhai),
+ support for Linux grsecurity systems (thanks Jonathan Mark).
+* spec: handle a corner case for shifts.
+* testing: check that tests and benchmarks do not affect GOMAXPROCS (thanks Dmitriy Vyukov).
+* unicode: add IsPrint and related properties, general categories.
+</pre>
+
+<h2 id="2011-06-02">2011-06-02</h2>
+
+<pre>
+This snapshot includes changes to the exec package that will require changes
+to client code.
+
+The exec package has been re-designed with a more convenient and succinct API.
+This code:
+ args := []string{"diff", "-u", "file1.txt", "file2.txt"}
+ p, err := exec.Run("/usr/bin/diff", args, os.Environ(), "",
+ exec.DevNull, exec.Pipe, exec.DevNull)
+ if err != nil {
+ return nil, err
+ }
+ var buf bytes.Buffer
+ io.Copy(&buf, p.Stdout)
+ w, err := p.Wait(0)
+ p.Close()
+ if err != nil {
+ return nil, err
+ }
+ return buf.Bytes(), err
+can be rewritten as:
+ return exec.Command("diff", "-u", "file1.txt", "file2.txt").Output()
+See the exec package documentation for the details ("godoc exec").
+
+By setting the GOPATH environment variable you can use goinstall to build and
+install your own code and external libraries outside of the Go tree (and avoid
+writing Makefiles).
+See the goinstall command documentation for the details ("godoc goinstall").
+
+Other changes:
+* 5g: alignment fixes.
+* 6l, 8l: fix Mach-O binaries with many dynamic libraries.
+* 8l: emit resources (.rsrc) in Windows PE. (thanks Wei Guangjing).
+* asn1: fix marshaling of empty optional RawValues (thanks Mikkel Krautz).
+* big: make Int and Rat implement fmt.Scanner (thanks Evan Shaw),
+ ~8x faster number scanning,
+ remove some unnecessary conversions.
+* cgo: restrict #cgo directives to prevent shell expansion (thanks Gustavo Niemeyer),
+ support pkg-config for flags and libs (thanks Gustavo Niemeyer).
+* compress/flate: fix Huffman tree bug,
+ do not use background goroutines.
+* crypto/openpgp: add support for symmetrically encrypting files.
+* crypto/tls/generate_cert.go: fix misspelling of O_CREATE.
+* dashboard: send notification emails when the build breaks.
+* doc: mention go/printer instead of container/vector in effective go,
+ put Release History link on 'Documentation' page,
+ put Weekly Snapshot History link on 'Contributing' page.
+* encoding/base64: add DecodeString and EncodeToString.
+* encoding/binary: add a non-reflect fast path for Read,
+ add a non-reflect fast path for Write.
+* encoding/hex: add hex dumping.
+* encoding/line: delete package. Its functionality is now in bufio.
+* filepath: Abs must always return a clean path (thanks Gustavo Niemeyer).
+* fmt: fix bug in UnreadRune,
+ make %q work for integers, printing a quoted character literal,
+ return EOF when out of input in Scan*.
+* gc: check parameter declarations in interface fields (thanks Anthony Martin),
+ disallow ... in type conversions (thanks Anthony Martin),
+ do not force heap allocation on referencing outer variable in a closure,
+ fix m[x], _ = y.(T),
+ implement new shift rules,
+ patch y.tab.c to fix build when using Bison 2.5,
+ relax assignability of method receivers (thanks Anthony Martin),
+ typecheck the whole tree before walking.
+* go/scanner: don't allow "0x" and "0X" as integers (thanks Evan Shaw).
+* gobuilder: fixes for windows (thanks Alex Brainman).
+* godoc: basic setup for running godoc on local app engine emulator,
+ display advert for the package dashboard on package list page.
+* goinstall: fixes for windows (thanks Alex Brainman),
+ more verbose logging with -v.
+* gotest, pkg/exec: use bash to run shell scripts on windows (thanks Alex Brainman).
+* http/spdy: redo interfaces, flesh out implementation & frame types (thanks William Chan).
+* http: Transport hook to register non-http(s) protocols,
+ add client+server benchmark,
+ catch Handler goroutine panics,
+ fix Set-Cookie date parsing,
+ have client set Content-Length when possible,
+ let Transport use a custom net.Dial function,
+ propagate Set-Cookie in reverse proxy,
+ ServeFile shouldn't send Content-Length when Content-Encoding is set.
+* image: add a SubImage method.
+* image/gif: simplify blockReader.Read.
+* image/png: fix encoding of images that don't start at (0, 0).
+* io, net, http: sendfile support.
+* io: add ByteScanner, RuneScanner interfaces.
+* ld: add -w to disable dwarf, make errors obviously from dwarf.
+* mail: new package.
+* mime/multipart: misc code/doc fixes.
+* misc/cgo: remove reference to 'destroy' function.
+* misc/emacs: don't select the mark after gofmt (thanks Eric Eisner).
+* misc/gophertool: Chrome extension to aid in Go development
+* misc/vim: limit Fmt command to Go buffers (thanks Yasuhiro Matsumoto).
+* net: if we stop polling, remove any pending events for the socket,
+ update IP multicast socket options (thanks Mikio Hara).
+* os: Fix test to work on Solaris,
+ fix Readdir(0) on EOF,
+ fix Readdir, Readdirnames (thanks Yuval Pavel Zholkover),
+ fix os.MkdirAll with backslash path separator (thanks Yasuhiro Matsumoto),
+ handle OpenFile flag parameter properly on Windows (thanks Alex Brainman).
+* path/filepath: remove string constants.
+* pkg: spelling tweaks, I-Z (thanks Robert Hencke).
+* quietgcc: fix typo, respect $TMPDIR.
+* runtime: do not garbage collect windows callbacks (thanks Alex Brainman),
+ fix mmap error return on linux (thanks Dmitry Chestnykh),
+ reset GOMAXPROCS during tests,
+ save cdecl registers in Windows SEH handler (thanks Alexey Borzenkov).
+* spec: be precise with the use of the informal ellipsis and the Go token,
+ clarify rules for shifts.
+* strconv: add QuoteRune; analogous to Quote but for runes rather than strings.
+* strings: implement UnreadByte, UnreadRune.
+* sync: always wake up sleeping goroutines on Cond.Signal (thanks Gustavo Niemeyer).
+* sync/atomic: fix check64.
+* syscall: add ProcAttr field to pass an unescaped command line on windows (thanks Vincent Vanackere),
+ add routing messages support for Linux and BSD (thanks Mikio Hara).
+* template: fixes and clean-ups (thanks Gustavo Niemeyer).
+* time: fix Format bug: midnight/noon are 12AM/PM not 0AM/PM.
+* unicode: make the tables smaller.
+</pre>
+
+<h2 id="2011-05-22">2011-05-22</h2>
+
+<pre>
+This snapshot includes changes to the http package that will require changes to
+client code.
+
+The finalURL return value of the Client.Get method has been removed.
+This value is now accessible via the new Request field on http.Response.
+For example, this code:
+
+ res, finalURL, err := http.Get(...)
+
+should be rewritten as:
+
+ res, err := http.Get(...)
+ if err != nil {
+ // ...
+ }
+ finalURL := res.Request.URL.String()
+
+Uses of http.Get that assign the finalURL value to _ can be rewritten
+automatically with gofix.
+
+This snapshot also includes an optimization to the append function that makes it
+between 2 and 5 times faster in typical use cases.
+
+Other changes:
+* 5a, 6a, 8a, cc: remove old environment variables.
+* 5c, 5g: fix build with too-smart gcc.
+* 5l, 8l: add ELF symbol table to binary.
+* 5l: delete pre-ARMv4 instruction implementations, other fixes.
+* 6l, 8l: emit windows dwarf sections like other platforms (thanks Alex Brainman).
+* 6l: fix emit windows dwarf sections (thanks Wei Guangjing).
+* 8g: fix conversion from float to uint64 (thanks Anthony Martin).
+* Make.cmd: create TARGDIR if necessary (thanks Gustavo Niemeyer).
+* asn1: add big support.
+* big: add Int methods to act on numbered bits (thanks Roger Peppe),
+ better support for string conversions,
+ support %v and # modifier, better handling of unknown formats.
+* cgi: export RequestFromMap (thanks Evan Shaw),
+ set Request.TLS and Request.RemoteAddr for children.
+* cgo: use packed struct to fix Windows behavior.
+* codereview: add release branch support,
+ fetch metadata using JSON API, not XML scraping,
+ handle 'null as missing field' in rietveld json.
+* compress/lzw: silently drop implied codes that are too large.
+* compress/zlib: actually use provided dictionary in NewWriterDict
+* crypto/openpgp: add key generation support,
+ change PublicKey.Serialize to include the header.
+* crypto/rand: add utility functions for number generation (thanks Anthony Martin).
+* crypto/tls: export the verified chains.
+* crypto/x509/crl: add package.
+* crypto/x509: export raw SubjectPublicKeyInfo,
+ support DSA public keys in X.509 certs,
+ support parsing and verifying DSA signatures (thanks Jonathan Allie).
+* doc/roadmap: put "App Engine support" under "Done".
+* doc: add I/O 2011 talks to talks/, docs.html, and front page.
+* effective go: explain about values/pointers in String() example,
+ update to new Open signature.
+* exp/draw: fast paths for drawing a YCbCr or an NRGBA onto an RGBA.
+* filepath: make EvalSymlinks work on Windows (thanks Alex Brainman).
+* flag: allow distinct sets of flags.
+* gc: fix type switch error message for invalid cases (thanks Lorenzo Stoakes),
+ fix unsafe.Sizeof,
+ preserve original expression for errors.
+* go/ast, go/doc, godoc: consider struct fields and interface methods when filtering ASTs.
+* go/ast: consider anonymous fields and set Incomplete bit when filtering ASTs,
+ properly maintain map of package global imports.
+* go/doc, godoc: when filtering for godoc, don't remove elements of a declaration.
+* go/parser: accept parenthesized receive operations in select statements,
+ always introduce an ast.Object when declaring an identifier.
+* go/printer, gofmt: fix alignment of "=" in const/var declarations,
+ fix formatting of expression lists (missing blank).
+* go/printer: added simple performance benchmark,
+ make tests follow syntactic restrictions,
+ more accurate comment for incomplete structs/interfaces,
+* go/token: faster FileSet.Position implementation.
+* go/types: type checker API + testing infrastructure.
+* godoc: added -index flag to enable/disable search index,
+ if there is no search box, don't run the respective JS code.
+* gofmt: update test.sh (exclude a file w/ incorrect syntax).
+* html: parse empty, unquoted, and single-quoted attribute values.
+* http/cgi: correctly set request Content-Type (thanks Evan Shaw),
+ pass down environment variables for IRIX and Solaris.
+* http/pprof: fix POST reading bug.
+* http/spdy: new incomplete package (thanks Ross Light).
+* http: Client.Do should follow redirects for GET and HEAD,
+ add Header.Write method (thanks Evan Shaw),
+ add Request.SetBasicAuth method,
+ add Transport.ProxySelector,
+ add http.SetCookie(ResponseWriter, *Cookie),
+ don't Clean query string in relative redirects,
+ fix FormFile nil pointer dereference on missing multipart form,
+ fix racy test with a simpler version,
+ fix two Transport gzip+persist crashes,
+ include Host header in requests,
+ make HEAD client request follow redirects (thanks Eivind Uggedal).
+ update cookie doc to reference new RFC 6265,
+ write cookies according to RFC 6265 (thanks Christian Himpel).
+* image/bmp: implement a BMP decoder.
+* image/gif: new package provides a GIF decoder.
+* image/jpeg: decode grayscale images, not just color images.
+ optimizations and tweaks.
+* image/png: encode paletted images with alpha channel (thanks Dmitry Chestnykh),
+ speed up opaque RGBA encoding.
+* image/tiff: implement a decoder (thanks Benny Siegert).
+* image: add type-specific Set methods and use them when decoding PNG,
+ make AlphaColor.Set conform to usual signature (thanks Roger Peppe),
+ png & jpeg encoding benchmarks.
+* ld: do not emit reference to dynamic library named "",
+ fix alignment of rodata section on Plan 9 (thanks Anthony Martin),
+ make ELF binaries with no shared library dependencies static binaries.
+* make.bash: remove old bash version of gotest on Windows (thanks Alex Brainman).
+* make: add nuke target for C commands and libs (thanks Anthony Martin).
+* mime/multipart: add FileName accessor on Part,
+ add Writer,
+ return an error on Reader EOF, not (nil, nil).
+* misc/cgo/test: run tests.
+* misc/emacs: use UTF-8 when invoking gofmt as a subprocess (thanks Sameer Ajmani).
+* misc/vim: new Vim indentation script.
+* net, http: add and make use of IP address scope identification API (thanks Mikio Hara).
+* net: default to 127.0.0.1, not localhost, in TestICMP,
+ don't crash on unexpected DNS SRV responses,
+ enable SO_REUSEPORT on BSD variants (thanks Mikio Hara),
+ protocol family adaptive address family selection (thanks Mikio Hara),
+ re-enable wildcard listening (thanks Mikio Hara),
+ sort records returned by LookupSRV (thanks Gary Burd).
+* os: make Readdir & Readdirnames return os.EOF at end,
+ make Setenv update C environment variables.
+* reflect: allow unexported key in Value.MapIndex.
+* runtime, sync/atomic: fix arm cas.
+* runtime: add newline to "finalizer already set" error (thanks Albert Strasheim),
+ handle out-of-threads on Linux gracefully (thanks Albert Strasheim),
+ fix function args not checked warning on ARM (thanks Dave Cheney),
+ make StackSystem part of StackGuard (thanks Alexey Borzenkov),
+ maybe fix Windows build broken by cgo setenv CL.
+* spec: clarify semantics of integer division,
+ clarify semantics of range clause,
+ fix error in production syntax,
+ narrow syntax for expression and select statements,
+ newlines cannot be used inside a char or "" string literal,
+ restricted expressions may still be parenthesized.
+* strings: make Reader.Read use copy instead of an explicit loop.
+* syscall: add Windows file mapping functions and constants (thanks Evan Shaw),
+ add IPv6 scope zone ID support (thanks Mikio Hara),
+ add netlink support for linux/386, linux/amd64, linux/arm (thanks Mikio Hara),
+ add Sendfile,
+ adjust freebsd syscalls.master URL properly (thanks Mikio Hara),
+ change Overlapped.HEvent type, it is a handle (thanks Alex Brainman).
+* syslog: fix skipping of net tests (thanks Gustavo Niemeyer).
+* template: support string, int and float literals (thanks Gustavo Niemeyer).
+* xml: fix reflect error.
+</pre>
+
+<h2 id="2011-04-27">2011-04-27 (<a href="release.html#r57">base for r57</a>)</h2>
+
+<pre>
+This snapshot includes revisions to the reflect package to make it more
+efficient, after the last weekly's major API update. If your code uses reflect
+it may require further changes, not all of which can be made automatically by
+gofix. For the full details of the change, see
+ http://codereview.appspot.com/4435042
+Also, the Typeof and NewValue functions have been renamed to TypeOf and ValueOf.
+
+Other changes:
+* 5c: make alignment rules match 5g, just like 6c matches 6g.
+* 8g, 8l: fix "set but not used" gcc error (thanks Fazlul Shahriar).
+* all-qemu.bash: remove DISABLE_NET_TESTS.
+* build: remove DISABLE_NET_TESTS.
+* builder: build multiple targets in parallel.
+* cgo: avoid "incompatible pointer type" warning (thanks Albert Strasheim).
+* codereview: add 'hg undo' command, various other fixes.
+* compress/flate: dictionary support.
+* compress/zlib: add FDICT flag in Reader/Writer (thanks Ross Light).
+* container/heap: fix circular dependency in test.
+* crypto/openpgp: better handling of keyrings.
+* crypto/rsa: support > 3 primes.
+* crypto/tls: add server-side OCSP stapling support.
+* crypto/x509: memorize chain building.
+* crypto: move certificate verification into x509.
+* dashboard: build most recent revision first.
+* doc: mention make version in install.html.
+* expvar: add Func for functions that return values that are JSON marshalable.
+* fmt: decrease recursion depth in tests to permit them to run under gccgo,
+ tweak the doc for %U.
+* gc: allow complex types to be receiver types (thanks Robert Hencke),
+ correct handling of unexported method names in embedded interfaces,
+ explain why invalid receiver types are invalid,
+ fix copy([]int, string) error message (thanks Quan Yong Zhai),
+ fix 'invalid recursive type' error (thanks Lorenzo Stoakes),
+ many bug fixes.
+* go spec: attempt at clarifying language for "append",
+ for map types, mention indexing operations.
+* go/types: update for export data format change.
+* gob: fix handling of indirect receivers for GobDecoders,
+ fix trivial bug in map marshaling,
+ have errorf always prefix the message with "gob: ",
+ test case for indirection to large field,
+ use new Implements and AssignableTo methods in reflect,
+ when decoding a string, allocate a string, not a []byte.
+* gobuilder: permit builders of the form goos-goarch-foo,
+ respect MAKEFLAGS if provided (thanks Dave Cheney).
+* godoc: use "search" input type for search box (thanks Dmitry Chestnykh).
+* gofix: add support for reflect rename.
+* gofmt: add -d (diff) (thanks David Crawshaw),
+ don't crash when rewriting nil interfaces in AST,
+ exclude test case that doesn't compile w/o errors,
+ gofmt test harness bug fix.
+* goinstall: support GOPATH; building and installing outside the Go tree,
+ support building executable commands.
+* gopack: fix prefix bug,
+ preserve safe flag when not adding unsafe objects to archive.
+* gotest: add timing, respect $GOARCH,
+ generate gofmt-compliant code.
+* http/cgi: copy some PATH environment variables to child,
+ improve Location response handling,
+ pass some default environment variables.
+* http/fcgi: new package (thanks Evan Shaw).
+* http: add NewRequest helper,
+ add MultipartForm, ParseMultipartForm, and FormFile to Request,
+ be clear when failing to connect to a proxy,
+ bug fixes and new tests,
+ consume request bodies before replying,
+ don't quote Set-Cookie Domain and Path (thanks Petar Maymounkov),
+ fix IP confusion in TestServerTimeouts,
+ handler timeout support,
+ ServerConn, ClientConn: add real Close (thanks Petar Maymounkov),
+ make Client redirect policy configurable,
+ put a limit on POST size,
+ reverse proxy handler.
+* image/jpeg: add an encoder,
+ decode to a YCbCr image instead of an RGBA image.
+* ioutil: add Discard.
+* json: keep track of error offset in SyntaxError.
+* ld: defend against some broken object files,
+ do not emit empty dwarf pe sections (thanks Alex Brainman),
+ fix 6l -d on Mac, diagnose invalid use of -d,
+ fix Plan 9 symbol table (thanks Anthony Martin),
+ remove MachoLoad limit.
+* make: prevent rm provoking 'text file busy' errors (thanks Lorenzo Stoakes).
+* mime/multipart: add ReadForm for parsing multipart forms,
+ limit line length to prevent abuse.
+* mime: RFC 2231 continuation / non-ASCII support,
+ bunch more tests, few minor parsing fixes.
+* misc/goplay: fix Tab and Shift+Enter in Firefox (thanks Dmitry Chestnykh).
+* net: disable one more external network test,
+ fix EAI_BADFLAGS error on freebsd (thanks Mikio Hara),
+ fix ParseIP (thanks Quan Yong Zhai),
+ fix dialgoogle_test.go (thanks Quan Yong Zhai),
+ try /etc/hosts before loading DNS config (thanks Dmitry Chestnykh),
+ use C library resolver on FreeBSD, Linux, OS X / amd64, 386.
+* os/user: new package to look up users.
+* os: Open with O_APPEND|O_CREATE to append on Windows (thanks Alex Brainman),
+ fix race in ReadAt/WriteAt on Windows (thanks Alex Brainman),
+ turn EPIPE exit into panic.
+* rc/env.bash: fix to build on windows under msys (thanks Joe Poirier).
+* reflect: allow Slice of arrays,
+ fix Copy of arrays (thanks Gustavo Niemeyer),
+ require package qualifiers to match during interface check,
+ add Type.Implements, Type.AssignableTo, Value.CallSlice,
+ make Set match Go.
+* rpc: allow the first argument of a method to be a value rather than a pointer,
+ run benchmarks over HTTP as well as direct network connections.
+* run.bash: remove redundant rebuilds.
+* runtime/plan9: warning remediation for Plan 9 (thanks Lucio De Re),
+* runtime: many bug fixes,
+ fix GOMAXPROCS vs garbage collection bug (thanks Dmitriy Vyukov),
+ fix mkversion to output valid path separators (thanks Peter Mundy),
+ more graceful out-of-memory crash,
+ require package qualifiers to match during interface check,
+ skip functions with no lines when building src line table,
+ turn "too many EPIPE" into real SIGPIPE.
+* src/pkg: make package doc comments consistently start with "Package foo".
+* syscall: Madvise and Mprotect for Linux (thanks Albert Strasheim),
+ Mlock, Munlock, Mlockall, Munlockall on Linux (thanks Albert Strasheim),
+ add BPF support for darwin/386, darwin/amd64 (thanks Mikio Hara),
+ correct Windows CreateProcess input parameters (thanks Alex Brainman),
+ fix Ftruncate under linux/arm5 (thanks Dave Cheney),
+ permit StartProcess to hide the executed program on windows (thanks Vincent Vanackere).
+* test/bench: update timings; moving to new machine.
+* time: support Irix 6 location for zoneinfo files.
+* tutorial: modernize the definition and use of Open,
+ replace the forever loops with finite counts in sieve programs.
+* websocket: include *http.Request in websocket.Conn.
+* xml: Parser hook for non-UTF-8 charset converters.
+</pre>
+
+<h2 id="2011-04-13">2011-04-13</h2>
+
+<pre>
+weekly.2011-04-13
+
+This weekly snapshot includes major changes to the reflect package and the
+os.Open function. Code that uses reflect or os.Open will require updating,
+which can be done mechanically using the gofix tool.
+
+The reflect package's Type and Value types have changed. Type is now an
+interface that implements all the possible type methods. Instead of a type
+switch on a reflect.Type t, switch on t.Kind(). Value is now a struct value
+that implements all the possible value methods. Instead of a type switch on a
+reflect.Value v, switch on v.Kind(). See the change for the full details:
+ http://code.google.com/p/go/source/detail?r=843855f3c026
+
+The os package's Open function has been replaced by three functions:
+ OpenFile(name, flag, perm) // same as old Open
+ Open(name) // same as old Open(name, O_RDONLY, 0)
+ Create(name) // same as old Open(name, O_RDWR|O_TRUNC|O_CREAT, 0666)
+
+To update your code to use the new APIs, run "gofix path/to/code". Gofix can't
+handle all situations perfectly, so read and test the changes it makes before
+committing them.
+
+Other changes:
+* archive/zip: add func OpenReader, type ReadCloser (thanks Dmitry Chestnykh).
+* asn1: Implement correct marshaling of length octets (thanks Luit van Drongelen).
+* big: don't crash when printing nil ints.
+* bufio: add ReadLine, to replace encoding/line.
+* build: make the build faster, quieter.
+* codereview: automatically port old diffs forward,
+ drop Author: line on self-clpatch,
+ recognize code URL without trailing slash.
+* crypto/block: remove deprecated package.
+* crypto/des: new package implementating DES and TDEA (thanks Yasuhiro Matsumoto).
+* crypto/ecdsa, crypto/rsa: use io.ReadFull to read from random source (thanks Dmitry Chestnykh).
+* crypto/rsa: add 3-prime support,
+ add support for precomputing CRT values,
+ flip the CRT code over so that it matches PKCS#1.
+* crypto/x509: expose complete DER data (thanks Mikkel Krautz).
+* doc: new "Functions" codewalk (thanks John DeNero).
+* doc/roadmap: add sections on tools, packages.
+* fmt: allow %U for unsigned integers.
+* gc: fixes and optimizations.
+* go/printer, gofmt: use blank to separate import rename from import path.
+* go/scanner: better TokenString output.
+* go/types: new Go type hierarchy implementation for AST.
+* godashboard: show packages at launchpad.net (thanks Gustavo Niemeyer).
+* gofix: add -diff, various fixes and helpers.
+* gotest: fix a bug in error handling,
+ fixes for [^.]_test file pattern (thanks Peter Mundy),
+ handle \r\n returned by gomake on Windows (thanks Alex Brainman).
+* gotype: use go/types GcImporter.
+* govet: make name-matching for printf etc. case-insensitive.
+* http: allow override of Content-Type for ServeFile,
+ client gzip support,
+ do not listen on 0.0.0.0 during test,
+ flesh out server Expect handling + tests.
+* image/ycbcr: new package.
+* image: allow "?" wildcards when registering image formats.
+* io: fixes for Read with n > 0, os.EOF (thanks Robert Hencke).
+* ld: correct Plan 9 compiler warnings (thanks Lucio De Re),
+ ELF header function declarations (thanks Lucio De Re),
+ fix Mach-O X86_64_RELOC_SIGNED relocations (thanks Mikkel Krautz),
+ fix Mach-O bss bug (thanks Mikkel Krautz),
+ fix dwarf decoding of strings for struct's fieldnames (thanks Luuk van Dijk),
+ fixes and optimizations (25% faster).
+* log: generalize getting and setting flags and prefix.
+* misc/cgo/life: enable build and test on Windows (thanks Alex Brainman).
+* misc/vim: add plugin with Fmt command (thanks Dmitry Chestnykh),
+ update type highlighting for new reflect package.
+* net: disable multicast tests by default (thanks Dave Cheney),
+ sort records returned by LookupMX (thanks Corey Thomasson).
+* openpgp: Fix improper := shadowing (thanks Gustavo Niemeyer).
+* os: rename Open to OpenFile, add new Open, Create,
+ fix Readdir in Plan 9 (thanks Fazlul Shahriar).
+* os/inotify: use _test for test files, not _obj.
+* pkg/path: enable tests on Windows (thanks Alex Brainman).
+* reflect: new Type and Value API.
+* src/pkg/Makefile: trim per-directory make output except on failure.
+* syscall: Add DT_* and MADV_* constants on Linux (thanks Albert Strasheim),
+ add Mmap, Munmap on Linux, FreeBSD, OS X,
+ fix StartProcess in Plan 9 (thanks Fazlul Shahriar),
+ fix Windows Signaled (thanks Alex Brainman).
+* test/bench: enable build and test on Windows (thanks Alex Brainman).
+</pre>
+
+<h2 id="2011-04-04">2011-04-04</h2>
+
+<pre>
+This snapshot includes changes to the net package. Your code will require
+changes if it uses the Dial or LookupHost functions.
+
+The laddr argument has been removed from net.Dial, and the cname return value
+has been removed from net.LookupHost. The new net.LookupCNAME function can be
+used to find the canonical host for a given name. You can update your
+networking code with gofix.
+
+The gotest shell script has been replaced by a Go program, making testing
+significantly faster.
+
+Other changes:
+* asn1: extensions needed for parsing Kerberos.
+* bufio: Write and WriteString cleanup (thanks Evan Shaw).
+* bytes, strings: simplify Join (thanks Evan Shaw).
+* crypto/cipher: bad CTR IV length now triggers panic.
+* crypto/tls: extend NPN support to the client,
+ added X509KeyPair function to parse a Certificate from memory.
+* crypto/x509: parse Extended Key Usage extension (thanks Mikkel Krautz).
+* debug/gosym: remove need for gotest to run preparatory commands.
+* fmt: implement precision (length of input) values for %q: %.20q.
+* go/parser: fix scoping for local type declarations (thanks Roger Peppe),
+ package name must not be the blank identifier.
+* go/printer, gofmt: remove special case for multi-line raw strings.
+* gopack: add P flag to remove prefix from filename information.
+* gotest: add -test.timeout option,
+ replace the shell script with the compiled program written in go,
+ execute gomake properly on Windows (thanks Alex Brainman).
+* gotry: move into its own directory, separate from gotest.
+* gotype: support for more tests, added one new test.
+* http: add Transport.MaxIdleConnsPerHost,
+ use upper case hex in URL escaping (thanks Matt Jones).
+* httptest: add NewTLSServer.
+* misc/kate: reorganize, remove closed() (thanks Evan Shaw).
+* misc/notepadplus: support for notepad++ (thanks Anthony Starks).
+* net: implement non-blocking connect (thanks Alexey Borzenkov).
+* os: fix MkdirAll("/thisdoesnotexist") (thanks Albert Strasheim),
+ Plan 9 support (thanks Yuval Pavel Zholkover),
+ add a few missing Plan 9 errors (thanks Andrey Mirtchovski),
+ fix FileInfo.Name returned by Stat (thanks David Forsythe).
+* path/filepath.Glob: add an error return,
+ don't drop known matches on error.
+* path/filepath: add support for Plan 9 (thanks Andrey Mirtchovski).
+* scanner: treat line comments like in Go.
+* syscall: Plan 9 support (thanks Yuval Pavel Zholkover),
+ StartProcess Chroot and Credential (thanks Albert Strasheim),
+ add BPF support for freebsd/386, freebsd/amd64 (thanks Mikio Hara),
+ make [Raw]Syscall6 pass 6th arg on linux/386 (thanks Evan Shaw).
+</pre>
+
+<h2 id="2011-03-28">2011-03-28</h2>
+
+<pre>
+This weekly release includes improved support for testing.
+
+Memory and CPU profiling is now available via the gotest tool. Gotest will
+produce memory and CPU profiling data when invoked with the -test.memprofile
+and -test.cpuprofile flags. Run "godoc gotest" for details.
+
+We have also introduced a way for tests to run quickly when an exhaustive test
+is unnecessary. Gotest's new -test.short flag in combination with the testing
+package's new Short function allows you to write tests that can be run in
+normal or "short" mode; short mode is now used by all.bash to reduce
+installation time.
+The Makefiles know about the flag - you can just run "make testshort".
+
+Other changes:
+* .hgignore: Ignore all goinstalled packages (thanks Evan Shaw).
+* build: add all-qemu.bash, handful of arm fixes,
+ add support for SWIG, and add two SWIG examples,
+ diagnose Ubuntu's buggy copy of gold,
+ handle broken awk in version.bash (thanks Dave Cheney),
+ reenable clean.bash without gomake (thanks Gustavo Niemeyer).
+* cgo: fix index-out-of-bounds bug.
+* codereview: permit CLs of the form weekly.DATE
+* crypto/ecdsa: truncate hash values.
+* crypto/openpgp: add DSA signature support.
+* dashboard: remove old python/bash builder, update README.
+* doc: explain release and weekly tags in install.html.
+* exec: document dir option for Run (thanks Gustavo Niemeyer).
+* flag: document Nflag function (thanks Fazlul Shahriar).
+* gc: remove interim ... error which rejects valid code.
+* go/ast: implemented NewPackage,
+ merge CaseClause and TypeCaseClause.
+* go/parser: fix memory leak by making a copy of token literals,
+ resolve identifiers properly.
+* go/printer, gofmt: avoid exponential layout algorithm,
+ gofmt: simplify struct formatting and respect line breaks.
+* go/scanner: to interpret line comments with Windows filenames (thanks Alex Brainman).
+* go/token: use array instead of map for token->string table.
+* gob: optimizations to reduce allocations,
+ use pointers in bootstrapType so interfaces behave properly.
+* gobuilder: recognize CLs of the form weekly.DATE.
+* godefs: handle volatile.
+* godoc: add -template flag to specify custom templates,
+ fix path problem for windows (thanks Yasuhiro Matsumoto).
+* gofix: httpserver - rewrite rw.SetHeader to rw.Header.Set.
+* gofmt: add profiling flag.
+* gopprof: fix bug: do not rotate 180 degrees for large scrolls,
+ update list of memory allocation functions.
+* gotest: fix gofmt issue in generated _testmain.go.
+* http: add NewProxyClientConn,
+ avoid crash when asked for multiple file ranges,
+ don't chunk 304 responses,
+ export Transport, add keep-alive support.
+* ld: return > 0 exit code on unsafe import.
+* misc/bbedit: remove closed keyword (thanks Anthony Starks).
+* misc/emacs: gofmt: don't clobber the current buffer on failure.
+* misc/vim: remove 'closed' as a builtin function.
+* net: add FileConn, FilePacketConn, FileListener (thanks Albert Strasheim),
+ don't force epoll/kqueue to wake up in order to add new events,
+ let OS-specific AddFD routine wake up polling thread,
+ use preallocated buffer for epoll and kqueue/kevent.
+* path/filepath: add EvalSymlinks function,
+ fix TestEvalSymlinks when run under symlinked GOROOT.
+* path: work for windows (thanks Yasuhiro Matsumoto).
+* rpc: increase server_test timeout (thanks Gustavo Niemeyer),
+ optimizations to reduce allocations.
+* runtime: fix darwin/amd64 thread VM footprint (thanks Alexey Borzenkov),
+ fix gdb support for goroutines,
+ more stack split fixes,
+ os-specific types and code for setitimer,
+ update defs.h for freebsd-386 (thanks Devon H. O'Dell).
+* strings: Map: avoid allocation when string is unchanged.
+* syscall: GetsockoptInt (thanks Albert Strasheim),
+ StartProcess fixes for windows (thanks Alex Brainman),
+ permit non-blocking syscalls,
+ rename from .sh to .pl, because these files are in Perl.
+* test: enable tests using v, ok := <-ch syntax (thanks Robert Hencke).
+* time: give a helpful message when we can't set the time zone for testing.
+ isolate syscall reference in sys.go.
+</pre>
+
+<h2 id="2011-03-15">2011-03-15</h2>
+
+<pre>
+This week's release introduces a new release tagging scheme. We intend to
+continue with our weekly releases, but have renamed the existing tags from
+"release" to "weekly". The "release" tag will now be applied to one hand-picked
+stable release each month or two.
+
+The revision formerly tagged "release.2011-03-07.1" (now "weekly.2011-03-07.1")
+has been nominated our first stable release, and has been given the tag
+"release.r56". As we tag each stable release we will post an announcement to
+the new golang-announce mailing list:
+ http://groups.google.com/group/golang-announce
+
+You can continue to keep your Go installation updated using "hg update
+release", but now you should only need to update once we tag a new stable
+release, which we will announce here. If you wish to stay at the leading edge,
+you should switch to the weekly tag with "hg update weekly".
+
+
+This weekly release includes significant changes to the language spec and the
+http, os, and syscall packages. Your code may need to be changed. It also
+introduces the new gofix tool.
+
+The closed function has been removed from the language. The syntax for channel
+receives has been changed to return an optional second value, a boolean value
+indicating whether the channel is closed. This code:
+ v := <-ch
+ if closed(ch) {
+ // channel is closed
+ }
+should now be written as:
+ v, ok := <-ch
+ if !ok {
+ // channel is closed
+ }
+
+It is now illegal to declare unused labels, just as it is illegal to declare
+unused local variables.
+
+The new gofix tool finds Go programs that use old APIs and rewrites them to use
+newer ones. After you update to a new Go release, gofix helps make the
+necessary changes to your programs. Gofix will handle the http, os, and syscall
+package changes described below, and we will update the program to keep up with
+future changes to the libraries.
+
+The Hijack and Flush methods have been removed from the http.ResponseWriter
+interface and are accessible via the new http.Hijacker and http.Flusher
+interfaces. The RemoteAddr and UsingTLS methods have been moved from
+http.ResponseWriter to http.Request.
+
+The http.ResponseWriter interface's SetHeader method has been replaced by a
+Header() method that returns the response's http.Header. Caller code needs to
+change. This code:
+ rw.SetHeader("Content-Type", "text/plain")
+should now be written as:
+ rw.Header().Set("Content-Type", "text/plain")
+The os and syscall packages' StartProcess functions now take their final three
+arguments as an *os.ProcAttr and *syscall.ProcAttr values, respectively. This
+code:
+ os.StartProcess(bin, args, env, dir, fds)
+should now be written as:
+ os.StartProcess(bin, args, &os.ProcAttr{Files: fds, Dir: dir, Env: env})
+
+The gob package will now encode and decode values of types that implement the
+gob.GobEncoder and gob.GobDecoder interfaces. This allows types with unexported
+fields to transmit self-consistent descriptions; one instance is big.Int and
+big.Rat.
+
+Other changes:
+* 5l, 6l, 8l: reduce binary size about 40% by omitting symbols for type, string, go.string.
+* 5l, 8l: output missing section symbols (thanks Anthony Martin).
+* 6l, 8l: fix gdb crash.
+* Make.cmd: also clean _test* (thanks Gustavo Niemeyer).
+* big: implemented custom Gob(En/De)coder for Int type.
+* build: remove duplicate dependency in Make.cmd (thanks Robert Hencke),
+ run gotest in misc/cgo/test.
+* codereview.py: don't suggest change -d if user is not CL author (thanks Robert Hencke).
+* compress/lzw: benchmark a range of input sizes.
+* crypto/ecdsa: add package.
+* crypto/elliptic: add the N value of each curve.
+* crypto/openpgp: bug fixes and fix misnamed function.
+* crypto/tls: fix compile error (thanks Dave Cheney).
+* doc: Effective Go: some small cleanups,
+ update FAQ. hello, world is now 1.1MB, down from 1.8MB,
+ update codelab wiki to fix template.Execute argument order.
+* flag: visit the flags in sorted order, for nicer messages.
+* fmt: do not export EOF = -1.
+* fmt: make ScanState.Token more general (thanks Roger Peppe).
+* gc: diagnose unused labels,
+ fix handling of return values named _,
+ include all dependencies in export metadata,
+ make unsafe.Pointer its own kind of type, instead of an equivalent to *any.
+* go/ast, go/parser: populate identifier scopes at parse time.
+* go/ast: add FileSet parameter to ast.Print and ast.Fprint.
+* go/parser: first constant in a constant declaration must have a value.
+* gob: efficiency and reliability fixes.
+* gofmt: remove -trace and -ast flags.
+* goinstall: handle $(GOOS) and $(GOARCH) in filenames,
+ handle .c files with gc when cgo isn't used, and
+ handle .s files with gc (thanks Gustavo Niemeyer).
+* gopack: omit time stamps, makes output deterministic.
+* gotype: commandline tool to typecheck go programs.
+* govet: handle '*' in print format strings.
+* hash: new FNV-1a implementation (thanks Pascal S. de Kloe).
+* http/cgi: child support (e.g. Go CGI under Apache).
+* http: adapt Cookie code to follow IETF draft (thanks Petar Maymounkov),
+ add test for fixed HTTP/1.0 keep-alive issue,
+ don't hit external network in client_test.go,
+ fix transport crash when request URL is nil,
+ rename interface Transport to RoundTripper,
+ run tests even with DISABLE_NET_TESTS=1.
+* httptest: default the Recorder status code to 200 on a Write.
+* io/ioutil: clean-up of ReadAll and ReadFile.
+* ioutil: add NopCloser.
+* ld: preserve symbol sizes during data layout.
+* lib9, libmach: Change GOOS references to GOHOSTOS (thanks Evan Shaw).
+* libmach: correct string comparison to revive 6cov on darwin (thanks Dave Cheney).
+* misc/vim: Add indent script for Vim (thanks Ross Light).
+* net, os, syslog: fixes for Solaris support.
+* net: don't loop to drain wakeup pipe.
+* nm: document -S flag.
+* openpgp: add PublicKey KeyId string accessors.
+* rpc: optimizations, add benchmarks and memory profiling,
+ use httptest.Server for tests (thanks Robert Hencke).
+* runtime: reduce lock contention via wakeup on scheduler unlock,
+ scheduler, cgo reorganization,
+ split non-debugging malloc interface out of debug.go into mem.go.
+* spec: clarify return statement rules.
+* strings: add IndexRune tests, ASCII fast path,
+ better benchmark names; add BenchmarkIndex.
+* syscall: implement Mount and Unmount for linux,
+ implement Reboot for linux.
+* time: fix Time.ZoneOffset documentation (thanks Peter Mundy).
+* tls: move PeerCertificates to ConnectionState.
+</pre>
+
+<h2 id="2011-03-07">2011-03-07 (<a href="release.html#r56">base for r56</a>)</h2>
+
+<pre>
+This release includes changes to the reflect and path packages.
+Code that uses reflect or path may need to be updated.
+
+The reflect package's Value.Addr method has been renamed to Value.UnsafeAddr.
+Code that uses the Addr method will have to call UnsafeAddr instead.
+
+The path package has been split into two packages: path and path/filepath.
+Package path manipulates slash-separated paths, regardless of operating system.
+Package filepath implements the local operating system's native file paths.
+OS-specific functioanlity in pacakge path, such as Walk, moved to filepath.
+
+Other changes:
+* build: fixes and simplifications (thanks Dave Cheney),
+ move $GOBIN ahead of /bin, /usr/bin in build $PATH.
+* bzip2: speed up decompression.
+* cgo: fix dwarf type parsing (thanks Gustavo Niemeyer),
+ put temporary source files in _obj (thanks Roger Peppe),
+ fix bug involving 0-argument callbacks.
+* compress/lzw: optimizations.
+* doc: add FAQ about "implements",
+ add FAQ about large binaries ,
+ add FAQ about stack vs heap allocation,
+ add internationalization to roadmap,
+ describe platform-specific conventions in code.html.
+* fmt: allow recursive calls to Fscan etc (thanks Roger Peppe),
+ make %#p suppress leading 0x.
+* gc, gopack: add some missing flags to the docs.
+* gc: fix init of packages named main (thanks Gustavo Niemeyer),
+* gob: make recursive map and slice types work, and other fixes.
+ tentative support for GobEncoder/GobDecoder interfaces.
+* gobuilder: add -package flag to build external packages and -v for verbose.
+* gofmt: exclude test file that is not legal Go.
+* goinstall: protect against malicious filenames (thanks Roger Peppe).
+* goyacc: provide -p flag to set prefix for names, documentation update.
+* http: add cookie support (thanks Petar Maymounkov),
+ allow handlers to send non-chunked responses,
+ export ParseHTTPVersion,
+ expose Client's Transport,
+ use WriteProxy,
+ rename ClientTransport to Transport.
+* http/cgi: new package.
+* http/httptest: new package.
+* image: add a decoding test for common file formats.
+* io/ioutil: add TempDir.
+* mime/multipart: Header changed from map to MIMEHeader
+* path/filepath: new OS-specific path support (thanks Gustavo Niemeyer).
+* reflect: add PtrTo, add Value.Addr (old Addr is now UnsafeAddr).
+* runtime: use kernel-supplied compare-and-swap on linux/arm.
+* spec: minor clarification of scope rule for functions.
+* sync/atomic: new package to expose atomic operations.
+* syscall: regenerate zerrors_freebsd_amd64.go (thanks Mikio Hara),
+ work around FreeBSD execve kernel bug (thanks Devon H. O'Dell).
+* template: document the delimiters.
+* testing: run GC before each benchmark run (thanks Roger Peppe).
+* unsafe: fix the documentation.
+* websocket: use httptest.Server for tests (thanks Robert Hencke).
+* xml: permit nested directives (thanks Chris Dollin).
+</pre>
+
+<h2 id="2011-02-24">2011-02-24</h2>
+
+<pre>
+This release includes changes to the http package and a small language change.
+Your code will require changes if it manipulates http Headers or omits the
+condition in if statements.
+
+The new http.Header type replaces map[string]string in the Header and Trailer
+fields of http.Request and http.Response.
+A Header value can be manipulated via its Get, Set, Add, and Del methods.
+See http://golang.org/pkg/http/#Header
+
+The condition is now mandatory in if statements.
+Previously it would default to true, as in switch and for statements.
+This code is now illegal:
+ if x := foo(); {
+ // code that is always executed
+ }
+The same effect can be achieved like this:
+ if x := foo(); true {
+ // code
+ }
+Or, in a simpler form:
+ {
+ x := foo()
+ // code
+ }
+
+Other changes:
+* 6l: new -Hwindowsgui flag allows to build windows gui pe (thanks Alex Brainman),
+ pe fixes (thanks Wei Guangjing).
+* 8l, 6l: allow for more os threads to be created on Windows (thanks Alex Brainman),
+* build: reduce the use of subshells in recursive make, and
+ remove unused NaCl conditional from make.bash (thanks Dave Cheney).
+* codereview: fix clpatch with empty diffs (thanks Gustavo Niemeyer).
+* compress/bzip2: add package.
+* compress/lzw: implement a decoder.
+* crypto/openpgp: add package.
+* crypto/rand: add read buffer to speed up small requests (thanks Albert Strasheim).
+* crypto/rsa: left-pad OAEP results when needed.
+* crypto/tls: make protocol negotiation failure fatal.
+* fmt: stop giving characters to the Scan method of Scanner when we hit a newline in Scanln.
+* gc: interface error message fixes,
+ make string const comparison unsigned (thanks Jeff R. Allen).
+* go spec: minor clarification on channel types.
+* go/ast, parser: condition in if statement is mandatory.
+* gob: compute information about a user's type once.
+ protect against pure recursive types.
+* godoc: accept symbolic links as path names provided to -path,
+ add robots.txt, log errors when reading filter files.
+* html: tokenize HTML comments.
+* http: add proxy support (thanks Yasuhiro Matsumoto),
+ implement with net/textproto (thanks Petar Maymounkov),
+ send full URL in proxy requests,
+ introduce start of Client and ClientTransport.
+* image/png: support for more formats (thanks Mikael Tillenius).
+* json: only use alphanumeric tags,
+ use base64 to encode []byte (thanks Roger Peppe).
+* ld: detect stack overflow due to NOSPLIT, drop rpath, support weak symbols.
+* misc/dashboard/builder: talk to hg with utf-8 encoding.
+* misc/dashboard: notify golang-dev on build failure.
+* net: *netFD.Read to return os.EOF on eof under windows (thanks Alex Brainman),
+ add IPv4 multicast to UDPConn (thanks Dave Cheney),
+ more accurate IPv4-in-IPv6 API test (thanks Mikio Hara),
+ reject invalid net:proto network names (thanks Olivier Antoine).
+* netchan: allow use of arbitrary connections (thanks Roger Peppe).
+* os: add ENODATA and ENOTCONN (thanks Albert Strasheim).
+* reflect: add a couple of sentences explaining how Methods operate,
+ add a secret method to ArrayOrSliceType to ensure it's only implemented by arrays and slices,
+ add pointer word to CommonType (placeholder for future work).
+* runtime-gdb.py: gdb pretty printer for go strings properly handles length.
+* runtime: various bug fixes, more complete stack traces,
+ record $GOROOT_FINAL for runtime.GOROOT.
+* spec: delete incorrect mention of selector working on pointer to interface type.
+* sync: add Cond (thanks Gustavo Niemeyer).
+* syscall: add MCL_* flags for mlockall (thanks Albert Strasheim),
+ implement chmod() for win32 (thanks Yasuhiro Matsumoto).
+* test/bench: update timings for new GC.
+* testing: rename cmdline flags to avoid conflicts (thanks Gustavo Niemeyer).
+* textproto: introduce Header type (thanks Petar Maymounkov).
+* websocket: use new interface to access Header.
+</pre>
+
+<h2 id="2011-02-15">2011-02-15</h2>
+
+<pre>
+This release includes changes to the io, os, and template packages.
+You may need to update your code.
+
+The io.ReadByter and io.ReadRuner interface types have been renamed to
+io.ByteReader and io.RuneReader respectively.
+
+The os package's ForkExec function has been superseded by the new StartProcess
+function and an API built around the Process type:
+ http://golang.org/pkg/os/#Process
+
+The order of arguments to template.Execute has been reversed to be consistent
+the notion of "destination first", as with io.Copy, fmt.Fprint, and others.
+
+Gotest now works for package main in directories using Make.cmd-based makefiles.
+
+The memory allocation runtime problems from the last release are not completely
+fixed. The virtual memory exhaustion problems encountered by people using
+ulimit -v have been fixed, but there remain known garbage collector problems
+when using GOMAXPROCS > 1.
+
+Other changes:
+* 5l: stopped generating 64-bit eor.
+* 8l: more work on plan9 support (thanks Yuval Pavel Zholkover).
+* archive/zip: handle files with data descriptors.
+* arm: working peep-hole optimizer.
+* asn1: marshal true as 255, not 1.
+* buffer.go: minor optimization, expanded comment.
+* build: drop syslog on DISABLE_NET_TESTS=1 (thanks Gustavo Niemeyer),
+ allow clean.bash to work on fresh checkout,
+ change "all tests pass" message to be more obvious,
+ fix spaces in GOROOT (thanks Christopher Nielsen).
+* bytes: fix bug in buffer.ReadBytes (thanks Evan Shaw).
+* 5g: better int64 code,
+ don't use MVN instruction.
+* cgo: don't run cgo when not compiling (thanks Gustavo Niemeyer),
+ fix _cgo_run timestamp file order (thanks Gustavo Niemeyer),
+ fix handling of signed enumerations (thanks Gustavo Niemeyer),
+ os/arch dependent #cgo directives (thanks Gustavo Niemeyer),
+ rename internal f to avoid conflict with possible C global named f.
+* codereview: fix hgpatch on windows (thanks Yasuhiro Matsumoto),
+ record repository, base revision,
+ use cmd.communicate (thanks Yasuhiro Matsumoto).
+* container/ring: replace Iter() with Do().
+* crypto/cipher: add resync open to OCFB mode.
+* crypto/openpgp/armor: bug fixes.
+* crypto/openpgp/packet: new subpackage.
+* crypto/tls: load a chain of certificates from a file,
+ select best cipher suite, not worst.
+* crypto/x509: add support for name constraints.
+* debug/pe: ImportedSymbols fixes (thanks Wei Guangjing).
+* doc/code: update to reflect that package names need not be unique.
+* doc/codelab/wiki: a bunch of fixes (thanks Andrey Mirtchovski).
+* doc/install: update for new versions of Mercurial.
+* encoding/line: fix line returned after EOF.
+* flag: allow hexadecimal (0xFF) and octal (0377) input for integer flags.
+* fmt.Scan: scan binary-exponent floating format, 2.4p-3,
+ hexadecimal (0xFF) and octal (0377) integers.
+* fmt: document %%; also %b for floating point.
+* gc, ld: detect stale or incompatible object files,
+ package name main no longer reserved.
+* gc: correct receiver in method missing error (thanks Lorenzo Stoakes),
+ correct rounding of denormal constants (thanks Eoghan Sherry),
+ select receive bug fix.
+* go/printer, gofmt: smarter handling of multi-line raw strings.
+* go/printer: line comments must always end in a newline,
+ remove notion of "Styler", remove HTML mode.
+* gob: allow Decode(nil) and have it just discard the next value.
+* godoc: use IsAbs to test for absolute paths (fix for win32) (thanks Yasuhiro Matsumoto),
+ don't hide package lookup error if there's no command with the same name.
+* gotest: enable unit tests for main programs.
+* http: add Server type supporting timeouts,
+ add pipelining to ClientConn, ServerConn (thanks Petar Maymounkov),
+ handle unchunked, un-lengthed HTTP/1.1 responses.
+* io: add RuneReader.
+* json: correct Marshal documentation.
+* netchan: graceful handling of closed connection (thanks Graham Miller).
+* os: implement new Process API (thanks Alex Brainman).
+* regexp tests: make some benchmarks more meaningful.
+* regexp: add support for matching against text read from RuneReader interface.
+* rpc: make more tolerant of errors, properly discard values (thanks Roger Peppe).
+* runtime: detect failed thread creation on Windows,
+ faster allocator, garbage collector,
+ fix virtual memory exhaustion,
+ implemented windows console ctrl handler (SIGINT) (thanks Hector Chu),
+ more detailed panic traces, line number work,
+ improved Windows callback handling (thanks Hector Chu).
+* spec: adjust notion of Assignability,
+ allow import of packages named main,
+ clarification re: method sets of newly declared pointer types,
+ fix a few typos (thanks Anthony Martin),
+ fix Typeof() return type (thanks Gustavo Niemeyer),
+ move to Unicode 6.0.
+* sync: diagnose Unlock of unlocked Mutex,
+ new Waitgroup type (thanks Gustavo Niemeyer).
+* syscall: add SetsockoptIpMreq (thanks Dave Cheney),
+ add sockaddr_dl, sysctl with routing message support for darwin, freebsd (thanks Mikio Hara),
+ do not use NULL for zero-length read, write,
+ implement windows version of Fsync (thanks Alex Brainman),
+ make ForkExec acquire the ForkLock under windows (thanks Hector Chu),
+ make windows API return errno instead of bool (thanks Alex Brainman),
+ remove obsolete socket IO control (thanks Mikio Hara).
+* template: add simple formatter chaining (thanks Kyle Consalus),
+ allow a leading '*' to indirect through a pointer.
+* testing: include elapsed time in test output
+* windows: replace remaining __MINGW32__ instances with _WIN32 (thanks Joe Poirier).
+</pre>
+
+<h2 id="2011-02-01">2011-02-01</h2>
+
+<pre>
+This release includes significant changes to channel operations and minor
+changes to the log package. Your code will require modification if it uses
+channels in non-blocking communications or the log package's Exit functions.
+
+Non-blocking channel operations have been removed from the language.
+The equivalent operations have always been possible using a select statement
+with a default clause. If a default clause is present in a select, that clause
+will execute (only) if no other is ready, which allows one to avoid blocking on
+a communication.
+
+For example, the old non-blocking send operation,
+
+ if ch <- v {
+ // sent
+ } else {
+ // not sent
+ }
+
+should be rewritten as,
+
+ select {
+ case ch <- v:
+ // sent
+ default:
+ // not sent
+ }
+
+Similarly, this receive,
+
+ v, ok := <-ch
+ if ok {
+ // received
+ } else {
+ // not received
+ }
+
+should be rewritten as,
+
+ select {
+ case v := <-ch:
+ // received
+ default:
+ // not received
+ }
+
+This change is a prelude to redefining the 'comma-ok' syntax for a receive.
+In a later release, a receive expression will return the received value and an
+optional boolean indicating whether the channel has been closed. These changes
+are being made in two stages to prevent this semantic change from silently
+breaking code that uses 'comma-ok' with receives.
+There are no plans to have a boolean expression form for sends.
+
+Sends to a closed channel will panic immediately. Previously, an unspecified
+number of sends would fail silently before causing a panic.
+
+The log package's Exit, Exitf, and Exitln functions have been renamed Fatal,
+Fatalf, and Fatalln respectively. This brings them in line with the naming of
+the testing package.
+
+The port to the "tiny" operating system has been removed. It is unmaintained
+and untested. It was a toy to show that Go can run on raw hardware and it
+served its purpose. The source code will of course remain in the repository
+history, so it could be brought back if needed later.
+
+This release also changes some of the internal structure of the memory
+allocator in preparation for other garbage collector changes.
+If you run into problems, please let us know.
+There is one known issue that we are aware of but have not debugged yet:
+ http://code.google.com/p/go/issues/detail?id=1464&.
+
+Other changes in this release:
+* 5l: document -F, force it on old ARMs (software floating point emulation)
+* 6g: fix registerization of temporaries (thanks Eoghan Sherry),
+ fix uint64(uintptr(unsafe.Pointer(&x))).
+* 6l: Relocate CMOV* instructions (thanks Gustavo Niemeyer),
+ windows/amd64 port (thanks Wei Guangjing).
+* 8l: add PE dynexport, emit DWARF in Windows PE, and
+ code generation fixes (thanks Wei Guangjing).
+* bufio: make Flush a no-op when the buffer is empty.
+* bytes: Add Buffer.ReadBytes, Buffer.ReadString (thanks Evan Shaw).
+* cc: mode to generate go-code for types and variables.
+* cgo: define CGO_CFLAGS and CGO_LDFLAGS in Go files (thanks Gustavo Niemeyer),
+ windows/386 port (thanks Wei Guangjing).
+* codereview: fix windows (thanks Hector Chu),
+ handle file patterns better,
+ more ASCII vs. Unicode nonsense.
+* crypto/dsa: add support for DSA.
+* crypto/openpgp: add s2k.
+* crypto/rand: use defer to unlock mutex (thanks Anschel Schaffer-Cohen).
+* crypto/rsa: correct docstring for SignPKCS1v15.
+* crypto: add package, a common place to store identifiers for hash functions.
+* doc/codelab/wiki: update to work with template changes, add to run.bash.
+* doc/spec: clarify address operators.
+* ebnflint: exit with non-zero status on error.
+* encoding/base32: new package (thanks Miek Gieben).
+* encoding/line: make it an io.Reader too.
+* exec: use custom error for LookPath (thanks Gustavo Niemeyer).
+* fmt/doc: define width and precision for strings.
+* gc: clearer error for struct == struct,
+ fix send precedence,
+ handle invalid name in type switch,
+ special case code for single-op blocking and non-blocking selects.
+* go/scanner: fix build (adjust scanner EOF linecount).
+* gob: better debugging, commentary,
+ make nested interfaces work,
+ report an error when encoding a non-empty struct with no public fields.
+* godoc: full text index for whitelisted non-Go files,
+ show line numbers for non-go files (bug fix).
+* gofmt -r: match(...) arguments may be nil; add missing guards.
+* govet: add Panic to the list of functions.
+* http: add host patterns (thanks Jose Luis Vázquez González),
+ follow relative redirect in Get.
+* json: handle capital floating point exponent (1E100) (thanks Pieter Droogendijk).
+* ld: add -I option to set ELF interpreter,
+ more robust decoding of reflection type info in generating dwarf.
+* lib9: update to Unicode 6.0.0.
+* make.bash: stricter selinux test (don't complain unless it is enabled).
+* misc/vim: Import/Drop commands (thanks Gustavo Niemeyer),
+ set 'syntax sync' to a large value (thanks Yasuhiro Matsumoto).
+* net: fix race condition in test,
+ return cname in LookupHost.
+* netchan: avoid race condition in test,
+ fixed documentation for import (thanks Anschel Schaffer-Cohen).
+* os: add ETIMEDOUT (thanks Albert Strasheim).
+* runtime: generate Go defs for C types,
+ implementation of callback functions for windows (thanks Alex Brainman),
+ make Walk web browser example work (thanks Hector Chu),
+ make select fairer,
+ prefer fixed stack allocator over general memory allocator,
+ simpler heap map, memory allocation.
+* scanner: fix Position returned by Scan, Pos,
+ don't read ahead in Init.
+* suffixarray: use binary search for both ends of Lookup (thanks Eric Eisner).
+* syscall: add missing network interface constants (thanks Mikio Hara).
+* template: treat map keys as zero, not non-existent (thanks Roger Peppe).
+* time: allow canceling of After events (thanks Roger Peppe),
+ support Solaris zoneinfo directory.
+* token/position: added SetLinesForContent.
+* unicode: update to unicode 6.0.0.
+* unsafe: add missing case to doc for Pointer.
+</pre>
+
+<h2 id="2011-01-20">2011-01-20</h2>
+
+<pre>
+This release removes the float and complex types from the language.
+
+The default type for a floating point literal is now float64, and
+the default type for a complex literal is now complex128.
+
+Existing code that uses float or complex must be rewritten to
+use explicitly sized types.
+
+The two-argument constructor cmplx is now spelled complex.
+</pre>
+
+<h2 id="2011-01-19">2011-01-19</h2>
+
+<pre>
+The 5g (ARM) compiler now has registerization enabled. If you discover it
+causes bugs, use 5g -N to disable the registerizer and please let us know.
+
+The xml package now allows the extraction of nested XML tags by specifying
+struct tags of the form "parent>child". See the XML documentation for an
+example: http://golang.org/pkg/xml/
+
+* 5a, 5l, 6a, 6l, 8a, 8l: handle out of memory, large allocations (thanks Jeff R. Allen).
+* 8l: pe changes (thanks Alex Brainman).
+* arm: fixes and improvements.
+* cc: fix vlong condition.
+* cgo: add complex float, complex double (thanks Sebastien Binet),
+ in _cgo_main.c define all provided symbols as functions.
+* codereview: don't mail change lists with no files (thanks Ryan Hitchman).
+* crypto/cipher: add OFB mode.
+* expvar: add Float.
+* fmt: document %X of string, []byte.
+* gc, runtime: make range on channel safe for multiple goroutines.
+* gc: fix typed constant declarations (thanks Anthony Martin).
+* go spec: adjust language for constant typing.
+* go/scanner: Make Init take a *token.File instead of a *token.FileSet.
+* godoc: bring back "indexing in progress" message,
+ don't double HTML-escape search result snippets,
+ enable qualified identifiers ("math.Sin") as query strings again,
+ peephole optimization for generated HTML,
+ remove tab before formatted section.
+* gofmt, go/printer: do not insert extra line breaks where they may break the code.
+* http: fix Content-Range and Content-Length in response (thanks Clement Skau),
+ fix scheme-relative URL parsing; add ParseRequestURL,
+ handle HEAD requests correctly,
+ support for relative URLs.
+* math: handle denormalized numbers in Frexp, Ilogb, Ldexp, and Logb (thanks Eoghan Sherry).
+* net, syscall: return source address in Recvmsg (thanks Albert Strasheim).
+* net: add LookupAddr (thanks Kyle Lemons),
+ add unixpacket (thanks Albert Strasheim),
+ avoid nil dereference if /etc/services can't be opened (thanks Corey Thomasson),
+ implement windows timeout (thanks Wei Guangjing).
+* netchan: do not block sends; implement flow control (thanks Roger Peppe).
+* regexp: reject bare '?'. (thanks Ben Lynn)
+* runtime/cgo: don't define crosscall2 in dummy _cgo_main.c.
+* runtime/debug: new package for printing stack traces from a running goroutine.
+* runtime: add per-pause gc stats,
+ fix arm reflect.call boundary case,
+ print signal information during panic.
+* spec: specify that int and uint have the same size.
+* syscall: correct WSTOPPED on OS X,
+ correct length of GNU/Linux abstract Unix domain sockaddr,
+ correct length of SockaddrUnix.
+* tutorial: make stdin, stdout, stderr work on Windows.
+* windows: implement exception handling (thanks Hector Chu).
+</pre>
+
+<h2 id="2011-01-12">2011-01-12</h2>
+
+<pre>
+The json, gob, and template packages have changed, and code that uses them
+may need to be updated after this release. They will no longer read or write
+unexported struct fields. When marshaling a struct with json or gob the
+unexported fields will be silently ignored. Attempting to unmarshal json or
+gob data into an unexported field will generate an error. Accessing an
+unexported field from a template will cause the Execute function to return
+an error.
+
+Godoc now supports regular expression full text search, and this
+functionality is now available on golang.org.
+
+Other changes:
+* arm: initial cut at arm optimizer.
+* bytes.Buffer: Fix bug in UnreadByte.
+* cgo: export unsafe.Pointer as void*, fix enum const conflict,
+ output alignment fix (thanks Gustavo Niemeyer).
+* crypto/block: mark as deprecated.
+* crypto/openpgp: add error and armor.
+* crypto: add twofish package (thanks Berengar Lehr).
+* doc/spec: remove Maxalign from spec.
+* encoding/line: new package for reading lines from an io.Reader.
+* go/ast: correct end position for Index and TypeAssert expressions.
+* gob: make (en|dec)code(Ui|I)nt methods rather than functions.
+* godefs: better handling of enums.
+* gofmt: don't attempt certain illegal rewrites,
+ rewriter matches apply to expressions only.
+* goinstall: preliminary support for cgo packages (thanks Gustavo Niemeyer).
+* hg: add cgo/_cgo_* to .hgignore.
+* http: fix text displayed in Redirect.
+* ld: fix exported dynamic symbols on Mach-O,
+ permit a Mach-O symbol to be exported in the dynamic symbol table.
+* log: add methods for exit and panic.
+* net: use closesocket api instead of CloseHandle on Windows (thanks Alex Brainman).
+* netchan: make fields exported for gob change.
+* os: add Sync to *File, wraps syscall.Fsync.
+* runtime/cgo: Add callbacks to support SWIG.
+* runtime: Restore scheduler stack position if cgo callback panics.
+* suffixarray: faster creation algorithm (thanks Eric Eisner).
+* syscall: fix mksysnum_linux.sh (thanks Anthony Martin).
+* time.NewTicker: panic for intervals <= 0.
+* time: add AfterFunc to call a function after a duration (thanks Roger Peppe),
+ fix tick accuracy when using multiple Tickers (thanks Eoghan Sherry).</pre>
+
+<h2 id="2011-01-06">2011-01-06</h2>
+
+<pre>
+This release includes several fixes and changes:
+
+* build: Make.pkg: use installed runtime.h for cgo.
+* cgo: disallow use of C.errno.
+* crypto/cipher: fix OCFB,
+ make NewCBCEncrypter return BlockMode.
+* doc: 6l: fix documentation of -L flag,
+ add golanguage.ru to foreign-language doc list,
+ effective go: explain the effect of repanicking better,
+ update Effective Go for template API change,
+ update contribution guidelines to prefix the change description.
+* encoding/binary: reject types with implementation-dependent sizes (thanks Patrick Gavlin).
+* exp/evalsimple fix handling of slices like s[:2] (thanks Sebastien Binet).
+* fmt: made format string handling more efficient,
+ normalize processing of format string.
+* gc: return constant floats for parts of complex constants (thanks Anthony Martin),
+ rewrite complex /= to l = l / r (thanks Patrick Gavlin),
+ fix &^=.
+* go/ast: provide complete node text range info.
+* gob: generate a better error message in one confusing place.
+* godoc: fix godoc -src (thanks Icarus Sparry).
+* goinstall: add -clean flag (thanks Kyle Lemons),
+ add checkout concept (thanks Caine Tighe),
+ fix -u for bzr (thanks Gustavo Niemeyer).
+* http: permit empty Reason-Phrase in response Status-Line.
+* io: fix Copyn EOF handling.
+* net: fix close of Listener (thanks Michael Hoisie).
+* regexp: fix performance bug, make anchored searches fail fast,
+ fix prefix bug.
+* runtime/cgo: fix stackguard on FreeBSD/amd64 (thanks Anthony Martin).
+* strconv: atof: added 'E' as valid token for exponent (thanks Stefan Nilsson),
+ update ftoa comment for 'E' and 'G'.
+* strings: fix description of FieldsFunc (thanks Roger Peppe).
+* syscall: correct Linux Splice definition,
+ make Access second argument consistently uint32.
+</pre>
+
+<h2 id="2010-12-22">2010-12-22</h2>
+
+<pre>
+A small release this week. The most significant change is that some
+outstanding cgo issues were resolved.
+
+* cgo: handle references to symbols in shared libraries.
+* crypto/elliptic: add serialisation and key pair generation.
+* crypto/hmac: add HMAC-SHA256 (thanks Anthony Martin).
+* crypto/tls: add ECDHE support ("Elliptic Curve Diffie Hellman Ephemeral"),
+ add support code for generating handshake scripts for testing.
+* darwin, freebsd: ignore write failure (during print, panic).
+* exp/draw: remove Border function.
+* expvar: quote StringFunc output, same as String output.
+* hash/crc64: fix typo in Sum.
+* ld: allow relocations pointing at ELF .bss symbols, ignore stab symbols.
+* misc/cgo/life: fix, add to build.
+* regexp: add HasMeta, HasOperator, and String methods to Regexp.
+* suffixarray: implemented FindAllIndex regexp search.
+* test/bench: update numbers for regex-dna after speedup to regexp.
+* time: explain the formats a little better.
+</pre>
+
+<h2 id="2010-12-15">2010-12-15</h2>
+
+<pre>
+Package crypto/cipher has been started, to replace crypto/block.
+As part of the changes, rc4.Cipher's XORKeyStream method signature has changed from
+ XORKeyStream(buf []byte)
+to
+ XORKeyStream(dst, src []byte)
+to implement the cipher.Stream interface. If you use crypto/block, you'll need
+to switch to crypto/cipher once it is complete.
+
+Package smtp's StartTLS now takes a *tls.Config argument.
+
+Package reflect's ArrayCopy has been renamed to Copy. There are new functions
+Append and AppendSlice.
+
+The print/println bootstrapping functions now write to standard error.
+To write to standard output, use fmt.Print[ln].
+
+A new tool, govet, has been added to the Go distribution. Govet is a static
+checker for Go programs. At the moment, and for the foreseeable future,
+it only checks arguments to print calls.
+
+The cgo tool for writing Go bindings for C code has changed so that it no
+longer uses stub .so files (like cgo_stdio.so). Cgo-based packages using the
+standard Makefiles should build without any changes. Any alternate build
+mechanisms will need to be updated.
+
+The C and Go compilers (6g, 6c, 8g, 8c, 5g, 5c) now align structs according to
+the maximum alignment of the fields they contain; previously they aligned
+structs to word boundaries. This may break non-cgo-based code that attempts to
+mix C and Go.
+
+NaCl support has been removed. The recent linker changes broke NaCl support
+a month ago, and there are no known users of it.
+If necessary, the NaCl code can be recovered from the repository history.
+
+* 5g/8g, 8l, ld, prof: fix output of 32-bit values (thanks Eoghan Sherry).
+* [68]l and runtime: GDB support for interfaces and goroutines.
+* 6l, 8l: support for linking ELF and Mach-O .o files.
+* all: simplify two-variable ranges with unused second variable (thanks Ryan Hitchman).
+* arm: updated soft float support.
+* codereview: keep quiet when not in use (thanks Eoghan Sherry).
+* compress/flate: implement Flush, equivalent to zlib's Z_SYNC_FLUSH.
+* crypto/tls: use rand.Reader in cert generation example (thanks Anthony Martin).
+* dashboard: fix project tag filter.
+* debug/elf, debug/macho: add ImportedLibraries, ImportedSymbols.
+* doc/go_mem: goroutine exit is not special.
+* event.go: another print glitch from gocheck.
+* gc: bug fixes,
+ syntax error for incomplete chan type (thanks Ryan Hitchman).
+* go/ast: fix ast.Walk.
+* gob: document the byte count used in the encoding of values,
+ fix bug sending zero-length top-level slices and maps,
+ Register should use the original type, not the indirected one.
+* godashboard: support submitting projects with non-ascii names (thanks Ryan Hitchman)
+* godefs: guard against structs with pad fields
+* godoc: added textual search, to enable use -fulltext flag.
+* gofmt: simplify "x, _ = range y" to "x = range y".
+* gopack: allow ELF/Mach-O objects in .a files without clearing allobj.
+* go/token,scanner: fix comments so godoc aligns properly.
+* govet: on error continue to the next file (thanks Christopher Wedgwood).
+* html: improved parsing.
+* http: ServeFile handles Range header for partial requests.
+* json: check for invalid UTF-8.
+* ld: allow .o files with no symbols,
+ reading of ELF object files,
+ reading of Mach-O object files.
+* math: change float64 bias constant from 1022 to 1023 (thanks Eoghan Sherry),
+ rename the MinFloat constant to SmallestNonzeroFloat.
+* nm: silently ignore .o files in .a files.
+* os: fix test of RemoveAll.
+* os/inotify: new package (thanks Balazs Lecz).
+* os: make MkdirAll work with symlinks (thanks Ryan Hitchman).
+* regexp: speed up by about 30%; also simplify code for brackets.
+* runtime/linux/386: set FPU to 64-bit precision.
+* runtime: remove paranoid mapping at 0.
+* suffixarray: add Bytes function.
+* syscall: add network interface constants for linux/386, linux/amd64 (thanks Mikio Hara).
+* syscall/windows: restrict access rights param of OpenProcess(),
+ remove \r and \n from error messages (thanks Alex Brainman).
+* test/bench: fixes to timing.sh (thanks Anthony Martin).
+* time: fix bug in Ticker: shutdown using channel rather than memory.
+* token/position: provide FileSet.File, provide files iterator.
+* xml: disallow invalid Unicode code points (thanks Nigel Kerr).
+</pre>
+
+<h2 id="2010-12-08">2010-12-08</h2>
+
+<pre>
+This release includes some package changes. If you use the crypto/tls or
+go/parser packages your code may require changes.
+
+The crypto/tls package's Dial function now takes an additional *Config
+argument. Most uses will pass nil to get the same default behavior as before.
+See the documentation for details:
+ http://golang.org/pkg/crypto/tls/#Config
+ http://golang.org/pkg/crypto/tls/#Dial
+
+The go/parser package's ParseFile function now takes a *token.FileSet as its
+first argument. This is a pointer to a data structure used to store
+position information. If you don't care about position information you
+can pass "token.NewFileSet()". See the documentation for details:
+ http://golang.org/pkg/go/parser/#ParseFile
+
+This release also splits the patent grant text out of the LICENSE file into a
+separate PATENTS file and changes it to be more like the WebM grant.
+These clarifications were made at the request of the Fedora project.
+
+Other changes:
+* [68]l: generate debug info for builtin structured types, prettyprinting in gdb.
+* 8l: add dynimport to import table in Windows PE (thanks Wei Guangjing).
+* 8l, runtime: fix Plan 9 386 build (thanks Yuval Pavel Zholkover).
+* all: fix broken calls to Printf etc.
+* bufio: make Reader.Read implement io.Reader semantics (thanks Roger Peppe).
+* build: allow archiver to be specified by HOST_AR (thanks Albert Strasheim).
+* bytes: add Buffer.UnreadRune, Buffer.UnreadByte (thanks Roger Peppe).
+* crypto/tls: fix build of certificate generation example (thanks Christian Himpel).
+* doc/install: describe GOHOSTOS and GOHOSTARCH.
+* errchk: accept multiple source files (thanks Eoghan Sherry).
+* exec.LookPath: return os.PathError instad of os.ENOENT (thanks Michael Hoisie)..
+* flag: fix format error in boolean error report,
+ handle multiple calls to flag.Parse.
+* fmt: add %U format for standard Unicode representation of code point values.
+* gc: fix method offsets of anonymous interfaces (thanks Eoghan Sherry),
+ skip undefined symbols in import . (thanks Eoghan Sherry).
+* go/scanner: remove Tokenize - was only used in tests
+* gobuilder: add buildroot command-line flag (thanks Devon H. O'Dell).
+* html: unescape numeric entities (thanks Ryan Hitchman).
+* http: Add EncodeQuery, helper for constructing query strings.
+* ld: fix dwarf decoding of 64-bit reflect values (thanks Eoghan Sherry).
+* math: improve accuracy of Exp2 (thanks Eoghan Sherry).
+* runtime: add Goroutines (thanks Keith Rarick).
+* sync: small naming fix for armv5 (thanks Dean Prichard).
+* syscall, net: Add Recvmsg and Sendmsg on Linux (thanks Albert Strasheim).
+* time: make After use fewer goroutines and host processes (thanks Roger Peppe).
+</pre>
+
+<h2 id="2010-12-02">2010-12-02</h2>
+
+<pre>
+Several package changes in this release may require you to update your code if
+you use the bytes, template, or utf8 packages. In all cases, any outdated code
+will fail to compile rather than behave erroneously.
+
+The bytes package has changed. Its Add and AddByte functions have been removed,
+as their functionality is provided by the recently-introduced built-in function
+"append". Any code that uses them will need to be changed:
+s = bytes.Add(s, b) -> s = append(s, b...)
+s = bytes.AddByte(b, c) -> s = append(s, b)
+s = bytes.Add(nil, c) -> append([]byte(nil), c)
+
+The template package has changed. Your code will need to be updated if it calls
+the HTMLFormatter or StringFormatter functions, or implements its own formatter
+functions. The function signature for formatter types has changed to:
+ func(wr io.Writer, formatter string, data ...interface{})
+to allow multiple arguments to the formatter. No templates will need updating.
+See the change for examples:
+ http://code.google.com/p/go/source/detail?r=2c2be793120e
+
+The template change permits the implementation of multi-word variable
+instantiation for formatters. Before one could say
+ {field}
+or
+ {field|formatter}
+Now one can also say
+ {field1 field2 field3}
+or
+ {field1 field2 field3|formatter}
+and the fields are passed as successive arguments to the formatter,
+by analogy to fmt.Print.
+
+The utf8 package has changed. The order of EncodeRune's arguments has been
+reversed to satisfy the convention of "destination first".
+Any code that uses EncodeRune will need to be updated.
+
+Other changes:
+* [68]l: correct dwarf location for globals and ranges for arrays.
+* big: fix (*Rat) SetFrac64(a, b) when b < 0 (thanks Eoghan Sherry).
+* compress/flate: fix typo in comment (thanks Mathieu Lonjaret).
+* crypto/elliptic: use a Jacobian transform for better performance.
+* doc/code.html: fix reference to "gomake build" (thanks Anschel Schaffer-Cohen).
+* doc/roadmap: update gdb status.
+* doc/spec: fixed some omissions and type errors.
+* doc: some typo fixes (thanks Peter Mundy).
+* exp/eval: build fix for parser.ParseFile API change (thanks Anschel Schaffer-Cohen).
+* fmt: Scan accepts Inf and NaN,
+ allow "% X" as well as "% x".
+* go/printer: preserve newlines in func parameter lists (thanks Jamie Gennis).
+* http: consume request body before next request.
+* log: ensure writes are atomic (thanks Roger Peppe).
+* path: Windows support for Split (thanks Benny Siegert).
+* runtime: fix SysFree to really free memory on Windows (thanks Alex Brainman),
+ parallel definitions in Go for all C structs.
+* sort: avoid overflow in pivot calculation,
+ reduced stack depth to lg(n) in quickSort (thanks Stefan Nilsson).
+* strconv: Atof on Infs and NaNs.
+</pre>
+
+<h2 id="2010-11-23">2010-11-23</h2>
+
+<pre>
+This release includes a backwards-incompatible package change to the
+sort.Search function (introduced in the last release).
+See the change for details and examples of how you might change your code:
+ http://code.google.com/p/go/source/detail?r=102866c369
+
+* build: automatically #define _64BIT in 6c.
+* cgo: print required space after parameter name in wrapper function.
+* crypto/cipher: new package to replace crypto/block (thanks Adam Langley).
+* crypto/elliptic: new package, implements elliptic curves over prime fields (thanks Adam Langley).
+* crypto/x509: policy OID support and fixes (thanks Adam Langley).
+* doc: add link to codewalks,
+ fix recover() documentation (thanks Anschel Schaffer-Cohen),
+ explain how to write Makefiles for commands.
+* exec: enable more tests on windows (thanks Alex Brainman).
+* gc: adjustable hash code in typecheck of composite literals
+ (thanks to vskrap, Andrey Mirtchovski, and Eoghan Sherry).
+* gc: better error message for bad type in channel send (thanks Anthony Martin).
+* godoc: bug fix in relativePath,
+ compute search index for all file systems under godoc's observation,
+ use correct time stamp to indicate accuracy of search result.
+* index/suffixarray: use sort.Search.
+* net: add ReadFrom and WriteTo windows version (thanks Wei Guangjing).
+* reflect: remove unnecessary casts in Get methods.
+* rpc: add RegisterName to allow override of default type name.
+* runtime: free memory allocated by windows CommandLineToArgv (thanks Alex Brainman).
+* sort: simplify Search (thanks Roger Peppe).
+* strings: add LastIndexAny (thanks Benny Siegert).
+</pre>
+
+<h2 id="2010-11-10">2010-11-10</h2>
+
+<pre>
+The birthday release includes a new Search capability inside the sort package.
+It takes an unusual but very general and easy-to-use approach to searching
+arbitrary indexable sorted data. See the documentation for details:
+ http://golang.org/pkg/sort/#Search
+
+The ARM port now uses the hardware floating point unit (VFP). It still has a
+few bugs, mostly around conversions between unsigned integer and floating-point
+values, but it's stabilizing.
+
+In addition, there have been many smaller fixes and updates:
+
+* 6l: generate dwarf variable names with disambiguating suffix.
+* container/list: make Remove return Value of removed element.
+ makes it easier to remove first or last item.
+* crypto: add cast5 (default PGP cipher),
+ switch block cipher methods to be destination first.
+* crypto/tls: use pool building for certificate checking
+* go/ast: change embedded token.Position fields to named fields
+ (preparation for a different position representation)
+* net: provide public access to file descriptors (thanks Keith Rarick)
+* os: add Expand function to evaluate environment variables.
+* path: add Glob (thanks Benny Siegert)
+* runtime: memequal optimization (thanks Graham Miller)
+ prefix all external symbols with "runtime·" to avoid
+ conflicts linking with external C libraries.
+</pre>
+
+<h2 id="2010-11-02">2010-11-02</h2>
+
+<pre>
+This release includes a language change: the new built-in function, append.
+Append makes growing slices much simpler. See the spec for details:
+ http://golang.org/doc/go_spec.html#Appending_and_copying_slices
+
+Other changes:
+* 8l: pe generation fixes (thanks Alex Brainman).
+* doc: Effective Go: append and a few words about "..." args.
+* build: fiddle with make variables.
+* codereview: fix sync and download in Python 2.7 (thanks Fazlul Shahriar).
+* debug/pe, cgo: add windows support (thanks Wei Guangjing).
+* go/ast: add Inspect function for easy AST inspection w/o a visitor.
+* go/printer: do not remove parens around composite literals starting with
+ a type name in control clauses.
+* go/scanner: bug fixes, revisions, and more tests.
+* gob: several fixes and documentation updates.
+* godoc: bug fix (bug introduced with revision 3ee58453e961).
+* gotest: print empty benchmark list in a way that gofmt will leave alone.
+* http server: correctly respond with 304 NotModified (thanks Michael Hoisie).
+* kate: update list of builtins (thanks Evan Shaw).
+* libutf: update to Unicode 5.2.0 to match pkg/unicode (thanks Anthony Martin).
+* misc/bbedit: update list of builtins (thanks Anthony Starks).
+* misc/vim: update list of builtins.
+* mkrunetype: install a Makefile and tweak it slightly so it can be built.
+* netchan: fix locking bug.
+* pidigits: minor improvements (thanks Evan Shaw).
+* rpc: fix client deadlock bug.
+* src: use append where appropriate (often instead of vector).
+* strings: add Contains helper function (thanks Brad Fitzpatrick).
+* syscall: SIO constants for Linux (thanks Albert Strasheim),
+ Stat(path) on windows (thanks Alex Brainman).
+* test/ken/convert.go: add conversion torture test.
+* testing: add Benchmark (thanks Roger Peppe).
+</pre>
+
+<h2 id="2010-10-27">2010-10-27</h2>
+
+<pre>
+*** This release changes the encoding used by package gob.
+ If you store gobs on disk, see below. ***
+
+The ARM port (5g) now passes all tests. The optimizer is not yet enabled, and
+floating point arithmetic is performed entirely in software. Work is underway
+to address both of these deficiencies.
+
+The syntax for arrays, slices, and maps of composite literals has been
+simplified. Within a composite literal of array, slice, or map type, elements
+that are themselves composite literals may elide the type if it is identical to
+the outer literal's element type. For example, these expressions:
+ [][]int{[]int{1, 2, 3}, []int{4, 5}}
+ map[string]Point{"x": Point{1.5, -3.5}, "y": Point{0, 0}}
+can be simplified to:
+ [][]int{{1, 2, 3}, {4, 5}}
+ map[string]Point{"x": {1.5, -3.5}, "y": {0, 0}}
+Gofmt can make these simplifications mechanically when invoked with the
+new -s flag.
+
+The built-in copy function can now copy bytes from a string value to a []byte.
+Code like this (for []byte b and string s):
+ for i := 0; i < len(s); i++ {
+ b[i] = s[i]
+ }
+can be rewritten as:
+ copy(b, s)
+
+The gob package can now encode and decode interface values containing types
+registered ahead of time with the new Register function. These changes required
+a backwards-incompatible change to the wire format. Data written with the old
+version of the package will not be readable with the new one, and vice versa.
+(Steps were made in this change to make sure this doesn't happen again.)
+We don't know of anyone using gobs to create permanent data, but if you do this
+and need help converting, please let us know, and do not update to this release
+yet. We will help you convert your data.
+
+Other changes:
+* 5g, 6g, 8g: generate code for string index instead of calling function.
+* 5l, 6l, 8l: introduce sub-symbols.
+* 6l/8l: global and local variables and type info.
+* Make.inc: delete unnecessary -fno-inline flag to quietgcc.
+* arm: precise float64 software floating point, bug fixes.
+* big: arm assembly, faster software mulWW, divWW.
+* build: only print "You need to add foo to PATH" when needed.
+* container/list: fix Remove bug and use pointer to self as identifier.
+* doc: show page title in browser title bar,
+ update roadmap.
+* encoding/binary: give LittleEndian, BigEndian specific types.
+* go/parser: consume auto-inserted semi when calling ParseExpr().
+* gobuilder: pass GOHOSTOS and GOHOSTARCH to build,
+ write build and benchmarking logs to disk.
+* goinstall: display helpful message when encountering a cgo package,
+ fix test for multiple package names (thanks Fazlul Shahriar).
+* gotest: generate correct gofmt-formatted _testmain.go.
+* image/png: speed up paletted encoding ~25% (thanks Brad Fitzpatrick).
+* misc: update python scripts to specify python2 as python3 is now "python".
+* net: fix comment on Dial to mention unix/unixgram.
+* rpc: expose Server type to allow multiple RPC Server instances.
+* runtime: print unknown types in panic.
+* spec: append built-in (not yet implemented).
+* src: gofmt -s -w src misc.
+ update code to use copy-from-string.
+* test/bench: update numbers.
+* websocket: fix short Read.
+</pre>
+
+<h2 id="2010-10-20">2010-10-20</h2>
+
+<pre>
+This release removes the log package's deprecated functions.
+Code that has not been updated to use the new interface will break.
+See the previous release notes for details:
+ http://golang.org/doc/devel/release.html#2010-10-13
+
+Also included are major improvements to the linker. It is now faster,
+uses less memory, and more parallelizable (but not yet parallel).
+
+The nntp package has been removed from the standard library.
+Its new home is the nntp-go project at Google Code:
+ http://code.google.com/p/nntp-go
+You can install it with goinstall:
+ goinstall nntp-go.googlecode.com/hg/nntp
+And import it in your code like so:
+ import "nntp-go.googlecode.com/hg/nntp"
+
+Other changes:
+* 6g: avoid too-large immediate constants.
+* 8l, runtime: initial support for Plan 9 (thanks Yuval Pavel Zholkover).
+* 6l, 8l: more improvements on exporting debug information (DWARF).
+* arm: code gen fixes. Most tests now pass, except for floating point code.
+* big: add random number generation (thanks Florian Uekermann).
+* gc: keep track of real actual type of identifiers,
+ report that shift must be unsigned integer,
+ select receive with implicit conversion.
+* goplay: fix to run under windows (thanks Yasuhiro Matsumoto).
+* http: do not close connection after sending HTTP/1.0 request.
+* netchan: add new method Hangup to terminate transmission on a channel.
+* os: change TestForkExec so it can run on windows (thanks Yasuhiro Matsumoto).
+* runtime: don't let select split stack.
+* syscall/arm: correct 64-bit system call arguments.
+</pre>
+
+<h2 id="2010-10-13">2010-10-13</h2>
+
+<pre>
+This release includes changes to the log package, the removal of exp/iterable,
+two new tools (gotry and goplay), one small language change, and many other
+changes and fixes. If you use the log or iterable packages, you need to make
+changes to your code.
+
+The log package has changed. Loggers now have only one output, and output to
+standard error by default. The names have also changed, although the old names
+are still supported. They will be deleted in the next release, though, so it
+would be good to update now if you can. For most purposes all you need to do
+is make these substitutions:
+ log.Stderr -> log.Println or log.Print
+ log.Stderrf -> log.Printf
+ log.Crash -> log.Panicln or log.Panic
+ log.Crashf -> log.Panicf
+ log.Exit -> log.Exitln or log.Exit
+ log.Exitf -> log.Exitf (no change)
+Calls to log.New() must drop the second argument.
+Also, custom loggers with exit or panic properties will need to be reworked.
+For full details, see the change description:
+ http://code.google.com/p/go/source/detail?r=d8a3c7563d
+
+The language change is that uses of pointers to interface values no longer
+automatically dereference the pointer. A pointer to an interface value is more
+often a beginner's bug than correct code.
+
+The package exp/iterable has been removed. It was an interesting experiment,
+but it encourages writing inefficient code and has outlived its utility.
+
+The new tools:
+* gotry: an exercise in reflection and an unusual tool. Run 'gotry' for details.
+* goplay: a stand-alone version of the Go Playground. See misc/goplay.
+
+Other changes:
+* 6l: Mach-O fixes, and fix to work with OS X nm/otool (thanks Jim McGrath).
+* [568]a: correct line numbers for statements.
+* arm: code generation and runtime fixes,
+ adjust recover for new reflect.call,
+ enable 6 more tests after net fix.
+* big: fix panic and round correctly in Rat.FloatString (thanks Anthony Martin).
+* build: Make.cmd: remove $(OFILES) (thanks Eric Clark),
+ Make.pkg: remove .so before installing new one,
+ add GOHOSTOS and GOHOSTARCH environment variables.
+* crypto/tls: better error messages for certificate issues,
+ make SetReadTimeout work.
+* doc: add Sydney University video,
+ add The Expressiveness of Go talk.
+* exp/draw/x11: support X11 vendors other than "The X.Org Foundation".
+* expvar: add (*Int).Set (thanks Sam Thorogood).
+* fmt: add Errorf helper function,
+ allow %d on []byte.
+* gc: O(1) string comparison when lengths differ,
+ various bug fixes.
+* http: return the correct error if a header line is too long.
+* image: add image.Tiled type, the Go equivalent of Plan 9's repl bit.
+* ld: be less picky about bad line number info.
+* misc/cgo/life: fix for new slice rules (thanks Graham Miller).
+* net: allow _ in DNS names.
+* netchan: export before import when testing, and
+ zero out request to ensure correct gob decoding. (thanks Roger Peppe).
+* os: make tests work on windows (thanks Alex Brainman).
+* runtime: bug fix: serialize mcache allocation,
+ correct iteration of large map values,
+ faster strequal, memequal (thanks Graham Miller),
+ fix argument dump in traceback,
+ fix tiny build.
+* smtp: new package (thanks Evan Shaw).
+* syscall: add sockaddr_ll support for linux/386, linux/amd64 (thanks Mikio Hara),
+ add ucred structure for SCM_CREDENTIALS over UNIX sockets. (thanks Albert Strasheim).
+* syscall: implement WaitStatus and Wait4() for windows (thanks Wei Guangjing).
+* time: add After.
+* websocket: enable tests on windows (thanks Alex Brainman).
+</pre>
+
+<h2 id="2010-09-29">2010-09-29</h2>
+
+<pre>
+This release includes some minor language changes and some significant package
+changes. You may need to change your code if you use ...T parameters or the
+http package.
+
+The semantics and syntax of forwarding ...T parameters have changed.
+ func message(f string, s ...interface{}) { fmt.Printf(f, s) }
+Here, s has type []interface{} and contains the parameters passed to message.
+Before this language change, the compiler recognized when a function call
+passed a ... parameter to another ... parameter of the same type, and just
+passed it as though it was a list of arguments. But this meant that you
+couldn't control whether to pass the slice as a single argument and you
+couldn't pass a regular slice as a ... parameter, which can be handy. This
+change gives you that control at the cost of a few characters in the call.
+If you want the promotion to ..., append ... to the argument:
+ func message(f string, s ...interface{}) { fmt.Printf(f, s...) }
+Without the ..., s would be passed to Printf as a single argument of type
+[]interface{}. The bad news is you might need to fix up some of your code,
+but the compiler will detect the situation and warn you.
+
+Also, the http.Handler and http.HandlerFunc types have changed. Where http
+handler functions previously accepted an *http.Conn, they now take an interface
+type http.ResponseWriter. ResponseWriter implements the same methods as *Conn,
+so in most cases the only change required will be changing the type signature
+of your handler function's first parameter. See:
+ http://golang.org/pkg/http/#Handler
+
+The utf8 package has a new type, String, that provides efficient indexing
+into utf8 strings by rune (previously an expensive conversion to []int
+was required). See:
+ http://golang.org/pkg/utf8/#String
+
+The compiler will now automatically insert a semicolon at the end of a file if
+one is not found. This effect of this is that Go source files are no longer
+required to have a trailing newline.
+
+Other changes:
+* 6prof: more accurate usage message.
+* archive/zip: new package for reading Zip files.
+* arm: fix code generation, 10 more package tests pass.
+* asn1: make interface consistent with json.
+* bufio.UnreadRune: fix bug at EOF.
+* build: clear custom variables like GREP_OPTIONS,
+ silence warnings generated by ubuntu gcc,
+ use full path when compiling libraries.
+* bytes, strings: change lastIndexFunc to use DecodeLastRune (thanks Roger Peppe).
+* doc: add to and consolidate non-english doc references,
+ consolidate FAQs into a single file, go_faq.html,
+ updates for new http interface.
+* fmt/Printf: document and tweak error messages produced for bad formats.
+* gc: allow select case expr = <-c,
+ eliminate duplicates in method table,
+ fix reflect table method receiver,
+ improve error message for x \= 0.
+* go/scanner: treat EOF like a newline for purposes of semicolon insertion.
+* gofmt: stability improvements.
+* gotest: leave _testmain.go for "make clean" to clean up.
+* http: correct escaping of different parts of URL,
+ support HTTP/1.0 Keep-Alive.
+* json: do not write to unexported fields.
+* libcgo: don't build for NaCl,
+ set g, m in thread local storage for windows 386 (thanks Wei Guangjing).
+* math: Fix off-by-one error in Ilogb and Logb. (thanks Charles L. Dorian).
+* misc/dashboard/builder: remove build files after benchmarking.
+* nacl: update instructions for new SDK.
+* net: enable v4-over-v6 on ip sockets,
+ fix crash in DialIP.
+* os: check for valid arguments in windows Readdir (thanks Peter Mundy).
+* runtime: add mmap of null page just in case,
+ correct stats in SysFree,
+ fix unwindstack crash.
+* syscall: add IPPROTO_IPV6 and IPV6_V6ONLY const to fix nacl and windows build,
+ add inotify on Linux (thanks Balazs Lecz),
+ fix socketpair in syscall_bsd,
+ fix windows value of IPV6_V6ONLY (thanks Alex Brainman),
+ implement windows version of Utimes (thanks Alex Brainman),
+ make mkall.sh work for nacl.
+* test: Add test that causes incorrect error from gccgo.
+* utf8: add DecodeLastRune and DecodeLastRuneInString (thanks Roger Peppe).
+* xml: Allow entities inside CDATA tags (thanks Dan Sinclair).
+</pre>
+
+<h2 id="2010-09-22">2010-09-22</h2>
+
+<pre>
+This release includes new package functionality, and many bug fixes and changes.
+It also improves support for the arm and nacl platforms.
+
+* 5l: avoid fixed buffers in list.
+* 6l, 8l: clean up ELF code, fix NaCl.
+* 6l/8l: emit DWARF frame info.
+* Make.inc: make GOOS detection work on windows (thanks Alex Brainman).
+* build: fixes for native arn build,
+ make all.bash run on Ubuntu ARM.
+* cgo: bug fixes,
+ show preamble gcc errors (thanks Eric Clark).
+* crypto/x509, crypto/tls: improve root matching and observe CA flag.
+* crypto: Fix certificate validation.
+* doc: variable-width layout.
+* env.bash: fix building in directory with spaces in the path (thanks Alex Brainman).
+* exp/4s, exp/nacl/av: sync to recent exp/draw changes.
+* exp/draw/x11: mouse location is a signed integer.
+* exp/nacl/av: update color to max out at 1<<16-1 instead of 1<<32-1.
+* fmt: support '*' for width or precision (thanks Anthony Martin).
+* gc: improvements to static initialization,
+ make sure path names are canonical.
+* gob: make robust when decoding a struct with non-struct data.
+* gobuilder: add -cmd for user-specified build command,
+ add -rev= flag to build specific revision and exit,
+ fix bug that caused old revisions to be rebuilt.
+* godoc: change default filter file name to "",
+ don't use quadratic algorithm to filter paths,
+ show "Last update" info for directory listings.
+* http: new redirect test,
+ URLEscape now escapes all reserved characters as per the RFC.
+* nacl: fix zero-length writes.
+* net/dict: parse response correctly (thanks Fazlul Shahriar).
+* netchan: add a cross-connect test,
+ handle closing of channels,
+ provide a method (Importer.Errors()) to recover protocol errors.
+* os: make Open() O_APPEND flag work on windows (thanks Alex Brainman),
+ make RemoveAll() work on windows (thanks Alex Brainman).
+* pkg/Makefile: disable netchan test to fix windows build (thanks Alex Brainman).
+* regexp: delete Iter methods.
+* runtime: better panic for send to nil channel.
+* strings: fix minor bug in LastIndexFunc (thanks Roger Peppe).
+* suffixarray: a package for creating suffixarray-based indexes.
+* syscall: Use vsyscall for syscall.Gettimeofday and .Time on linux amd64.
+* test: fix NaCl build.
+* windows: fix netchan test by using 127.0.0.1.
+</pre>
+
+<h2 id="2010-09-15">2010-09-15</h2>
+
+<pre>
+This release includes a language change: the lower bound of a subslice may
+now be omitted, in which case the value will default to 0.
+For example, s[0:10] may now be written as s[:10], and s[0:] as s[:].
+
+The release also includes important bug fixes for the ARM architecture,
+as well as the following fixes and changes:
+
+* 5g: register allocation bugs
+* 6c, 8c: show line numbers in -S output
+* 6g, 6l, 8g, 8l: move read-only data to text segment
+* 6l, 8l: make etext accurate; introduce rodata, erodata.
+* arm: fix build bugs.
+ make libcgo build during OS X cross-compile
+ remove reference to deleted file syntax/slice.go
+ use the correct stat syscalls
+ work around reg allocator bug in 5g
+* bufio: add UnreadRune.
+* build: avoid bad environment interactions
+ fix build for tiny
+ generate, clean .exe files on Windows (thanks Joe Poirier)
+ test for _WIN32, not _MINGW32 (thanks Joe Poirier)
+ work with GNU Make 3.82 (thanks Jukka-Pekka Kekkonen)
+* cgo: add typedef for uintptr in generated headers
+ silence warning for C call returning const pointer
+* codereview: convert email address to lower case before checking CONTRIBUTORS
+* crypto/tls: don't return an error from Close()
+* doc/tutorial: update for slice changes.
+* exec: separate LookPath implementations for unix/windows (thanks Joe Poirier)
+* exp/draw/x11: allow clean shutdown when the user closes the window.
+* exp/draw: clip destination rectangle to the image bounds.
+ fast path for drawing overlapping image.RGBAs.
+ fix double-counting of pt.Min for the src and mask points.
+ reintroduce the MouseEvent.Nsec timestamp.
+ rename Context to Window, and add a Close method.
+* exp/debug: preliminary support for 'copy' function (thanks Sebastien Binet)
+* fmt.Fscan: use UnreadRune to preserve data across calls.
+* gc: better printing of named constants, func literals in errors
+ many bug fixes
+ fix line number printing with //line directives
+ fix symbol table generation on windows (thanks Alex Brainman)
+ implement comparison rule from spec change 33abb649cb63
+ implement new slice spec (thanks Scott Lawrence)
+ make string x + y + z + ... + w efficient
+ more accurate line numbers for ATEXT
+ remove &[10]int -> []int conversion
+* go-mode.el: fix highlighting for 'chan' type (thanks Scott Lawrence)
+* godoc: better support for directory trees for user-supplied paths
+ use correct delay time (bug fix)
+* gofmt, go/printer: update internal estimated position correctly
+* goinstall: warn when package name starts with http:// (thanks Scott Lawrence)
+* http: check https certificate against host name
+ do not cache CanonicalHeaderKey (thanks Jukka-Pekka Kekkonen)
+* image: change a ColorImage's minimum point from (0, 0) to (-1e9, -1e9).
+ introduce Intersect and Union rectangle methods.
+* ld: handle quoted spaces in package path (thanks Dan Sinclair)
+* libcgo: fix NaCl build.
+* libmach: fix build on arm host
+ fix new thread race with Linux
+* math: make portable Tan(Pi/2) return NaN
+* misc/dashboard/builder: gobuilder, a continuous build client
+* net: disable tests for functions not available on windows (thanks Alex Brainman)
+* netchan: make -1 unlimited, as advertised.
+* os, exec: rename argv0 to name
+* path: add IsAbs (thanks Ivan Krasin)
+* runtime: fix bug in tracebacks
+ fix crash trace on amd64
+ fix windows build (thanks Alex Brainman)
+ use manual stack for garbage collection
+* spec: add examples for slices with omitted index expressions.
+ allow omission of low slice bound (thanks Scott Lawrence)
+* syscall: fix windows Gettimeofday (thanks Alex Brainman)
+* test(arm): disable zerodivide.go because compilation fails.
+* test(windows): disable tests that cause the build to fail (thanks Joe Poirier)
+* test/garbage/parser: sync with recent parser changes
+* test: Add test for //line
+ Make gccgo believe that the variables can change.
+ Recognize gccgo error messages.
+ Reduce race conditions in chan/nonblock.go.
+ Run garbage collector before testing malloc numbers.
+* websocket: Add support for secure WebSockets (thanks Jukka-Pekka Kekkonen)
+* windows: disable unimplemented tests (thanks Joe Poirier)
+</pre>
+
+<h2 id="2010-09-06">2010-09-06</h2>
+
+<pre>
+This release includes the syntactic modernization of more than 100 files in /test,
+and these additions, changes, and fixes:
+* 6l/8l: emit DWARF in macho.
+* 8g: use FCHS, not FMUL, for minus float.
+* 8l: emit DWARF in ELF,
+ suppress emitting DWARF in Windows PE (thanks Alex Brainman).
+* big: added RatString, some simplifications.
+* build: create bin and pkg directories as needed; drop from hg,
+ delete Make.386 Make.amd64 Make.arm (obsoleted by Make.inc),
+ fix cgo with -j2,
+ let pkg/Makefile coordinate building of Go commands,
+ never use quietgcc in Make.pkg,
+ remove more references to GOBIN and GOROOT (thanks Christian Himpel).
+* codereview: Fix uploading for Mercurial 1.6.3 (thanks Evan Shaw),
+ consistent indent, cut dead code,
+ fix hang on standard hg commands,
+ print status when tasks take longer than 30 seconds,
+ really disable codereview when not available,
+ upload files in parallel (5x improvement on large CLs).
+* crypto/hmac: make Sum idempotent (thanks Jukka-Pekka Kekkonen).
+* doc: add links to more German docs,
+ add round-robin flag to io2010 balance example,
+ fix a bug in the example in Constants subsection (thanks James Fysh),
+ various changes for validating HTML (thanks Scott Lawrence).
+* fmt: delete erroneous sentence about return value for Sprint*.
+* gc: appease bison version running on FreeBSD builder,
+ fix spurious syntax error.
+* go/doc: use correct escaper for URL.
+* go/printer: align ImportPaths in ImportDecls (thanks Scott Lawrence).
+* go/typechecker: 2nd step towards augmenting AST with full type information.
+* gofmt: permit omission of first index in slice expression.
+* goinstall: added -a flag to mean "all remote packages" (thanks Scott Lawrence),
+ assume go binaries are in path (following new convention),
+ use https for Google Code checkouts.
+* gotest: allow make test of cgo packages (without make install).
+* http: add Date to server, Last-Modified and If-Modified-Since to file server,
+ add PostForm function to post url-encoded key/value data,
+ obscure passwords in return value of URL.String (thanks Scott Lawrence).
+* image: introduce Config type and DecodeConfig function.
+* libcgo: update Makefile to use Make.inc.
+* list: update comment to state that the zero value is ready to use.
+* math: amd64 version of Sincos (thanks Charles L. Dorian).
+* misc/bash: add *.go completion for gofmt (thanks Scott Lawrence).
+* misc/emacs: make _ a word symbol (thanks Scott Lawrence).
+* misc: add zsh completion (using compctl),
+ syntax highlighting for Fraise.app (OS X) (thanks Vincent Ambo).
+* net/textproto: Handle multi-line responses (thanks Evan Shaw).
+* net: add LookupMX (thanks Corey Thomasson).
+* netchan: Fix race condition in test,
+ rather than 0, make -1 mean infinite (a la strings.Split et al),
+ use acknowledgements on export send.
+ new methods Sync and Drain for clean teardown.
+* regexp: interpret all Go characer escapes \a \b \f \n \r \t \v.
+* rpc: fix bug that caused private methods to attempt to be registered.
+* runtime: Correct commonType.kind values to match compiler,
+ add GOOS, GOARCH; fix FuncLine,
+ special case copy, equal for one-word interface values (thanks Kyle Consalus).
+* scanner: fix incorrect reporting of error in Next (thanks Kyle Consalus).
+* spec: clarify that arrays must be addressable to be sliceable.
+* template: fix space handling around actions.
+* test/solitaire: an exercise in backtracking and string conversions.
+* test: Recognize gccgo error messages and other fixes.
+* time: do not crash in String on nil Time.
+* tutorial: regenerate HTML to pick up change to progs/file.go.
+* websocket: fix missing Sec-WebSocket-Protocol on server response (thanks Jukka-Pekka Kekkonen).
+</pre>
+
+<h2 id="2010-08-25">2010-08-25</h2>
+
+<pre>
+This release includes changes to the build system that will likely require you
+to make changes to your environment variables and Makefiles.
+
+All environment variables are now optional:
+ - $GOOS and $GOARCH are now optional; their values should now be inferred
+ automatically by the build system,
+ - $GOROOT is now optional, but if you choose not to set it you must run
+ 'gomake' instead of 'make' or 'gmake' when developing Go programs
+ using the conventional Makefiles,
+ - $GOBIN remains optional and now defaults to $GOROOT/bin;
+ if you wish to use this new default, make sure it is in your $PATH
+ and that you have removed the existing binaries from $HOME/bin.
+
+As a result of these changes, the Go Makefiles have changed. If your Makefiles
+inherit from the Go Makefiles, you must change this line:
+ include ../../Make.$(GOARCH)
+to this:
+ include ../../Make.inc
+
+This release also removes the deprecated functions in regexp and the
+once package. Any code that still uses them will break.
+See the notes from the last release for details:
+ http://golang.org/doc/devel/release.html#2010-08-11
+
+Other changes:
+* 6g: better registerization for slices, strings, interface values
+* 6l: line number information in DWARF format
+* build: $GOBIN defaults to $GOROOT/bin,
+ no required environment variables
+* cgo: add C.GoStringN (thanks Eric Clark).
+* codereview: fix issues with leading tabs in CL descriptions,
+ do not send "Abandoned" mail if the CL has not been mailed.
+* crypto/ocsp: add missing Makefile.
+* crypto/tls: client certificate support (thanks Mikkel Krautz).
+* doc: update gccgo information for recent changes.
+ fix errors in Effective Go.
+* fmt/print: give %p priority, analogous to %T,
+ honor Formatter in Print, Println.
+* gc: fix parenthesization check.
+* go/ast: facility for printing AST nodes,
+ first step towards augmenting AST with full type information.
+* go/printer: do not modify tabwriter.Escape'd text.
+* gofmt: do not modify multi-line string literals,
+ print AST nodes by setting -ast flag.
+* http: fix typo in http.Request documentation (thanks Scott Lawrence)
+ parse query string always, not just in GET
+* image/png: support 16-bit color.
+* io: ReadAtLeast now errors if min > len(buf).
+* jsonrpc: use `error: null` for success, not `error: ""`.
+* libmach: implement register fetch for 32-bit x86 kernel.
+* net: make IPv6 String method standards-compliant (thanks Mikio Hara).
+* os: FileInfo.Permission() now returns uint32 (thanks Scott Lawrence),
+ implement env using native Windows API (thanks Alex Brainman).
+* reflect: allow PtrValue.PointTo(nil).
+* runtime: correct line numbers for .goc files,
+ fix another stack split bug,
+ fix freebsd/386 mmap.
+* syscall: regenerate syscall/z* files for linux/386, linux/amd64, linux/arm.
+* tabwriter: Introduce a new flag StripEscape.
+* template: fix handling of space around actions,
+ vars preceded by white space parse correctly (thanks Roger Peppe).
+* test: add test case that crashes gccgo.
+* time: parse no longer requires minutes for time zone (thanks Jan H. Hosang)
+* yacc: fix bounds check in error recovery.
+</pre>
+
+<h2 id="2010-08-11">2010-08-11</h2>
+
+<pre>
+This release introduces some package changes. You may need to change your
+code if you use the once, regexp, image, or exp/draw packages.
+
+The type Once has been added to the sync package. The new sync.Once will
+supersede the functionality provided by the once package. We intend to remove
+the once package after this release. See:
+ http://golang.org/pkg/sync/#Once
+All instances of once in the standard library have been replaced with
+sync.Once. Reviewing these changes may help you modify your existing code.
+The relevant changeset:
+ http://code.google.com/p/go/source/detail?r=fa2c43595119
+
+A new set of methods has been added to the regular expression package, regexp.
+These provide a uniformly named approach to discovering the matches of an
+expression within a piece of text; see the package documentation for details:
+ http://golang.org/pkg/regexp/
+These new methods will, in a later release, replace the old methods for
+matching substrings. The following methods are deprecated:
+ Execute (use FindSubmatchIndex)
+ ExecuteString (use FindStringSubmatchIndex)
+ MatchStrings(use FindStringSubmatch)
+ MatchSlices (use FindSubmatch)
+ AllMatches (use FindAll; note that n<0 means 'all matches'; was n<=0)
+ AllMatchesString (use FindAllString; note that n<0 means 'all matches'; was n<=0)
+(Plus there are ten new methods you didn't know you wanted.)
+Please update your code to use the new routines before the next release.
+
+An image.Image now has a Bounds rectangle, where previously it ranged
+from (0, 0) to (Width, Height). Loops that previously looked like:
+ for y := 0; y < img.Height(); y++ {
+ for x := 0; x < img.Width(); x++ {
+ // Do something with img.At(x, y)
+ }
+ }
+should instead be:
+ b := img.Bounds()
+ for y := b.Min.Y; y < b.Max.Y; y++ {
+ for x := b.Min.X; x < b.Max.X; x++ {
+ // Do something with img.At(x, y)
+ }
+ }
+The Point and Rectangle types have also moved from exp/draw to image.
+
+Other changes:
+* arm: bugfixes and syscall (thanks Kai Backman).
+* asn1: fix incorrect encoding of signed integers (thanks Nicholas Waples).
+* big: fixes to bitwise functions (thanks Evan Shaw).
+* bytes: add IndexRune, FieldsFunc and To*Special (thanks Christian Himpel).
+* encoding/binary: add complex (thanks Roger Peppe).
+* exp/iterable: add UintArray (thanks Anschel Schaffer-Cohen).
+* godoc: report Status 404 if a pkg or file is not found.
+* gofmt: better reporting for unexpected semicolon errors.
+* html: new package, an HTML tokenizer.
+* image: change image representation from slice-of-slices to linear buffer,
+ introduce Decode and RegisterFormat,
+ introduce Transparent and Opaque,
+ replace Width and Height by Bounds, add the Point and Rect types.
+* libbio: fix Bprint to address 6g issues with large data structures.
+* math: fix amd64 Hypot (thanks Charles L. Dorian).
+* net/textproto: new package, with example net/dict.
+* os: fix ForkExec() handling of envv == nil (thanks Alex Brainman).
+* png: grayscale support (thanks Mathieu Lonjaret).
+* regexp: document that backslashes are the escape character.
+* rpc: catch errors from ReadResponseBody.
+* runtime: memory free fix (thanks Alex Brainman).
+* template: add ParseFile method to template.Template.
+* test/peano: use directly recursive type def.
+</pre>
+
+<h2 id="2010-08-04">2010-08-04</h2>
+
+<pre>
+This release includes a change to os.Open (and co.). The file permission
+argument has been changed to a uint32. Your code may require changes - a simple
+conversion operation at most.
+
+Other changes:
+* amd64: use segment memory for thread-local storage.
+* arm: add gdb support to android launcher script,
+ bugfixes (stack clobbering, indices),
+ disable another flaky test,
+ remove old qemu dependency from gotest.
+* bufio: introduce Peek.
+* bytes: added test case for explode with blank string (thanks Scott Lawrence).
+* cgo: correct multiple return value function invocations (thanks Christian Himpel).
+* crypto/x509: unwrap Subject Key Identifier (thanks Adam Langley).
+* gc: index bounds tests and other fixes.
+* gofmt/go/parser: strengthen syntax checks.
+* goinstall: check for error from exec.*Cmd.Wait() (thanks Alex Brainman).
+* image/png: use image-specific methods for checking opacity.
+* image: introduce Gray and Gray16 types,
+ remove the named colors except for Black and White.
+* json: object members must have a value (thanks Anthony Martin).
+* misc/vim: highlight misspelled words only in comments (thanks Christian Himpel).
+* os: Null device (thanks Peter Mundy).
+* runtime: do not fall through in SIGBUS/SIGSEGV.
+* strings: fix Split("", "", -1) (thanks Scott Lawrence).
+* syscall: make go errors not clash with windows errors (thanks Alex Brainman).
+* test/run: diff old new,
+* websocket: correct challenge response (thanks Tarmigan Casebolt),
+ fix bug involving spaces in header keys (thanks Bill Neubauer).
+</pre>
+
+<h2 id="2010-07-29">2010-07-29</h2>
+
+<pre>
+* 5g: more soft float support and several bugfixes.
+* asn1: Enumerated, Flag and GeneralizedTime support.
+* build: clean.bash to check that GOOS and GOARCH are set.
+* bytes: add IndexFunc and LastIndexFunc (thanks Fazlul Shahriar),
+ add Title.
+* cgo: If CC is set in environment, use it rather than "gcc",
+ use new command line syntax: -- separates cgo flags from gcc flags.
+* codereview: avoid crash if no config,
+ don't run gofmt with an empty file list,
+ make 'hg submit' work with Mercurial 1.6.
+* crypto/ocsp: add package to parse OCSP responses.
+* crypto/tls: add client-side SNI support and PeerCertificates.
+* exp/bignum: delete package - functionality subsumed by package big.
+* fmt.Print: fix bug in placement of spaces introduced when ...T went in.
+* fmt.Scanf: handle trailing spaces.
+* gc: fix smaller-than-pointer-sized receivers in interfaces,
+ floating point precision/normalization fixes,
+ graceful exit on seg fault,
+ import dot shadowing bug,
+ many fixes including better handling of invalid input,
+ print error detail about failure to open import.
+* gccgo_install.html: add description of the port to RTEMS (thanks Vinu Rajashekhar).
+* gobs: fix bug in singleton arrays.
+* godoc: display synopses for all packages that have some kind of documentation..
+* gofmt: fix some linebreak issues.
+* http: add https client support (thanks Fazlul Shahriar),
+ write body when content length unknown (thanks James Whitehead).
+* io: MultiReader and MultiWriter (thanks Brad Fitzpatrick),
+ fix another race condition in Pipes.
+* ld: many fixes including better handling of invalid input.
+* libmach: correct handling of .5 files with D_REGREG addresses.
+* linux/386: use Xen-friendly ELF TLS instruction sequence.
+* mime: add AddExtensionType (thanks Yuusei Kuwana).
+* misc/vim: syntax file recognizes constants like 1e9 (thanks Petar Maymounkov).
+* net: TCPConn.SetNoDelay, back by popular demand.
+* net(windows): fix crashing Read/Write when passed empty slice on (thanks Alex Brainman),
+ implement LookupHost/Port/SRV (thanks Wei Guangjing),
+ properly handle EOF in (*netFD).Read() (thanks Alex Brainman).
+* runtime: fix bug introduced in revision 4a01b8d28570 (thanks Alex Brainman),
+ rename cgo2c, *.cgo to goc2c, *.goc (thanks Peter Mundy).
+* scanner: better comment.
+* strings: add Title.
+* syscall: add ForkExec, Syscall12 on Windows (thanks Daniel Theophanes),
+ improve windows errno handling (thanks Alex Brainman).
+* syscall(windows): fix FormatMessage (thanks Peter Mundy),
+ implement Pipe() (thanks Wei Guangjing).
+* time: fix parsing of minutes in time zones.
+* utf16(windows): fix cyclic dependency when testing (thanks Peter Mundy).
+</pre>
+
+<h2 id="2010-07-14">2010-07-14</h2>
+
+<pre>
+This release includes a package change. In container/vector, the Iter method
+has been removed from the Vector, IntVector, and StringVector types. Also, the
+Data method has been renamed to Copy to better express its actual behavior.
+Now that Vector is just a slice, any for loops ranging over v.Iter() or
+v.Data() can be changed to range over v instead.
+
+Other changes:
+* big: Improvements to Rat.SetString (thanks Evan Shaw),
+ add sign, abs, Rat.IsInt.
+* cgo: various bug fixes.
+* codereview: Fix for Mercurial >= 1.6 (thanks Evan Shaw).
+* crypto/rand: add Windows implementation (thanks Peter Mundy).
+* crypto/tls: make HTTPS servers easier,
+ add client OCSP stapling support.
+* exp/eval: converted from bignum to big (thanks Evan Shaw).
+* gc: implement new len spec, range bug fix, optimization.
+* go/parser: require that '...' parameters are followed by a type.
+* http: fix ParseURL to handle //relative_path properly.
+* io: fix SectionReader Seek to seek backwards (thanks Peter Mundy).
+* json: Add HTMLEscape (thanks Micah Stetson).
+* ld: bug fixes.
+* math: amd64 version of log (thanks Charles L. Dorian).
+* mime/multipart: new package to parse multipart MIME messages
+ and HTTP multipart/form-data support.
+* os: use TempFile with default TempDir for test files (thanks Peter Mundy).
+* runtime/tiny: add docs for additional VMs, fix build (thanks Markus Duft).
+* runtime: better error for send/recv on nil channel.
+* spec: clarification of channel close(),
+ lock down some details about channels and select,
+ restrict when len(x) is constant,
+ specify len/cap for nil slices, maps, and channels.
+* windows: append .exe to binary names (thanks Joe Poirier).
+</pre>
+
+<h2 id="2010-07-01">2010-07-01</h2>
+
+<pre>
+This release includes some package changes that may require changes to
+client code.
+
+The Split function in the bytes and strings packages has been changed.
+The count argument, which limits the size of the return, previously treated
+zero as unbounded. It now treats 0 as 0, and will return an empty slice.
+To request unbounded results, use -1 (or some other negative value).
+The new Replace functions in bytes and strings share this behavior.
+This may require you change your existing code.
+
+The gob package now allows the transmission of non-struct values at the
+top-level. As a result, the rpc and netchan packages have fewer restrictions
+on the types they can handle. For example, netchan can now share a chan int.
+
+The release also includes a Code Walk: "Share Memory By Communicating".
+It describes an idiomatic Go program that uses goroutines and channels:
+ http://golang.org/doc/codewalk/sharemem/
+
+There is now a Projects page on the Go Dashboard that lists Go programs,
+tools, and libraries:
+ http://godashboard.appspot.com/project
+
+Other changes:
+* 6a, 6l: bug fixes.
+* bytes, strings: add Replace.
+* cgo: use slash-free relative paths for .so references.
+* cmath: correct IsNaN for argument cmplx(Inf, NaN) (thanks Charles L. Dorian).
+* codereview: allow multiple email addresses in CONTRIBUTORS.
+* doc/codewalk: add Share Memory By Communicating.
+* exp/draw/x11: implement the mapping from keycodes to keysyms.
+* fmt: Printf: fix bug in handling of %#v, allow other verbs for slices
+ Scan: fix handling of EOFs.
+* gc: bug fixes and optimizations.
+* gob: add DecodeValue and EncodeValue,
+ add support for complex numbers.
+* goinstall: support for Bazaar+Launchpad (thanks Gustavo Niemeyer).
+* io/ioutil: add TempFile for Windows (thanks Peter Mundy).
+* ld: add -u flag to check safe bits; discard old -u, -x flags.
+* math: amd64 versions of Exp and Fabs (thanks Charles L. Dorian).
+* misc/vim: always override filetype detection for .go files.
+* net: add support for DNS SRV requests (thanks Kirklin McDonald),
+ initial attempt to implement Windows version (thanks Alex Brainman).
+* netchan: allow chan of basic types now that gob can handle such,
+ eliminate the need for a pointer value in Import and Export.
+* os/signal: only catch all signals if os/signal package imported.
+* regexp: bug fix: need to track whether match begins with fixed prefix.
+* rpc: allow non-struct args and reply (they must still be pointers).
+* runtime: bug fixes and reorganization.
+* strconv: fix bugs in floating-point and base 2 conversions
+* syscall: add syscall_bsd.go to zsycall_freebsd_386.go (thanks Peter Mundy),
+ add socketpair (thanks Ivan Krasin).
+* time: implement time zones for Windows (thanks Alex Brainman).
+* x509: support non-self-signed certs.
+</pre>
+
+<h2 id="2010-06-21">2010-06-21</h2>
+
+<pre>
+This release includes a language change. The "..." function parameter form is
+gone; "...T" remains. Typically, "...interface{}" can be used instead of "...".
+
+The implementation of Printf has changed in a way that subtly affects its
+handling of the fmt.Stringer interface. You may need to make changes to your
+code. For details, see:
+ https://groups.google.com/group/golang-nuts/msg/6fffba90a3e3dc06
+
+The reflect package has been changed. If you have code that uses reflect,
+it will need to be updated. For details, see:
+ https://groups.google.com/group/golang-nuts/msg/7a93d07c590e7beb
+
+Other changes:
+* 8l: correct test for sp == top of stack in 8l -K code.
+* asn1: allow '*' in PrintableString.
+* bytes.Buffer.ReadFrom: fix bug.
+* codereview: avoid exception in match (thanks Paolo Giarrusso).
+* complex divide: match C99 implementation.
+* exp/draw: small draw.drawGlyphOver optimization.
+* fmt: Print*: reimplement to switch on type first,
+ Scanf: improve error message when input does not match format.
+* gc: better error messages for interface failures, conversions, undefined symbols.
+* go/scanner: report illegal escape sequences.
+* gob: substitute slice for map.
+* goinstall: process dependencies for package main (thanks Roger Peppe).
+* gopack: add S flag to force marking a package as safe,
+ simplify go metadata code.
+* html: sync testdata/webkit to match WebKit tip.
+* http: reply to Expect 100-continue requests automatically (thanks Brad Fitzpatrick).
+* image: add an Alpha16 type.
+* ld: pad Go symbol table out to page boundary (fixes cgo crash).
+* misc/vim: reorganize plugin to be easier to use (thanks James Whitehead).
+* path: add Base, analogous to Unix basename.
+* pkg/Makefile: allow DISABLE_NET_TESTS=1 to disable network tests.
+* reflect: add Kind, Type.Bits, remove Int8Type, Int8Value, etc.
+* runtime: additional Windows support (thanks Alex Brainman),
+ correct fault for 16-bit divide on Leopard,
+ fix 386 signal handler bug.
+* strconv: add AtofN, FtoaN.
+* string: add IndexFunc and LastIndexFunc (thanks Roger Peppe).
+* syslog: use local network for tests.
+</pre>
+
+<h2 id="2010-06-09">2010-06-09</h2>
+
+<pre>
+This release contains many fixes and improvements, including several
+clarifications and consolidations to the Language Specification.
+
+The type checking rules around assignments and conversions are simpler but more
+restrictive: assignments no longer convert implicitly from *[10]int to []int
+(write x[0:] instead of &x), and conversions can no longer change the names of
+types inside composite types.
+
+The fmt package now includes flexible type-driven (fmt.Scan) and
+format-driven (fmt.Scanf) scanners for all basic types.
+
+* big: bug fix for Quo aliasing problem.
+* bufio: change ReadSlice to match description.
+* cgo: bug fixes.
+* doc: add Google I/O talk and programs,
+ codereview + Mercurial Queues info (thanks Peter Williams).
+* exp/draw: Draw fast paths for the Over operator,
+ add Rectangle.Eq and Point.In, fix Rectangle.Clip (thanks Roger Peppe).
+* fmt: Scan fixes and improvements.
+* gc: backslash newline is not a legal escape sequence in strings,
+ better error message when ~ operator is found,
+ fix export of complex types,
+ new typechecking rules.
+* go/parser: correct position of empty statement ';'.
+* gofmt: fix test script.
+* goinstall: use 'git pull' instead of 'git checkout' (thanks Michael Hoisie).
+* http: add Head function for making HTTP HEAD requests,
+ handle status 304 correctly.
+* image: add Opaque method to the image types.
+ make Color.RGBA return 16 bit color instead of 32 bit color.
+* io/ioutil: add TempFile.
+* math: Pow special cases and additional tests (thanks Charles L. Dorian).
+* netchan: improve closing and shutdown.
+* os: implement os.FileInfo.*time_ns for windows (thanks Alex Brainman).
+* os/signal: correct the regexp for finding Unix signal names (thanks Vinu Rajashekhar).
+* regexp: optimizations (thanks Kyle Consalus).
+* runtime: fix printing -Inf (thanks Evan Shaw),
+ finish pchw -> tiny, added gettime for tiny (thanks Daniel Theophanes).
+* spec: clean-ups and consolidation.
+* syscall: additional Windows compatibility fixes (thanks Alex Brainman).
+* test/bench: added regex-dna-parallel.go (thanks Kyle Consalus).
+* vector: type-specific Do functions now take f(type) (thanks Michael Hoisie).
+</pre>
+
+<h2 id="2010-05-27">2010-05-27</h2>
+
+<pre>
+A sizeable release, including standard library improvements and a slew of
+compiler bug fixes. The three-week interval was largely caused by the team
+preparing for Google I/O.
+
+* big: add Rat type (thanks Evan Shaw),
+ new features, much performance tuning, cleanups, and more tests.
+* bignum: deprecate by moving into exp directory.
+* build: allow MAKEFLAGS to be set outside the build scripts (thanks Christopher Wedgwood).
+* bytes: add Trim, TrimLeft, TrimRight, and generic functions (thanks Michael Hoisie).
+* cgo: fix to permit cgo callbacks from init code.
+* cmath: update range of Phase and Polar due to signed zero (thanks Charles L. Dorian).
+* codereview: work better with mq (thanks Peter Williams).
+* compress: renamings
+ NewDeflater -> NewWriter
+ NewInflater -> NewReader
+ Deflater -> Compressor
+ Inflater -> Decompressor
+* exp/draw/x11: respect $XAUTHORITY,
+ treat $DISPLAY the same way x-go-bindings does.
+* exp/draw: fast path for glyph images, other optimizations,
+ fix Rectangle.Canon (thanks Roger Peppe).
+* fmt: Scan, Scanln: Start of a simple scanning API in the fmt package,
+ fix Printf crash when given an extra nil argument (thanks Roger Peppe).
+* gc: better error when computing remainder of non-int (thanks Evan Shaw),
+ disallow middot in Go programs,
+ distinguish array, slice literal in error messages,
+ fix shift/reduce conflict in go.y export syntax,
+ fix unsafe.Sizeof on ideal constants,
+ handle use of builtin function outside function call,
+ many other bug fixes.
+* gob: add support for maps,
+ add test for indirect maps, slices, arrays.
+* godoc: collect package comments from all package files.
+* gofmt: don't lose mandatory semicolons,
+ exclude test w/ illegal syntax from test cases,
+ fix printing of labels.
+* http: prevent crash if remote server is not responding with "HTTP/".
+* json: accept escaped slash in string scanner (thanks Michael Hoisie),
+ fix array -> non-array decoding.
+* libmach: skip __nl_symbol_ptr section on OS X.
+* math: amd64 versions of Fdim, Fmax, Fmin,
+ signed zero Sqrt special case (thanks Charles L. Dorian).
+* misc/kate: convert isn't a built in function (thanks Evan Shaw).
+* net: implement BindToDevice,
+ implement raw sockets (thanks Christopher Wedgwood).
+* netFD: fix race between Close and Read/Write (thanks Michael Hoisie).
+* os: add Chtimes function (thanks Brad Fitzpatrick).
+* pkg/Makefile: add netchan to standard package list.
+* runtime: GOMAXPROCS returns previous value,
+ allow large map values,
+ avoid allocation for fixed strings,
+ correct tracebacks for nascent goroutines, even closures,
+ free old hashmap pieces during resizing.
+* spec: added imaginary literal to semicolon rules (was missing),
+ fix and clarify syntax of conversions,
+ simplify section on channel types,
+ other minor tweaks.
+* strconv: Btoui64 optimizations (thanks Kyle Consalus).
+* strings: use copy instead of for loop in Map (thanks Kyle Consalus).
+* syscall: implement BindToDevice (thanks Christopher Wedgwood),
+ add Utimes on Darwin/FreeBSD, add Futimes everywhere,
+ regenerate syscalls for some platforms.
+* template: regularize name lookups of interfaces, pointers, and methods.
+</pre>
+
+<h2 id="2010-05-04">2010-05-04</h2>
+
+<pre>
+In this release we renamed the Windows OS target from 'mingw' to 'windows'.
+If you are currently building for 'mingw' you should set GOOS=windows instead.
+
+* 5l, 6l, 8l, runtime: make -s binaries work.
+* 5l, 6l, 8l: change ELF header so that strip doesn't destroy binary.
+* 8l: fix absolute path detection on Windows.
+* big: new functions, optimizations, and cleanups,
+ add bitwise methods for Int (thanks Evan Shaw).
+* bytes: Change IndexAny to look for UTF-8 encoded characters.
+* darwin: bsdthread_create can fail; print good error.
+* fmt: %T missing print <nil> for nil (thanks Christopher Wedgwood).
+* gc: many fixes.
+* misc/cgo/gmp: fix bug in SetString.
+* net: fix resolv.conf EOF without newline bug (thanks Christopher Wedgwood).
+* spec: some small clarifications (no language changes).
+* syscall: add EWOULDBLOCK to sycall_nacl.go,
+ force O_LARGEFILE in Linux open system call,
+ handle EOF on pipe - special case on Windows (thanks Alex Brainman),
+ mingw Sleep (thanks Joe Poirier).
+* test/bench: import new fasta C reference, update Go, optimizations.
+* test: test of static initialization (fails).
+* vector: use correct capacity in call to make.
+* xml: allow text segments to end at EOF.
+</pre>
+
+<h2 id="2010-04-27">2010-04-27</h2>
+
+<pre>
+This release includes a new Codelab that illustrates the construction of a
+simple wiki web application:
+ http://golang.org/doc/codelab/wiki/
+
+It also includes a Codewalk framework for documenting code. See:
+ http://golang.org/doc/codewalk/
+
+Other changes:
+* 6g: fix need for parens around array index expression.
+* 6l, 8l: include ELF header in PT_LOAD mapping for text segment.
+* arm: add android runner script,
+ support for printing floats.
+* big: implemented Karatsuba multiplication,
+ many fixes and improvements (thanks Evan Shaw).
+* bytes: add Next method to Buffer, simplify Read,
+ shuffle implementation, making WriteByte 50% faster.
+* crypto/tls: simpler implementation of record layer.
+* exp/eval: fixes (thanks Evan Shaw).
+* flag: eliminate unnecessary structs.
+* gc: better windows support,
+ cmplx typecheck bug fix,
+ more specific error for statements at top level.
+* go/parser: don't require unnecessary parens.
+* godoc: exclude duplicate entries (thanks Andrei Vieru),
+ use int64 for timestamps (thanks Christopher Wedgwood).
+* gofmt: fine-tune stripping of parentheses,
+* json: Marshal, Unmarshal using new scanner,
+ preserve field name case by default,
+ scanner, Compact, Indent, and tests,
+ support for streaming.
+* libmach: disassemble MOVLQZX correctly.
+* math: more special cases for signed zero (thanks Charles L. Dorian).
+* net: add Pipe,
+ fix bugs in packStructValue (thanks Michael Hoisie),
+ introduce net.Error interface.
+* os: FileInfo: regularize the types of some fields,
+ create sys_bsd.go (thanks Giles Lean),
+ mingw bug fixes (thanks Alex Brainman).
+* reflect: add FieldByNameFunc (thanks Raif S. Naffah),
+ implement Set(nil), SetValue(nil) for PtrValue and MapValue.
+* regexp: allow escaping of any punctuation.
+* rpc/jsonrpc: support for jsonrpc wire encoding.
+* rpc: abstract client and server encodings,
+ add Close() method to rpc.Client.
+* runtime: closures, defer bug fix for Native Client,
+ rename cgo2c, *.cgo to goc2c, *.goc to avoid confusion with real cgo.
+ several other fixes.
+* scanner: implement Peek() to look at the next char w/o advancing.
+* strings: add ReadRune to Reader, add FieldsFunc (thanks Kyle Consalus).
+* syscall: match linux Setsid function signature to darwin,
+ mingw bug fixes (thanks Alex Brainman).
+* template: fix handling of pointer inside interface.
+* test/bench: add fannkuch-parallel.go (thanks Kyle Consalus),
+ pidigits ~10% performance win by using adds instead of shifts.
+* time: remove incorrect time.ISO8601 and add time.RFC3339 (thanks Micah Stetson).
+* utf16: add DecodeRune, EncodeRune.
+* xml: add support for XML marshaling embedded structs (thanks Raif S. Naffah),
+ new "innerxml" tag to collect inner XML.
+</pre>
+
+<h2 id="2010-04-13">2010-04-13</h2>
+
+<pre>
+This release contains many changes:
+
+* 8l: add DOS stub to PE binaries (thanks Evan Shaw).
+* cgo: add //export.
+* cmath: new complex math library (thanks Charles L. Dorian).
+* docs: update to match current coding style (thanks Christopher Wedgwood).
+* exp/eval: fix example and add target to Makefile (thanks Evan Shaw).
+* fmt: change behavior of format verb %b to match %x when negative (thanks Andrei Vieru).
+* gc: compile s == "" as len(s) == 0,
+ distinguish fatal compiler bug from error+exit,
+ fix alignment on non-amd64,
+ good syntax error for defer func() {} - missing fina (),
+ implement panic and recover,
+ zero unnamed return values on entry if func has defer.
+* goyacc: change to be reentrant (thanks Roger Peppe).
+* io/ioutil: fix bug in ReadFile when Open succeeds but Stat fails.
+* kate: update for recent language changes (thanks Evan Shaw).
+* libcgo: initial mingw port work - builds but untested (thanks Joe Poirier).
+* math: new functions and special cases (thanks Charles L. Dorian)
+* net: use chan bool instead of chan *netFD to avoid cycle.
+* netchan: allow client to send as well as receive.
+* nntp: new package, NNTP client (thanks Conrad Meyer).
+* os: rename os.Dir to os.FileInfo.
+* rpc: don't log normal EOF,
+ fix ServeConn to block as documented.
+* runtime: many bug fixes, better ARM support.
+* strings: add IndexRune, Trim, TrimLeft, TrimRight, etc (thanks Michael Hoisie).
+* syscall: implement some mingw syscalls required by os (thanks Alex Brainman).
+* test/bench: add k-nucleotide-parallel (thanks Kyle Consalus).
+* Unicode: add support for Turkish case mapping.
+* xgb: move from the main repository to http://code.google.com/p/x-go-binding/
+</pre>
+
+<h2 id="2010-03-30">2010-03-30</h2>
+
+<pre>
+This release contains three language changes:
+
+1. Accessing a non-existent key in a map is no longer a run-time error.
+It now evaluates to the zero value for that type. For example:
+ x := myMap[i] is now equivalent to: x, _ := myMap[i]
+
+2. It is now legal to take the address of a function's return value.
+The return values are copied back to the caller only after deferred
+functions have run.
+
+3. The functions panic and recover, intended for reporting and recovering from
+failure, have been added to the spec:
+ http://golang.org/doc/go_spec.html#Handling_panics
+In a related change, panicln is gone, and panic is now a single-argument
+function. Panic and recover are recognized by the gc compilers but the new
+behavior is not yet implemented.
+
+The ARM build is broken in this release; ARM users should stay at release.2010-03-22.
+
+Other changes:
+* bytes, strings: add IndexAny.
+* cc/ld: Add support for #pragma dynexport,
+ Rename dynld to dynimport throughout. Cgo users will need to rerun cgo.
+* expvar: default publishings for cmdline, memstats
+* flag: add user-defined flag types.
+* gc: usual bug fixes
+* go/ast: generalized ast filtering.
+* go/printer: avoid reflect in print.
+* godefs: fix handling of negative constants.
+* godoc: export pprof debug information, exported variables,
+ support for filtering of command-line output in -src mode,
+ use http GET for remote search instead of rpc.
+* gofmt: don't convert multi-line functions into one-liners,
+ preserve newlines in multiline selector expressions (thanks Risto Jaakko Saarelma).
+* goinstall: include command name in error reporting (thanks Andrey Mirtchovski)
+* http: add HandleFunc as shortcut to Handle(path, HandlerFunc(func))
+* make: use actual dependency for install
+* math: add J1, Y1, Jn, Yn, J0, Y0 (Bessel functions) (thanks Charles L. Dorian)
+* prof: add pprof from google-perftools
+* regexp: don't return non-nil *Regexp if there is an error.
+* runtime: add Callers,
+ add malloc sampling, pprof interface,
+ add memory profiling, more statistics to runtime.MemStats,
+ implement missing destroylock() (thanks Alex Brainman),
+ more malloc statistics,
+ run all finalizers in a single goroutine,
+ Goexit runs deferred calls.
+* strconv: add Atob and Btoa,
+ Unquote could wrongly return a nil error on error (thanks Roger Peppe).
+* syscall: add IPV6 constants,
+ add syscall_bsd.go for Darwin and other *BSDs (thanks Giles Lean),
+ implement SetsockoptString (thanks Christopher Wedgwood).
+* websocket: implement new protocol (thanks Fumitoshi Ukai).
+* xgb: fix request length and request size (thanks Firmansyah Adiputra).
+* xml: add CopyToken (thanks Kyle Consalus),
+ add line numbers to syntax errors (thanks Kyle Consalus),
+ use io.ReadByter in place of local readByter (thanks Raif S. Naffah).
+</pre>
+
+<h2 id="2010-03-22">2010-03-22</h2>
+
+<pre>
+With this release we announce the launch of the Go Blog:
+ http://blog.golang.org/
+The first post is a brief update covering what has happened since the launch.
+
+This release contains some new packages and functionality, and many fixes:
+* 6g/8g: fix issues with complex data types, other bug fixes.
+* Makefiles: refactored to make writing external Makefiles easier.
+* crypto/rand: new package.
+* godoc: implemented command-line search via RPC,
+ improved comment formatting: recognize URLs.
+* gofmt: more consistent formatting of const/var decls.
+* http: add Error helper function,
+ add ParseQuery (thanks Petar Maymounkov),
+ change RawPath to mean raw path, not raw everything-after-scheme.
+* image/jpeg: fix typos.
+* json: add MarshalIndent (accepts user-specified indent string).
+* math: add Gamma function (thanks Charles L. Dorian).
+* misc/bbedit: support for cmplx, real, imag (thanks Anthony Starks).
+* misc/vim: add new complex types, functions and literals.
+* net: fix IPMask.String not to crash on all-0xff mask.
+* os: drop File finalizer after normal Close.
+* runtime: add GOROOT and Version,
+ lock finalizer table accesses.
+* sha512: add sha384 (truncated version) (thanks Conrad Meyer).
+* syscall: add const ARCH, analogous to OS.
+* syscall: further additions to mingw port (thanks Alex Brainman).
+* template: fixed html formatter []byte input bug.
+* utf16: new package.
+* version.bash: cope with ancient Mercurial.
+* websocket: use URL.RawPath to construct WebSocket-Location: header.
+</pre>
+
+<h2 id="2010-03-15">2010-03-15</h2>
+
+<pre>
+This release includes a language change: support for complex numbers.
+ http://golang.org/doc/go_spec.html#Imaginary_literals
+ http://golang.org/doc/go_spec.html#Complex_numbers
+There is no library support as yet.
+
+This release also includes the goinstall command-line tool.
+ http://golang.org/cmd/goinstall/
+ http://groups.google.com/group/golang-nuts/t/f091704771128e32
+
+* 5g/6g/8g: fix double function call in slice.
+* arm: cleanup build warnings. (thanks Dean Prichard)
+* big: fix mistakes with probablyPrime.
+* bufio: add WriteRune.
+* bytes: add ReadRune and WriteRune to bytes.Buffer.
+* cc: stack split bug fix.
+* crypto: add SHA-224 to sha256, add sha512 package. (thanks Conrad Meyer)
+* crypto/ripemd160: new package. (thanks Raif S. Naffah)
+* crypto/rsa: don't use safe primes.
+* gc: avoid fixed length buffer cleanbuf. (thanks Dean Prichard)
+ better compilation of floating point +=
+ fix crash on complicated arg to make slice.
+ remove duplicate errors, give better error for I.(T)
+* godoc: support for multiple packages in a directory, other fixes.
+* gofmt: bug fixes.
+* hash: add Sum64 interface.
+* hash/crc32: add Update function.
+* hash/crc64: new package implementing 64-bit CRC.
+* math: add ilogb, logb, remainder. (thanks Charles L. Dorian)
+* regexp: add ReplaceAllFunc, ReplaceAllStringFunc.
+* runtime: clock garbage collection on bytes allocated, not pages in use.
+* strings: make Split(s, "", n) faster. (thanks Spring Mc)
+* syscall: minimal mingw version of syscall. (thanks Alex Brainman)
+* template: add ParseFile, MustParseFile.
+</pre>
+
+<h2 id="2010-03-04">2010-03-04</h2>
+
+<pre>
+There is one language change: the ability to convert a string to []byte or
+[]int. This deprecates the strings.Bytes and strings.Runes functions.
+You can convert your existing sources using these gofmt commands:
+ gofmt -r 'strings.Bytes(x) -> []byte(x)' -w file-or-directory-list
+ gofmt -r 'strings.Runes(x) -> []int(x)' -w file-or-directory-list
+After running these you might need to delete unused imports of the "strings"
+package.
+
+Other changes and fixes:
+* 6l/8l/5l: add -r option
+* 8g: make a[byte(x)] truncate x
+* codereview.py: fix for compatibility with hg >=1.4.3
+* crypto/blowfish: new package (thanks Raif S. Naffah)
+* dashboard: more performance tuning
+* fmt: use String method in %q to get the value to quote.
+* gofmt: several cosmetic changes
+* http: fix handling of Connection: close, bug in http.Post
+* net: correct DNS configuration,
+ fix network timeout boundary condition,
+ put [ ] around IPv6 addresses for Dial.
+* path: add Match,
+ fix bug in Match with non-greedy stars (thanks Kevin Ballard)
+* strings: delete Bytes, Runes (see above)
+* tests: an Eratosthenesque concurrent prime sieve (thanks Anh Hai Trinh)
+</pre>
+
+<h2 id="2010-02-23">2010-02-23</h2>
+
+<pre>
+This release is mainly bug fixes and a little new code.
+There are no language changes.
+
+6g/5g/8g: bug fixes
+8a/8l: Added FCMOVcc instructions (thanks Evan Shaw and Charles Dorian)
+crypto/x509: support certificate creation
+dashboard: caching to avoid datastore queries
+exec: add dir argument to Run
+godoc: bug fixes and code cleanups
+http: continued implementation and bug fixes (thanks Petar Maymounkov)
+json: fix quoted strings in Marshal (thanks Sergei Skorobogatov)
+math: more functions, test cases, and benchmarks (thanks Charles L. Dorian)
+misc/bbedit: treat predeclared identifiers as "keywords" (thanks Anthony Starks)
+net: disable UDP server test (flaky on various architectures)
+runtime: work around Linux kernel bug in futex,
+ pchw is now tiny
+sync: fix to work on armv5 (thanks Dean Prichard)
+websocket: fix binary frame size decoding (thanks Timo Savola)
+xml: allow unquoted attribute values in non-Strict mode (thanks Amrut Joshi)
+ treat bool as value in Unmarshal (thanks Michael Hoisie)
+</pre>
+
+<h2 id="2010-02-17">2010-02-17</h2>
+
+<pre>
+There are two small language changes:
+* NUL bytes may be rejected in souce files, and the tools do reject them.
+* Conversions from string to []int and []byte are defined but not yet implemented.
+
+Other changes and fixes:
+* 5a/6a/8a/5c/6c/8c: remove fixed-size arrays for -I and -D options (thanks Dean Prichard)
+* 5c/6c/8c/5l/6l/8l: add -V flag to display version number
+* 5c/6c/8c: use "cpp" not "/bin/cpp" for external preprocessor (thanks Giles Lean)
+* 8a/8l: Added CMOVcc instructions (thanks Evan Shaw)
+* 8l: pe executable building code changed to include import table for kernel32.dll functions (thanks Alex Brainman)
+* 5g/6g/8g: bug fixes
+* asn1: bug fixes and additions (incl marshaling)
+* build: fix build for Native Client, Linux/ARM
+* dashboard: show benchmarks, add garbage collector benchmarks
+* encoding/pem: add marshaling support
+* exp/draw: fast paths for a nil mask
+* godoc: support for directories outside $GOROOT
+* http: sort header keys when writing Response or Request to wire (thanks Petar Maymounkov)
+* math: special cases and new functions (thanks Charles Dorian)
+* mime: new package, used in http (thanks Michael Hoisie)
+* net: dns bug fix - use random request id
+* os: finalize File, to close fd.
+* path: make Join variadic (thanks Stephen Weinberg)
+* regexp: optimization bug fix
+* runtime: misc fixes and optimizations
+* syscall: make signature of Umask on OS X, FreeBSD match Linux. (thanks Giles Lean)
+</pre>
+
+<h2 id="2010-02-04">2010-02-04</h2>
+
+<pre>
+There is one language change: support for ...T parameters:
+ http://golang.org/doc/go_spec.html#Function_types
+
+You can now check build status on various platforms at the Go Dashboard:
+ http://godashboard.appspot.com
+
+* 5l/6l/8l: several minor fixes
+* 5a/6a/8a/5l/6l/8l: avoid overflow of symb buffer (thanks Dean Prichard)
+* compress/gzip: gzip deflater (i.e., writer)
+* debug/proc: add mingw specific build stubs (thanks Joe Poirier)
+* exp/draw: separate the source-point and mask-point in Draw
+* fmt: handle nils safely in Printf
+* gccgo: error messages now match those of gc
+* godoc: several fixes
+* http: bug fixes, revision of Request/Response (thanks Petar Maymounkov)
+* image: new image.A type to represent anti-aliased font glyphs
+ add named colors (e.g. image.Blue), suitable for exp/draw
+* io: fixed bugs in Pipe
+* malloc: merge into package runtime
+* math: fix tests on FreeBSD (thanks Devon H. O'Dell)
+ add functions; update tests and special cases (thanks Charles L. Dorian)
+* os/signal: send SIGCHLDs to Incoming (thanks Chris Wedgwood)
+* reflect: add StringHeader to reflect
+* runtime: add SetFinalizer
+* time: Sleep through interruptions (thanks Chris Wedgwood)
+ add RFC822 formats
+ experimental implementation of Ticker using two goroutines for all tickers
+* xml: allow underscores in XML element names (thanks Michael Hoisie)
+ allow any scalar type in xml.Unmarshal
+</pre>
+
+<h2 id="2010-01-27">2010-01-27</h2>
+
+<pre>
+There are two small language changes: the meaning of chan <- chan int
+is now defined, and functions returning functions do not need to
+parenthesize the result type.
+
+There is one significant implementation change: the compilers can
+handle multiple packages using the same name in a single binary.
+In the gc compilers, this comes at the cost of ensuring that you
+always import a particular package using a consistent import path.
+In the gccgo compiler, the cost is that you must use the -fgo-prefix
+flag to pass a unique prefix (like the eventual import path).
+
+5a/6a/8a: avoid use of fixed-size buffers (thanks Dean Prichard)
+5g, 6g, 8g: many minor bug fixes
+bufio: give Writer.WriteString same signature as bytes.Buffer.WriteString.
+container/list: PushFrontList, PushBackList (thanks Jan Hosang)
+godoc: trim spaces from search query (thanks Christopher Wedgwood)
+hash: document that Sum does not change state, fix crypto hashes
+http: bug fixes, revision of Request/Response (thanks Petar Maymounkov)
+math: more handling of IEEE 754 special cases (thanks Charles Dorian)
+misc/dashboard: new build dashboard
+net: allow UDP broadcast,
+ use /etc/hosts to resolve names (thanks Yves Junqueira, Michael Hoisie)
+netchan: beginnings of new package for connecting channels across a network
+os: allow FQDN in Hostname test (thanks Icarus Sparry)
+reflect: garbage collection bug in Call
+runtime: demo of Go on raw (emulated) hw in runtime/pchw,
+ performance fix on OS X
+spec: clarify meaning of chan <- chan int,
+ func() func() int is allowed now,
+ define ... T (not yet implemented)
+template: can use interface values
+time: fix for +0000 time zone,
+ more robust tick.Stop.
+xgb: support for authenticated connections (thanks Firmansyah Adiputra)
+xml: add Escape (thanks Stephen Weinberg)
+</pre>
+
+<h2 id="2010-01-13">2010-01-13</h2>
+
+<pre>
+This release is mainly bug fixes with a little new code.
+There are no language changes.
+
+build: $GOBIN should no longer be required in $PATH (thanks Devon H. O'Dell),
+ new package target "make bench" to run benchmarks
+8g: faster float -> uint64 conversion (thanks Evan Shaw)
+5g, 6g, 8g:
+ clean opnames.h to avoid stale errors (thanks Yongjian Xu),
+ a handful of small compiler fixes
+5g, 6g, 8g, 5l, 6l, 8l: ignore $GOARCH, which is implied by name of tool
+6prof: support for writing input files for google-perftools's pprof
+asn1: fix a few structure-handling bugs
+cgo: many bug fixes (thanks Devon H. O'Dell)
+codereview: repeated "hg mail" sends "please take another look"
+gob: reserve ids for future expansion
+godoc: distinguish HTML generation from plain text HTML escaping (thanks Roger Peppe)
+gofmt: minor bug fixes, removed -oldprinter flag
+http: add CanonicalPath (thanks Ivan Krasin),
+ avoid header duplication in Response.Write,
+ correctly escape/unescape URL sections
+io: new interface ReadByter
+json: better error, pointer handling in Marshal (thanks Ivan Krasin)
+libmach: disassembly of FUCOMI, etc (thanks Evan Shaw)
+math: special cases for most functions and 386 hardware Sqrt (thanks Charles Dorian)
+misc/dashboard: beginning of a build dashboard at godashboard.appspot.com.
+misc/emacs: handling of new semicolon rules (thanks Austin Clements),
+ empty buffer bug fix (thanks Kevin Ballard)
+misc/kate: highlighting improvements (tahnks Evan Shaw)
+os/signal: add signal names: signal.SIGHUP, etc (thanks David Symonds)
+runtime: preliminary Windows support (thanks Hector Chu),
+ preemption polling to reduce garbage collector pauses
+scanner: new lightweight scanner package
+template: bug fix involving spaces before a delimited block
+test/bench: updated timings
+time: new Format, Parse functions
+</pre>
+
+<h2 id="2010-01-05">2010-01-05</h2>
+
+<pre>
+This release is mainly bug fixes. There are no language changes.
+
+6prof: now works on 386
+8a, 8l: add FCOMI, FCOMIP, FUCOMI, and FUCOMIP (thanks Evan Shaw)
+big: fix ProbablyPrime on small numbers
+container/vector: faster []-based implementation (thanks Jan Mercl)
+crypto/tls: extensions and Next Protocol Negotiation
+gob: one encoding bug fix, one decoding bug fix
+image/jpeg: support for RST markers
+image/png: support for transparent paletted images
+misc/xcode: improved support (thanks Ken Friedenbach)
+net: return nil Conn on error from Dial (thanks Roger Peppe)
+regexp: add Regexp.NumSubexp (thanks Peter Froehlich)
+syscall: add Nanosleep on FreeBSD (thanks Devon H. O'Dell)
+template: can use map in .repeated section
+
+There is now a public road map, in the repository and online
+at <a href="http://golang.org/doc/devel/roadmap.html">http://golang.org/doc/devel/roadmap.html</a>.
+</pre>
+
+<h2 id="2009-12-22">2009-12-22</h2>
+
+<pre>
+Since the last release there has been one large syntactic change to
+the language, already discussed extensively on this list: semicolons
+are now implied between statement-ending tokens and newline characters.
+See http://groups.google.com/group/golang-nuts/t/5ee32b588d10f2e9 for
+details.
+
+By default, gofmt now parses and prints the new lighter weight syntax.
+To convert programs written in the old syntax, you can use:
+
+ gofmt -oldparser -w *.go
+
+Since everything was being reformatted anyway, we took the opportunity to
+change the way gofmt does alignment. Now gofmt uses tabs at the start
+of a line for basic code alignment, but it uses spaces for alignment of
+interior columns. Thus, in an editor with a fixed-width font, you can
+choose your own tab size to change the indentation, and no matter what
+tab size you choose, columns will be aligned properly.
+
+
+In addition to the syntax and formatting changes, there have been many
+smaller fixes and updates:
+
+6g,8g,5g: many bug fixes, better registerization,
+ build process fix involving mkbuiltin (thanks Yongjian Xu),
+ method expressions for concrete types
+8l: support for Windows PE files (thanks Hector Chu)
+bytes: more efficient Buffer handling
+bytes, strings: new function Fields (thanks Andrey Mirtchovski)
+cgo: handling of enums (thanks Moriyoshi Koizumi),
+ handling of structs with bit fields, multiple files (thanks Devon H. O'Dell),
+ installation of .so to non-standard locations
+crypto/sha256: new package for SHA 256 (thanks Andy Davis)
+encoding/binary: support for slices of fixed-size values (thanks Maxim Ushakov)
+exp/vector: experimental alternate vector representation (thanks Jan Mercl)
+fmt: %p for chan, map, slice types
+gob: a couple more bug fixes
+http: support for basic authentication (thanks Ivan Krasin)
+image/jpeg: basic JPEG decoder
+math: correct handling of Inf and NaN in Pow (thanks Charles Dorian)
+misc/bash: completion file for bash (thanks Alex Ray)
+os/signal: support for handling Unix signals (thanks David Symonds)
+rand: Zipf-distributed random values (thanks William Josephson)
+syscall: correct error return bug on 32-bit machines (thanks Christopher Wedgwood)
+syslog: new package for writing to Unix syslog daemon (thanks Yves Junqueira)
+template: will automatically invoke niladic methods
+time: new ISO8601 format generator (thanks Ben Olive)
+xgb: converted generator to new syntax (thanks Tor Andersson)
+xml: better mapping of tag names to Go identifiers (thanks Kei Son),
+ better handling of unexpected EOF (thanks Arvindh Rajesh Tamilmani)
+</pre>
+
+<h2 id="2009-12-09">2009-12-09</h2>
+
+<pre>
+Since the last release there are two changes to the language:
+
+* new builtin copy(dst, src) copies n = min(len(dst), len(src))
+ elements to dst from src and returns n. It works correctly
+ even if dst and src overlap. bytes.Copy is gone.
+ Convert your programs using:
+ gofmt -w -r 'bytes.Copy(d, s) -> copy(d, s)' *.go
+
+* new syntax x[lo:] is shorthand for x[lo:len(x)].
+ Convert your programs using:
+ gofmt -w -r 'a[b:len(a)] -> a[b:]' *.go
+
+In addition, there have been many smaller fixes and updates:
+
+* 6g/8g/5g: many bug fixes
+* 8g: fix 386 floating point stack bug (thanks Charles Dorian)
+* all.bash: now works even when $GOROOT has spaces (thanks Sergio Luis O. B. Correia),
+ starting to make build work with mingw (thanks Hector Chu),
+ FreeBSD support (thanks Devon O'Dell)
+* big: much faster on 386.
+* bytes: new function IndexByte, implemented in assembly
+ new function Runes (thanks Peter Froehlich),
+ performance tuning in bytes.Buffer.
+* codereview: various bugs fixed
+* container/vector: New is gone; just declare a Vector instead.
+ call Resize to set len and cap.
+* cgo: many bug fixes (thanks Eden Li)
+* crypto: added MD4 (thanks Chris Lennert),
+ added XTEA (thanks Adrian O'Grady).
+* crypto/tls: basic client
+* exp/iterable: new functions (thanks Michael Elkins)
+* exp/nacl: native client tree builds again
+* fmt: preliminary performance tuning
+* go/ast: more powerful Visitor (thanks Roger Peppe)
+* gob: a few bug fixes
+* gofmt: better handling of standard input, error reporting (thanks Fazlul Shahriar)
+ new -r flag for rewriting programs
+* gotest: support for Benchmark functions (thanks Trevor Strohman)
+* io: ReadFile, WriteFile, ReadDir now in separate package io/ioutil.
+* json: new Marshal function (thanks Michael Hoisie),
+ better white space handling (thanks Andrew Skiba),
+ decoding into native data structures (thanks Sergey Gromov),
+ handling of nil interface values (thanks Ross Light).
+* math: correct handling of sin/cos of large angles
+* net: better handling of Close (thanks Devon O'Dell and Christopher Wedgwood)
+ support for UDP broadcast (thanks Jonathan Wills),
+ support for empty packets
+* rand: top-level functions now safe to call from multiple goroutines
+(thanks Roger Peppe).
+* regexp: a few easy optimizations
+* rpc: better error handling, a few bug fixes
+* runtime: better signal handling on OS X, malloc fixes,
+ global channel lock is gone.
+* sync: RWMutex now allows concurrent readers (thanks Péter Szabó)
+* template: can use maps as data (thanks James Meneghello)
+* unicode: updated to Unicode 5.2.
+* websocket: new package (thanks Fumitoshi Ukai)
+* xgb: preliminary X Go Bindings (thanks Tor Andersson)
+* xml: fixed crash (thanks Vish Subramanian)
+* misc: bbedit config (thanks Anthony Starks),
+ kate config (thanks Evan Shaw)
+</pre>
diff --git a/_content/doc/diagnostics.html b/_content/doc/diagnostics.html
new file mode 100644
index 0000000..438cdce
--- /dev/null
+++ b/_content/doc/diagnostics.html
@@ -0,0 +1,472 @@
+<!--{
+ "Title": "Diagnostics",
+ "Template": true
+}-->
+
+<!--
+NOTE: In this document and others in this directory, the convention is to
+set fixed-width phrases with non-fixed-width spaces, as in
+<code>hello</code> <code>world</code>.
+Do not send CLs removing the interior tags from such phrases.
+-->
+
+<h2 id="introduction">Introduction</h2>
+
+<p>
+The Go ecosystem provides a large suite of APIs and tools to
+diagnose logic and performance problems in Go programs. This page
+summarizes the available tools and helps Go users pick the right one
+for their specific problem.
+</p>
+
+<p>
+Diagnostics solutions can be categorized into the following groups:
+</p>
+
+<ul>
+<li><strong>Profiling</strong>: Profiling tools analyze the complexity and costs of a
+Go program such as its memory usage and frequently called
+functions to identify the expensive sections of a Go program.</li>
+<li><strong>Tracing</strong>: Tracing is a way to instrument code to analyze latency
+throughout the lifecycle of a call or user request. Traces provide an
+overview of how much latency each component contributes to the overall
+latency in a system. Traces can span multiple Go processes.</li>
+<li><strong>Debugging</strong>: Debugging allows us to pause a Go program and examine
+its execution. Program state and flow can be verified with debugging.</li>
+<li><strong>Runtime statistics and events</strong>: Collection and analysis of runtime stats and events
+provides a high-level overview of the health of Go programs. Spikes/dips of metrics
+helps us to identify changes in throughput, utilization, and performance.</li>
+</ul>
+
+<p>
+Note: Some diagnostics tools may interfere with each other. For example, precise
+memory profiling skews CPU profiles and goroutine blocking profiling affects scheduler
+trace. Use tools in isolation to get more precise info.
+</p>
+
+<h2 id="profiling">Profiling</h2>
+
+<p>
+Profiling is useful for identifying expensive or frequently called sections
+of code. The Go runtime provides <a href="https://golang.org/pkg/runtime/pprof/">
+profiling data</a> in the format expected by the
+<a href="https://github.com/google/pprof/blob/master/doc/README.md">pprof visualization tool</a>.
+The profiling data can be collected during testing
+via <code>go</code> <code>test</code> or endpoints made available from the <a href="/pkg/net/http/pprof/">
+net/http/pprof</a> package. Users need to collect the profiling data and use pprof tools to filter
+and visualize the top code paths.
+</p>
+
+<p>Predefined profiles provided by the <a href="/pkg/runtime/pprof">runtime/pprof</a> package:</p>
+
+<ul>
+<li>
+<strong>cpu</strong>: CPU profile determines where a program spends
+its time while actively consuming CPU cycles (as opposed to while sleeping or waiting for I/O).
+</li>
+<li>
+<strong>heap</strong>: Heap profile reports memory allocation samples;
+used to monitor current and historical memory usage, and to check for memory leaks.
+</li>
+<li>
+<strong>threadcreate</strong>: Thread creation profile reports the sections
+of the program that lead the creation of new OS threads.
+</li>
+<li>
+<strong>goroutine</strong>: Goroutine profile reports the stack traces of all current goroutines.
+</li>
+<li>
+<strong>block</strong>: Block profile shows where goroutines block waiting on synchronization
+primitives (including timer channels). Block profile is not enabled by default;
+use <code>runtime.SetBlockProfileRate</code> to enable it.
+</li>
+<li>
+<strong>mutex</strong>: Mutex profile reports the lock contentions. When you think your
+CPU is not fully utilized due to a mutex contention, use this profile. Mutex profile
+is not enabled by default, see <code>runtime.SetMutexProfileFraction</code> to enable it.
+</li>
+</ul>
+
+
+<p><strong>What other profilers can I use to profile Go programs?</strong></p>
+
+<p>
+On Linux, <a href="https://perf.wiki.kernel.org/index.php/Tutorial">perf tools</a>
+can be used for profiling Go programs. Perf can profile
+and unwind cgo/SWIG code and kernel, so it can be useful to get insights into
+native/kernel performance bottlenecks. On macOS,
+<a href="https://developer.apple.com/library/content/documentation/DeveloperTools/Conceptual/InstrumentsUserGuide/">Instruments</a>
+suite can be used profile Go programs.
+</p>
+
+<p><strong>Can I profile my production services?</strong></p>
+
+<p>Yes. It is safe to profile programs in production, but enabling
+some profiles (e.g. the CPU profile) adds cost. You should expect to
+see performance downgrade. The performance penalty can be estimated
+by measuring the overhead of the profiler before turning it on in
+production.
+</p>
+
+<p>
+You may want to periodically profile your production services.
+Especially in a system with many replicas of a single process, selecting
+a random replica periodically is a safe option.
+Select a production process, profile it for
+X seconds for every Y seconds and save the results for visualization and
+analysis; then repeat periodically. Results may be manually and/or automatically
+reviewed to find problems.
+Collection of profiles can interfere with each other,
+so it is recommended to collect only a single profile at a time.
+</p>
+
+<p>
+<strong>What are the best ways to visualize the profiling data?</strong>
+</p>
+
+<p>
+The Go tools provide text, graph, and <a href="http://valgrind.org/docs/manual/cl-manual.html">callgrind</a>
+visualization of the profile data using
+<code><a href="https://github.com/google/pprof/blob/master/doc/README.md">go tool pprof</a></code>.
+Read <a href="https://blog.golang.org/profiling-go-programs">Profiling Go programs</a>
+to see them in action.
+</p>
+
+<p>
+<img width="800" src="https://storage.googleapis.com/golangorg-assets/pprof-text.png">
+<br>
+<small>Listing of the most expensive calls as text.</small>
+</p>
+
+<p>
+<img width="800" src="https://storage.googleapis.com/golangorg-assets/pprof-dot.png">
+<br>
+<small>Visualization of the most expensive calls as a graph.</small>
+</p>
+
+<p>Weblist view displays the expensive parts of the source line by line in
+an HTML page. In the following example, 530ms is spent in the
+<code>runtime.concatstrings</code> and cost of each line is presented
+in the listing.</p>
+
+<p>
+<img width="800" src="https://storage.googleapis.com/golangorg-assets/pprof-weblist.png">
+<br>
+<small>Visualization of the most expensive calls as weblist.</small>
+</p>
+
+<p>
+Another way to visualize profile data is a <a href="http://www.brendangregg.com/flamegraphs.html">flame graph</a>.
+Flame graphs allow you to move in a specific ancestry path, so you can zoom
+in/out of specific sections of code.
+The <a href="https://github.com/google/pprof">upstream pprof</a>
+has support for flame graphs.
+</p>
+
+<p>
+<img width="800" src="https://storage.googleapis.com/golangorg-assets/flame.png">
+<br>
+<small>Flame graphs offers visualization to spot the most expensive code-paths.</small>
+</p>
+
+<p><strong>Am I restricted to the built-in profiles?</strong></p>
+
+<p>
+Additionally to what is provided by the runtime, Go users can create
+their custom profiles via <a href="/pkg/runtime/pprof/#Profile">pprof.Profile</a>
+and use the existing tools to examine them.
+</p>
+
+<p><strong>Can I serve the profiler handlers (/debug/pprof/...) on a different path and port?</strong></p>
+
+<p>
+Yes. The <code>net/http/pprof</code> package registers its handlers to the default
+mux by default, but you can also register them yourself by using the handlers
+exported from the package.
+</p>
+
+<p>
+For example, the following example will serve the pprof.Profile
+handler on :7777 at /custom_debug_path/profile:
+</p>
+
+<p>
+<pre>
+package main
+
+import (
+ "log"
+ "net/http"
+ "net/http/pprof"
+)
+
+func main() {
+ mux := http.NewServeMux()
+ mux.HandleFunc("/custom_debug_path/profile", pprof.Profile)
+ log.Fatal(http.ListenAndServe(":7777", mux))
+}
+</pre>
+</p>
+
+<h2 id="tracing">Tracing</h2>
+
+<p>
+Tracing is a way to instrument code to analyze latency throughout the
+lifecycle of a chain of calls. Go provides
+<a href="https://godoc.org/golang.org/x/net/trace">golang.org/x/net/trace</a>
+package as a minimal tracing backend per Go node and provides a minimal
+instrumentation library with a simple dashboard. Go also provides
+an execution tracer to trace the runtime events within an interval.
+</p>
+
+<p>Tracing enables us to:</p>
+
+<ul>
+<li>Instrument and analyze application latency in a Go process.</li>
+<li>Measure the cost of specific calls in a long chain of calls.</li>
+<li>Figure out the utilization and performance improvements.
+Bottlenecks are not always obvious without tracing data.</li>
+</ul>
+
+<p>
+In monolithic systems, it's relatively easy to collect diagnostic data
+from the building blocks of a program. All modules live within one
+process and share common resources to report logs, errors, and other
+diagnostic information. Once your system grows beyond a single process and
+starts to become distributed, it becomes harder to follow a call starting
+from the front-end web server to all of its back-ends until a response is
+returned back to the user. This is where distributed tracing plays a big
+role to instrument and analyze your production systems.
+</p>
+
+<p>
+Distributed tracing is a way to instrument code to analyze latency throughout
+the lifecycle of a user request. When a system is distributed and when
+conventional profiling and debugging tools don’t scale, you might want
+to use distributed tracing tools to analyze the performance of your user
+requests and RPCs.
+</p>
+
+<p>Distributed tracing enables us to:</p>
+
+<ul>
+<li>Instrument and profile application latency in a large system.</li>
+<li>Track all RPCs within the lifecycle of a user request and see integration issues
+that are only visible in production.</li>
+<li>Figure out performance improvements that can be applied to our systems.
+Many bottlenecks are not obvious before the collection of tracing data.</li>
+</ul>
+
+<p>The Go ecosystem provides various distributed tracing libraries per tracing system
+and backend-agnostic ones.</p>
+
+
+<p><strong>Is there a way to automatically intercept each function call and create traces?</strong></p>
+
+<p>
+Go doesn’t provide a way to automatically intercept every function call and create
+trace spans. You need to manually instrument your code to create, end, and annotate spans.
+</p>
+
+<p><strong>How should I propagate trace headers in Go libraries?</strong></p>
+
+<p>
+You can propagate trace identifiers and tags in the
+<a href="/pkg/context#Context"><code>context.Context</code></a>.
+There is no canonical trace key or common representation of trace headers
+in the industry yet. Each tracing provider is responsible for providing propagation
+utilities in their Go libraries.
+</p>
+
+<p>
+<strong>What other low-level events from the standard library or
+runtime can be included in a trace?</strong>
+</p>
+
+<p>
+The standard library and runtime are trying to expose several additional APIs
+to notify on low level internal events. For example,
+<a href="/pkg/net/http/httptrace#ClientTrace"><code>httptrace.ClientTrace</code></a>
+provides APIs to follow low-level events in the life cycle of an outgoing request.
+There is an ongoing effort to retrieve low-level runtime events from
+the runtime execution tracer and allow users to define and record their user events.
+</p>
+
+<h2 id="debugging">Debugging</h2>
+
+<p>
+Debugging is the process of identifying why a program misbehaves.
+Debuggers allow us to understand a program’s execution flow and current state.
+There are several styles of debugging; this section will only focus on attaching
+a debugger to a program and core dump debugging.
+</p>
+
+<p>Go users mostly use the following debuggers:</p>
+
+<ul>
+<li>
+<a href="https://github.com/derekparker/delve">Delve</a>:
+Delve is a debugger for the Go programming language. It has
+support for Go’s runtime concepts and built-in types. Delve is
+trying to be a fully featured reliable debugger for Go programs.
+</li>
+<li>
+<a href="https://golang.org/doc/gdb">GDB</a>:
+Go provides GDB support via the standard Go compiler and Gccgo.
+The stack management, threading, and runtime contain aspects that differ
+enough from the execution model GDB expects that they can confuse the
+debugger, even when the program is compiled with gccgo. Even though
+GDB can be used to debug Go programs, it is not ideal and may
+create confusion.
+</li>
+</ul>
+
+<p><strong>How well do debuggers work with Go programs?</strong></p>
+
+<p>
+The <code>gc</code> compiler performs optimizations such as
+function inlining and variable registerization. These optimizations
+sometimes make debugging with debuggers harder. There is an ongoing
+effort to improve the quality of the DWARF information generated for
+optimized binaries. Until those improvements are available, we recommend
+disabling optimizations when building the code being debugged. The following
+command builds a package with no compiler optimizations:
+
+<p>
+<pre>
+$ go build -gcflags=all="-N -l"
+</pre>
+</p>
+
+As part of the improvement effort, Go 1.10 introduced a new compiler
+flag <code>-dwarflocationlists</code>. The flag causes the compiler to
+add location lists that helps debuggers work with optimized binaries.
+The following command builds a package with optimizations but with
+the DWARF location lists:
+
+<p>
+<pre>
+$ go build -gcflags="-dwarflocationlists=true"
+</pre>
+</p>
+
+<p><strong>What’s the recommended debugger user interface?</strong></p>
+
+<p>
+Even though both delve and gdb provides CLIs, most editor integrations
+and IDEs provides debugging-specific user interfaces.
+</p>
+
+<p><strong>Is it possible to do postmortem debugging with Go programs?</strong></p>
+
+<p>
+A core dump file is a file that contains the memory dump of a running
+process and its process status. It is primarily used for post-mortem
+debugging of a program and to understand its state
+while it is still running. These two cases make debugging of core
+dumps a good diagnostic aid to postmortem and analyze production
+services. It is possible to obtain core files from Go programs and
+use delve or gdb to debug, see the
+<a href="https://golang.org/wiki/CoreDumpDebugging">core dump debugging</a>
+page for a step-by-step guide.
+</p>
+
+<h2 id="runtime">Runtime statistics and events</h2>
+
+<p>
+The runtime provides stats and reporting of internal events for
+users to diagnose performance and utilization problems at the
+runtime level.
+</p>
+
+<p>
+Users can monitor these stats to better understand the overall
+health and performance of Go programs.
+Some frequently monitored stats and states:
+</p>
+
+<ul>
+<li><code><a href="/pkg/runtime/#ReadMemStats">runtime.ReadMemStats</a></code>
+reports the metrics related to heap
+allocation and garbage collection. Memory stats are useful for
+monitoring how much memory resources a process is consuming,
+whether the process can utilize memory well, and to catch
+memory leaks.</li>
+<li><code><a href="/pkg/runtime/debug/#ReadGCStats">debug.ReadGCStats</a></code>
+reads statistics about garbage collection.
+It is useful to see how much of the resources are spent on GC pauses.
+It also reports a timeline of garbage collector pauses and pause time percentiles.</li>
+<li><code><a href="/pkg/runtime/debug/#Stack">debug.Stack</a></code>
+returns the current stack trace. Stack trace
+is useful to see how many goroutines are currently running,
+what they are doing, and whether they are blocked or not.</li>
+<li><code><a href="/pkg/runtime/debug/#WriteHeapDump">debug.WriteHeapDump</a></code>
+suspends the execution of all goroutines
+and allows you to dump the heap to a file. A heap dump is a
+snapshot of a Go process' memory at a given time. It contains all
+allocated objects as well as goroutines, finalizers, and more.</li>
+<li><code><a href="/pkg/runtime#NumGoroutine">runtime.NumGoroutine</a></code>
+returns the number of current goroutines.
+The value can be monitored to see whether enough goroutines are
+utilized, or to detect goroutine leaks.</li>
+</ul>
+
+<h3 id="execution-tracer">Execution tracer</h3>
+
+<p>Go comes with a runtime execution tracer to capture a wide range
+of runtime events. Scheduling, syscall, garbage collections,
+heap size, and other events are collected by runtime and available
+for visualization by the go tool trace. Execution tracer is a tool
+to detect latency and utilization problems. You can examine how well
+the CPU is utilized, and when networking or syscalls are a cause of
+preemption for the goroutines.</p>
+
+<p>Tracer is useful to:</p>
+<ul>
+<li>Understand how your goroutines execute.</li>
+<li>Understand some of the core runtime events such as GC runs.</li>
+<li>Identify poorly parallelized execution.</li>
+</ul>
+
+<p>However, it is not great for identifying hot spots such as
+analyzing the cause of excessive memory or CPU usage.
+Use profiling tools instead first to address them.</p>
+
+<p>
+<img width="800" src="https://storage.googleapis.com/golangorg-assets/tracer-lock.png">
+</p>
+
+<p>Above, the go tool trace visualization shows the execution started
+fine, and then it became serialized. It suggests that there might
+be lock contention for a shared resource that creates a bottleneck.</p>
+
+<p>See <a href="https://golang.org/cmd/trace/"><code>go</code> <code>tool</code> <code>trace</code></a>
+to collect and analyze runtime traces.
+</p>
+
+<h3 id="godebug">GODEBUG</h3>
+
+<p>Runtime also emits events and information if
+<a href="https://golang.org/pkg/runtime/#hdr-Environment_Variables">GODEBUG</a>
+environmental variable is set accordingly.</p>
+
+<ul>
+<li>GODEBUG=gctrace=1 prints garbage collector events at
+each collection, summarizing the amount of memory collected
+and the length of the pause.</li>
+<li>GODEBUG=inittrace=1 prints a summary of execution time and memory allocation
+information for completed package initialization work.</li>
+<li>GODEBUG=schedtrace=X prints scheduling events every X milliseconds.</li>
+</ul>
+
+<p>The GODEBUG environmental variable can be used to disable use of
+instruction set extensions in the standard library and runtime.</p>
+
+<ul>
+<li>GODEBUG=cpu.all=off disables the use of all optional
+instruction set extensions.</li>
+<li>GODEBUG=cpu.<em>extension</em>=off disables use of instructions from the
+specified instruction set extension.<br>
+<em>extension</em> is the lower case name for the instruction set extension
+such as <em>sse41</em> or <em>avx</em>.</li>
+</ul>
diff --git a/_content/doc/docs.html b/_content/doc/docs.html
new file mode 100644
index 0000000..e876bb2
--- /dev/null
+++ b/_content/doc/docs.html
@@ -0,0 +1,285 @@
+<!--{
+ "Title": "Documentation",
+ "Path": "/doc/",
+ "Template": true
+}-->
+
+<p>
+The Go programming language is an open source project to make programmers more
+productive.
+</p>
+
+<p>
+Go is expressive, concise, clean, and efficient. Its concurrency
+mechanisms make it easy to write programs that get the most out of multicore
+and networked machines, while its novel type system enables flexible and
+modular program construction. Go compiles quickly to machine code yet has the
+convenience of garbage collection and the power of run-time reflection. It's a
+fast, statically typed, compiled language that feels like a dynamically typed,
+interpreted language.
+</p>
+
+<div id="manual-nav"></div>
+
+<h2 id="getting-started">Getting started</h2>
+
+<h3 id="installing"><a href="/doc/install">Installing Go</a></h3>
+<p>
+Instructions for downloading and installing Go.
+</p>
+
+<h3 id="get-started-tutorial"><a href="/doc/tutorial/getting-started.html">Tutorial: Getting started</a></h3>
+<p>
+A brief Hello, World tutorial to get started. Learn a bit about Go code, tools, packages, and modules.
+</p>
+
+<h3 id="create-module-tutorial"><a href="/doc/tutorial/create-module.html">Tutorial: Create a module</a></h3>
+<p>
+A tutorial of short topics introducing functions, error handling, arrays, maps, unit testing, and compiling.
+</p>
+
+<h3 id="writing-web-applications"><a href="/doc/articles/wiki/">Writing Web Applications</a></h3>
+<p>
+Building a simple web application.
+</p>
+
+<h3 id="code"><a href="code.html">How to write Go code</a></h3>
+<p>
+This doc explains how to develop a simple set of Go packages inside a module,
+and it shows how to use the <a href="/cmd/go/"><code>go</code> command</a>
+to build and test packages.
+</p>
+
+<img class="gopher" src="/doc/gopher/doc.png" alt=""/>
+
+<h3 id="go_tour">
+ {{if $.GoogleCN}}
+ A Tour of Go
+ {{else}}
+ <a href="//tour.golang.org/">A Tour of Go</a>
+ {{end}}
+</h3>
+<p>
+An interactive introduction to Go in three sections.
+The first section covers basic syntax and data structures; the second discusses
+methods and interfaces; and the third introduces Go's concurrency primitives.
+Each section concludes with a few exercises so you can practice what you've
+learned. You can {{if not $.GoogleCN}}<a href="//tour.golang.org/">take the tour
+online</a> or{{end}} install it locally with:
+</p>
+<pre>
+$ go get golang.org/x/tour
+</pre>
+<p>
+This will place the <code>tour</code> binary in your workspace's <code>bin</code> directory.
+</p>
+
+<h2 id="learning">Using and understanding Go</h2>
+
+<h3 id="effective_go"><a href="effective_go.html">Effective Go</a></h3>
+<p>
+A document that gives tips for writing clear, idiomatic Go code.
+A must read for any new Go programmer. It augments the tour and
+the language specification, both of which should be read first.
+</p>
+
+<h3 id="editors"><a href="editors.html">Editor plugins and IDEs</a></h3>
+<p>
+A document that summarizes commonly used editor plugins and IDEs with
+Go support.
+</p>
+
+<h3 id="diagnostics"><a href="/doc/diagnostics.html">Diagnostics</a></h3>
+<p>
+Summarizes tools and methodologies to diagnose problems in Go programs.
+</p>
+
+<h3 id="dependencies"><a href="/doc/modules/managing-dependencies">Managing dependencies</a></h3>
+<p>
+When your code uses external packages, those packages (distributed as modules) become dependencies.
+</p>
+
+<h3 id="developing-modules">Developing modules</h3>
+
+<h4 id="modules-develop-publish"><a href="/doc/modules/developing">Developing and publishing modules</a></h4>
+<p>
+You can collect related packages into modules, then publish the modules for other developers to use. This topic gives an overview of developing and publishing modules.
+</p>
+
+<h4 id="modules-release-workflow"><a href="/doc/modules/release-workflow">Module release and versioning workflow</a></h4>
+<p>
+When you develop modules for use by other developers, you can follow a workflow that helps ensure a reliable, consistent experience for developers using the module. This topic describes the high-level steps in that workflow.
+</p>
+
+<h4 id="modules-managing-source"><a href="/doc/modules/managing-source">Managing module source</a></h4>
+<p>
+When you're developing modules to publish for others to use, you can help ensure that your modules are easier for other developers to use by following the repository conventions described in this topic.
+</p>
+
+<h4 id="modules-major-version"><a href="/doc/modules/major-version">Developing a major version update</a></h4>
+<p>
+A major version update can be very disruptive to your module's users because it includes breaking changes and represents a new module. Learn more in this topic.
+</p>
+
+<h4 id="modules-publishing"><a href="/doc/modules/publishing">Publishing a module</a></h4>
+<p>
+When you want to make a module available for other developers, you publish it so that it's visible to Go tools. Once you've published the module, developers importing its packages will be able to resolve a dependency on the module by running commands such as go get.
+</p>
+
+<h4 id="modules-version-numbers"><a href="/doc/modules/version-numbers">Module version numbering</a></h4>
+<p>
+A module's developer uses each part of a module's version number to signal the version’s stability and backward compatibility. For each new release, a module's release version number specifically reflects the nature of the module's changes since the preceding release.
+</p>
+
+<h3 id="faq"><a href="/doc/faq">Frequently Asked Questions (FAQ)</a></h3>
+<p>
+Answers to common questions about Go.
+</p>
+
+<h2 id="references">References</h2>
+
+<h3 id="pkg"><a href="/pkg/">Package Documentation</a></h3>
+<p>
+The documentation for the Go standard library.
+</p>
+
+<h3 id="cmd"><a href="/doc/cmd">Command Documentation</a></h3>
+<p>
+The documentation for the Go tools.
+</p>
+
+<h3 id="spec"><a href="/ref/spec">Language Specification</a></h3>
+<p>
+The official Go Language specification.
+</p>
+
+<h3 id="mod"><a href="/ref/mod">Go Modules Reference</a></h3>
+<p>
+A detailed reference manual for Go's dependency management system.
+</p>
+
+<h3><a href="/doc/modules/gomod-ref">go.mod file reference</a></h3>
+<p>
+Reference for the directives included in a go.mod file.
+</p>
+
+<h3 id="go_mem"><a href="/ref/mem">The Go Memory Model</a></h3>
+<p>
+A document that specifies the conditions under which reads of a variable in
+one goroutine can be guaranteed to observe values produced by writes to the
+same variable in a different goroutine.
+</p>
+
+<h3 id="release"><a href="/doc/devel/release.html">Release History</a></h3>
+<p>A summary of the changes between Go releases.</p>
+
+<h2 id="codewalks">Codewalks</h2>
+<p>
+Guided tours of Go programs.
+</p>
+<ul>
+<li><a href="/doc/codewalk/functions">First-Class Functions in Go</a></li>
+<li><a href="/doc/codewalk/markov">Generating arbitrary text: a Markov chain algorithm</a></li>
+<li><a href="/doc/codewalk/sharemem">Share Memory by Communicating</a></li>
+</ul>
+
+{{if not $.GoogleCN}}
+<h2 id="blog">From the Go Blog</h2>
+<p>The <a href="//blog.golang.org/">official blog of the Go project</a>, featuring news and in-depth articles by
+the Go team and guests.</p>
+
+<h4>Language</h4>
+<ul>
+<li><a href="/blog/json-rpc-tale-of-interfaces">JSON-RPC: a tale of interfaces</a></li>
+<li><a href="/blog/gos-declaration-syntax">Go's Declaration Syntax</a></li>
+<li><a href="/blog/defer-panic-and-recover">Defer, Panic, and Recover</a></li>
+<li><a href="/blog/go-concurrency-patterns-timing-out-and">Go Concurrency Patterns: Timing out, moving on</a></li>
+<li><a href="/blog/go-slices-usage-and-internals">Go Slices: usage and internals</a></li>
+<li><a href="/blog/gif-decoder-exercise-in-go-interfaces">A GIF decoder: an exercise in Go interfaces</a></li>
+<li><a href="/blog/error-handling-and-go">Error Handling and Go</a></li>
+<li><a href="/blog/organizing-go-code">Organizing Go code</a></li>
+</ul>
+
+<h4>Packages</h4>
+<ul>
+<li><a href="/blog/json-and-go">JSON and Go</a> - using the <a href="/pkg/encoding/json/">json</a> package.</li>
+<li><a href="/blog/gobs-of-data">Gobs of data</a> - the design and use of the <a href="/pkg/encoding/gob/">gob</a> package.</li>
+<li><a href="/blog/laws-of-reflection">The Laws of Reflection</a> - the fundamentals of the <a href="/pkg/reflect/">reflect</a> package.</li>
+<li><a href="/blog/go-image-package">The Go image package</a> - the fundamentals of the <a href="/pkg/image/">image</a> package.</li>
+<li><a href="/blog/go-imagedraw-package">The Go image/draw package</a> - the fundamentals of the <a href="/pkg/image/draw/">image/draw</a> package.</li>
+</ul>
+
+<h4>Modules</h4>
+<ul>
+<li><a href="/blog/using-go-modules">Using Go Modules</a> - an introduction to using modules in a simple project.</li>
+<li><a href="/blog/migrating-to-go-modules">Migrating to Go Modules</a> - converting an existing project to use modules.</li>
+<li><a href="/blog/publishing-go-modules">Publishing Go Modules</a> - how to make new versions of modules available to others.</li>
+<li><a href="/blog/v2-go-modules">Go Modules: v2 and Beyond</a> - creating and publishing major versions 2 and higher.</li>
+<li><a href="/blog/module-compatibility">Keeping Your Modules Compatible</a> - how to keep your modules compatible with prior minor/patch versions.</li>
+</ul>
+{{end}}
+
+<h4>Tools</h4>
+<ul>
+<li><a href="/doc/articles/go_command.html">About the Go command</a> - why we wrote it, what it is, what it's not, and how to use it.</li>
+<li><a href="/doc/gdb">Debugging Go Code with GDB</a></li>
+<li><a href="/doc/articles/race_detector.html">Data Race Detector</a> - a manual for the data race detector.</li>
+<li><a href="/doc/asm">A Quick Guide to Go's Assembler</a> - an introduction to the assembler used by Go.</li>
+{{if not $.GoogleCN}}
+<li><a href="/blog/c-go-cgo">C? Go? Cgo!</a> - linking against C code with <a href="/cmd/cgo/">cgo</a>.</li>
+<li><a href="/blog/godoc-documenting-go-code">Godoc: documenting Go code</a> - writing good documentation for <a href="/cmd/godoc/">godoc</a>.</li>
+<li><a href="/blog/profiling-go-programs">Profiling Go Programs</a></li>
+<li><a href="/blog/race-detector">Introducing the Go Race Detector</a> - an introduction to the race detector.</li>
+{{end}}
+</ul>
+
+<h2 id="wiki">Wiki</h2>
+<p>
+The <a href="/wiki">Go Wiki</a>, maintained by the Go community, includes articles about the Go language, tools, and other resources.
+</p>
+
+<p id="learn_more">
+See the <a href="/wiki/Learn">Learn</a> page at the <a href="/wiki">Wiki</a>
+for more Go learning resources.
+</p>
+
+{{if not $.GoogleCN}}
+<h2 id="talks">Talks</h2>
+
+<img class="gopher" src="/doc/gopher/talks.png" alt=""/>
+
+<h3 id="video_tour_of_go"><a href="https://research.swtch.com/gotour">A Video Tour of Go</a></h3>
+<p>
+Three things that make Go fast, fun, and productive:
+interfaces, reflection, and concurrency. Builds a toy web crawler to
+demonstrate these.
+</p>
+
+<h3 id="go_code_that_grows"><a href="//vimeo.com/53221560">Code that grows with grace</a></h3>
+<p>
+One of Go's key design goals is code adaptability; that it should be easy to take a simple design and build upon it in a clean and natural way. In this talk Andrew Gerrand describes a simple "chat roulette" server that matches pairs of incoming TCP connections, and then use Go's concurrency mechanisms, interfaces, and standard library to extend it with a web interface and other features. While the function of the program changes dramatically, Go's flexibility preserves the original design as it grows.
+</p>
+
+<h3 id="go_concurrency_patterns"><a href="//www.youtube.com/watch?v=f6kdp27TYZs">Go Concurrency Patterns</a></h3>
+<p>
+Concurrency is the key to designing high performance network services. Go's concurrency primitives (goroutines and channels) provide a simple and efficient means of expressing concurrent execution. In this talk we see how tricky concurrency problems can be solved gracefully with simple Go code.
+</p>
+
+<h3 id="advanced_go_concurrency_patterns"><a href="//www.youtube.com/watch?v=QDDwwePbDtw">Advanced Go Concurrency Patterns</a></h3>
+<p>
+This talk expands on the <i>Go Concurrency Patterns</i> talk to dive deeper into Go's concurrency primitives.
+</p>
+
+<h4 id="talks_more">More</h4>
+<p>
+See the <a href="/talks">Go Talks site</a> and <a href="/wiki/GoTalks">wiki page</a> for more Go talks.
+</p>
+{{end}}
+
+<h2 id="nonenglish">Non-English Documentation</h2>
+
+<p>
+See the <a href="/wiki/NonEnglish">NonEnglish</a> page
+at the <a href="/wiki">Wiki</a> for localized
+documentation.
+</p>
diff --git a/_content/doc/download.js b/_content/doc/download.js
new file mode 100644
index 0000000..11f2a5a
--- /dev/null
+++ b/_content/doc/download.js
@@ -0,0 +1,143 @@
+class DownloadsController {
+ constructor() {
+ // Parts of tabbed section.
+ this.tablist = document.querySelector('.js-tabSection');
+ this.tabs = this.tablist.querySelectorAll('[role="tab"]');
+ this.panels = document.querySelectorAll('[role="tabpanel"]');
+
+ // OS for which to display download and install steps.
+ this.osName = 'Unknown OS';
+
+ // URL to JSON containing list of installer downloads.
+ const fileListUrl = 'https://golang.org/dl/?mode=json';
+ this.activeTabIndex = 0;
+
+ // Get the install file list, then get names and sizes
+ // for each OS supported on the install page.
+ fetch(fileListUrl)
+ .then((response) => response.json())
+ .then((data) => {
+ const files = data[0]['files'];
+ for (var i = 0; i < files.length; i++) {
+ let file = files[i].filename;
+ let fileSize = files[i].size;
+ if (file.match('.linux-amd64.tar.gz$')) {
+ this.linuxFileName = file;
+ this.linuxFileSize = Math.round(fileSize / Math.pow(1024, 2));
+ }
+ if (file.match('.darwin-amd64(-osx10.8)?.pkg$')) {
+ this.macFileName = file;
+ this.macFileSize = Math.round(fileSize / Math.pow(1024, 2));
+ }
+ if (file.match('.windows-amd64.msi$')) {
+ this.windowsFileName = file;
+ this.windowsFileSize = Math.round(fileSize / Math.pow(1024, 2));
+ }
+ }
+ this.detectOS();
+ const osTab = document.getElementById(this.osName);
+ if (osTab !== null) {
+ osTab.click();
+ }
+ this.setDownloadForOS(this.osName);
+ })
+ .catch(console.error);
+ this.setEventListeners();
+ }
+
+ setEventListeners() {
+ this.tabs.forEach((tabEl) => {
+ tabEl.addEventListener('click', e => this.handleTabClick((e)));
+ });
+ }
+
+ // Set the download button UI for a specific OS.
+ setDownloadForOS(osName) {
+ const baseURL = 'https://golang.org/dl/';
+ let download;
+
+ switch(osName){
+ case 'linux':
+ document.querySelector('.js-downloadButton').textContent =
+ 'Download Go for Linux';
+ document.querySelector('.js-downloadDescription').textContent =
+ this.linuxFileName + ' (' + this.linuxFileSize + ' MB)';
+ document.querySelector('.js-download').href = baseURL + this.linuxFileName;
+ break;
+ case 'mac':
+ document.querySelector('.js-downloadButton').textContent =
+ 'Download Go for Mac';
+ document.querySelector('.js-downloadDescription').textContent =
+ this.macFileName + ' (' + this.macFileSize + ' MB)';
+ document.querySelector('.js-download').href = baseURL + this.macFileName;
+ break;
+ case 'windows':
+ document.querySelector('.js-downloadButton').textContent =
+ 'Download Go for Windows';
+ document.querySelector('.js-downloadDescription').textContent =
+ this.windowsFileName + ' (' + this.windowsFileSize + ' MB)';
+ document.querySelector('.js-download').href = baseURL + this.windowsFileName;
+ break;
+ default:
+ document.querySelector('.js-downloadButton').textContent = 'Download Go';
+ document.querySelector('.js-downloadDescription').textContent =
+ 'Visit the downloads page.';
+ document.querySelector('.js-download').href = baseURL;
+ break;
+ }
+ }
+
+ // Updates install tab with dynamic data.
+ setInstallTabData(osName) {
+ const fnId = `#${osName}-filename`;
+ const el = document.querySelector(fnId);
+ if (!el) {
+ return;
+ }
+ switch(osName) {
+ case 'linux':
+ // Update filename for linux installation step
+ if (this.linuxFileName) {
+ el.textContent = this.linuxFileName;
+ }
+ break;
+ }
+ }
+
+ // Detect the users OS for installation default.
+ detectOS() {
+ if (navigator.userAgent.indexOf('Linux') !== -1) {
+ this.osName = 'linux';
+ } else if (navigator.userAgent.indexOf('Mac') !== -1) {
+ this.osName = 'mac';
+ } else if (navigator.userAgent.indexOf('X11') !== -1) {
+ this.osName = 'unix';
+ } else if (navigator.userAgent.indexOf('Win') !== -1) {
+ this.osName = 'windows';
+ }
+ }
+
+ // Activates the tab at the given index.
+ activateTab(index) {
+ this.tabs[this.activeTabIndex].setAttribute('aria-selected', 'false');
+ this.tabs[this.activeTabIndex].setAttribute('tabindex', '-1');
+ this.panels[this.activeTabIndex].setAttribute('hidden', '');
+ this.tabs[index].setAttribute('aria-selected', 'true');
+ this.tabs[index].setAttribute('tabindex', '0');
+ this.panels[index].removeAttribute('hidden');
+ this.tabs[index].focus();
+ this.activeTabIndex = index;
+ }
+
+ // Handles clicks on tabs.
+ handleTabClick(e) {
+ const el = (e.target);
+ this.activateTab(Array.prototype.indexOf.call(this.tabs, el));
+ this.setDownloadForOS(el.id);
+ this.setInstallTabData(el.id);
+ }
+
+}
+
+// Instantiate controller for page event handling.
+new DownloadsController();
diff --git a/_content/doc/editors.html b/_content/doc/editors.html
new file mode 100644
index 0000000..e0d0c53
--- /dev/null
+++ b/_content/doc/editors.html
@@ -0,0 +1,33 @@
+<!--{
+ "Title": "Editor plugins and IDEs",
+ "Template": true
+}-->
+
+<h2 id="introduction">Introduction</h2>
+
+<p>
+ This document lists commonly used editor plugins and IDEs from the Go ecosystem
+ that make Go development more productive and seamless.
+ A comprehensive list of editor support and IDEs for Go development is available at
+ <a href="https://golang.org/wiki/IDEsAndTextEditorPlugins">the wiki</a>.
+</p>
+
+<h2 id="options">Options</h2>
+<p>
+The Go ecosystem provides a variety of editor plugins and IDEs to enhance your day-to-day
+editing, navigation, testing, and debugging experience.
+</p>
+
+<ul>
+<li><a href="https://marketplace.visualstudio.com/items?itemName=golang.go">Visual Studio Code</a>:
+Go extension provides support for the Go programming language</li>
+<li><a href="https://www.jetbrains.com/go">GoLand</a>: GoLand is distributed either as a standalone IDE
+or as a plugin for IntelliJ IDEA Ultimate</li>
+<li><a href="https://github.com/fatih/vim-go">vim</a>: vim-go plugin provides Go programming language support</li>
+
+<p>
+Note that these are only a few top solutions; a more comprehensive
+community-maintained list of
+<a href="https://github.com/golang/go/wiki/IDEsAndTextEditorPlugins">IDEs and text editor plugins</a>
+is available at the Wiki.
+</p>
diff --git a/_content/doc/effective_go.html b/_content/doc/effective_go.html
new file mode 100644
index 0000000..3db4d1b
--- /dev/null
+++ b/_content/doc/effective_go.html
@@ -0,0 +1,3673 @@
+<!--{
+ "Title": "Effective Go",
+ "Template": true
+}-->
+
+<h2 id="introduction">Introduction</h2>
+
+<p>
+Go is a new language. Although it borrows ideas from
+existing languages,
+it has unusual properties that make effective Go programs
+different in character from programs written in its relatives.
+A straightforward translation of a C++ or Java program into Go
+is unlikely to produce a satisfactory result—Java programs
+are written in Java, not Go.
+On the other hand, thinking about the problem from a Go
+perspective could produce a successful but quite different
+program.
+In other words,
+to write Go well, it's important to understand its properties
+and idioms.
+It's also important to know the established conventions for
+programming in Go, such as naming, formatting, program
+construction, and so on, so that programs you write
+will be easy for other Go programmers to understand.
+</p>
+
+<p>
+This document gives tips for writing clear, idiomatic Go code.
+It augments the <a href="/ref/spec">language specification</a>,
+the <a href="//tour.golang.org/">Tour of Go</a>,
+and <a href="/doc/code.html">How to Write Go Code</a>,
+all of which you
+should read first.
+</p>
+
+<h3 id="examples">Examples</h3>
+
+<p>
+The <a href="/src/">Go package sources</a>
+are intended to serve not
+only as the core library but also as examples of how to
+use the language.
+Moreover, many of the packages contain working, self-contained
+executable examples you can run directly from the
+<a href="//golang.org">golang.org</a> web site, such as
+<a href="//golang.org/pkg/strings/#example_Map">this one</a> (if
+necessary, click on the word "Example" to open it up).
+If you have a question about how to approach a problem or how something
+might be implemented, the documentation, code and examples in the
+library can provide answers, ideas and
+background.
+</p>
+
+
+<h2 id="formatting">Formatting</h2>
+
+<p>
+Formatting issues are the most contentious
+but the least consequential.
+People can adapt to different formatting styles
+but it's better if they don't have to, and
+less time is devoted to the topic
+if everyone adheres to the same style.
+The problem is how to approach this Utopia without a long
+prescriptive style guide.
+</p>
+
+<p>
+With Go we take an unusual
+approach and let the machine
+take care of most formatting issues.
+The <code>gofmt</code> program
+(also available as <code>go fmt</code>, which
+operates at the package level rather than source file level)
+reads a Go program
+and emits the source in a standard style of indentation
+and vertical alignment, retaining and if necessary
+reformatting comments.
+If you want to know how to handle some new layout
+situation, run <code>gofmt</code>; if the answer doesn't
+seem right, rearrange your program (or file a bug about <code>gofmt</code>),
+don't work around it.
+</p>
+
+<p>
+As an example, there's no need to spend time lining up
+the comments on the fields of a structure.
+<code>Gofmt</code> will do that for you. Given the
+declaration
+</p>
+
+<pre>
+type T struct {
+ name string // name of the object
+ value int // its value
+}
+</pre>
+
+<p>
+<code>gofmt</code> will line up the columns:
+</p>
+
+<pre>
+type T struct {
+ name string // name of the object
+ value int // its value
+}
+</pre>
+
+<p>
+All Go code in the standard packages has been formatted with <code>gofmt</code>.
+</p>
+
+
+<p>
+Some formatting details remain. Very briefly:
+</p>
+
+<dl>
+ <dt>Indentation</dt>
+ <dd>We use tabs for indentation and <code>gofmt</code> emits them by default.
+ Use spaces only if you must.
+ </dd>
+ <dt>Line length</dt>
+ <dd>
+ Go has no line length limit. Don't worry about overflowing a punched card.
+ If a line feels too long, wrap it and indent with an extra tab.
+ </dd>
+ <dt>Parentheses</dt>
+ <dd>
+ Go needs fewer parentheses than C and Java: control structures (<code>if</code>,
+ <code>for</code>, <code>switch</code>) do not have parentheses in
+ their syntax.
+ Also, the operator precedence hierarchy is shorter and clearer, so
+<pre>
+x<<8 + y<<16
+</pre>
+ means what the spacing implies, unlike in the other languages.
+ </dd>
+</dl>
+
+<h2 id="commentary">Commentary</h2>
+
+<p>
+Go provides C-style <code>/* */</code> block comments
+and C++-style <code>//</code> line comments.
+Line comments are the norm;
+block comments appear mostly as package comments, but
+are useful within an expression or to disable large swaths of code.
+</p>
+
+<p>
+The program—and web server—<code>godoc</code> processes
+Go source files to extract documentation about the contents of the
+package.
+Comments that appear before top-level declarations, with no intervening newlines,
+are extracted along with the declaration to serve as explanatory text for the item.
+The nature and style of these comments determines the
+quality of the documentation <code>godoc</code> produces.
+</p>
+
+<p>
+Every package should have a <i>package comment</i>, a block
+comment preceding the package clause.
+For multi-file packages, the package comment only needs to be
+present in one file, and any one will do.
+The package comment should introduce the package and
+provide information relevant to the package as a whole.
+It will appear first on the <code>godoc</code> page and
+should set up the detailed documentation that follows.
+</p>
+
+<pre>
+/*
+Package regexp implements a simple library for regular expressions.
+
+The syntax of the regular expressions accepted is:
+
+ regexp:
+ concatenation { '|' concatenation }
+ concatenation:
+ { closure }
+ closure:
+ term [ '*' | '+' | '?' ]
+ term:
+ '^'
+ '$'
+ '.'
+ character
+ '[' [ '^' ] character-ranges ']'
+ '(' regexp ')'
+*/
+package regexp
+</pre>
+
+<p>
+If the package is simple, the package comment can be brief.
+</p>
+
+<pre>
+// Package path implements utility routines for
+// manipulating slash-separated filename paths.
+</pre>
+
+<p>
+Comments do not need extra formatting such as banners of stars.
+The generated output may not even be presented in a fixed-width font, so don't depend
+on spacing for alignment—<code>godoc</code>, like <code>gofmt</code>,
+takes care of that.
+The comments are uninterpreted plain text, so HTML and other
+annotations such as <code>_this_</code> will reproduce <i>verbatim</i> and should
+not be used.
+One adjustment <code>godoc</code> does do is to display indented
+text in a fixed-width font, suitable for program snippets.
+The package comment for the
+<a href="/pkg/fmt/"><code>fmt</code> package</a> uses this to good effect.
+</p>
+
+<p>
+Depending on the context, <code>godoc</code> might not even
+reformat comments, so make sure they look good straight up:
+use correct spelling, punctuation, and sentence structure,
+fold long lines, and so on.
+</p>
+
+<p>
+Inside a package, any comment immediately preceding a top-level declaration
+serves as a <i>doc comment</i> for that declaration.
+Every exported (capitalized) name in a program should
+have a doc comment.
+</p>
+
+<p>
+Doc comments work best as complete sentences, which allow
+a wide variety of automated presentations.
+The first sentence should be a one-sentence summary that
+starts with the name being declared.
+</p>
+
+<pre>
+// Compile parses a regular expression and returns, if successful,
+// a Regexp that can be used to match against text.
+func Compile(str string) (*Regexp, error) {
+</pre>
+
+<p>
+If every doc comment begins with the name of the item it describes,
+you can use the <a href="/cmd/go/#hdr-Show_documentation_for_package_or_symbol">doc</a>
+subcommand of the <a href="/cmd/go/">go</a> tool
+and run the output through <code>grep</code>.
+Imagine you couldn't remember the name "Compile" but were looking for
+the parsing function for regular expressions, so you ran
+the command,
+</p>
+
+<pre>
+$ go doc -all regexp | grep -i parse
+</pre>
+
+<p>
+If all the doc comments in the package began, "This function...", <code>grep</code>
+wouldn't help you remember the name. But because the package starts each
+doc comment with the name, you'd see something like this,
+which recalls the word you're looking for.
+</p>
+
+<pre>
+$ go doc -all regexp | grep -i parse
+ Compile parses a regular expression and returns, if successful, a Regexp
+ MustCompile is like Compile but panics if the expression cannot be parsed.
+ parsed. It simplifies safe initialization of global variables holding
+$
+</pre>
+
+<p>
+Go's declaration syntax allows grouping of declarations.
+A single doc comment can introduce a group of related constants or variables.
+Since the whole declaration is presented, such a comment can often be perfunctory.
+</p>
+
+<pre>
+// Error codes returned by failures to parse an expression.
+var (
+ ErrInternal = errors.New("regexp: internal error")
+ ErrUnmatchedLpar = errors.New("regexp: unmatched '('")
+ ErrUnmatchedRpar = errors.New("regexp: unmatched ')'")
+ ...
+)
+</pre>
+
+<p>
+Grouping can also indicate relationships between items,
+such as the fact that a set of variables is protected by a mutex.
+</p>
+
+<pre>
+var (
+ countLock sync.Mutex
+ inputCount uint32
+ outputCount uint32
+ errorCount uint32
+)
+</pre>
+
+<h2 id="names">Names</h2>
+
+<p>
+Names are as important in Go as in any other language.
+They even have semantic effect:
+the visibility of a name outside a package is determined by whether its
+first character is upper case.
+It's therefore worth spending a little time talking about naming conventions
+in Go programs.
+</p>
+
+
+<h3 id="package-names">Package names</h3>
+
+<p>
+When a package is imported, the package name becomes an accessor for the
+contents. After
+</p>
+
+<pre>
+import "bytes"
+</pre>
+
+<p>
+the importing package can talk about <code>bytes.Buffer</code>. It's
+helpful if everyone using the package can use the same name to refer to
+its contents, which implies that the package name should be good:
+short, concise, evocative. By convention, packages are given
+lower case, single-word names; there should be no need for underscores
+or mixedCaps.
+Err on the side of brevity, since everyone using your
+package will be typing that name.
+And don't worry about collisions <i>a priori</i>.
+The package name is only the default name for imports; it need not be unique
+across all source code, and in the rare case of a collision the
+importing package can choose a different name to use locally.
+In any case, confusion is rare because the file name in the import
+determines just which package is being used.
+</p>
+
+<p>
+Another convention is that the package name is the base name of
+its source directory;
+the package in <code>src/encoding/base64</code>
+is imported as <code>"encoding/base64"</code> but has name <code>base64</code>,
+not <code>encoding_base64</code> and not <code>encodingBase64</code>.
+</p>
+
+<p>
+The importer of a package will use the name to refer to its contents,
+so exported names in the package can use that fact
+to avoid repetition.
+(Don't use the <code>import .</code> notation, which can simplify
+tests that must run outside the package they are testing, but should otherwise be avoided.)
+For instance, the buffered reader type in the <code>bufio</code> package is called <code>Reader</code>,
+not <code>BufReader</code>, because users see it as <code>bufio.Reader</code>,
+which is a clear, concise name.
+Moreover,
+because imported entities are always addressed with their package name, <code>bufio.Reader</code>
+does not conflict with <code>io.Reader</code>.
+Similarly, the function to make new instances of <code>ring.Ring</code>—which
+is the definition of a <em>constructor</em> in Go—would
+normally be called <code>NewRing</code>, but since
+<code>Ring</code> is the only type exported by the package, and since the
+package is called <code>ring</code>, it's called just <code>New</code>,
+which clients of the package see as <code>ring.New</code>.
+Use the package structure to help you choose good names.
+</p>
+
+<p>
+Another short example is <code>once.Do</code>;
+<code>once.Do(setup)</code> reads well and would not be improved by
+writing <code>once.DoOrWaitUntilDone(setup)</code>.
+Long names don't automatically make things more readable.
+A helpful doc comment can often be more valuable than an extra long name.
+</p>
+
+<h3 id="Getters">Getters</h3>
+
+<p>
+Go doesn't provide automatic support for getters and setters.
+There's nothing wrong with providing getters and setters yourself,
+and it's often appropriate to do so, but it's neither idiomatic nor necessary
+to put <code>Get</code> into the getter's name. If you have a field called
+<code>owner</code> (lower case, unexported), the getter method should be
+called <code>Owner</code> (upper case, exported), not <code>GetOwner</code>.
+The use of upper-case names for export provides the hook to discriminate
+the field from the method.
+A setter function, if needed, will likely be called <code>SetOwner</code>.
+Both names read well in practice:
+</p>
+<pre>
+owner := obj.Owner()
+if owner != user {
+ obj.SetOwner(user)
+}
+</pre>
+
+<h3 id="interface-names">Interface names</h3>
+
+<p>
+By convention, one-method interfaces are named by
+the method name plus an -er suffix or similar modification
+to construct an agent noun: <code>Reader</code>,
+<code>Writer</code>, <code>Formatter</code>,
+<code>CloseNotifier</code> etc.
+</p>
+
+<p>
+There are a number of such names and it's productive to honor them and the function
+names they capture.
+<code>Read</code>, <code>Write</code>, <code>Close</code>, <code>Flush</code>,
+<code>String</code> and so on have
+canonical signatures and meanings. To avoid confusion,
+don't give your method one of those names unless it
+has the same signature and meaning.
+Conversely, if your type implements a method with the
+same meaning as a method on a well-known type,
+give it the same name and signature;
+call your string-converter method <code>String</code> not <code>ToString</code>.
+</p>
+
+<h3 id="mixed-caps">MixedCaps</h3>
+
+<p>
+Finally, the convention in Go is to use <code>MixedCaps</code>
+or <code>mixedCaps</code> rather than underscores to write
+multiword names.
+</p>
+
+<h2 id="semicolons">Semicolons</h2>
+
+<p>
+Like C, Go's formal grammar uses semicolons to terminate statements,
+but unlike in C, those semicolons do not appear in the source.
+Instead the lexer uses a simple rule to insert semicolons automatically
+as it scans, so the input text is mostly free of them.
+</p>
+
+<p>
+The rule is this. If the last token before a newline is an identifier
+(which includes words like <code>int</code> and <code>float64</code>),
+a basic literal such as a number or string constant, or one of the
+tokens
+</p>
+<pre>
+break continue fallthrough return ++ -- ) }
+</pre>
+<p>
+the lexer always inserts a semicolon after the token.
+This could be summarized as, “if the newline comes
+after a token that could end a statement, insert a semicolon”.
+</p>
+
+<p>
+A semicolon can also be omitted immediately before a closing brace,
+so a statement such as
+</p>
+<pre>
+ go func() { for { dst <- <-src } }()
+</pre>
+<p>
+needs no semicolons.
+Idiomatic Go programs have semicolons only in places such as
+<code>for</code> loop clauses, to separate the initializer, condition, and
+continuation elements. They are also necessary to separate multiple
+statements on a line, should you write code that way.
+</p>
+
+<p>
+One consequence of the semicolon insertion rules
+is that you cannot put the opening brace of a
+control structure (<code>if</code>, <code>for</code>, <code>switch</code>,
+or <code>select</code>) on the next line. If you do, a semicolon
+will be inserted before the brace, which could cause unwanted
+effects. Write them like this
+</p>
+
+<pre>
+if i < f() {
+ g()
+}
+</pre>
+<p>
+not like this
+</p>
+<pre>
+if i < f() // wrong!
+{ // wrong!
+ g()
+}
+</pre>
+
+
+<h2 id="control-structures">Control structures</h2>
+
+<p>
+The control structures of Go are related to those of C but differ
+in important ways.
+There is no <code>do</code> or <code>while</code> loop, only a
+slightly generalized
+<code>for</code>;
+<code>switch</code> is more flexible;
+<code>if</code> and <code>switch</code> accept an optional
+initialization statement like that of <code>for</code>;
+<code>break</code> and <code>continue</code> statements
+take an optional label to identify what to break or continue;
+and there are new control structures including a type switch and a
+multiway communications multiplexer, <code>select</code>.
+The syntax is also slightly different:
+there are no parentheses
+and the bodies must always be brace-delimited.
+</p>
+
+<h3 id="if">If</h3>
+
+<p>
+In Go a simple <code>if</code> looks like this:
+</p>
+<pre>
+if x > 0 {
+ return y
+}
+</pre>
+
+<p>
+Mandatory braces encourage writing simple <code>if</code> statements
+on multiple lines. It's good style to do so anyway,
+especially when the body contains a control statement such as a
+<code>return</code> or <code>break</code>.
+</p>
+
+<p>
+Since <code>if</code> and <code>switch</code> accept an initialization
+statement, it's common to see one used to set up a local variable.
+</p>
+
+<pre>
+if err := file.Chmod(0664); err != nil {
+ log.Print(err)
+ return err
+}
+</pre>
+
+<p id="else">
+In the Go libraries, you'll find that
+when an <code>if</code> statement doesn't flow into the next statement—that is,
+the body ends in <code>break</code>, <code>continue</code>,
+<code>goto</code>, or <code>return</code>—the unnecessary
+<code>else</code> is omitted.
+</p>
+
+<pre>
+f, err := os.Open(name)
+if err != nil {
+ return err
+}
+codeUsing(f)
+</pre>
+
+<p>
+This is an example of a common situation where code must guard against a
+sequence of error conditions. The code reads well if the
+successful flow of control runs down the page, eliminating error cases
+as they arise. Since error cases tend to end in <code>return</code>
+statements, the resulting code needs no <code>else</code> statements.
+</p>
+
+<pre>
+f, err := os.Open(name)
+if err != nil {
+ return err
+}
+d, err := f.Stat()
+if err != nil {
+ f.Close()
+ return err
+}
+codeUsing(f, d)
+</pre>
+
+
+<h3 id="redeclaration">Redeclaration and reassignment</h3>
+
+<p>
+An aside: The last example in the previous section demonstrates a detail of how the
+<code>:=</code> short declaration form works.
+The declaration that calls <code>os.Open</code> reads,
+</p>
+
+<pre>
+f, err := os.Open(name)
+</pre>
+
+<p>
+This statement declares two variables, <code>f</code> and <code>err</code>.
+A few lines later, the call to <code>f.Stat</code> reads,
+</p>
+
+<pre>
+d, err := f.Stat()
+</pre>
+
+<p>
+which looks as if it declares <code>d</code> and <code>err</code>.
+Notice, though, that <code>err</code> appears in both statements.
+This duplication is legal: <code>err</code> is declared by the first statement,
+but only <em>re-assigned</em> in the second.
+This means that the call to <code>f.Stat</code> uses the existing
+<code>err</code> variable declared above, and just gives it a new value.
+</p>
+
+<p>
+In a <code>:=</code> declaration a variable <code>v</code> may appear even
+if it has already been declared, provided:
+</p>
+
+<ul>
+<li>this declaration is in the same scope as the existing declaration of <code>v</code>
+(if <code>v</code> is already declared in an outer scope, the declaration will create a new variable §),</li>
+<li>the corresponding value in the initialization is assignable to <code>v</code>, and</li>
+<li>there is at least one other variable that is created by the declaration.</li>
+</ul>
+
+<p>
+This unusual property is pure pragmatism,
+making it easy to use a single <code>err</code> value, for example,
+in a long <code>if-else</code> chain.
+You'll see it used often.
+</p>
+
+<p>
+§ It's worth noting here that in Go the scope of function parameters and return values
+is the same as the function body, even though they appear lexically outside the braces
+that enclose the body.
+</p>
+
+<h3 id="for">For</h3>
+
+<p>
+The Go <code>for</code> loop is similar to—but not the same as—C's.
+It unifies <code>for</code>
+and <code>while</code> and there is no <code>do-while</code>.
+There are three forms, only one of which has semicolons.
+</p>
+<pre>
+// Like a C for
+for init; condition; post { }
+
+// Like a C while
+for condition { }
+
+// Like a C for(;;)
+for { }
+</pre>
+
+<p>
+Short declarations make it easy to declare the index variable right in the loop.
+</p>
+<pre>
+sum := 0
+for i := 0; i < 10; i++ {
+ sum += i
+}
+</pre>
+
+<p>
+If you're looping over an array, slice, string, or map,
+or reading from a channel, a <code>range</code> clause can
+manage the loop.
+</p>
+<pre>
+for key, value := range oldMap {
+ newMap[key] = value
+}
+</pre>
+
+<p>
+If you only need the first item in the range (the key or index), drop the second:
+</p>
+<pre>
+for key := range m {
+ if key.expired() {
+ delete(m, key)
+ }
+}
+</pre>
+
+<p>
+If you only need the second item in the range (the value), use the <em>blank identifier</em>, an underscore, to discard the first:
+</p>
+<pre>
+sum := 0
+for _, value := range array {
+ sum += value
+}
+</pre>
+
+<p>
+The blank identifier has many uses, as described in <a href="#blank">a later section</a>.
+</p>
+
+<p>
+For strings, the <code>range</code> does more work for you, breaking out individual
+Unicode code points by parsing the UTF-8.
+Erroneous encodings consume one byte and produce the
+replacement rune U+FFFD.
+(The name (with associated builtin type) <code>rune</code> is Go terminology for a
+single Unicode code point.
+See <a href="/ref/spec#Rune_literals">the language specification</a>
+for details.)
+The loop
+</p>
+<pre>
+for pos, char := range "日本\x80語" { // \x80 is an illegal UTF-8 encoding
+ fmt.Printf("character %#U starts at byte position %d\n", char, pos)
+}
+</pre>
+<p>
+prints
+</p>
+<pre>
+character U+65E5 '日' starts at byte position 0
+character U+672C '本' starts at byte position 3
+character U+FFFD '�' starts at byte position 6
+character U+8A9E '語' starts at byte position 7
+</pre>
+
+<p>
+Finally, Go has no comma operator and <code>++</code> and <code>--</code>
+are statements not expressions.
+Thus if you want to run multiple variables in a <code>for</code>
+you should use parallel assignment (although that precludes <code>++</code> and <code>--</code>).
+</p>
+<pre>
+// Reverse a
+for i, j := 0, len(a)-1; i < j; i, j = i+1, j-1 {
+ a[i], a[j] = a[j], a[i]
+}
+</pre>
+
+<h3 id="switch">Switch</h3>
+
+<p>
+Go's <code>switch</code> is more general than C's.
+The expressions need not be constants or even integers,
+the cases are evaluated top to bottom until a match is found,
+and if the <code>switch</code> has no expression it switches on
+<code>true</code>.
+It's therefore possible—and idiomatic—to write an
+<code>if</code>-<code>else</code>-<code>if</code>-<code>else</code>
+chain as a <code>switch</code>.
+</p>
+
+<pre>
+func unhex(c byte) byte {
+ switch {
+ case '0' <= c && c <= '9':
+ return c - '0'
+ case 'a' <= c && c <= 'f':
+ return c - 'a' + 10
+ case 'A' <= c && c <= 'F':
+ return c - 'A' + 10
+ }
+ return 0
+}
+</pre>
+
+<p>
+There is no automatic fall through, but cases can be presented
+in comma-separated lists.
+</p>
+<pre>
+func shouldEscape(c byte) bool {
+ switch c {
+ case ' ', '?', '&', '=', '#', '+', '%':
+ return true
+ }
+ return false
+}
+</pre>
+
+<p>
+Although they are not nearly as common in Go as some other C-like
+languages, <code>break</code> statements can be used to terminate
+a <code>switch</code> early.
+Sometimes, though, it's necessary to break out of a surrounding loop,
+not the switch, and in Go that can be accomplished by putting a label
+on the loop and "breaking" to that label.
+This example shows both uses.
+</p>
+
+<pre>
+Loop:
+ for n := 0; n < len(src); n += size {
+ switch {
+ case src[n] < sizeOne:
+ if validateOnly {
+ break
+ }
+ size = 1
+ update(src[n])
+
+ case src[n] < sizeTwo:
+ if n+1 >= len(src) {
+ err = errShortInput
+ break Loop
+ }
+ if validateOnly {
+ break
+ }
+ size = 2
+ update(src[n] + src[n+1]<<shift)
+ }
+ }
+</pre>
+
+<p>
+Of course, the <code>continue</code> statement also accepts an optional label
+but it applies only to loops.
+</p>
+
+<p>
+To close this section, here's a comparison routine for byte slices that uses two
+<code>switch</code> statements:
+</p>
+<pre>
+// Compare returns an integer comparing the two byte slices,
+// lexicographically.
+// The result will be 0 if a == b, -1 if a < b, and +1 if a > b
+func Compare(a, b []byte) int {
+ for i := 0; i < len(a) && i < len(b); i++ {
+ switch {
+ case a[i] > b[i]:
+ return 1
+ case a[i] < b[i]:
+ return -1
+ }
+ }
+ switch {
+ case len(a) > len(b):
+ return 1
+ case len(a) < len(b):
+ return -1
+ }
+ return 0
+}
+</pre>
+
+<h3 id="type_switch">Type switch</h3>
+
+<p>
+A switch can also be used to discover the dynamic type of an interface
+variable. Such a <em>type switch</em> uses the syntax of a type
+assertion with the keyword <code>type</code> inside the parentheses.
+If the switch declares a variable in the expression, the variable will
+have the corresponding type in each clause.
+It's also idiomatic to reuse the name in such cases, in effect declaring
+a new variable with the same name but a different type in each case.
+</p>
+<pre>
+var t interface{}
+t = functionOfSomeType()
+switch t := t.(type) {
+default:
+ fmt.Printf("unexpected type %T\n", t) // %T prints whatever type t has
+case bool:
+ fmt.Printf("boolean %t\n", t) // t has type bool
+case int:
+ fmt.Printf("integer %d\n", t) // t has type int
+case *bool:
+ fmt.Printf("pointer to boolean %t\n", *t) // t has type *bool
+case *int:
+ fmt.Printf("pointer to integer %d\n", *t) // t has type *int
+}
+</pre>
+
+<h2 id="functions">Functions</h2>
+
+<h3 id="multiple-returns">Multiple return values</h3>
+
+<p>
+One of Go's unusual features is that functions and methods
+can return multiple values. This form can be used to
+improve on a couple of clumsy idioms in C programs: in-band
+error returns such as <code>-1</code> for <code>EOF</code>
+and modifying an argument passed by address.
+</p>
+
+<p>
+In C, a write error is signaled by a negative count with the
+error code secreted away in a volatile location.
+In Go, <code>Write</code>
+can return a count <i>and</i> an error: “Yes, you wrote some
+bytes but not all of them because you filled the device”.
+The signature of the <code>Write</code> method on files from
+package <code>os</code> is:
+</p>
+
+<pre>
+func (file *File) Write(b []byte) (n int, err error)
+</pre>
+
+<p>
+and as the documentation says, it returns the number of bytes
+written and a non-nil <code>error</code> when <code>n</code>
+<code>!=</code> <code>len(b)</code>.
+This is a common style; see the section on error handling for more examples.
+</p>
+
+<p>
+A similar approach obviates the need to pass a pointer to a return
+value to simulate a reference parameter.
+Here's a simple-minded function to
+grab a number from a position in a byte slice, returning the number
+and the next position.
+</p>
+
+<pre>
+func nextInt(b []byte, i int) (int, int) {
+ for ; i < len(b) && !isDigit(b[i]); i++ {
+ }
+ x := 0
+ for ; i < len(b) && isDigit(b[i]); i++ {
+ x = x*10 + int(b[i]) - '0'
+ }
+ return x, i
+}
+</pre>
+
+<p>
+You could use it to scan the numbers in an input slice <code>b</code> like this:
+</p>
+
+<pre>
+ for i := 0; i < len(b); {
+ x, i = nextInt(b, i)
+ fmt.Println(x)
+ }
+</pre>
+
+<h3 id="named-results">Named result parameters</h3>
+
+<p>
+The return or result "parameters" of a Go function can be given names and
+used as regular variables, just like the incoming parameters.
+When named, they are initialized to the zero values for their types when
+the function begins; if the function executes a <code>return</code> statement
+with no arguments, the current values of the result parameters are
+used as the returned values.
+</p>
+
+<p>
+The names are not mandatory but they can make code shorter and clearer:
+they're documentation.
+If we name the results of <code>nextInt</code> it becomes
+obvious which returned <code>int</code>
+is which.
+</p>
+
+<pre>
+func nextInt(b []byte, pos int) (value, nextPos int) {
+</pre>
+
+<p>
+Because named results are initialized and tied to an unadorned return, they can simplify
+as well as clarify. Here's a version
+of <code>io.ReadFull</code> that uses them well:
+</p>
+
+<pre>
+func ReadFull(r Reader, buf []byte) (n int, err error) {
+ for len(buf) > 0 && err == nil {
+ var nr int
+ nr, err = r.Read(buf)
+ n += nr
+ buf = buf[nr:]
+ }
+ return
+}
+</pre>
+
+<h3 id="defer">Defer</h3>
+
+<p>
+Go's <code>defer</code> statement schedules a function call (the
+<i>deferred</i> function) to be run immediately before the function
+executing the <code>defer</code> returns. It's an unusual but
+effective way to deal with situations such as resources that must be
+released regardless of which path a function takes to return. The
+canonical examples are unlocking a mutex or closing a file.
+</p>
+
+<pre>
+// Contents returns the file's contents as a string.
+func Contents(filename string) (string, error) {
+ f, err := os.Open(filename)
+ if err != nil {
+ return "", err
+ }
+ defer f.Close() // f.Close will run when we're finished.
+
+ var result []byte
+ buf := make([]byte, 100)
+ for {
+ n, err := f.Read(buf[0:])
+ result = append(result, buf[0:n]...) // append is discussed later.
+ if err != nil {
+ if err == io.EOF {
+ break
+ }
+ return "", err // f will be closed if we return here.
+ }
+ }
+ return string(result), nil // f will be closed if we return here.
+}
+</pre>
+
+<p>
+Deferring a call to a function such as <code>Close</code> has two advantages. First, it
+guarantees that you will never forget to close the file, a mistake
+that's easy to make if you later edit the function to add a new return
+path. Second, it means that the close sits near the open,
+which is much clearer than placing it at the end of the function.
+</p>
+
+<p>
+The arguments to the deferred function (which include the receiver if
+the function is a method) are evaluated when the <i>defer</i>
+executes, not when the <i>call</i> executes. Besides avoiding worries
+about variables changing values as the function executes, this means
+that a single deferred call site can defer multiple function
+executions. Here's a silly example.
+</p>
+
+<pre>
+for i := 0; i < 5; i++ {
+ defer fmt.Printf("%d ", i)
+}
+</pre>
+
+<p>
+Deferred functions are executed in LIFO order, so this code will cause
+<code>4 3 2 1 0</code> to be printed when the function returns. A
+more plausible example is a simple way to trace function execution
+through the program. We could write a couple of simple tracing
+routines like this:
+</p>
+
+<pre>
+func trace(s string) { fmt.Println("entering:", s) }
+func untrace(s string) { fmt.Println("leaving:", s) }
+
+// Use them like this:
+func a() {
+ trace("a")
+ defer untrace("a")
+ // do something....
+}
+</pre>
+
+<p>
+We can do better by exploiting the fact that arguments to deferred
+functions are evaluated when the <code>defer</code> executes. The
+tracing routine can set up the argument to the untracing routine.
+This example:
+</p>
+
+<pre>
+func trace(s string) string {
+ fmt.Println("entering:", s)
+ return s
+}
+
+func un(s string) {
+ fmt.Println("leaving:", s)
+}
+
+func a() {
+ defer un(trace("a"))
+ fmt.Println("in a")
+}
+
+func b() {
+ defer un(trace("b"))
+ fmt.Println("in b")
+ a()
+}
+
+func main() {
+ b()
+}
+</pre>
+
+<p>
+prints
+</p>
+
+<pre>
+entering: b
+in b
+entering: a
+in a
+leaving: a
+leaving: b
+</pre>
+
+<p>
+For programmers accustomed to block-level resource management from
+other languages, <code>defer</code> may seem peculiar, but its most
+interesting and powerful applications come precisely from the fact
+that it's not block-based but function-based. In the section on
+<code>panic</code> and <code>recover</code> we'll see another
+example of its possibilities.
+</p>
+
+<h2 id="data">Data</h2>
+
+<h3 id="allocation_new">Allocation with <code>new</code></h3>
+
+<p>
+Go has two allocation primitives, the built-in functions
+<code>new</code> and <code>make</code>.
+They do different things and apply to different types, which can be confusing,
+but the rules are simple.
+Let's talk about <code>new</code> first.
+It's a built-in function that allocates memory, but unlike its namesakes
+in some other languages it does not <em>initialize</em> the memory,
+it only <em>zeros</em> it.
+That is,
+<code>new(T)</code> allocates zeroed storage for a new item of type
+<code>T</code> and returns its address, a value of type <code>*T</code>.
+In Go terminology, it returns a pointer to a newly allocated zero value of type
+<code>T</code>.
+</p>
+
+<p>
+Since the memory returned by <code>new</code> is zeroed, it's helpful to arrange
+when designing your data structures that the
+zero value of each type can be used without further initialization. This means a user of
+the data structure can create one with <code>new</code> and get right to
+work.
+For example, the documentation for <code>bytes.Buffer</code> states that
+"the zero value for <code>Buffer</code> is an empty buffer ready to use."
+Similarly, <code>sync.Mutex</code> does not
+have an explicit constructor or <code>Init</code> method.
+Instead, the zero value for a <code>sync.Mutex</code>
+is defined to be an unlocked mutex.
+</p>
+
+<p>
+The zero-value-is-useful property works transitively. Consider this type declaration.
+</p>
+
+<pre>
+type SyncedBuffer struct {
+ lock sync.Mutex
+ buffer bytes.Buffer
+}
+</pre>
+
+<p>
+Values of type <code>SyncedBuffer</code> are also ready to use immediately upon allocation
+or just declaration. In the next snippet, both <code>p</code> and <code>v</code> will work
+correctly without further arrangement.
+</p>
+
+<pre>
+p := new(SyncedBuffer) // type *SyncedBuffer
+var v SyncedBuffer // type SyncedBuffer
+</pre>
+
+<h3 id="composite_literals">Constructors and composite literals</h3>
+
+<p>
+Sometimes the zero value isn't good enough and an initializing
+constructor is necessary, as in this example derived from
+package <code>os</code>.
+</p>
+
+<pre>
+func NewFile(fd int, name string) *File {
+ if fd < 0 {
+ return nil
+ }
+ f := new(File)
+ f.fd = fd
+ f.name = name
+ f.dirinfo = nil
+ f.nepipe = 0
+ return f
+}
+</pre>
+
+<p>
+There's a lot of boiler plate in there. We can simplify it
+using a <i>composite literal</i>, which is
+an expression that creates a
+new instance each time it is evaluated.
+</p>
+
+<pre>
+func NewFile(fd int, name string) *File {
+ if fd < 0 {
+ return nil
+ }
+ f := File{fd, name, nil, 0}
+ return &f
+}
+</pre>
+
+<p>
+Note that, unlike in C, it's perfectly OK to return the address of a local variable;
+the storage associated with the variable survives after the function
+returns.
+In fact, taking the address of a composite literal
+allocates a fresh instance each time it is evaluated,
+so we can combine these last two lines.
+</p>
+
+<pre>
+ return &File{fd, name, nil, 0}
+</pre>
+
+<p>
+The fields of a composite literal are laid out in order and must all be present.
+However, by labeling the elements explicitly as <i>field</i><code>:</code><i>value</i>
+pairs, the initializers can appear in any
+order, with the missing ones left as their respective zero values. Thus we could say
+</p>
+
+<pre>
+ return &File{fd: fd, name: name}
+</pre>
+
+<p>
+As a limiting case, if a composite literal contains no fields at all, it creates
+a zero value for the type. The expressions <code>new(File)</code> and <code>&File{}</code> are equivalent.
+</p>
+
+<p>
+Composite literals can also be created for arrays, slices, and maps,
+with the field labels being indices or map keys as appropriate.
+In these examples, the initializations work regardless of the values of <code>Enone</code>,
+<code>Eio</code>, and <code>Einval</code>, as long as they are distinct.
+</p>
+
+<pre>
+a := [...]string {Enone: "no error", Eio: "Eio", Einval: "invalid argument"}
+s := []string {Enone: "no error", Eio: "Eio", Einval: "invalid argument"}
+m := map[int]string{Enone: "no error", Eio: "Eio", Einval: "invalid argument"}
+</pre>
+
+<h3 id="allocation_make">Allocation with <code>make</code></h3>
+
+<p>
+Back to allocation.
+The built-in function <code>make(T, </code><i>args</i><code>)</code> serves
+a purpose different from <code>new(T)</code>.
+It creates slices, maps, and channels only, and it returns an <em>initialized</em>
+(not <em>zeroed</em>)
+value of type <code>T</code> (not <code>*T</code>).
+The reason for the distinction
+is that these three types represent, under the covers, references to data structures that
+must be initialized before use.
+A slice, for example, is a three-item descriptor
+containing a pointer to the data (inside an array), the length, and the
+capacity, and until those items are initialized, the slice is <code>nil</code>.
+For slices, maps, and channels,
+<code>make</code> initializes the internal data structure and prepares
+the value for use.
+For instance,
+</p>
+
+<pre>
+make([]int, 10, 100)
+</pre>
+
+<p>
+allocates an array of 100 ints and then creates a slice
+structure with length 10 and a capacity of 100 pointing at the first
+10 elements of the array.
+(When making a slice, the capacity can be omitted; see the section on slices
+for more information.)
+In contrast, <code>new([]int)</code> returns a pointer to a newly allocated, zeroed slice
+structure, that is, a pointer to a <code>nil</code> slice value.
+</p>
+
+<p>
+These examples illustrate the difference between <code>new</code> and
+<code>make</code>.
+</p>
+
+<pre>
+var p *[]int = new([]int) // allocates slice structure; *p == nil; rarely useful
+var v []int = make([]int, 100) // the slice v now refers to a new array of 100 ints
+
+// Unnecessarily complex:
+var p *[]int = new([]int)
+*p = make([]int, 100, 100)
+
+// Idiomatic:
+v := make([]int, 100)
+</pre>
+
+<p>
+Remember that <code>make</code> applies only to maps, slices and channels
+and does not return a pointer.
+To obtain an explicit pointer allocate with <code>new</code> or take the address
+of a variable explicitly.
+</p>
+
+<h3 id="arrays">Arrays</h3>
+
+<p>
+Arrays are useful when planning the detailed layout of memory and sometimes
+can help avoid allocation, but primarily
+they are a building block for slices, the subject of the next section.
+To lay the foundation for that topic, here are a few words about arrays.
+</p>
+
+<p>
+There are major differences between the ways arrays work in Go and C.
+In Go,
+</p>
+<ul>
+<li>
+Arrays are values. Assigning one array to another copies all the elements.
+</li>
+<li>
+In particular, if you pass an array to a function, it
+will receive a <i>copy</i> of the array, not a pointer to it.
+<li>
+The size of an array is part of its type. The types <code>[10]int</code>
+and <code>[20]int</code> are distinct.
+</li>
+</ul>
+
+<p>
+The value property can be useful but also expensive; if you want C-like behavior and efficiency,
+you can pass a pointer to the array.
+</p>
+
+<pre>
+func Sum(a *[3]float64) (sum float64) {
+ for _, v := range *a {
+ sum += v
+ }
+ return
+}
+
+array := [...]float64{7.0, 8.5, 9.1}
+x := Sum(&array) // Note the explicit address-of operator
+</pre>
+
+<p>
+But even this style isn't idiomatic Go.
+Use slices instead.
+</p>
+
+<h3 id="slices">Slices</h3>
+
+<p>
+Slices wrap arrays to give a more general, powerful, and convenient
+interface to sequences of data. Except for items with explicit
+dimension such as transformation matrices, most array programming in
+Go is done with slices rather than simple arrays.
+</p>
+<p>
+Slices hold references to an underlying array, and if you assign one
+slice to another, both refer to the same array.
+If a function takes a slice argument, changes it makes to
+the elements of the slice will be visible to the caller, analogous to
+passing a pointer to the underlying array. A <code>Read</code>
+function can therefore accept a slice argument rather than a pointer
+and a count; the length within the slice sets an upper
+limit of how much data to read. Here is the signature of the
+<code>Read</code> method of the <code>File</code> type in package
+<code>os</code>:
+</p>
+<pre>
+func (f *File) Read(buf []byte) (n int, err error)
+</pre>
+<p>
+The method returns the number of bytes read and an error value, if
+any.
+To read into the first 32 bytes of a larger buffer
+<code>buf</code>, <i>slice</i> (here used as a verb) the buffer.
+</p>
+<pre>
+ n, err := f.Read(buf[0:32])
+</pre>
+<p>
+Such slicing is common and efficient. In fact, leaving efficiency aside for
+the moment, the following snippet would also read the first 32 bytes of the buffer.
+</p>
+<pre>
+ var n int
+ var err error
+ for i := 0; i < 32; i++ {
+ nbytes, e := f.Read(buf[i:i+1]) // Read one byte.
+ n += nbytes
+ if nbytes == 0 || e != nil {
+ err = e
+ break
+ }
+ }
+</pre>
+<p>
+The length of a slice may be changed as long as it still fits within
+the limits of the underlying array; just assign it to a slice of
+itself. The <i>capacity</i> of a slice, accessible by the built-in
+function <code>cap</code>, reports the maximum length the slice may
+assume. Here is a function to append data to a slice. If the data
+exceeds the capacity, the slice is reallocated. The
+resulting slice is returned. The function uses the fact that
+<code>len</code> and <code>cap</code> are legal when applied to the
+<code>nil</code> slice, and return 0.
+</p>
+<pre>
+func Append(slice, data []byte) []byte {
+ l := len(slice)
+ if l + len(data) > cap(slice) { // reallocate
+ // Allocate double what's needed, for future growth.
+ newSlice := make([]byte, (l+len(data))*2)
+ // The copy function is predeclared and works for any slice type.
+ copy(newSlice, slice)
+ slice = newSlice
+ }
+ slice = slice[0:l+len(data)]
+ copy(slice[l:], data)
+ return slice
+}
+</pre>
+<p>
+We must return the slice afterwards because, although <code>Append</code>
+can modify the elements of <code>slice</code>, the slice itself (the run-time data
+structure holding the pointer, length, and capacity) is passed by value.
+</p>
+
+<p>
+The idea of appending to a slice is so useful it's captured by the
+<code>append</code> built-in function. To understand that function's
+design, though, we need a little more information, so we'll return
+to it later.
+</p>
+
+<h3 id="two_dimensional_slices">Two-dimensional slices</h3>
+
+<p>
+Go's arrays and slices are one-dimensional.
+To create the equivalent of a 2D array or slice, it is necessary to define an array-of-arrays
+or slice-of-slices, like this:
+</p>
+
+<pre>
+type Transform [3][3]float64 // A 3x3 array, really an array of arrays.
+type LinesOfText [][]byte // A slice of byte slices.
+</pre>
+
+<p>
+Because slices are variable-length, it is possible to have each inner
+slice be a different length.
+That can be a common situation, as in our <code>LinesOfText</code>
+example: each line has an independent length.
+</p>
+
+<pre>
+text := LinesOfText{
+ []byte("Now is the time"),
+ []byte("for all good gophers"),
+ []byte("to bring some fun to the party."),
+}
+</pre>
+
+<p>
+Sometimes it's necessary to allocate a 2D slice, a situation that can arise when
+processing scan lines of pixels, for instance.
+There are two ways to achieve this.
+One is to allocate each slice independently; the other
+is to allocate a single array and point the individual slices into it.
+Which to use depends on your application.
+If the slices might grow or shrink, they should be allocated independently
+to avoid overwriting the next line; if not, it can be more efficient to construct
+the object with a single allocation.
+For reference, here are sketches of the two methods.
+First, a line at a time:
+</p>
+
+<pre>
+// Allocate the top-level slice.
+picture := make([][]uint8, YSize) // One row per unit of y.
+// Loop over the rows, allocating the slice for each row.
+for i := range picture {
+ picture[i] = make([]uint8, XSize)
+}
+</pre>
+
+<p>
+And now as one allocation, sliced into lines:
+</p>
+
+<pre>
+// Allocate the top-level slice, the same as before.
+picture := make([][]uint8, YSize) // One row per unit of y.
+// Allocate one large slice to hold all the pixels.
+pixels := make([]uint8, XSize*YSize) // Has type []uint8 even though picture is [][]uint8.
+// Loop over the rows, slicing each row from the front of the remaining pixels slice.
+for i := range picture {
+ picture[i], pixels = pixels[:XSize], pixels[XSize:]
+}
+</pre>
+
+<h3 id="maps">Maps</h3>
+
+<p>
+Maps are a convenient and powerful built-in data structure that associate
+values of one type (the <em>key</em>) with values of another type
+(the <em>element</em> or <em>value</em>).
+The key can be of any type for which the equality operator is defined,
+such as integers,
+floating point and complex numbers,
+strings, pointers, interfaces (as long as the dynamic type
+supports equality), structs and arrays.
+Slices cannot be used as map keys,
+because equality is not defined on them.
+Like slices, maps hold references to an underlying data structure.
+If you pass a map to a function
+that changes the contents of the map, the changes will be visible
+in the caller.
+</p>
+<p>
+Maps can be constructed using the usual composite literal syntax
+with colon-separated key-value pairs,
+so it's easy to build them during initialization.
+</p>
+<pre>
+var timeZone = map[string]int{
+ "UTC": 0*60*60,
+ "EST": -5*60*60,
+ "CST": -6*60*60,
+ "MST": -7*60*60,
+ "PST": -8*60*60,
+}
+</pre>
+<p>
+Assigning and fetching map values looks syntactically just like
+doing the same for arrays and slices except that the index doesn't
+need to be an integer.
+</p>
+<pre>
+offset := timeZone["EST"]
+</pre>
+<p>
+An attempt to fetch a map value with a key that
+is not present in the map will return the zero value for the type
+of the entries
+in the map. For instance, if the map contains integers, looking
+up a non-existent key will return <code>0</code>.
+A set can be implemented as a map with value type <code>bool</code>.
+Set the map entry to <code>true</code> to put the value in the set, and then
+test it by simple indexing.
+</p>
+<pre>
+attended := map[string]bool{
+ "Ann": true,
+ "Joe": true,
+ ...
+}
+
+if attended[person] { // will be false if person is not in the map
+ fmt.Println(person, "was at the meeting")
+}
+</pre>
+<p>
+Sometimes you need to distinguish a missing entry from
+a zero value. Is there an entry for <code>"UTC"</code>
+or is that 0 because it's not in the map at all?
+You can discriminate with a form of multiple assignment.
+</p>
+<pre>
+var seconds int
+var ok bool
+seconds, ok = timeZone[tz]
+</pre>
+<p>
+For obvious reasons this is called the “comma ok” idiom.
+In this example, if <code>tz</code> is present, <code>seconds</code>
+will be set appropriately and <code>ok</code> will be true; if not,
+<code>seconds</code> will be set to zero and <code>ok</code> will
+be false.
+Here's a function that puts it together with a nice error report:
+</p>
+<pre>
+func offset(tz string) int {
+ if seconds, ok := timeZone[tz]; ok {
+ return seconds
+ }
+ log.Println("unknown time zone:", tz)
+ return 0
+}
+</pre>
+<p>
+To test for presence in the map without worrying about the actual value,
+you can use the <a href="#blank">blank identifier</a> (<code>_</code>)
+in place of the usual variable for the value.
+</p>
+<pre>
+_, present := timeZone[tz]
+</pre>
+<p>
+To delete a map entry, use the <code>delete</code>
+built-in function, whose arguments are the map and the key to be deleted.
+It's safe to do this even if the key is already absent
+from the map.
+</p>
+<pre>
+delete(timeZone, "PDT") // Now on Standard Time
+</pre>
+
+<h3 id="printing">Printing</h3>
+
+<p>
+Formatted printing in Go uses a style similar to C's <code>printf</code>
+family but is richer and more general. The functions live in the <code>fmt</code>
+package and have capitalized names: <code>fmt.Printf</code>, <code>fmt.Fprintf</code>,
+<code>fmt.Sprintf</code> and so on. The string functions (<code>Sprintf</code> etc.)
+return a string rather than filling in a provided buffer.
+</p>
+<p>
+You don't need to provide a format string. For each of <code>Printf</code>,
+<code>Fprintf</code> and <code>Sprintf</code> there is another pair
+of functions, for instance <code>Print</code> and <code>Println</code>.
+These functions do not take a format string but instead generate a default
+format for each argument. The <code>Println</code> versions also insert a blank
+between arguments and append a newline to the output while
+the <code>Print</code> versions add blanks only if the operand on neither side is a string.
+In this example each line produces the same output.
+</p>
+<pre>
+fmt.Printf("Hello %d\n", 23)
+fmt.Fprint(os.Stdout, "Hello ", 23, "\n")
+fmt.Println("Hello", 23)
+fmt.Println(fmt.Sprint("Hello ", 23))
+</pre>
+<p>
+The formatted print functions <code>fmt.Fprint</code>
+and friends take as a first argument any object
+that implements the <code>io.Writer</code> interface; the variables <code>os.Stdout</code>
+and <code>os.Stderr</code> are familiar instances.
+</p>
+<p>
+Here things start to diverge from C. First, the numeric formats such as <code>%d</code>
+do not take flags for signedness or size; instead, the printing routines use the
+type of the argument to decide these properties.
+</p>
+<pre>
+var x uint64 = 1<<64 - 1
+fmt.Printf("%d %x; %d %x\n", x, x, int64(x), int64(x))
+</pre>
+<p>
+prints
+</p>
+<pre>
+18446744073709551615 ffffffffffffffff; -1 -1
+</pre>
+<p>
+If you just want the default conversion, such as decimal for integers, you can use
+the catchall format <code>%v</code> (for “value”); the result is exactly
+what <code>Print</code> and <code>Println</code> would produce.
+Moreover, that format can print <em>any</em> value, even arrays, slices, structs, and
+maps. Here is a print statement for the time zone map defined in the previous section.
+</p>
+<pre>
+fmt.Printf("%v\n", timeZone) // or just fmt.Println(timeZone)
+</pre>
+<p>
+which gives output:
+</p>
+<pre>
+map[CST:-21600 EST:-18000 MST:-25200 PST:-28800 UTC:0]
+</pre>
+<p>
+For maps, <code>Printf</code> and friends sort the output lexicographically by key.
+</p>
+<p>
+When printing a struct, the modified format <code>%+v</code> annotates the
+fields of the structure with their names, and for any value the alternate
+format <code>%#v</code> prints the value in full Go syntax.
+</p>
+<pre>
+type T struct {
+ a int
+ b float64
+ c string
+}
+t := &T{ 7, -2.35, "abc\tdef" }
+fmt.Printf("%v\n", t)
+fmt.Printf("%+v\n", t)
+fmt.Printf("%#v\n", t)
+fmt.Printf("%#v\n", timeZone)
+</pre>
+<p>
+prints
+</p>
+<pre>
+&{7 -2.35 abc def}
+&{a:7 b:-2.35 c:abc def}
+&main.T{a:7, b:-2.35, c:"abc\tdef"}
+map[string]int{"CST":-21600, "EST":-18000, "MST":-25200, "PST":-28800, "UTC":0}
+</pre>
+<p>
+(Note the ampersands.)
+That quoted string format is also available through <code>%q</code> when
+applied to a value of type <code>string</code> or <code>[]byte</code>.
+The alternate format <code>%#q</code> will use backquotes instead if possible.
+(The <code>%q</code> format also applies to integers and runes, producing a
+single-quoted rune constant.)
+Also, <code>%x</code> works on strings, byte arrays and byte slices as well as
+on integers, generating a long hexadecimal string, and with
+a space in the format (<code>% x</code>) it puts spaces between the bytes.
+</p>
+<p>
+Another handy format is <code>%T</code>, which prints the <em>type</em> of a value.
+</p>
+<pre>
+fmt.Printf("%T\n", timeZone)
+</pre>
+<p>
+prints
+</p>
+<pre>
+map[string]int
+</pre>
+<p>
+If you want to control the default format for a custom type, all that's required is to define
+a method with the signature <code>String() string</code> on the type.
+For our simple type <code>T</code>, that might look like this.
+</p>
+<pre>
+func (t *T) String() string {
+ return fmt.Sprintf("%d/%g/%q", t.a, t.b, t.c)
+}
+fmt.Printf("%v\n", t)
+</pre>
+<p>
+to print in the format
+</p>
+<pre>
+7/-2.35/"abc\tdef"
+</pre>
+<p>
+(If you need to print <em>values</em> of type <code>T</code> as well as pointers to <code>T</code>,
+the receiver for <code>String</code> must be of value type; this example used a pointer because
+that's more efficient and idiomatic for struct types.
+See the section below on <a href="#pointers_vs_values">pointers vs. value receivers</a> for more information.)
+</p>
+
+<p>
+Our <code>String</code> method is able to call <code>Sprintf</code> because the
+print routines are fully reentrant and can be wrapped this way.
+There is one important detail to understand about this approach,
+however: don't construct a <code>String</code> method by calling
+<code>Sprintf</code> in a way that will recur into your <code>String</code>
+method indefinitely. This can happen if the <code>Sprintf</code>
+call attempts to print the receiver directly as a string, which in
+turn will invoke the method again. It's a common and easy mistake
+to make, as this example shows.
+</p>
+
+<pre>
+type MyString string
+
+func (m MyString) String() string {
+ return fmt.Sprintf("MyString=%s", m) // Error: will recur forever.
+}
+</pre>
+
+<p>
+It's also easy to fix: convert the argument to the basic string type, which does not have the
+method.
+</p>
+
+<pre>
+type MyString string
+func (m MyString) String() string {
+ return fmt.Sprintf("MyString=%s", string(m)) // OK: note conversion.
+}
+</pre>
+
+<p>
+In the <a href="#initialization">initialization section</a> we'll see another technique that avoids this recursion.
+</p>
+
+<p>
+Another printing technique is to pass a print routine's arguments directly to another such routine.
+The signature of <code>Printf</code> uses the type <code>...interface{}</code>
+for its final argument to specify that an arbitrary number of parameters (of arbitrary type)
+can appear after the format.
+</p>
+<pre>
+func Printf(format string, v ...interface{}) (n int, err error) {
+</pre>
+<p>
+Within the function <code>Printf</code>, <code>v</code> acts like a variable of type
+<code>[]interface{}</code> but if it is passed to another variadic function, it acts like
+a regular list of arguments.
+Here is the implementation of the
+function <code>log.Println</code> we used above. It passes its arguments directly to
+<code>fmt.Sprintln</code> for the actual formatting.
+</p>
+<pre>
+// Println prints to the standard logger in the manner of fmt.Println.
+func Println(v ...interface{}) {
+ std.Output(2, fmt.Sprintln(v...)) // Output takes parameters (int, string)
+}
+</pre>
+<p>
+We write <code>...</code> after <code>v</code> in the nested call to <code>Sprintln</code> to tell the
+compiler to treat <code>v</code> as a list of arguments; otherwise it would just pass
+<code>v</code> as a single slice argument.
+</p>
+<p>
+There's even more to printing than we've covered here. See the <code>godoc</code> documentation
+for package <code>fmt</code> for the details.
+</p>
+<p>
+By the way, a <code>...</code> parameter can be of a specific type, for instance <code>...int</code>
+for a min function that chooses the least of a list of integers:
+</p>
+<pre>
+func Min(a ...int) int {
+ min := int(^uint(0) >> 1) // largest int
+ for _, i := range a {
+ if i < min {
+ min = i
+ }
+ }
+ return min
+}
+</pre>
+
+<h3 id="append">Append</h3>
+<p>
+Now we have the missing piece we needed to explain the design of
+the <code>append</code> built-in function. The signature of <code>append</code>
+is different from our custom <code>Append</code> function above.
+Schematically, it's like this:
+</p>
+<pre>
+func append(slice []<i>T</i>, elements ...<i>T</i>) []<i>T</i>
+</pre>
+<p>
+where <i>T</i> is a placeholder for any given type. You can't
+actually write a function in Go where the type <code>T</code>
+is determined by the caller.
+That's why <code>append</code> is built in: it needs support from the
+compiler.
+</p>
+<p>
+What <code>append</code> does is append the elements to the end of
+the slice and return the result. The result needs to be returned
+because, as with our hand-written <code>Append</code>, the underlying
+array may change. This simple example
+</p>
+<pre>
+x := []int{1,2,3}
+x = append(x, 4, 5, 6)
+fmt.Println(x)
+</pre>
+<p>
+prints <code>[1 2 3 4 5 6]</code>. So <code>append</code> works a
+little like <code>Printf</code>, collecting an arbitrary number of
+arguments.
+</p>
+<p>
+But what if we wanted to do what our <code>Append</code> does and
+append a slice to a slice? Easy: use <code>...</code> at the call
+site, just as we did in the call to <code>Output</code> above. This
+snippet produces identical output to the one above.
+</p>
+<pre>
+x := []int{1,2,3}
+y := []int{4,5,6}
+x = append(x, y...)
+fmt.Println(x)
+</pre>
+<p>
+Without that <code>...</code>, it wouldn't compile because the types
+would be wrong; <code>y</code> is not of type <code>int</code>.
+</p>
+
+<h2 id="initialization">Initialization</h2>
+
+<p>
+Although it doesn't look superficially very different from
+initialization in C or C++, initialization in Go is more powerful.
+Complex structures can be built during initialization and the ordering
+issues among initialized objects, even among different packages, are handled
+correctly.
+</p>
+
+<h3 id="constants">Constants</h3>
+
+<p>
+Constants in Go are just that—constant.
+They are created at compile time, even when defined as
+locals in functions,
+and can only be numbers, characters (runes), strings or booleans.
+Because of the compile-time restriction, the expressions
+that define them must be constant expressions,
+evaluatable by the compiler. For instance,
+<code>1<<3</code> is a constant expression, while
+<code>math.Sin(math.Pi/4)</code> is not because
+the function call to <code>math.Sin</code> needs
+to happen at run time.
+</p>
+
+<p>
+In Go, enumerated constants are created using the <code>iota</code>
+enumerator. Since <code>iota</code> can be part of an expression and
+expressions can be implicitly repeated, it is easy to build intricate
+sets of values.
+</p>
+{{code "/doc/progs/eff_bytesize.go" `/^type ByteSize/` `/^\)/`}}
+<p>
+The ability to attach a method such as <code>String</code> to any
+user-defined type makes it possible for arbitrary values to format themselves
+automatically for printing.
+Although you'll see it most often applied to structs, this technique is also useful for
+scalar types such as floating-point types like <code>ByteSize</code>.
+</p>
+{{code "/doc/progs/eff_bytesize.go" `/^func.*ByteSize.*String/` `/^}/`}}
+<p>
+The expression <code>YB</code> prints as <code>1.00YB</code>,
+while <code>ByteSize(1e13)</code> prints as <code>9.09TB</code>.
+</p>
+
+<p>
+The use here of <code>Sprintf</code>
+to implement <code>ByteSize</code>'s <code>String</code> method is safe
+(avoids recurring indefinitely) not because of a conversion but
+because it calls <code>Sprintf</code> with <code>%f</code>,
+which is not a string format: <code>Sprintf</code> will only call
+the <code>String</code> method when it wants a string, and <code>%f</code>
+wants a floating-point value.
+</p>
+
+<h3 id="variables">Variables</h3>
+
+<p>
+Variables can be initialized just like constants but the
+initializer can be a general expression computed at run time.
+</p>
+<pre>
+var (
+ home = os.Getenv("HOME")
+ user = os.Getenv("USER")
+ gopath = os.Getenv("GOPATH")
+)
+</pre>
+
+<h3 id="init">The init function</h3>
+
+<p>
+Finally, each source file can define its own niladic <code>init</code> function to
+set up whatever state is required. (Actually each file can have multiple
+<code>init</code> functions.)
+And finally means finally: <code>init</code> is called after all the
+variable declarations in the package have evaluated their initializers,
+and those are evaluated only after all the imported packages have been
+initialized.
+</p>
+<p>
+Besides initializations that cannot be expressed as declarations,
+a common use of <code>init</code> functions is to verify or repair
+correctness of the program state before real execution begins.
+</p>
+
+<pre>
+func init() {
+ if user == "" {
+ log.Fatal("$USER not set")
+ }
+ if home == "" {
+ home = "/home/" + user
+ }
+ if gopath == "" {
+ gopath = home + "/go"
+ }
+ // gopath may be overridden by --gopath flag on command line.
+ flag.StringVar(&gopath, "gopath", gopath, "override default GOPATH")
+}
+</pre>
+
+<h2 id="methods">Methods</h2>
+
+<h3 id="pointers_vs_values">Pointers vs. Values</h3>
+<p>
+As we saw with <code>ByteSize</code>,
+methods can be defined for any named type (except a pointer or an interface);
+the receiver does not have to be a struct.
+</p>
+<p>
+In the discussion of slices above, we wrote an <code>Append</code>
+function. We can define it as a method on slices instead. To do
+this, we first declare a named type to which we can bind the method, and
+then make the receiver for the method a value of that type.
+</p>
+<pre>
+type ByteSlice []byte
+
+func (slice ByteSlice) Append(data []byte) []byte {
+ // Body exactly the same as the Append function defined above.
+}
+</pre>
+<p>
+This still requires the method to return the updated slice. We can
+eliminate that clumsiness by redefining the method to take a
+<i>pointer</i> to a <code>ByteSlice</code> as its receiver, so the
+method can overwrite the caller's slice.
+</p>
+<pre>
+func (p *ByteSlice) Append(data []byte) {
+ slice := *p
+ // Body as above, without the return.
+ *p = slice
+}
+</pre>
+<p>
+In fact, we can do even better. If we modify our function so it looks
+like a standard <code>Write</code> method, like this,
+</p>
+<pre>
+func (p *ByteSlice) Write(data []byte) (n int, err error) {
+ slice := *p
+ // Again as above.
+ *p = slice
+ return len(data), nil
+}
+</pre>
+<p>
+then the type <code>*ByteSlice</code> satisfies the standard interface
+<code>io.Writer</code>, which is handy. For instance, we can
+print into one.
+</p>
+<pre>
+ var b ByteSlice
+ fmt.Fprintf(&b, "This hour has %d days\n", 7)
+</pre>
+<p>
+We pass the address of a <code>ByteSlice</code>
+because only <code>*ByteSlice</code> satisfies <code>io.Writer</code>.
+The rule about pointers vs. values for receivers is that value methods
+can be invoked on pointers and values, but pointer methods can only be
+invoked on pointers.
+</p>
+
+<p>
+This rule arises because pointer methods can modify the receiver; invoking
+them on a value would cause the method to receive a copy of the value, so
+any modifications would be discarded.
+The language therefore disallows this mistake.
+There is a handy exception, though. When the value is addressable, the
+language takes care of the common case of invoking a pointer method on a
+value by inserting the address operator automatically.
+In our example, the variable <code>b</code> is addressable, so we can call
+its <code>Write</code> method with just <code>b.Write</code>. The compiler
+will rewrite that to <code>(&b).Write</code> for us.
+</p>
+
+<p>
+By the way, the idea of using <code>Write</code> on a slice of bytes
+is central to the implementation of <code>bytes.Buffer</code>.
+</p>
+
+<h2 id="interfaces_and_types">Interfaces and other types</h2>
+
+<h3 id="interfaces">Interfaces</h3>
+<p>
+Interfaces in Go provide a way to specify the behavior of an
+object: if something can do <em>this</em>, then it can be used
+<em>here</em>. We've seen a couple of simple examples already;
+custom printers can be implemented by a <code>String</code> method
+while <code>Fprintf</code> can generate output to anything
+with a <code>Write</code> method.
+Interfaces with only one or two methods are common in Go code, and are
+usually given a name derived from the method, such as <code>io.Writer</code>
+for something that implements <code>Write</code>.
+</p>
+<p>
+A type can implement multiple interfaces.
+For instance, a collection can be sorted
+by the routines in package <code>sort</code> if it implements
+<code>sort.Interface</code>, which contains <code>Len()</code>,
+<code>Less(i, j int) bool</code>, and <code>Swap(i, j int)</code>,
+and it could also have a custom formatter.
+In this contrived example <code>Sequence</code> satisfies both.
+</p>
+{{code "/doc/progs/eff_sequence.go" `/^type/` "$"}}
+
+<h3 id="conversions">Conversions</h3>
+
+<p>
+The <code>String</code> method of <code>Sequence</code> is recreating the
+work that <code>Sprint</code> already does for slices.
+(It also has complexity O(N²), which is poor.) We can share the
+effort (and also speed it up) if we convert the <code>Sequence</code> to a plain
+<code>[]int</code> before calling <code>Sprint</code>.
+</p>
+<pre>
+func (s Sequence) String() string {
+ s = s.Copy()
+ sort.Sort(s)
+ return fmt.Sprint([]int(s))
+}
+</pre>
+<p>
+This method is another example of the conversion technique for calling
+<code>Sprintf</code> safely from a <code>String</code> method.
+Because the two types (<code>Sequence</code> and <code>[]int</code>)
+are the same if we ignore the type name, it's legal to convert between them.
+The conversion doesn't create a new value, it just temporarily acts
+as though the existing value has a new type.
+(There are other legal conversions, such as from integer to floating point, that
+do create a new value.)
+</p>
+<p>
+It's an idiom in Go programs to convert the
+type of an expression to access a different
+set of methods. As an example, we could use the existing
+type <code>sort.IntSlice</code> to reduce the entire example
+to this:
+</p>
+<pre>
+type Sequence []int
+
+// Method for printing - sorts the elements before printing
+func (s Sequence) String() string {
+ s = s.Copy()
+ sort.IntSlice(s).Sort()
+ return fmt.Sprint([]int(s))
+}
+</pre>
+<p>
+Now, instead of having <code>Sequence</code> implement multiple
+interfaces (sorting and printing), we're using the ability of a data item to be
+converted to multiple types (<code>Sequence</code>, <code>sort.IntSlice</code>
+and <code>[]int</code>), each of which does some part of the job.
+That's more unusual in practice but can be effective.
+</p>
+
+<h3 id="interface_conversions">Interface conversions and type assertions</h3>
+
+<p>
+<a href="#type_switch">Type switches</a> are a form of conversion: they take an interface and, for
+each case in the switch, in a sense convert it to the type of that case.
+Here's a simplified version of how the code under <code>fmt.Printf</code> turns a value into
+a string using a type switch.
+If it's already a string, we want the actual string value held by the interface, while if it has a
+<code>String</code> method we want the result of calling the method.
+</p>
+
+<pre>
+type Stringer interface {
+ String() string
+}
+
+var value interface{} // Value provided by caller.
+switch str := value.(type) {
+case string:
+ return str
+case Stringer:
+ return str.String()
+}
+</pre>
+
+<p>
+The first case finds a concrete value; the second converts the interface into another interface.
+It's perfectly fine to mix types this way.
+</p>
+
+<p>
+What if there's only one type we care about? If we know the value holds a <code>string</code>
+and we just want to extract it?
+A one-case type switch would do, but so would a <em>type assertion</em>.
+A type assertion takes an interface value and extracts from it a value of the specified explicit type.
+The syntax borrows from the clause opening a type switch, but with an explicit
+type rather than the <code>type</code> keyword:
+</p>
+
+<pre>
+value.(typeName)
+</pre>
+
+<p>
+and the result is a new value with the static type <code>typeName</code>.
+That type must either be the concrete type held by the interface, or a second interface
+type that the value can be converted to.
+To extract the string we know is in the value, we could write:
+</p>
+
+<pre>
+str := value.(string)
+</pre>
+
+<p>
+But if it turns out that the value does not contain a string, the program will crash with a run-time error.
+To guard against that, use the "comma, ok" idiom to test, safely, whether the value is a string:
+</p>
+
+<pre>
+str, ok := value.(string)
+if ok {
+ fmt.Printf("string value is: %q\n", str)
+} else {
+ fmt.Printf("value is not a string\n")
+}
+</pre>
+
+<p>
+If the type assertion fails, <code>str</code> will still exist and be of type string, but it will have
+the zero value, an empty string.
+</p>
+
+<p>
+As an illustration of the capability, here's an <code>if</code>-<code>else</code>
+statement that's equivalent to the type switch that opened this section.
+</p>
+
+<pre>
+if str, ok := value.(string); ok {
+ return str
+} else if str, ok := value.(Stringer); ok {
+ return str.String()
+}
+</pre>
+
+<h3 id="generality">Generality</h3>
+<p>
+If a type exists only to implement an interface and will
+never have exported methods beyond that interface, there is
+no need to export the type itself.
+Exporting just the interface makes it clear the value has no
+interesting behavior beyond what is described in the
+interface.
+It also avoids the need to repeat the documentation
+on every instance of a common method.
+</p>
+<p>
+In such cases, the constructor should return an interface value
+rather than the implementing type.
+As an example, in the hash libraries
+both <code>crc32.NewIEEE</code> and <code>adler32.New</code>
+return the interface type <code>hash.Hash32</code>.
+Substituting the CRC-32 algorithm for Adler-32 in a Go program
+requires only changing the constructor call;
+the rest of the code is unaffected by the change of algorithm.
+</p>
+<p>
+A similar approach allows the streaming cipher algorithms
+in the various <code>crypto</code> packages to be
+separated from the block ciphers they chain together.
+The <code>Block</code> interface
+in the <code>crypto/cipher</code> package specifies the
+behavior of a block cipher, which provides encryption
+of a single block of data.
+Then, by analogy with the <code>bufio</code> package,
+cipher packages that implement this interface
+can be used to construct streaming ciphers, represented
+by the <code>Stream</code> interface, without
+knowing the details of the block encryption.
+</p>
+<p>
+The <code>crypto/cipher</code> interfaces look like this:
+</p>
+<pre>
+type Block interface {
+ BlockSize() int
+ Encrypt(dst, src []byte)
+ Decrypt(dst, src []byte)
+}
+
+type Stream interface {
+ XORKeyStream(dst, src []byte)
+}
+</pre>
+
+<p>
+Here's the definition of the counter mode (CTR) stream,
+which turns a block cipher into a streaming cipher; notice
+that the block cipher's details are abstracted away:
+</p>
+
+<pre>
+// NewCTR returns a Stream that encrypts/decrypts using the given Block in
+// counter mode. The length of iv must be the same as the Block's block size.
+func NewCTR(block Block, iv []byte) Stream
+</pre>
+<p>
+<code>NewCTR</code> applies not
+just to one specific encryption algorithm and data source but to any
+implementation of the <code>Block</code> interface and any
+<code>Stream</code>. Because they return
+interface values, replacing CTR
+encryption with other encryption modes is a localized change. The constructor
+calls must be edited, but because the surrounding code must treat the result only
+as a <code>Stream</code>, it won't notice the difference.
+</p>
+
+<h3 id="interface_methods">Interfaces and methods</h3>
+<p>
+Since almost anything can have methods attached, almost anything can
+satisfy an interface. One illustrative example is in the <code>http</code>
+package, which defines the <code>Handler</code> interface. Any object
+that implements <code>Handler</code> can serve HTTP requests.
+</p>
+<pre>
+type Handler interface {
+ ServeHTTP(ResponseWriter, *Request)
+}
+</pre>
+<p>
+<code>ResponseWriter</code> is itself an interface that provides access
+to the methods needed to return the response to the client.
+Those methods include the standard <code>Write</code> method, so an
+<code>http.ResponseWriter</code> can be used wherever an <code>io.Writer</code>
+can be used.
+<code>Request</code> is a struct containing a parsed representation
+of the request from the client.
+</p>
+<p>
+For brevity, let's ignore POSTs and assume HTTP requests are always
+GETs; that simplification does not affect the way the handlers are set up.
+Here's a trivial implementation of a handler to count the number of times
+the page is visited.
+</p>
+<pre>
+// Simple counter server.
+type Counter struct {
+ n int
+}
+
+func (ctr *Counter) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+ ctr.n++
+ fmt.Fprintf(w, "counter = %d\n", ctr.n)
+}
+</pre>
+<p>
+(Keeping with our theme, note how <code>Fprintf</code> can print to an
+<code>http.ResponseWriter</code>.)
+In a real server, access to <code>ctr.n</code> would need protection from
+concurrent access.
+See the <code>sync</code> and <code>atomic</code> packages for suggestions.
+</p>
+<p>
+For reference, here's how to attach such a server to a node on the URL tree.
+</p>
+<pre>
+import "net/http"
+...
+ctr := new(Counter)
+http.Handle("/counter", ctr)
+</pre>
+<p>
+But why make <code>Counter</code> a struct? An integer is all that's needed.
+(The receiver needs to be a pointer so the increment is visible to the caller.)
+</p>
+<pre>
+// Simpler counter server.
+type Counter int
+
+func (ctr *Counter) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+ *ctr++
+ fmt.Fprintf(w, "counter = %d\n", *ctr)
+}
+</pre>
+<p>
+What if your program has some internal state that needs to be notified that a page
+has been visited? Tie a channel to the web page.
+</p>
+<pre>
+// A channel that sends a notification on each visit.
+// (Probably want the channel to be buffered.)
+type Chan chan *http.Request
+
+func (ch Chan) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+ ch <- req
+ fmt.Fprint(w, "notification sent")
+}
+</pre>
+<p>
+Finally, let's say we wanted to present on <code>/args</code> the arguments
+used when invoking the server binary.
+It's easy to write a function to print the arguments.
+</p>
+<pre>
+func ArgServer() {
+ fmt.Println(os.Args)
+}
+</pre>
+<p>
+How do we turn that into an HTTP server? We could make <code>ArgServer</code>
+a method of some type whose value we ignore, but there's a cleaner way.
+Since we can define a method for any type except pointers and interfaces,
+we can write a method for a function.
+The <code>http</code> package contains this code:
+</p>
+<pre>
+// The HandlerFunc type is an adapter to allow the use of
+// ordinary functions as HTTP handlers. If f is a function
+// with the appropriate signature, HandlerFunc(f) is a
+// Handler object that calls f.
+type HandlerFunc func(ResponseWriter, *Request)
+
+// ServeHTTP calls f(w, req).
+func (f HandlerFunc) ServeHTTP(w ResponseWriter, req *Request) {
+ f(w, req)
+}
+</pre>
+<p>
+<code>HandlerFunc</code> is a type with a method, <code>ServeHTTP</code>,
+so values of that type can serve HTTP requests. Look at the implementation
+of the method: the receiver is a function, <code>f</code>, and the method
+calls <code>f</code>. That may seem odd but it's not that different from, say,
+the receiver being a channel and the method sending on the channel.
+</p>
+<p>
+To make <code>ArgServer</code> into an HTTP server, we first modify it
+to have the right signature.
+</p>
+<pre>
+// Argument server.
+func ArgServer(w http.ResponseWriter, req *http.Request) {
+ fmt.Fprintln(w, os.Args)
+}
+</pre>
+<p>
+<code>ArgServer</code> now has same signature as <code>HandlerFunc</code>,
+so it can be converted to that type to access its methods,
+just as we converted <code>Sequence</code> to <code>IntSlice</code>
+to access <code>IntSlice.Sort</code>.
+The code to set it up is concise:
+</p>
+<pre>
+http.Handle("/args", http.HandlerFunc(ArgServer))
+</pre>
+<p>
+When someone visits the page <code>/args</code>,
+the handler installed at that page has value <code>ArgServer</code>
+and type <code>HandlerFunc</code>.
+The HTTP server will invoke the method <code>ServeHTTP</code>
+of that type, with <code>ArgServer</code> as the receiver, which will in turn call
+<code>ArgServer</code> (via the invocation <code>f(w, req)</code>
+inside <code>HandlerFunc.ServeHTTP</code>).
+The arguments will then be displayed.
+</p>
+<p>
+In this section we have made an HTTP server from a struct, an integer,
+a channel, and a function, all because interfaces are just sets of
+methods, which can be defined for (almost) any type.
+</p>
+
+<h2 id="blank">The blank identifier</h2>
+
+<p>
+We've mentioned the blank identifier a couple of times now, in the context of
+<a href="#for"><code>for</code> <code>range</code> loops</a>
+and <a href="#maps">maps</a>.
+The blank identifier can be assigned or declared with any value of any type, with the
+value discarded harmlessly.
+It's a bit like writing to the Unix <code>/dev/null</code> file:
+it represents a write-only value
+to be used as a place-holder
+where a variable is needed but the actual value is irrelevant.
+It has uses beyond those we've seen already.
+</p>
+
+<h3 id="blank_assign">The blank identifier in multiple assignment</h3>
+
+<p>
+The use of a blank identifier in a <code>for</code> <code>range</code> loop is a
+special case of a general situation: multiple assignment.
+</p>
+
+<p>
+If an assignment requires multiple values on the left side,
+but one of the values will not be used by the program,
+a blank identifier on the left-hand-side of
+the assignment avoids the need
+to create a dummy variable and makes it clear that the
+value is to be discarded.
+For instance, when calling a function that returns
+a value and an error, but only the error is important,
+use the blank identifier to discard the irrelevant value.
+</p>
+
+<pre>
+if _, err := os.Stat(path); os.IsNotExist(err) {
+ fmt.Printf("%s does not exist\n", path)
+}
+</pre>
+
+<p>
+Occasionally you'll see code that discards the error value in order
+to ignore the error; this is terrible practice. Always check error returns;
+they're provided for a reason.
+</p>
+
+<pre>
+// Bad! This code will crash if path does not exist.
+fi, _ := os.Stat(path)
+if fi.IsDir() {
+ fmt.Printf("%s is a directory\n", path)
+}
+</pre>
+
+<h3 id="blank_unused">Unused imports and variables</h3>
+
+<p>
+It is an error to import a package or to declare a variable without using it.
+Unused imports bloat the program and slow compilation,
+while a variable that is initialized but not used is at least
+a wasted computation and perhaps indicative of a
+larger bug.
+When a program is under active development, however,
+unused imports and variables often arise and it can
+be annoying to delete them just to have the compilation proceed,
+only to have them be needed again later.
+The blank identifier provides a workaround.
+</p>
+<p>
+This half-written program has two unused imports
+(<code>fmt</code> and <code>io</code>)
+and an unused variable (<code>fd</code>),
+so it will not compile, but it would be nice to see if the
+code so far is correct.
+</p>
+{{code "/doc/progs/eff_unused1.go" `/package/` `$`}}
+<p>
+To silence complaints about the unused imports, use a
+blank identifier to refer to a symbol from the imported package.
+Similarly, assigning the unused variable <code>fd</code>
+to the blank identifier will silence the unused variable error.
+This version of the program does compile.
+</p>
+{{code "/doc/progs/eff_unused2.go" `/package/` `$`}}
+
+<p>
+By convention, the global declarations to silence import errors
+should come right after the imports and be commented,
+both to make them easy to find and as a reminder to clean things up later.
+</p>
+
+<h3 id="blank_import">Import for side effect</h3>
+
+<p>
+An unused import like <code>fmt</code> or <code>io</code> in the
+previous example should eventually be used or removed:
+blank assignments identify code as a work in progress.
+But sometimes it is useful to import a package only for its
+side effects, without any explicit use.
+For example, during its <code>init</code> function,
+the <code><a href="/pkg/net/http/pprof/">net/http/pprof</a></code>
+package registers HTTP handlers that provide
+debugging information. It has an exported API, but
+most clients need only the handler registration and
+access the data through a web page.
+To import the package only for its side effects, rename the package
+to the blank identifier:
+</p>
+<pre>
+import _ "net/http/pprof"
+</pre>
+<p>
+This form of import makes clear that the package is being
+imported for its side effects, because there is no other possible
+use of the package: in this file, it doesn't have a name.
+(If it did, and we didn't use that name, the compiler would reject the program.)
+</p>
+
+<h3 id="blank_implements">Interface checks</h3>
+
+<p>
+As we saw in the discussion of <a href="#interfaces_and_types">interfaces</a> above,
+a type need not declare explicitly that it implements an interface.
+Instead, a type implements the interface just by implementing the interface's methods.
+In practice, most interface conversions are static and therefore checked at compile time.
+For example, passing an <code>*os.File</code> to a function
+expecting an <code>io.Reader</code> will not compile unless
+<code>*os.File</code> implements the <code>io.Reader</code> interface.
+</p>
+
+<p>
+Some interface checks do happen at run-time, though.
+One instance is in the <code><a href="/pkg/encoding/json/">encoding/json</a></code>
+package, which defines a <code><a href="/pkg/encoding/json/#Marshaler">Marshaler</a></code>
+interface. When the JSON encoder receives a value that implements that interface,
+the encoder invokes the value's marshaling method to convert it to JSON
+instead of doing the standard conversion.
+The encoder checks this property at run time with a <a href="#interface_conversions">type assertion</a> like:
+</p>
+
+<pre>
+m, ok := val.(json.Marshaler)
+</pre>
+
+<p>
+If it's necessary only to ask whether a type implements an interface, without
+actually using the interface itself, perhaps as part of an error check, use the blank
+identifier to ignore the type-asserted value:
+</p>
+
+<pre>
+if _, ok := val.(json.Marshaler); ok {
+ fmt.Printf("value %v of type %T implements json.Marshaler\n", val, val)
+}
+</pre>
+
+<p>
+One place this situation arises is when it is necessary to guarantee within the package implementing the type that
+it actually satisfies the interface.
+If a type—for example,
+<code><a href="/pkg/encoding/json/#RawMessage">json.RawMessage</a></code>—needs
+a custom JSON representation, it should implement
+<code>json.Marshaler</code>, but there are no static conversions that would
+cause the compiler to verify this automatically.
+If the type inadvertently fails to satisfy the interface, the JSON encoder will still work,
+but will not use the custom implementation.
+To guarantee that the implementation is correct,
+a global declaration using the blank identifier can be used in the package:
+</p>
+<pre>
+var _ json.Marshaler = (*RawMessage)(nil)
+</pre>
+<p>
+In this declaration, the assignment involving a conversion of a
+<code>*RawMessage</code> to a <code>Marshaler</code>
+requires that <code>*RawMessage</code> implements <code>Marshaler</code>,
+and that property will be checked at compile time.
+Should the <code>json.Marshaler</code> interface change, this package
+will no longer compile and we will be on notice that it needs to be updated.
+</p>
+
+<p>
+The appearance of the blank identifier in this construct indicates that
+the declaration exists only for the type checking,
+not to create a variable.
+Don't do this for every type that satisfies an interface, though.
+By convention, such declarations are only used
+when there are no static conversions already present in the code,
+which is a rare event.
+</p>
+
+
+<h2 id="embedding">Embedding</h2>
+
+<p>
+Go does not provide the typical, type-driven notion of subclassing,
+but it does have the ability to “borrow” pieces of an
+implementation by <em>embedding</em> types within a struct or
+interface.
+</p>
+<p>
+Interface embedding is very simple.
+We've mentioned the <code>io.Reader</code> and <code>io.Writer</code> interfaces before;
+here are their definitions.
+</p>
+<pre>
+type Reader interface {
+ Read(p []byte) (n int, err error)
+}
+
+type Writer interface {
+ Write(p []byte) (n int, err error)
+}
+</pre>
+<p>
+The <code>io</code> package also exports several other interfaces
+that specify objects that can implement several such methods.
+For instance, there is <code>io.ReadWriter</code>, an interface
+containing both <code>Read</code> and <code>Write</code>.
+We could specify <code>io.ReadWriter</code> by listing the
+two methods explicitly, but it's easier and more evocative
+to embed the two interfaces to form the new one, like this:
+</p>
+<pre>
+// ReadWriter is the interface that combines the Reader and Writer interfaces.
+type ReadWriter interface {
+ Reader
+ Writer
+}
+</pre>
+<p>
+This says just what it looks like: A <code>ReadWriter</code> can do
+what a <code>Reader</code> does <em>and</em> what a <code>Writer</code>
+does; it is a union of the embedded interfaces.
+Only interfaces can be embedded within interfaces.
+</p>
+<p>
+The same basic idea applies to structs, but with more far-reaching
+implications. The <code>bufio</code> package has two struct types,
+<code>bufio.Reader</code> and <code>bufio.Writer</code>, each of
+which of course implements the analogous interfaces from package
+<code>io</code>.
+And <code>bufio</code> also implements a buffered reader/writer,
+which it does by combining a reader and a writer into one struct
+using embedding: it lists the types within the struct
+but does not give them field names.
+</p>
+<pre>
+// ReadWriter stores pointers to a Reader and a Writer.
+// It implements io.ReadWriter.
+type ReadWriter struct {
+ *Reader // *bufio.Reader
+ *Writer // *bufio.Writer
+}
+</pre>
+<p>
+The embedded elements are pointers to structs and of course
+must be initialized to point to valid structs before they
+can be used.
+The <code>ReadWriter</code> struct could be written as
+</p>
+<pre>
+type ReadWriter struct {
+ reader *Reader
+ writer *Writer
+}
+</pre>
+<p>
+but then to promote the methods of the fields and to
+satisfy the <code>io</code> interfaces, we would also need
+to provide forwarding methods, like this:
+</p>
+<pre>
+func (rw *ReadWriter) Read(p []byte) (n int, err error) {
+ return rw.reader.Read(p)
+}
+</pre>
+<p>
+By embedding the structs directly, we avoid this bookkeeping.
+The methods of embedded types come along for free, which means that <code>bufio.ReadWriter</code>
+not only has the methods of <code>bufio.Reader</code> and <code>bufio.Writer</code>,
+it also satisfies all three interfaces:
+<code>io.Reader</code>,
+<code>io.Writer</code>, and
+<code>io.ReadWriter</code>.
+</p>
+<p>
+There's an important way in which embedding differs from subclassing. When we embed a type,
+the methods of that type become methods of the outer type,
+but when they are invoked the receiver of the method is the inner type, not the outer one.
+In our example, when the <code>Read</code> method of a <code>bufio.ReadWriter</code> is
+invoked, it has exactly the same effect as the forwarding method written out above;
+the receiver is the <code>reader</code> field of the <code>ReadWriter</code>, not the
+<code>ReadWriter</code> itself.
+</p>
+<p>
+Embedding can also be a simple convenience.
+This example shows an embedded field alongside a regular, named field.
+</p>
+<pre>
+type Job struct {
+ Command string
+ *log.Logger
+}
+</pre>
+<p>
+The <code>Job</code> type now has the <code>Print</code>, <code>Printf</code>, <code>Println</code>
+and other
+methods of <code>*log.Logger</code>. We could have given the <code>Logger</code>
+a field name, of course, but it's not necessary to do so. And now, once
+initialized, we can
+log to the <code>Job</code>:
+</p>
+<pre>
+job.Println("starting now...")
+</pre>
+<p>
+The <code>Logger</code> is a regular field of the <code>Job</code> struct,
+so we can initialize it in the usual way inside the constructor for <code>Job</code>, like this,
+</p>
+<pre>
+func NewJob(command string, logger *log.Logger) *Job {
+ return &Job{command, logger}
+}
+</pre>
+<p>
+or with a composite literal,
+</p>
+<pre>
+job := &Job{command, log.New(os.Stderr, "Job: ", log.Ldate)}
+</pre>
+<p>
+If we need to refer to an embedded field directly, the type name of the field,
+ignoring the package qualifier, serves as a field name, as it did
+in the <code>Read</code> method of our <code>ReadWriter</code> struct.
+Here, if we needed to access the
+<code>*log.Logger</code> of a <code>Job</code> variable <code>job</code>,
+we would write <code>job.Logger</code>,
+which would be useful if we wanted to refine the methods of <code>Logger</code>.
+</p>
+<pre>
+func (job *Job) Printf(format string, args ...interface{}) {
+ job.Logger.Printf("%q: %s", job.Command, fmt.Sprintf(format, args...))
+}
+</pre>
+<p>
+Embedding types introduces the problem of name conflicts but the rules to resolve
+them are simple.
+First, a field or method <code>X</code> hides any other item <code>X</code> in a more deeply
+nested part of the type.
+If <code>log.Logger</code> contained a field or method called <code>Command</code>, the <code>Command</code> field
+of <code>Job</code> would dominate it.
+</p>
+<p>
+Second, if the same name appears at the same nesting level, it is usually an error;
+it would be erroneous to embed <code>log.Logger</code> if the <code>Job</code> struct
+contained another field or method called <code>Logger</code>.
+However, if the duplicate name is never mentioned in the program outside the type definition, it is OK.
+This qualification provides some protection against changes made to types embedded from outside; there
+is no problem if a field is added that conflicts with another field in another subtype if neither field
+is ever used.
+</p>
+
+
+<h2 id="concurrency">Concurrency</h2>
+
+<h3 id="sharing">Share by communicating</h3>
+
+<p>
+Concurrent programming is a large topic and there is space only for some
+Go-specific highlights here.
+</p>
+<p>
+Concurrent programming in many environments is made difficult by the
+subtleties required to implement correct access to shared variables. Go encourages
+a different approach in which shared values are passed around on channels
+and, in fact, never actively shared by separate threads of execution.
+Only one goroutine has access to the value at any given time.
+Data races cannot occur, by design.
+To encourage this way of thinking we have reduced it to a slogan:
+</p>
+<blockquote>
+Do not communicate by sharing memory;
+instead, share memory by communicating.
+</blockquote>
+<p>
+This approach can be taken too far. Reference counts may be best done
+by putting a mutex around an integer variable, for instance. But as a
+high-level approach, using channels to control access makes it easier
+to write clear, correct programs.
+</p>
+<p>
+One way to think about this model is to consider a typical single-threaded
+program running on one CPU. It has no need for synchronization primitives.
+Now run another such instance; it too needs no synchronization. Now let those
+two communicate; if the communication is the synchronizer, there's still no need
+for other synchronization. Unix pipelines, for example, fit this model
+perfectly. Although Go's approach to concurrency originates in Hoare's
+Communicating Sequential Processes (CSP),
+it can also be seen as a type-safe generalization of Unix pipes.
+</p>
+
+<h3 id="goroutines">Goroutines</h3>
+
+<p>
+They're called <em>goroutines</em> because the existing
+terms—threads, coroutines, processes, and so on—convey
+inaccurate connotations. A goroutine has a simple model: it is a
+function executing concurrently with other goroutines in the same
+address space. It is lightweight, costing little more than the
+allocation of stack space.
+And the stacks start small, so they are cheap, and grow
+by allocating (and freeing) heap storage as required.
+</p>
+<p>
+Goroutines are multiplexed onto multiple OS threads so if one should
+block, such as while waiting for I/O, others continue to run. Their
+design hides many of the complexities of thread creation and
+management.
+</p>
+<p>
+Prefix a function or method call with the <code>go</code>
+keyword to run the call in a new goroutine.
+When the call completes, the goroutine
+exits, silently. (The effect is similar to the Unix shell's
+<code>&</code> notation for running a command in the
+background.)
+</p>
+<pre>
+go list.Sort() // run list.Sort concurrently; don't wait for it.
+</pre>
+<p>
+A function literal can be handy in a goroutine invocation.
+</p>
+<pre>
+func Announce(message string, delay time.Duration) {
+ go func() {
+ time.Sleep(delay)
+ fmt.Println(message)
+ }() // Note the parentheses - must call the function.
+}
+</pre>
+<p>
+In Go, function literals are closures: the implementation makes
+sure the variables referred to by the function survive as long as they are active.
+</p>
+<p>
+These examples aren't too practical because the functions have no way of signaling
+completion. For that, we need channels.
+</p>
+
+<h3 id="channels">Channels</h3>
+
+<p>
+Like maps, channels are allocated with <code>make</code>, and
+the resulting value acts as a reference to an underlying data structure.
+If an optional integer parameter is provided, it sets the buffer size for the channel.
+The default is zero, for an unbuffered or synchronous channel.
+</p>
+<pre>
+ci := make(chan int) // unbuffered channel of integers
+cj := make(chan int, 0) // unbuffered channel of integers
+cs := make(chan *os.File, 100) // buffered channel of pointers to Files
+</pre>
+<p>
+Unbuffered channels combine communication—the exchange of a value—with
+synchronization—guaranteeing that two calculations (goroutines) are in
+a known state.
+</p>
+<p>
+There are lots of nice idioms using channels. Here's one to get us started.
+In the previous section we launched a sort in the background. A channel
+can allow the launching goroutine to wait for the sort to complete.
+</p>
+<pre>
+c := make(chan int) // Allocate a channel.
+// Start the sort in a goroutine; when it completes, signal on the channel.
+go func() {
+ list.Sort()
+ c <- 1 // Send a signal; value does not matter.
+}()
+doSomethingForAWhile()
+<-c // Wait for sort to finish; discard sent value.
+</pre>
+<p>
+Receivers always block until there is data to receive.
+If the channel is unbuffered, the sender blocks until the receiver has
+received the value.
+If the channel has a buffer, the sender blocks only until the
+value has been copied to the buffer; if the buffer is full, this
+means waiting until some receiver has retrieved a value.
+</p>
+<p>
+A buffered channel can be used like a semaphore, for instance to
+limit throughput. In this example, incoming requests are passed
+to <code>handle</code>, which sends a value into the channel, processes
+the request, and then receives a value from the channel
+to ready the “semaphore” for the next consumer.
+The capacity of the channel buffer limits the number of
+simultaneous calls to <code>process</code>.
+</p>
+<pre>
+var sem = make(chan int, MaxOutstanding)
+
+func handle(r *Request) {
+ sem <- 1 // Wait for active queue to drain.
+ process(r) // May take a long time.
+ <-sem // Done; enable next request to run.
+}
+
+func Serve(queue chan *Request) {
+ for {
+ req := <-queue
+ go handle(req) // Don't wait for handle to finish.
+ }
+}
+</pre>
+
+<p>
+Once <code>MaxOutstanding</code> handlers are executing <code>process</code>,
+any more will block trying to send into the filled channel buffer,
+until one of the existing handlers finishes and receives from the buffer.
+</p>
+
+<p>
+This design has a problem, though: <code>Serve</code>
+creates a new goroutine for
+every incoming request, even though only <code>MaxOutstanding</code>
+of them can run at any moment.
+As a result, the program can consume unlimited resources if the requests come in too fast.
+We can address that deficiency by changing <code>Serve</code> to
+gate the creation of the goroutines.
+Here's an obvious solution, but beware it has a bug we'll fix subsequently:
+</p>
+
+<pre>
+func Serve(queue chan *Request) {
+ for req := range queue {
+ sem <- 1
+ go func() {
+ process(req) // Buggy; see explanation below.
+ <-sem
+ }()
+ }
+}</pre>
+
+<p>
+The bug is that in a Go <code>for</code> loop, the loop variable
+is reused for each iteration, so the <code>req</code>
+variable is shared across all goroutines.
+That's not what we want.
+We need to make sure that <code>req</code> is unique for each goroutine.
+Here's one way to do that, passing the value of <code>req</code> as an argument
+to the closure in the goroutine:
+</p>
+
+<pre>
+func Serve(queue chan *Request) {
+ for req := range queue {
+ sem <- 1
+ go func(req *Request) {
+ process(req)
+ <-sem
+ }(req)
+ }
+}</pre>
+
+<p>
+Compare this version with the previous to see the difference in how
+the closure is declared and run.
+Another solution is just to create a new variable with the same
+name, as in this example:
+</p>
+
+<pre>
+func Serve(queue chan *Request) {
+ for req := range queue {
+ req := req // Create new instance of req for the goroutine.
+ sem <- 1
+ go func() {
+ process(req)
+ <-sem
+ }()
+ }
+}</pre>
+
+<p>
+It may seem odd to write
+</p>
+
+<pre>
+req := req
+</pre>
+
+<p>
+but it's legal and idiomatic in Go to do this.
+You get a fresh version of the variable with the same name, deliberately
+shadowing the loop variable locally but unique to each goroutine.
+</p>
+
+<p>
+Going back to the general problem of writing the server,
+another approach that manages resources well is to start a fixed
+number of <code>handle</code> goroutines all reading from the request
+channel.
+The number of goroutines limits the number of simultaneous
+calls to <code>process</code>.
+This <code>Serve</code> function also accepts a channel on which
+it will be told to exit; after launching the goroutines it blocks
+receiving from that channel.
+</p>
+
+<pre>
+func handle(queue chan *Request) {
+ for r := range queue {
+ process(r)
+ }
+}
+
+func Serve(clientRequests chan *Request, quit chan bool) {
+ // Start handlers
+ for i := 0; i < MaxOutstanding; i++ {
+ go handle(clientRequests)
+ }
+ <-quit // Wait to be told to exit.
+}
+</pre>
+
+<h3 id="chan_of_chan">Channels of channels</h3>
+<p>
+One of the most important properties of Go is that
+a channel is a first-class value that can be allocated and passed
+around like any other. A common use of this property is
+to implement safe, parallel demultiplexing.
+</p>
+<p>
+In the example in the previous section, <code>handle</code> was
+an idealized handler for a request but we didn't define the
+type it was handling. If that type includes a channel on which
+to reply, each client can provide its own path for the answer.
+Here's a schematic definition of type <code>Request</code>.
+</p>
+<pre>
+type Request struct {
+ args []int
+ f func([]int) int
+ resultChan chan int
+}
+</pre>
+<p>
+The client provides a function and its arguments, as well as
+a channel inside the request object on which to receive the answer.
+</p>
+<pre>
+func sum(a []int) (s int) {
+ for _, v := range a {
+ s += v
+ }
+ return
+}
+
+request := &Request{[]int{3, 4, 5}, sum, make(chan int)}
+// Send request
+clientRequests <- request
+// Wait for response.
+fmt.Printf("answer: %d\n", <-request.resultChan)
+</pre>
+<p>
+On the server side, the handler function is the only thing that changes.
+</p>
+<pre>
+func handle(queue chan *Request) {
+ for req := range queue {
+ req.resultChan <- req.f(req.args)
+ }
+}
+</pre>
+<p>
+There's clearly a lot more to do to make it realistic, but this
+code is a framework for a rate-limited, parallel, non-blocking RPC
+system, and there's not a mutex in sight.
+</p>
+
+<h3 id="parallel">Parallelization</h3>
+<p>
+Another application of these ideas is to parallelize a calculation
+across multiple CPU cores. If the calculation can be broken into
+separate pieces that can execute independently, it can be parallelized,
+with a channel to signal when each piece completes.
+</p>
+<p>
+Let's say we have an expensive operation to perform on a vector of items,
+and that the value of the operation on each item is independent,
+as in this idealized example.
+</p>
+<pre>
+type Vector []float64
+
+// Apply the operation to v[i], v[i+1] ... up to v[n-1].
+func (v Vector) DoSome(i, n int, u Vector, c chan int) {
+ for ; i < n; i++ {
+ v[i] += u.Op(v[i])
+ }
+ c <- 1 // signal that this piece is done
+}
+</pre>
+<p>
+We launch the pieces independently in a loop, one per CPU.
+They can complete in any order but it doesn't matter; we just
+count the completion signals by draining the channel after
+launching all the goroutines.
+</p>
+<pre>
+const numCPU = 4 // number of CPU cores
+
+func (v Vector) DoAll(u Vector) {
+ c := make(chan int, numCPU) // Buffering optional but sensible.
+ for i := 0; i < numCPU; i++ {
+ go v.DoSome(i*len(v)/numCPU, (i+1)*len(v)/numCPU, u, c)
+ }
+ // Drain the channel.
+ for i := 0; i < numCPU; i++ {
+ <-c // wait for one task to complete
+ }
+ // All done.
+}
+</pre>
+<p>
+Rather than create a constant value for numCPU, we can ask the runtime what
+value is appropriate.
+The function <code><a href="/pkg/runtime#NumCPU">runtime.NumCPU</a></code>
+returns the number of hardware CPU cores in the machine, so we could write
+</p>
+<pre>
+var numCPU = runtime.NumCPU()
+</pre>
+<p>
+There is also a function
+<code><a href="/pkg/runtime#GOMAXPROCS">runtime.GOMAXPROCS</a></code>,
+which reports (or sets)
+the user-specified number of cores that a Go program can have running
+simultaneously.
+It defaults to the value of <code>runtime.NumCPU</code> but can be
+overridden by setting the similarly named shell environment variable
+or by calling the function with a positive number. Calling it with
+zero just queries the value.
+Therefore if we want to honor the user's resource request, we should write
+</p>
+<pre>
+var numCPU = runtime.GOMAXPROCS(0)
+</pre>
+<p>
+Be sure not to confuse the ideas of concurrency—structuring a program
+as independently executing components—and parallelism—executing
+calculations in parallel for efficiency on multiple CPUs.
+Although the concurrency features of Go can make some problems easy
+to structure as parallel computations, Go is a concurrent language,
+not a parallel one, and not all parallelization problems fit Go's model.
+For a discussion of the distinction, see the talk cited in
+<a href="//blog.golang.org/2013/01/concurrency-is-not-parallelism.html">this
+blog post</a>.
+
+<h3 id="leaky_buffer">A leaky buffer</h3>
+
+<p>
+The tools of concurrent programming can even make non-concurrent
+ideas easier to express. Here's an example abstracted from an RPC
+package. The client goroutine loops receiving data from some source,
+perhaps a network. To avoid allocating and freeing buffers, it keeps
+a free list, and uses a buffered channel to represent it. If the
+channel is empty, a new buffer gets allocated.
+Once the message buffer is ready, it's sent to the server on
+<code>serverChan</code>.
+</p>
+<pre>
+var freeList = make(chan *Buffer, 100)
+var serverChan = make(chan *Buffer)
+
+func client() {
+ for {
+ var b *Buffer
+ // Grab a buffer if available; allocate if not.
+ select {
+ case b = <-freeList:
+ // Got one; nothing more to do.
+ default:
+ // None free, so allocate a new one.
+ b = new(Buffer)
+ }
+ load(b) // Read next message from the net.
+ serverChan <- b // Send to server.
+ }
+}
+</pre>
+<p>
+The server loop receives each message from the client, processes it,
+and returns the buffer to the free list.
+</p>
+<pre>
+func server() {
+ for {
+ b := <-serverChan // Wait for work.
+ process(b)
+ // Reuse buffer if there's room.
+ select {
+ case freeList <- b:
+ // Buffer on free list; nothing more to do.
+ default:
+ // Free list full, just carry on.
+ }
+ }
+}
+</pre>
+<p>
+The client attempts to retrieve a buffer from <code>freeList</code>;
+if none is available, it allocates a fresh one.
+The server's send to <code>freeList</code> puts <code>b</code> back
+on the free list unless the list is full, in which case the
+buffer is dropped on the floor to be reclaimed by
+the garbage collector.
+(The <code>default</code> clauses in the <code>select</code>
+statements execute when no other case is ready,
+meaning that the <code>selects</code> never block.)
+This implementation builds a leaky bucket free list
+in just a few lines, relying on the buffered channel and
+the garbage collector for bookkeeping.
+</p>
+
+<h2 id="errors">Errors</h2>
+
+<p>
+Library routines must often return some sort of error indication to
+the caller.
+As mentioned earlier, Go's multivalue return makes it
+easy to return a detailed error description alongside the normal
+return value.
+It is good style to use this feature to provide detailed error information.
+For example, as we'll see, <code>os.Open</code> doesn't
+just return a <code>nil</code> pointer on failure, it also returns an
+error value that describes what went wrong.
+</p>
+
+<p>
+By convention, errors have type <code>error</code>,
+a simple built-in interface.
+</p>
+<pre>
+type error interface {
+ Error() string
+}
+</pre>
+<p>
+A library writer is free to implement this interface with a
+richer model under the covers, making it possible not only
+to see the error but also to provide some context.
+As mentioned, alongside the usual <code>*os.File</code>
+return value, <code>os.Open</code> also returns an
+error value.
+If the file is opened successfully, the error will be <code>nil</code>,
+but when there is a problem, it will hold an
+<code>os.PathError</code>:
+</p>
+<pre>
+// PathError records an error and the operation and
+// file path that caused it.
+type PathError struct {
+ Op string // "open", "unlink", etc.
+ Path string // The associated file.
+ Err error // Returned by the system call.
+}
+
+func (e *PathError) Error() string {
+ return e.Op + " " + e.Path + ": " + e.Err.Error()
+}
+</pre>
+<p>
+<code>PathError</code>'s <code>Error</code> generates
+a string like this:
+</p>
+<pre>
+open /etc/passwx: no such file or directory
+</pre>
+<p>
+Such an error, which includes the problematic file name, the
+operation, and the operating system error it triggered, is useful even
+if printed far from the call that caused it;
+it is much more informative than the plain
+"no such file or directory".
+</p>
+
+<p>
+When feasible, error strings should identify their origin, such as by having
+a prefix naming the operation or package that generated the error. For example, in package
+<code>image</code>, the string representation for a decoding error due to an
+unknown format is "image: unknown format".
+</p>
+
+<p>
+Callers that care about the precise error details can
+use a type switch or a type assertion to look for specific
+errors and extract details. For <code>PathErrors</code>
+this might include examining the internal <code>Err</code>
+field for recoverable failures.
+</p>
+
+<pre>
+for try := 0; try < 2; try++ {
+ file, err = os.Create(filename)
+ if err == nil {
+ return
+ }
+ if e, ok := err.(*os.PathError); ok && e.Err == syscall.ENOSPC {
+ deleteTempFiles() // Recover some space.
+ continue
+ }
+ return
+}
+</pre>
+
+<p>
+The second <code>if</code> statement here is another <a href="#interface_conversions">type assertion</a>.
+If it fails, <code>ok</code> will be false, and <code>e</code>
+will be <code>nil</code>.
+If it succeeds, <code>ok</code> will be true, which means the
+error was of type <code>*os.PathError</code>, and then so is <code>e</code>,
+which we can examine for more information about the error.
+</p>
+
+<h3 id="panic">Panic</h3>
+
+<p>
+The usual way to report an error to a caller is to return an
+<code>error</code> as an extra return value. The canonical
+<code>Read</code> method is a well-known instance; it returns a byte
+count and an <code>error</code>. But what if the error is
+unrecoverable? Sometimes the program simply cannot continue.
+</p>
+
+<p>
+For this purpose, there is a built-in function <code>panic</code>
+that in effect creates a run-time error that will stop the program
+(but see the next section). The function takes a single argument
+of arbitrary type—often a string—to be printed as the
+program dies. It's also a way to indicate that something impossible has
+happened, such as exiting an infinite loop.
+</p>
+
+
+<pre>
+// A toy implementation of cube root using Newton's method.
+func CubeRoot(x float64) float64 {
+ z := x/3 // Arbitrary initial value
+ for i := 0; i < 1e6; i++ {
+ prevz := z
+ z -= (z*z*z-x) / (3*z*z)
+ if veryClose(z, prevz) {
+ return z
+ }
+ }
+ // A million iterations has not converged; something is wrong.
+ panic(fmt.Sprintf("CubeRoot(%g) did not converge", x))
+}
+</pre>
+
+<p>
+This is only an example but real library functions should
+avoid <code>panic</code>. If the problem can be masked or worked
+around, it's always better to let things continue to run rather
+than taking down the whole program. One possible counterexample
+is during initialization: if the library truly cannot set itself up,
+it might be reasonable to panic, so to speak.
+</p>
+
+<pre>
+var user = os.Getenv("USER")
+
+func init() {
+ if user == "" {
+ panic("no value for $USER")
+ }
+}
+</pre>
+
+<h3 id="recover">Recover</h3>
+
+<p>
+When <code>panic</code> is called, including implicitly for run-time
+errors such as indexing a slice out of bounds or failing a type
+assertion, it immediately stops execution of the current function
+and begins unwinding the stack of the goroutine, running any deferred
+functions along the way. If that unwinding reaches the top of the
+goroutine's stack, the program dies. However, it is possible to
+use the built-in function <code>recover</code> to regain control
+of the goroutine and resume normal execution.
+</p>
+
+<p>
+A call to <code>recover</code> stops the unwinding and returns the
+argument passed to <code>panic</code>. Because the only code that
+runs while unwinding is inside deferred functions, <code>recover</code>
+is only useful inside deferred functions.
+</p>
+
+<p>
+One application of <code>recover</code> is to shut down a failing goroutine
+inside a server without killing the other executing goroutines.
+</p>
+
+<pre>
+func server(workChan <-chan *Work) {
+ for work := range workChan {
+ go safelyDo(work)
+ }
+}
+
+func safelyDo(work *Work) {
+ defer func() {
+ if err := recover(); err != nil {
+ log.Println("work failed:", err)
+ }
+ }()
+ do(work)
+}
+</pre>
+
+<p>
+In this example, if <code>do(work)</code> panics, the result will be
+logged and the goroutine will exit cleanly without disturbing the
+others. There's no need to do anything else in the deferred closure;
+calling <code>recover</code> handles the condition completely.
+</p>
+
+<p>
+Because <code>recover</code> always returns <code>nil</code> unless called directly
+from a deferred function, deferred code can call library routines that themselves
+use <code>panic</code> and <code>recover</code> without failing. As an example,
+the deferred function in <code>safelyDo</code> might call a logging function before
+calling <code>recover</code>, and that logging code would run unaffected
+by the panicking state.
+</p>
+
+<p>
+With our recovery pattern in place, the <code>do</code>
+function (and anything it calls) can get out of any bad situation
+cleanly by calling <code>panic</code>. We can use that idea to
+simplify error handling in complex software. Let's look at an
+idealized version of a <code>regexp</code> package, which reports
+parsing errors by calling <code>panic</code> with a local
+error type. Here's the definition of <code>Error</code>,
+an <code>error</code> method, and the <code>Compile</code> function.
+</p>
+
+<pre>
+// Error is the type of a parse error; it satisfies the error interface.
+type Error string
+func (e Error) Error() string {
+ return string(e)
+}
+
+// error is a method of *Regexp that reports parsing errors by
+// panicking with an Error.
+func (regexp *Regexp) error(err string) {
+ panic(Error(err))
+}
+
+// Compile returns a parsed representation of the regular expression.
+func Compile(str string) (regexp *Regexp, err error) {
+ regexp = new(Regexp)
+ // doParse will panic if there is a parse error.
+ defer func() {
+ if e := recover(); e != nil {
+ regexp = nil // Clear return value.
+ err = e.(Error) // Will re-panic if not a parse error.
+ }
+ }()
+ return regexp.doParse(str), nil
+}
+</pre>
+
+<p>
+If <code>doParse</code> panics, the recovery block will set the
+return value to <code>nil</code>—deferred functions can modify
+named return values. It will then check, in the assignment
+to <code>err</code>, that the problem was a parse error by asserting
+that it has the local type <code>Error</code>.
+If it does not, the type assertion will fail, causing a run-time error
+that continues the stack unwinding as though nothing had interrupted
+it.
+This check means that if something unexpected happens, such
+as an index out of bounds, the code will fail even though we
+are using <code>panic</code> and <code>recover</code> to handle
+parse errors.
+</p>
+
+<p>
+With error handling in place, the <code>error</code> method (because it's a
+method bound to a type, it's fine, even natural, for it to have the same name
+as the builtin <code>error</code> type)
+makes it easy to report parse errors without worrying about unwinding
+the parse stack by hand:
+</p>
+
+<pre>
+if pos == 0 {
+ re.error("'*' illegal at start of expression")
+}
+</pre>
+
+<p>
+Useful though this pattern is, it should be used only within a package.
+<code>Parse</code> turns its internal <code>panic</code> calls into
+<code>error</code> values; it does not expose <code>panics</code>
+to its client. That is a good rule to follow.
+</p>
+
+<p>
+By the way, this re-panic idiom changes the panic value if an actual
+error occurs. However, both the original and new failures will be
+presented in the crash report, so the root cause of the problem will
+still be visible. Thus this simple re-panic approach is usually
+sufficient—it's a crash after all—but if you want to
+display only the original value, you can write a little more code to
+filter unexpected problems and re-panic with the original error.
+That's left as an exercise for the reader.
+</p>
+
+
+<h2 id="web_server">A web server</h2>
+
+<p>
+Let's finish with a complete Go program, a web server.
+This one is actually a kind of web re-server.
+Google provides a service at <code>chart.apis.google.com</code>
+that does automatic formatting of data into charts and graphs.
+It's hard to use interactively, though,
+because you need to put the data into the URL as a query.
+The program here provides a nicer interface to one form of data: given a short piece of text,
+it calls on the chart server to produce a QR code, a matrix of boxes that encode the
+text.
+That image can be grabbed with your cell phone's camera and interpreted as,
+for instance, a URL, saving you typing the URL into the phone's tiny keyboard.
+</p>
+<p>
+Here's the complete program.
+An explanation follows.
+</p>
+{{code "/doc/progs/eff_qr.go" `/package/` `$`}}
+<p>
+The pieces up to <code>main</code> should be easy to follow.
+The one flag sets a default HTTP port for our server. The template
+variable <code>templ</code> is where the fun happens. It builds an HTML template
+that will be executed by the server to display the page; more about
+that in a moment.
+</p>
+<p>
+The <code>main</code> function parses the flags and, using the mechanism
+we talked about above, binds the function <code>QR</code> to the root path
+for the server. Then <code>http.ListenAndServe</code> is called to start the
+server; it blocks while the server runs.
+</p>
+<p>
+<code>QR</code> just receives the request, which contains form data, and
+executes the template on the data in the form value named <code>s</code>.
+</p>
+<p>
+The template package <code>html/template</code> is powerful;
+this program just touches on its capabilities.
+In essence, it rewrites a piece of HTML text on the fly by substituting elements derived
+from data items passed to <code>templ.Execute</code>, in this case the
+form value.
+Within the template text (<code>templateStr</code>),
+double-brace-delimited pieces denote template actions.
+The piece from <code>{{html "{{if .}}"}}</code>
+to <code>{{html "{{end}}"}}</code> executes only if the value of the current data item, called <code>.</code> (dot),
+is non-empty.
+That is, when the string is empty, this piece of the template is suppressed.
+</p>
+<p>
+The two snippets <code>{{html "{{.}}"}}</code> say to show the data presented to
+the template—the query string—on the web page.
+The HTML template package automatically provides appropriate escaping so the
+text is safe to display.
+</p>
+<p>
+The rest of the template string is just the HTML to show when the page loads.
+If this is too quick an explanation, see the <a href="/pkg/html/template/">documentation</a>
+for the template package for a more thorough discussion.
+</p>
+<p>
+And there you have it: a useful web server in a few lines of code plus some
+data-driven HTML text.
+Go is powerful enough to make a lot happen in a few lines.
+</p>
+
+<!--
+TODO
+<pre>
+verifying implementation
+type Color uint32
+
+// Check that Color implements image.Color and image.Image
+var _ image.Color = Black
+var _ image.Image = Black
+</pre>
+-->
diff --git a/_content/doc/gccgo_contribute.html b/_content/doc/gccgo_contribute.html
new file mode 100644
index 0000000..395902d
--- /dev/null
+++ b/_content/doc/gccgo_contribute.html
@@ -0,0 +1,112 @@
+<!--{
+ "Title": "Contributing to the gccgo frontend"
+}-->
+
+<h2>Introduction</h2>
+
+<p>
+These are some notes on contributing to the gccgo frontend for GCC.
+For information on contributing to parts of Go other than gccgo,
+see <a href="/doc/contribute.html">Contributing to the Go project</a>. For
+information on building gccgo for yourself,
+see <a href="/doc/gccgo_install.html">Setting up and using gccgo</a>.
+For more of the gritty details on the process of doing development
+with the gccgo frontend,
+see <a href="https://go.googlesource.com/gofrontend/+/master/HACKING">the
+file HACKING</a> in the gofrontend repository.
+</p>
+
+<h2>Legal Prerequisites</h2>
+
+<p>
+You must follow the <a href="/doc/contribute.html#copyright">Go copyright
+rules</a> for all changes to the gccgo frontend and the associated
+libgo library. Code that is part of GCC rather than gccgo must follow
+the general <a href="https://gcc.gnu.org/contribute.html">GCC
+contribution rules</a>.
+</p>
+
+<h2>Code</h2>
+
+<p>
+The master sources for the gccgo frontend may be found at
+<a href="https://go.googlesource.com/gofrontend">https://go.googlesource.com/gofrontend</a>.
+They are mirrored
+at <a href="https://github.com/golang/gofrontend">https://github.com/golang/gofrontend</a>.
+The master sources are not buildable by themselves, but only in
+conjunction with GCC (in the future, other compilers may be
+supported). Changes made to the gccgo frontend are also applied to
+the GCC source code repository hosted at <code>gcc.gnu.org</code>. In
+the <code>gofrontend</code> repository, the <code>go</code> directory
+is mirrored to the <code>gcc/go/gofrontend</code> directory in the GCC
+repository, and the <code>gofrontend</code> <code>libgo</code>
+directory is mirrored to the GCC <code>libgo</code> directory. In
+addition, the <code>test</code> directory
+from <a href="//go.googlesource.com/go">the main Go repository</a>
+is mirrored to the <code>gcc/testsuite/go.test/test</code> directory
+in the GCC repository.
+</p>
+
+<p>
+Changes to these directories always flow from the master sources to
+the GCC repository. The files should never be changed in the GCC
+repository except by changing them in the master sources and mirroring
+them.
+</p>
+
+<p>
+The gccgo frontend is written in C++.
+It follows the GNU and GCC coding standards for C++.
+In writing code for the frontend, follow the formatting of the
+surrounding code.
+Almost all GCC-specific code is not in the frontend proper and is
+instead in the GCC sources in the <code>gcc/go</code> directory.
+</p>
+
+<p>
+The run-time library for gccgo is mostly the same as the library
+in <a href="//go.googlesource.com/go">the main Go repository</a>.
+The library code in the Go repository is periodically merged into
+the <code>libgo/go</code> directory of the <code>gofrontend</code> and
+then the GCC repositories, using the shell
+script <code>libgo/merge.sh</code>. Accordingly, most library changes
+should be made in the main Go repository. The files outside
+of <code>libgo/go</code> are gccgo-specific; that said, some of the
+files in <code>libgo/runtime</code> are based on files
+in <code>src/runtime</code> in the main Go repository.
+</p>
+
+<h2>Testing</h2>
+
+<p>
+All patches must be tested. A patch that introduces new failures is
+not acceptable.
+</p>
+
+<p>
+To run the gccgo test suite, run <code>make check-go</code> in your
+build directory. This will run various tests
+under <code>gcc/testsuite/go.*</code> and will also run
+the <code>libgo</code> testsuite. This copy of the tests from the
+main Go repository is run using the DejaGNU script found
+in <code>gcc/testsuite/go.test/go-test.exp</code>.
+</p>
+
+<p>
+Most new tests should be submitted to the main Go repository for later
+mirroring into the GCC repository. If there is a need for specific
+tests for gccgo, they should go in
+the <code>gcc/testsuite/go.go-torture</code>
+or <code>gcc/testsuite/go.dg</code> directories in the GCC repository.
+</p>
+
+<h2>Submitting Changes</h2>
+
+<p>
+Changes to the Go frontend should follow the same process as for the
+main Go repository, only for the <code>gofrontend</code> project and
+the <code>gofrontend-dev@googlegroups.com</code> mailing list
+rather than the <code>go</code> project and the
+<code>golang-dev@googlegroups.com</code> mailing list. Those changes
+will then be merged into the GCC sources.
+</p>
diff --git a/_content/doc/gccgo_install.html b/_content/doc/gccgo_install.html
new file mode 100644
index 0000000..c478a9e
--- /dev/null
+++ b/_content/doc/gccgo_install.html
@@ -0,0 +1,533 @@
+<!--{
+ "Title": "Setting up and using gccgo",
+ "Path": "/doc/install/gccgo"
+}-->
+
+<p>
+This document explains how to use gccgo, a compiler for
+the Go language. The gccgo compiler is a new frontend
+for GCC, the widely used GNU compiler. Although the
+frontend itself is under a BSD-style license, gccgo is
+normally used as part of GCC and is then covered by
+the <a href="https://www.gnu.org/licenses/gpl.html">GNU General Public
+License</a> (the license covers gccgo itself as part of GCC; it
+does not cover code generated by gccgo).
+</p>
+
+<p>
+Note that gccgo is not the <code>gc</code> compiler; see
+the <a href="/doc/install.html">Installing Go</a> instructions for that
+compiler.
+</p>
+
+<h2 id="Releases">Releases</h2>
+
+<p>
+The simplest way to install gccgo is to install a GCC binary release
+built to include Go support. GCC binary releases are available from
+<a href="https://gcc.gnu.org/install/binaries.html">various
+websites</a> and are typically included as part of GNU/Linux
+distributions. We expect that most people who build these binaries
+will include Go support.
+</p>
+
+<p>
+The GCC 4.7.1 release and all later 4.7 releases include a complete
+<a href="/doc/go1.html">Go 1</a> compiler and libraries.
+</p>
+
+<p>
+Due to timing, the GCC 4.8.0 and 4.8.1 releases are close to but not
+identical to Go 1.1. The GCC 4.8.2 release includes a complete Go
+1.1.2 implementation.
+</p>
+
+<p>
+The GCC 4.9 releases include a complete Go 1.2 implementation.
+</p>
+
+<p>
+The GCC 5 releases include a complete implementation of the Go 1.4
+user libraries. The Go 1.4 runtime is not fully merged, but that
+should not be visible to Go programs.
+</p>
+
+<p>
+The GCC 6 releases include a complete implementation of the Go 1.6.1
+user libraries. The Go 1.6 runtime is not fully merged, but that
+should not be visible to Go programs.
+</p>
+
+<p>
+The GCC 7 releases include a complete implementation of the Go 1.8.1
+user libraries. As with earlier releases, the Go 1.8 runtime is not
+fully merged, but that should not be visible to Go programs.
+</p>
+
+<p>
+The GCC 8 releases include a complete implementation of the Go 1.10.1
+release. The Go 1.10 runtime has now been fully merged into the GCC
+development sources, and concurrent garbage collection is fully
+supported.
+</p>
+
+<p>
+The GCC 9 releases include a complete implementation of the Go 1.12.2
+release.
+</p>
+
+<h2 id="Source_code">Source code</h2>
+
+<p>
+If you cannot use a release, or prefer to build gccgo for yourself, the
+gccgo source code is accessible via Git. The GCC web site has
+<a href="https://gcc.gnu.org/git.html">instructions for getting the GCC
+source code</a>. The gccgo source code is included. As a convenience, a
+stable version of the Go support is available in the
+<code>devel/gccgo</code> branch of the main GCC code repository:
+<code>git://gcc.gnu.org/git/gcc.git</code>.
+This branch is periodically updated with stable Go compiler sources.
+</p>
+
+<p>
+Note that although <code>gcc.gnu.org</code> is the most convenient way
+to get the source code for the Go frontend, it is not where the master
+sources live. If you want to contribute changes to the Go frontend
+compiler, see <a href="/doc/gccgo_contribute.html">Contributing to
+gccgo</a>.
+</p>
+
+
+<h2 id="Building">Building</h2>
+
+<p>
+Building gccgo is just like building GCC
+with one or two additional options. See
+the <a href="https://gcc.gnu.org/install/">instructions on the gcc web
+site</a>. When you run <code>configure</code>, add the
+option <code>--enable-languages=c,c++,go</code> (along with other
+languages you may want to build). If you are targeting a 32-bit x86,
+then you will want to build gccgo to default to
+supporting locked compare and exchange instructions; do this by also
+using the <code>configure</code> option <code>--with-arch=i586</code>
+(or a newer architecture, depending on where you need your programs to
+run). If you are targeting a 64-bit x86, but sometimes want to use
+the <code>-m32</code> option, then use the <code>configure</code>
+option <code>--with-arch-32=i586</code>.
+</p>
+
+<h3 id="Gold">Gold</h3>
+
+<p>
+On x86 GNU/Linux systems the gccgo compiler is able to
+use a small discontiguous stack for goroutines. This permits programs
+to run many more goroutines, since each goroutine can use a relatively
+small stack. Doing this requires using the gold linker version 2.22
+or later. You can either install GNU binutils 2.22 or later, or you
+can build gold yourself.
+</p>
+
+<p>
+To build gold yourself, build the GNU binutils,
+using <code>--enable-gold=default</code> when you run
+the <code>configure</code> script. Before building, you must install
+the flex and bison packages. A typical sequence would look like
+this (you can replace <code>/opt/gold</code> with any directory to
+which you have write access):
+</p>
+
+<pre>
+git clone git://sourceware.org/git/binutils-gdb.git
+mkdir binutils-objdir
+cd binutils-objdir
+../binutils-gdb/configure --enable-gold=default --prefix=/opt/gold
+make
+make install
+</pre>
+
+<p>
+However you install gold, when you configure gccgo, use the
+option <code>--with-ld=<var>GOLD_BINARY</var></code>.
+</p>
+
+<h3 id="Prerequisites">Prerequisites</h3>
+
+<p>
+A number of prerequisites are required to build GCC, as
+described on
+the <a href="https://gcc.gnu.org/install/prerequisites.html">gcc web
+site</a>. It is important to install all the prerequisites before
+running the gcc <code>configure</code> script.
+The prerequisite libraries can be conveniently downloaded using the
+script <code>contrib/download_prerequisites</code> in the GCC sources.
+
+<h3 id="Build_commands">Build commands</h3>
+
+<p>
+Once all the prerequisites are installed, then a typical build and
+install sequence would look like this (only use
+the <code>--with-ld</code> option if you are using the gold linker as
+described above):
+</p>
+
+<pre>
+git clone --branch devel/gccgo git://gcc.gnu.org/git/gcc.git gccgo
+mkdir objdir
+cd objdir
+../gccgo/configure --prefix=/opt/gccgo --enable-languages=c,c++,go --with-ld=/opt/gold/bin/ld
+make
+make install
+</pre>
+
+<h2 id="Using_gccgo">Using gccgo</h2>
+
+<p>
+The gccgo compiler works like other gcc frontends. As of GCC 5 the gccgo
+installation also includes a version of the <code>go</code> command,
+which may be used to build Go programs as described at
+<a href="https://golang.org/cmd/go">https://golang.org/cmd/go</a>.
+</p>
+
+<p>
+To compile a file without using the <code>go</code> command:
+</p>
+
+<pre>
+gccgo -c file.go
+</pre>
+
+<p>
+That produces <code>file.o</code>. To link files together to form an
+executable:
+</p>
+
+<pre>
+gccgo -o file file.o
+</pre>
+
+<p>
+To run the resulting file, you will need to tell the program where to
+find the compiled Go packages. There are a few ways to do this:
+</p>
+
+<ul>
+<li>
+<p>
+Set the <code>LD_LIBRARY_PATH</code> environment variable:
+</p>
+
+<pre>
+LD_LIBRARY_PATH=${prefix}/lib/gcc/MACHINE/VERSION
+[or]
+LD_LIBRARY_PATH=${prefix}/lib64/gcc/MACHINE/VERSION
+export LD_LIBRARY_PATH
+</pre>
+
+<p>
+Here <code>${prefix}</code> is the <code>--prefix</code> option used
+when building gccgo. For a binary install this is
+normally <code>/usr</code>. Whether to use <code>lib</code>
+or <code>lib64</code> depends on the target.
+Typically <code>lib64</code> is correct for x86_64 systems,
+and <code>lib</code> is correct for other systems. The idea is to
+name the directory where <code>libgo.so</code> is found.
+</p>
+
+</li>
+
+<li>
+<p>
+Passing a <code>-Wl,-R</code> option when you link (replace lib with
+lib64 if appropriate for your system):
+</p>
+
+<pre>
+go build -gccgoflags -Wl,-R,${prefix}/lib/gcc/MACHINE/VERSION
+[or]
+gccgo -o file file.o -Wl,-R,${prefix}/lib/gcc/MACHINE/VERSION
+</pre>
+</li>
+
+<li>
+<p>
+Use the <code>-static-libgo</code> option to link statically against
+the compiled packages.
+</p>
+</li>
+
+<li>
+<p>
+Use the <code>-static</code> option to do a fully static link (the
+default for the <code>gc</code> compiler).
+</p>
+</li>
+</ul>
+
+<h2 id="Options">Options</h2>
+
+<p>
+The gccgo compiler supports all GCC options
+that are language independent, notably the <code>-O</code>
+and <code>-g</code> options.
+</p>
+
+<p>
+The <code>-fgo-pkgpath=PKGPATH</code> option may be used to set a
+unique prefix for the package being compiled.
+This option is automatically used by the go command, but you may want
+to use it if you invoke gccgo directly.
+This option is intended for use with large
+programs that contain many packages, in order to allow multiple
+packages to use the same identifier as the package name.
+The <code>PKGPATH</code> may be any string; a good choice for the
+string is the path used to import the package.
+</p>
+
+<p>
+The <code>-I</code> and <code>-L</code> options, which are synonyms
+for the compiler, may be used to set the search path for finding
+imports.
+These options are not needed if you build with the go command.
+</p>
+
+<h2 id="Imports">Imports</h2>
+
+<p>
+When you compile a file that exports something, the export
+information will be stored directly in the object file.
+If you build with gccgo directly, rather than with the go command,
+then when you import a package, you must tell gccgo how to find the
+file.
+</p>
+
+<p>
+When you import the package <var>FILE</var> with gccgo,
+it will look for the import data in the following files, and use the
+first one that it finds.
+
+<ul>
+<li><code><var>FILE</var>.gox</code>
+<li><code>lib<var>FILE</var>.so</code>
+<li><code>lib<var>FILE</var>.a</code>
+<li><code><var>FILE</var>.o</code>
+</ul>
+
+<p>
+<code><var>FILE</var>.gox</code>, when used, will typically contain
+nothing but export data. This can be generated from
+<code><var>FILE</var>.o</code> via
+</p>
+
+<pre>
+objcopy -j .go_export FILE.o FILE.gox
+</pre>
+
+<p>
+The gccgo compiler will look in the current
+directory for import files. In more complex scenarios you
+may pass the <code>-I</code> or <code>-L</code> option to
+gccgo. Both options take directories to search. The
+<code>-L</code> option is also passed to the linker.
+</p>
+
+<p>
+The gccgo compiler does not currently (2015-06-15) record
+the file name of imported packages in the object file. You must
+arrange for the imported data to be linked into the program.
+Again, this is not necessary when building with the go command.
+</p>
+
+<pre>
+gccgo -c mypackage.go # Exports mypackage
+gccgo -c main.go # Imports mypackage
+gccgo -o main main.o mypackage.o # Explicitly links with mypackage.o
+</pre>
+
+<h2 id="Debugging">Debugging</h2>
+
+<p>
+If you use the <code>-g</code> option when you compile, you can run
+<code>gdb</code> on your executable. The debugger has only limited
+knowledge about Go. You can set breakpoints, single-step,
+etc. You can print variables, but they will be printed as though they
+had C/C++ types. For numeric types this doesn't matter. Go strings
+and interfaces will show up as two-element structures. Go
+maps and channels are always represented as C pointers to run-time
+structures.
+</p>
+
+<h2 id="C_Interoperability">C Interoperability</h2>
+
+<p>
+When using gccgo there is limited interoperability with C,
+or with C++ code compiled using <code>extern "C"</code>.
+</p>
+
+<h3 id="Types">Types</h3>
+
+<p>
+Basic types map directly: an <code>int32</code> in Go is
+an <code>int32_t</code> in C, an <code>int64</code> is
+an <code>int64_t</code>, etc.
+The Go type <code>int</code> is an integer that is the same size as a
+pointer, and as such corresponds to the C type <code>intptr_t</code>.
+Go <code>byte</code> is equivalent to C <code>unsigned char</code>.
+Pointers in Go are pointers in C.
+A Go <code>struct</code> is the same as C <code>struct</code> with the
+same fields and types.
+</p>
+
+<p>
+The Go <code>string</code> type is currently defined as a two-element
+structure (this is <b style="color: red;">subject to change</b>):
+</p>
+
+<pre>
+struct __go_string {
+ const unsigned char *__data;
+ intptr_t __length;
+};
+</pre>
+
+<p>
+You can't pass arrays between C and Go. However, a pointer to an
+array in Go is equivalent to a C pointer to the
+equivalent of the element type.
+For example, Go <code>*[10]int</code> is equivalent to C <code>int*</code>,
+assuming that the C pointer does point to 10 elements.
+</p>
+
+<p>
+A slice in Go is a structure. The current definition is
+(this is <b style="color: red;">subject to change</b>):
+</p>
+
+<pre>
+struct __go_slice {
+ void *__values;
+ intptr_t __count;
+ intptr_t __capacity;
+};
+</pre>
+
+<p>
+The type of a Go function is a pointer to a struct (this is
+<b style="color: red;">subject to change</b>). The first field in the
+struct points to the code of the function, which will be equivalent to
+a pointer to a C function whose parameter types are equivalent, with
+an additional trailing parameter. The trailing parameter is the
+closure, and the argument to pass is a pointer to the Go function
+struct.
+
+When a Go function returns more than one value, the C function returns
+a struct. For example, these functions are roughly equivalent:
+</p>
+
+<pre>
+func GoFunction(int) (int, float64)
+struct { int i; float64 f; } CFunction(int, void*)
+</pre>
+
+<p>
+Go <code>interface</code>, <code>channel</code>, and <code>map</code>
+types have no corresponding C type (<code>interface</code> is a
+two-element struct and <code>channel</code> and <code>map</code> are
+pointers to structs in C, but the structs are deliberately undocumented). C
+<code>enum</code> types correspond to some integer type, but precisely
+which one is difficult to predict in general; use a cast. C <code>union</code>
+types have no corresponding Go type. C <code>struct</code> types containing
+bitfields have no corresponding Go type. C++ <code>class</code> types have
+no corresponding Go type.
+</p>
+
+<p>
+Memory allocation is completely different between C and Go, as Go uses
+garbage collection. The exact guidelines in this area are undetermined,
+but it is likely that it will be permitted to pass a pointer to allocated
+memory from C to Go. The responsibility of eventually freeing the pointer
+will remain with C side, and of course if the C side frees the pointer
+while the Go side still has a copy the program will fail. When passing a
+pointer from Go to C, the Go function must retain a visible copy of it in
+some Go variable. Otherwise the Go garbage collector may delete the
+pointer while the C function is still using it.
+</p>
+
+<h3 id="Function_names">Function names</h3>
+
+<p>
+Go code can call C functions directly using a Go extension implemented
+in gccgo: a function declaration may be preceded by
+<code>//extern NAME</code>. For example, here is how the C function
+<code>open</code> can be declared in Go:
+</p>
+
+<pre>
+//extern open
+func c_open(name *byte, mode int, perm int) int
+</pre>
+
+<p>
+The C function naturally expects a NUL-terminated string, which in
+Go is equivalent to a pointer to an array (not a slice!) of
+<code>byte</code> with a terminating zero byte. So a sample call
+from Go would look like (after importing the <code>syscall</code> package):
+</p>
+
+<pre>
+var name = [4]byte{'f', 'o', 'o', 0};
+i := c_open(&name[0], syscall.O_RDONLY, 0);
+</pre>
+
+<p>
+(this serves as an example only, to open a file in Go please use Go's
+<code>os.Open</code> function instead).
+</p>
+
+<p>
+Note that if the C function can block, such as in a call
+to <code>read</code>, calling the C function may block the Go program.
+Unless you have a clear understanding of what you are doing, all calls
+between C and Go should be implemented through cgo or SWIG, as for
+the <code>gc</code> compiler.
+</p>
+
+<p>
+The name of Go functions accessed from C is subject to change. At present
+the name of a Go function that does not have a receiver is
+<code>prefix.package.Functionname</code>. The prefix is set by
+the <code>-fgo-prefix</code> option used when the package is compiled;
+if the option is not used, the default is <code>go</code>.
+To call the function from C you must set the name using
+a GCC extension.
+</p>
+
+<pre>
+extern int go_function(int) __asm__ ("myprefix.mypackage.Function");
+</pre>
+
+<h3 id="Automatic_generation_of_Go_declarations_from_C_source_code">
+Automatic generation of Go declarations from C source code</h3>
+
+<p>
+The Go version of GCC supports automatically generating
+Go declarations from C code. The facility is rather awkward, and most
+users should use the <a href="/cmd/cgo">cgo</a> program with
+the <code>-gccgo</code> option instead.
+</p>
+
+<p>
+Compile your C code as usual, and add the option
+<code>-fdump-go-spec=<var>FILENAME</var></code>. This will create the
+file <code><var>FILENAME</var></code> as a side effect of the
+compilation. This file will contain Go declarations for the types,
+variables and functions declared in the C code. C types that can not
+be represented in Go will be recorded as comments in the Go code. The
+generated file will not have a <code>package</code> declaration, but
+can otherwise be compiled directly by gccgo.
+</p>
+
+<p>
+This procedure is full of unstated caveats and restrictions and we make no
+guarantee that it will not change in the future. It is more useful as a
+starting point for real Go code than as a regular procedure.
+</p>
diff --git a/_content/doc/go-get-install-deprecation.md b/_content/doc/go-get-install-deprecation.md
new file mode 100644
index 0000000..e7f2f09
--- /dev/null
+++ b/_content/doc/go-get-install-deprecation.md
@@ -0,0 +1,64 @@
+<!--{
+ "Title": "Deprecation of 'go get' for installing executables",
+ "Path": "/doc/go-get-install-deprecation"
+}-->
+
+## Overview
+
+Starting in Go 1.17, installing executables with `go get` is deprecated.
+`go install` may be used instead.
+
+In a future Go release, `go get` will no longer build packages; it will only
+be used to add, update, or remove dependencies in `go.mod`. Specifically,
+`go get` will act as if the `-d` flag were enabled.
+
+## What to use instead
+
+To install an executable in the context of the current module, use `go install`,
+without a version suffix, as below. This applies version requirements and
+other directives from the `go.mod` file in the current directory or a parent
+directory.
+
+```
+go install example.com/cmd
+```
+
+To install an executable while ignoring the current module, use `go install`
+*with* a [version suffix](/ref/mod#version-queries) like `@v1.2.3` or `@latest`,
+as below. When used with a version suffix, `go install` does not read or update
+the `go.mod` file in the current directory or a parent directory.
+
+```
+# Install a specific version.
+go install example.com/cmd@v1.2.3
+
+# Install the highest available version.
+go install example.com/cmd@latest
+```
+
+In order to avoid ambiguity, when `go install` is used with a version suffix,
+all arguments must refer to `main` packages in the same module at the same
+version. If that module has a `go.mod` file, it must not contain directives like
+`replace` or `exclude` that would cause it to be interpreted differently if it
+were the main module.
+
+See [`go install`](#/ref/mod#go-install) for details.
+
+## Why this is happening
+
+Since modules were introduced, the `go get` command has been used both to update
+dependencies in `go.mod` and to install commands. This combination is frequently
+confusing and inconvenient: in most cases, developers want to update a
+dependency or install a command but not both at the same time.
+
+Since Go 1.16, `go install` can install a command at a version specified on the
+command line while ignoring the `go.mod` file in the current directory (if one
+exists). `go install` should now be used to install commands in most cases.
+
+`go get`'s ability to build and install commands is now deprecated, since that
+functionality is redundant with `go install`. Removing this functionality
+will make `go get` faster, since it won't compile or link packages by default.
+`go get` also won't report an error when updating a package that can't be built
+for the current platform.
+
+See proposal [#40276](https://golang.org/issue/40276) for the full discussion.
diff --git a/_content/doc/go-logo-black.png b/_content/doc/go-logo-black.png
new file mode 100644
index 0000000..3077ebd
--- /dev/null
+++ b/_content/doc/go-logo-black.png
Binary files differ
diff --git a/_content/doc/go-logo-blue.png b/_content/doc/go-logo-blue.png
new file mode 100644
index 0000000..8d43a56
--- /dev/null
+++ b/_content/doc/go-logo-blue.png
Binary files differ
diff --git a/_content/doc/go-logo-white.png b/_content/doc/go-logo-white.png
new file mode 100644
index 0000000..fa29169
--- /dev/null
+++ b/_content/doc/go-logo-white.png
Binary files differ
diff --git a/_content/doc/go1.1.html b/_content/doc/go1.1.html
new file mode 100644
index 0000000..a1130c0
--- /dev/null
+++ b/_content/doc/go1.1.html
@@ -0,0 +1,1098 @@
+<!--{
+ "Title": "Go 1.1 Release Notes",
+ "Template": true
+}-->
+
+<h2 id="introduction">Introduction to Go 1.1</h2>
+
+<p>
+The release of <a href="/doc/go1.html">Go version 1</a> (Go 1 or Go 1.0 for short)
+in March of 2012 introduced a new period
+of stability in the Go language and libraries.
+That stability has helped nourish a growing community of Go users
+and systems around the world.
+Several "point" releases since
+then—1.0.1, 1.0.2, and 1.0.3—have been issued.
+These point releases fixed known bugs but made
+no non-critical changes to the implementation.
+</p>
+
+<p>
+This new release, Go 1.1, keeps the <a href="/doc/go1compat.html">promise
+of compatibility</a> but adds a couple of significant
+(backwards-compatible, of course) language changes, has a long list
+of (again, compatible) library changes, and
+includes major work on the implementation of the compilers,
+libraries, and run-time.
+The focus is on performance.
+Benchmarking is an inexact science at best, but we see significant,
+sometimes dramatic speedups for many of our test programs.
+We trust that many of our users' programs will also see improvements
+just by updating their Go installation and recompiling.
+</p>
+
+<p>
+This document summarizes the changes between Go 1 and Go 1.1.
+Very little if any code will need modification to run with Go 1.1,
+although a couple of rare error cases surface with this release
+and need to be addressed if they arise.
+Details appear below; see the discussion of
+<a href="#int">64-bit ints</a> and <a href="#unicode_literals">Unicode literals</a>
+in particular.
+</p>
+
+<h2 id="language">Changes to the language</h2>
+
+<p>
+<a href="/doc/go1compat.html">The Go compatibility document</a> promises
+that programs written to the Go 1 language specification will continue to operate,
+and those promises are maintained.
+In the interest of firming up the specification, though, there are
+details about some error cases that have been clarified.
+There are also some new language features.
+</p>
+
+<h3 id="divzero">Integer division by zero</h3>
+
+<p>
+In Go 1, integer division by a constant zero produced a run-time panic:
+</p>
+
+<pre>
+func f(x int) int {
+ return x/0
+}
+</pre>
+
+<p>
+In Go 1.1, an integer division by constant zero is not a legal program, so it is a compile-time error.
+</p>
+
+<h3 id="unicode_literals">Surrogates in Unicode literals</h3>
+
+<p>
+The definition of string and rune literals has been refined to exclude surrogate halves from the
+set of valid Unicode code points.
+See the <a href="#unicode">Unicode</a> section for more information.
+</p>
+
+<h3 id="method_values">Method values</h3>
+
+<p>
+Go 1.1 now implements
+<a href="/ref/spec#Method_values">method values</a>,
+which are functions that have been bound to a specific receiver value.
+For instance, given a
+<a href="/pkg/bufio/#Writer"><code>Writer</code></a>
+value <code>w</code>,
+the expression
+<code>w.Write</code>,
+a method value, is a function that will always write to <code>w</code>; it is equivalent to
+a function literal closing over <code>w</code>:
+</p>
+
+<pre>
+func (p []byte) (n int, err error) {
+ return w.Write(p)
+}
+</pre>
+
+<p>
+Method values are distinct from method expressions, which generate functions
+from methods of a given type; the method expression <code>(*bufio.Writer).Write</code>
+is equivalent to a function with an extra first argument, a receiver of type
+<code>(*bufio.Writer)</code>:
+</p>
+
+<pre>
+func (w *bufio.Writer, p []byte) (n int, err error) {
+ return w.Write(p)
+}
+</pre>
+
+<p>
+<em>Updating</em>: No existing code is affected; the change is strictly backward-compatible.
+</p>
+
+<h3 id="return">Return requirements</h3>
+
+<p>
+Before Go 1.1, a function that returned a value needed an explicit "return"
+or call to <code>panic</code> at
+the end of the function; this was a simple way to make the programmer
+be explicit about the meaning of the function. But there are many cases
+where a final "return" is clearly unnecessary, such as a function with
+only an infinite "for" loop.
+</p>
+
+<p>
+In Go 1.1, the rule about final "return" statements is more permissive.
+It introduces the concept of a
+<a href="/ref/spec#Terminating_statements"><em>terminating statement</em></a>,
+a statement that is guaranteed to be the last one a function executes.
+Examples include
+"for" loops with no condition and "if-else"
+statements in which each half ends in a "return".
+If the final statement of a function can be shown <em>syntactically</em> to
+be a terminating statement, no final "return" statement is needed.
+</p>
+
+<p>
+Note that the rule is purely syntactic: it pays no attention to the values in the
+code and therefore requires no complex analysis.
+</p>
+
+<p>
+<em>Updating</em>: The change is backward-compatible, but existing code
+with superfluous "return" statements and calls to <code>panic</code> may
+be simplified manually.
+Such code can be identified by <code>go vet</code>.
+</p>
+
+<h2 id="impl">Changes to the implementations and tools</h2>
+
+<h3 id="gccgo">Status of gccgo</h3>
+
+<p>
+The GCC release schedule does not coincide with the Go release schedule, so some skew is inevitable in
+<code>gccgo</code>'s releases.
+The 4.8.0 version of GCC shipped in March, 2013 and includes a nearly-Go 1.1 version of <code>gccgo</code>.
+Its library is a little behind the release, but the biggest difference is that method values are not implemented.
+Sometime around July 2013, we expect 4.8.2 of GCC to ship with a <code>gccgo</code>
+providing a complete Go 1.1 implementation.
+</p>
+
+<h3 id="gc_flag">Command-line flag parsing</h3>
+
+<p>
+In the gc toolchain, the compilers and linkers now use the
+same command-line flag parsing rules as the Go flag package, a departure
+from the traditional Unix flag parsing. This may affect scripts that invoke
+the tool directly.
+For example,
+<code>go tool 6c -Fw -Dfoo</code> must now be written
+<code>go tool 6c -F -w -D foo</code>.
+</p>
+
+<h3 id="int">Size of int on 64-bit platforms</h3>
+
+<p>
+The language allows the implementation to choose whether the <code>int</code> type and
+<code>uint</code> types are 32 or 64 bits. Previous Go implementations made <code>int</code>
+and <code>uint</code> 32 bits on all systems. Both the gc and gccgo implementations
+now make
+<code>int</code> and <code>uint</code> 64 bits on 64-bit platforms such as AMD64/x86-64.
+Among other things, this enables the allocation of slices with
+more than 2 billion elements on 64-bit platforms.
+</p>
+
+<p>
+<em>Updating</em>:
+Most programs will be unaffected by this change.
+Because Go does not allow implicit conversions between distinct
+<a href="/ref/spec#Numeric_types">numeric types</a>,
+no programs will stop compiling due to this change.
+However, programs that contain implicit assumptions
+that <code>int</code> is only 32 bits may change behavior.
+For example, this code prints a positive number on 64-bit systems and
+a negative one on 32-bit systems:
+</p>
+
+<pre>
+x := ^uint32(0) // x is 0xffffffff
+i := int(x) // i is -1 on 32-bit systems, 0xffffffff on 64-bit
+fmt.Println(i)
+</pre>
+
+<p>Portable code intending 32-bit sign extension (yielding <code>-1</code> on all systems)
+would instead say:
+</p>
+
+<pre>
+i := int(int32(x))
+</pre>
+
+<h3 id="heap">Heap size on 64-bit architectures</h3>
+
+<p>
+On 64-bit architectures, the maximum heap size has been enlarged substantially,
+from a few gigabytes to several tens of gigabytes.
+(The exact details depend on the system and may change.)
+</p>
+
+<p>
+On 32-bit architectures, the heap size has not changed.
+</p>
+
+<p>
+<em>Updating</em>:
+This change should have no effect on existing programs beyond allowing them
+to run with larger heaps.
+</p>
+
+<h3 id="unicode">Unicode</h3>
+
+<p>
+To make it possible to represent code points greater than 65535 in UTF-16,
+Unicode defines <em>surrogate halves</em>,
+a range of code points to be used only in the assembly of large values, and only in UTF-16.
+The code points in that surrogate range are illegal for any other purpose.
+In Go 1.1, this constraint is honored by the compiler, libraries, and run-time:
+a surrogate half is illegal as a rune value, when encoded as UTF-8, or when
+encoded in isolation as UTF-16.
+When encountered, for example in converting from a rune to UTF-8, it is
+treated as an encoding error and will yield the replacement rune,
+<a href="/pkg/unicode/utf8/#RuneError"><code>utf8.RuneError</code></a>,
+U+FFFD.
+</p>
+
+<p>
+This program,
+</p>
+
+<pre>
+import "fmt"
+
+func main() {
+ fmt.Printf("%+q\n", string(0xD800))
+}
+</pre>
+
+<p>
+printed <code>"\ud800"</code> in Go 1.0, but prints <code>"\ufffd"</code> in Go 1.1.
+</p>
+
+<p>
+Surrogate-half Unicode values are now illegal in rune and string constants, so constants such as
+<code>'\ud800'</code> and <code>"\ud800"</code> are now rejected by the compilers.
+When written explicitly as UTF-8 encoded bytes,
+such strings can still be created, as in <code>"\xed\xa0\x80"</code>.
+However, when such a string is decoded as a sequence of runes, as in a range loop, it will yield only <code>utf8.RuneError</code>
+values.
+</p>
+
+<p>
+The Unicode byte order mark U+FEFF, encoded in UTF-8, is now permitted as the first
+character of a Go source file.
+Even though its appearance in the byte-order-free UTF-8 encoding is clearly unnecessary,
+some editors add the mark as a kind of "magic number" identifying a UTF-8 encoded file.
+</p>
+
+<p>
+<em>Updating</em>:
+Most programs will be unaffected by the surrogate change.
+Programs that depend on the old behavior should be modified to avoid the issue.
+The byte-order-mark change is strictly backward-compatible.
+</p>
+
+<h3 id="race">Race detector</h3>
+
+<p>
+A major addition to the tools is a <em>race detector</em>, a way to
+find bugs in programs caused by concurrent access of the same
+variable, where at least one of the accesses is a write.
+This new facility is built into the <code>go</code> tool.
+For now, it is only available on Linux, Mac OS X, and Windows systems with
+64-bit x86 processors.
+To enable it, set the <code>-race</code> flag when building or testing your program
+(for instance, <code>go test -race</code>).
+The race detector is documented in <a href="/doc/articles/race_detector.html">a separate article</a>.
+</p>
+
+<h3 id="gc_asm">The gc assemblers</h3>
+
+<p>
+Due to the change of the <a href="#int"><code>int</code></a> to 64 bits and
+a new internal <a href="//golang.org/s/go11func">representation of functions</a>,
+the arrangement of function arguments on the stack has changed in the gc toolchain.
+Functions written in assembly will need to be revised at least
+to adjust frame pointer offsets.
+</p>
+
+<p>
+<em>Updating</em>:
+The <code>go vet</code> command now checks that functions implemented in assembly
+match the Go function prototypes they implement.
+</p>
+
+<h3 id="gocmd">Changes to the go command</h3>
+
+<p>
+The <a href="/cmd/go/"><code>go</code></a> command has acquired several
+changes intended to improve the experience for new Go users.
+</p>
+
+<p>
+First, when compiling, testing, or running Go code, the <code>go</code> command will now give more detailed error messages,
+including a list of paths searched, when a package cannot be located.
+</p>
+
+<pre>
+$ go build foo/quxx
+can't load package: package foo/quxx: cannot find package "foo/quxx" in any of:
+ /home/you/go/src/pkg/foo/quxx (from $GOROOT)
+ /home/you/src/foo/quxx (from $GOPATH)
+</pre>
+
+<p>
+Second, the <code>go get</code> command no longer allows <code>$GOROOT</code>
+as the default destination when downloading package source.
+To use the <code>go get</code>
+command, a <a href="/doc/code.html#GOPATH">valid <code>$GOPATH</code></a> is now required.
+</p>
+
+<pre>
+$ GOPATH= go get code.google.com/p/foo/quxx
+package code.google.com/p/foo/quxx: cannot download, $GOPATH not set. For more details see: go help gopath
+</pre>
+
+<p>
+Finally, as a result of the previous change, the <code>go get</code> command will also fail
+when <code>$GOPATH</code> and <code>$GOROOT</code> are set to the same value.
+</p>
+
+<pre>
+$ GOPATH=$GOROOT go get code.google.com/p/foo/quxx
+warning: GOPATH set to GOROOT (/home/you/go) has no effect
+package code.google.com/p/foo/quxx: cannot download, $GOPATH must not be set to $GOROOT. For more details see: go help gopath
+</pre>
+
+<h3 id="gotest">Changes to the go test command</h3>
+
+<p>
+The <a href="/cmd/go/#hdr-Test_packages"><code>go test</code></a>
+command no longer deletes the binary when run with profiling enabled,
+to make it easier to analyze the profile.
+The implementation sets the <code>-c</code> flag automatically, so after running,
+</p>
+
+<pre>
+$ go test -cpuprofile cpuprof.out mypackage
+</pre>
+
+<p>
+the file <code>mypackage.test</code> will be left in the directory where <code>go test</code> was run.
+</p>
+
+<p>
+The <a href="/cmd/go/#hdr-Test_packages"><code>go test</code></a>
+command can now generate profiling information
+that reports where goroutines are blocked, that is,
+where they tend to stall waiting for an event such as a channel communication.
+The information is presented as a
+<em>blocking profile</em>
+enabled with the
+<code>-blockprofile</code>
+option of
+<code>go test</code>.
+Run <code>go help test</code> for more information.
+</p>
+
+<h3 id="gofix">Changes to the go fix command</h3>
+
+<p>
+The <a href="/cmd/fix/"><code>fix</code></a> command, usually run as
+<code>go fix</code>, no longer applies fixes to update code from
+before Go 1 to use Go 1 APIs.
+To update pre-Go 1 code to Go 1.1, use a Go 1.0 toolchain
+to convert the code to Go 1.0 first.
+</p>
+
+<h3 id="tags">Build constraints</h3>
+
+<p>
+The "<code>go1.1</code>" tag has been added to the list of default
+<a href="/pkg/go/build/#hdr-Build_Constraints">build constraints</a>.
+This permits packages to take advantage of the new features in Go 1.1 while
+remaining compatible with earlier versions of Go.
+</p>
+
+<p>
+To build a file only with Go 1.1 and above, add this build constraint:
+</p>
+
+<pre>
+// +build go1.1
+</pre>
+
+<p>
+To build a file only with Go 1.0.x, use the converse constraint:
+</p>
+
+<pre>
+// +build !go1.1
+</pre>
+
+<h3 id="platforms">Additional platforms</h3>
+
+<p>
+The Go 1.1 toolchain adds experimental support for <code>freebsd/arm</code>,
+<code>netbsd/386</code>, <code>netbsd/amd64</code>, <code>netbsd/arm</code>,
+<code>openbsd/386</code> and <code>openbsd/amd64</code> platforms.
+</p>
+
+<p>
+An ARMv6 or later processor is required for <code>freebsd/arm</code> or
+<code>netbsd/arm</code>.
+</p>
+
+<p>
+Go 1.1 adds experimental support for <code>cgo</code> on <code>linux/arm</code>.
+</p>
+
+<h3 id="crosscompile">Cross compilation</h3>
+
+<p>
+When cross-compiling, the <code>go</code> tool will disable <code>cgo</code>
+support by default.
+</p>
+
+<p>
+To explicitly enable <code>cgo</code>, set <code>CGO_ENABLED=1</code>.
+</p>
+
+<h2 id="performance">Performance</h2>
+
+<p>
+The performance of code compiled with the Go 1.1 gc tool suite should be noticeably
+better for most Go programs.
+Typical improvements relative to Go 1.0 seem to be about 30%-40%, sometimes
+much more, but occasionally less or even non-existent.
+There are too many small performance-driven tweaks through the tools and libraries
+to list them all here, but the following major changes are worth noting:
+</p>
+
+<ul>
+<li>The gc compilers generate better code in many cases, most noticeably for
+floating point on the 32-bit Intel architecture.</li>
+<li>The gc compilers do more in-lining, including for some operations
+in the run-time such as <a href="/pkg/builtin/#append"><code>append</code></a>
+and interface conversions.</li>
+<li>There is a new implementation of Go maps with significant reduction in
+memory footprint and CPU time.</li>
+<li>The garbage collector has been made more parallel, which can reduce
+latencies for programs running on multiple CPUs.</li>
+<li>The garbage collector is also more precise, which costs a small amount of
+CPU time but can reduce the size of the heap significantly, especially
+on 32-bit architectures.</li>
+<li>Due to tighter coupling of the run-time and network libraries, fewer
+context switches are required on network operations.</li>
+</ul>
+
+<h2 id="library">Changes to the standard library</h2>
+
+<h3 id="bufio_scanner">bufio.Scanner</h3>
+
+<p>
+The various routines to scan textual input in the
+<a href="/pkg/bufio/"><code>bufio</code></a>
+package,
+<a href="/pkg/bufio/#Reader.ReadBytes"><code>ReadBytes</code></a>,
+<a href="/pkg/bufio/#Reader.ReadString"><code>ReadString</code></a>
+and particularly
+<a href="/pkg/bufio/#Reader.ReadLine"><code>ReadLine</code></a>,
+are needlessly complex to use for simple purposes.
+In Go 1.1, a new type,
+<a href="/pkg/bufio/#Scanner"><code>Scanner</code></a>,
+has been added to make it easier to do simple tasks such as
+read the input as a sequence of lines or space-delimited words.
+It simplifies the problem by terminating the scan on problematic
+input such as pathologically long lines, and having a simple
+default: line-oriented input, with each line stripped of its terminator.
+Here is code to reproduce the input a line at a time:
+</p>
+
+<pre>
+scanner := bufio.NewScanner(os.Stdin)
+for scanner.Scan() {
+ fmt.Println(scanner.Text()) // Println will add back the final '\n'
+}
+if err := scanner.Err(); err != nil {
+ fmt.Fprintln(os.Stderr, "reading standard input:", err)
+}
+</pre>
+
+<p>
+Scanning behavior can be adjusted through a function to control subdividing the input
+(see the documentation for <a href="/pkg/bufio/#SplitFunc"><code>SplitFunc</code></a>),
+but for tough problems or the need to continue past errors, the older interface
+may still be required.
+</p>
+
+<h3 id="net">net</h3>
+
+<p>
+The protocol-specific resolvers in the <a href="/pkg/net/"><code>net</code></a> package were formerly
+lax about the network name passed in.
+Although the documentation was clear
+that the only valid networks for
+<a href="/pkg/net/#ResolveTCPAddr"><code>ResolveTCPAddr</code></a>
+are <code>"tcp"</code>,
+<code>"tcp4"</code>, and <code>"tcp6"</code>, the Go 1.0 implementation silently accepted any string.
+The Go 1.1 implementation returns an error if the network is not one of those strings.
+The same is true of the other protocol-specific resolvers <a href="/pkg/net/#ResolveIPAddr"><code>ResolveIPAddr</code></a>,
+<a href="/pkg/net/#ResolveUDPAddr"><code>ResolveUDPAddr</code></a>, and
+<a href="/pkg/net/#ResolveUnixAddr"><code>ResolveUnixAddr</code></a>.
+</p>
+
+<p>
+The previous implementation of
+<a href="/pkg/net/#ListenUnixgram"><code>ListenUnixgram</code></a>
+returned a
+<a href="/pkg/net/#UDPConn"><code>UDPConn</code></a> as
+a representation of the connection endpoint.
+The Go 1.1 implementation instead returns a
+<a href="/pkg/net/#UnixConn"><code>UnixConn</code></a>
+to allow reading and writing
+with its
+<a href="/pkg/net/#UnixConn.ReadFrom"><code>ReadFrom</code></a>
+and
+<a href="/pkg/net/#UnixConn.WriteTo"><code>WriteTo</code></a>
+methods.
+</p>
+
+<p>
+The data structures
+<a href="/pkg/net/#IPAddr"><code>IPAddr</code></a>,
+<a href="/pkg/net/#TCPAddr"><code>TCPAddr</code></a>, and
+<a href="/pkg/net/#UDPAddr"><code>UDPAddr</code></a>
+add a new string field called <code>Zone</code>.
+Code using untagged composite literals (e.g. <code>net.TCPAddr{ip, port}</code>)
+instead of tagged literals (<code>net.TCPAddr{IP: ip, Port: port}</code>)
+will break due to the new field.
+The Go 1 compatibility rules allow this change: client code must use tagged literals to avoid such breakages.
+</p>
+
+<p>
+<em>Updating</em>:
+To correct breakage caused by the new struct field,
+<code>go fix</code> will rewrite code to add tags for these types.
+More generally, <code>go vet</code> will identify composite literals that
+should be revised to use field tags.
+</p>
+
+<h3 id="reflect">reflect</h3>
+
+<p>
+The <a href="/pkg/reflect/"><code>reflect</code></a> package has several significant additions.
+</p>
+
+<p>
+It is now possible to run a "select" statement using
+the <code>reflect</code> package; see the description of
+<a href="/pkg/reflect/#Select"><code>Select</code></a>
+and
+<a href="/pkg/reflect/#SelectCase"><code>SelectCase</code></a>
+for details.
+</p>
+
+<p>
+The new method
+<a href="/pkg/reflect/#Value.Convert"><code>Value.Convert</code></a>
+(or
+<a href="/pkg/reflect/#Type"><code>Type.ConvertibleTo</code></a>)
+provides functionality to execute a Go conversion or type assertion operation
+on a
+<a href="/pkg/reflect/#Value"><code>Value</code></a>
+(or test for its possibility).
+</p>
+
+<p>
+The new function
+<a href="/pkg/reflect/#MakeFunc"><code>MakeFunc</code></a>
+creates a wrapper function to make it easier to call a function with existing
+<a href="/pkg/reflect/#Value"><code>Values</code></a>,
+doing the standard Go conversions among the arguments, for instance
+to pass an actual <code>int</code> to a formal <code>interface{}</code>.
+</p>
+
+<p>
+Finally, the new functions
+<a href="/pkg/reflect/#ChanOf"><code>ChanOf</code></a>,
+<a href="/pkg/reflect/#MapOf"><code>MapOf</code></a>
+and
+<a href="/pkg/reflect/#SliceOf"><code>SliceOf</code></a>
+construct new
+<a href="/pkg/reflect/#Type"><code>Types</code></a>
+from existing types, for example to construct the type <code>[]T</code> given
+only <code>T</code>.
+</p>
+
+
+<h3 id="time">time</h3>
+<p>
+On FreeBSD, Linux, NetBSD, OS X and OpenBSD, previous versions of the
+<a href="/pkg/time/"><code>time</code></a> package
+returned times with microsecond precision.
+The Go 1.1 implementation on these
+systems now returns times with nanosecond precision.
+Programs that write to an external format with microsecond precision
+and read it back, expecting to recover the original value, will be affected
+by the loss of precision.
+There are two new methods of <a href="/pkg/time/#Time"><code>Time</code></a>,
+<a href="/pkg/time/#Time.Round"><code>Round</code></a>
+and
+<a href="/pkg/time/#Time.Truncate"><code>Truncate</code></a>,
+that can be used to remove precision from a time before passing it to
+external storage.
+</p>
+
+<p>
+The new method
+<a href="/pkg/time/#Time.YearDay"><code>YearDay</code></a>
+returns the one-indexed integral day number of the year specified by the time value.
+</p>
+
+<p>
+The
+<a href="/pkg/time/#Timer"><code>Timer</code></a>
+type has a new method
+<a href="/pkg/time/#Timer.Reset"><code>Reset</code></a>
+that modifies the timer to expire after a specified duration.
+</p>
+
+<p>
+Finally, the new function
+<a href="/pkg/time/#ParseInLocation"><code>ParseInLocation</code></a>
+is like the existing
+<a href="/pkg/time/#Parse"><code>Parse</code></a>
+but parses the time in the context of a location (time zone), ignoring
+time zone information in the parsed string.
+This function addresses a common source of confusion in the time API.
+</p>
+
+<p>
+<em>Updating</em>:
+Code that needs to read and write times using an external format with
+lower precision should be modified to use the new methods.
+</p>
+
+<h3 id="exp_old">Exp and old subtrees moved to go.exp and go.text subrepositories</h3>
+
+<p>
+To make it easier for binary distributions to access them if desired, the <code>exp</code>
+and <code>old</code> source subtrees, which are not included in binary distributions,
+have been moved to the new <code>go.exp</code> subrepository at
+<code>code.google.com/p/go.exp</code>. To access the <code>ssa</code> package,
+for example, run
+</p>
+
+<pre>
+$ go get code.google.com/p/go.exp/ssa
+</pre>
+
+<p>
+and then in Go source,
+</p>
+
+<pre>
+import "code.google.com/p/go.exp/ssa"
+</pre>
+
+<p>
+The old package <code>exp/norm</code> has also been moved, but to a new repository
+<code>go.text</code>, where the Unicode APIs and other text-related packages will
+be developed.
+</p>
+
+<h3 id="new_packages">New packages</h3>
+
+<p>
+There are three new packages.
+</p>
+
+<ul>
+<li>
+The <a href="/pkg/go/format/"><code>go/format</code></a> package provides
+a convenient way for a program to access the formatting capabilities of the
+<a href="/cmd/go/#hdr-Run_gofmt_on_package_sources"><code>go fmt</code></a> command.
+It has two functions,
+<a href="/pkg/go/format/#Node"><code>Node</code></a> to format a Go parser
+<a href="/pkg/go/ast/#Node"><code>Node</code></a>,
+and
+<a href="/pkg/go/format/#Source"><code>Source</code></a>
+to reformat arbitrary Go source code into the standard format as provided by the
+<a href="/cmd/go/#hdr-Run_gofmt_on_package_sources"><code>go fmt</code></a> command.
+</li>
+
+<li>
+The <a href="/pkg/net/http/cookiejar/"><code>net/http/cookiejar</code></a> package provides the basics for managing HTTP cookies.
+</li>
+
+<li>
+The <a href="/pkg/runtime/race/"><code>runtime/race</code></a> package provides low-level facilities for data race detection.
+It is internal to the race detector and does not otherwise export any user-visible functionality.
+</li>
+</ul>
+
+<h3 id="minor_library_changes">Minor changes to the library</h3>
+
+<p>
+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.
+</p>
+
+<ul>
+<li>
+The <a href="/pkg/bytes/"><code>bytes</code></a> package has two new functions,
+<a href="/pkg/bytes/#TrimPrefix"><code>TrimPrefix</code></a>
+and
+<a href="/pkg/bytes/#TrimSuffix"><code>TrimSuffix</code></a>,
+with self-evident properties.
+Also, the <a href="/pkg/bytes/#Buffer"><code>Buffer</code></a> type
+has a new method
+<a href="/pkg/bytes/#Buffer.Grow"><code>Grow</code></a> that
+provides some control over memory allocation inside the buffer.
+Finally, the
+<a href="/pkg/bytes/#Reader"><code>Reader</code></a> type now has a
+<a href="/pkg/strings/#Reader.WriteTo"><code>WriteTo</code></a> method
+so it implements the
+<a href="/pkg/io/#WriterTo"><code>io.WriterTo</code></a> interface.
+</li>
+
+<li>
+The <a href="/pkg/compress/gzip/"><code>compress/gzip</code></a> package has
+a new <a href="/pkg/compress/gzip/#Writer.Flush"><code>Flush</code></a>
+method for its
+<a href="/pkg/compress/gzip/#Writer"><code>Writer</code></a>
+type that flushes its underlying <code>flate.Writer</code>.
+</li>
+
+<li>
+The <a href="/pkg/crypto/hmac/"><code>crypto/hmac</code></a> package has a new function,
+<a href="/pkg/crypto/hmac/#Equal"><code>Equal</code></a>, to compare two MACs.
+</li>
+
+<li>
+The <a href="/pkg/crypto/x509/"><code>crypto/x509</code></a> package
+now supports PEM blocks (see
+<a href="/pkg/crypto/x509/#DecryptPEMBlock"><code>DecryptPEMBlock</code></a> for instance),
+and a new function
+<a href="/pkg/crypto/x509/#ParseECPrivateKey"><code>ParseECPrivateKey</code></a> to parse elliptic curve private keys.
+</li>
+
+<li>
+The <a href="/pkg/database/sql/"><code>database/sql</code></a> package
+has a new
+<a href="/pkg/database/sql/#DB.Ping"><code>Ping</code></a>
+method for its
+<a href="/pkg/database/sql/#DB"><code>DB</code></a>
+type that tests the health of the connection.
+</li>
+
+<li>
+The <a href="/pkg/database/sql/driver/"><code>database/sql/driver</code></a> package
+has a new
+<a href="/pkg/database/sql/driver/#Queryer"><code>Queryer</code></a>
+interface that a
+<a href="/pkg/database/sql/driver/#Conn"><code>Conn</code></a>
+may implement to improve performance.
+</li>
+
+<li>
+The <a href="/pkg/encoding/json/"><code>encoding/json</code></a> package's
+<a href="/pkg/encoding/json/#Decoder"><code>Decoder</code></a>
+has a new method
+<a href="/pkg/encoding/json/#Decoder.Buffered"><code>Buffered</code></a>
+to provide access to the remaining data in its buffer,
+as well as a new method
+<a href="/pkg/encoding/json/#Decoder.UseNumber"><code>UseNumber</code></a>
+to unmarshal a value into the new type
+<a href="/pkg/encoding/json/#Number"><code>Number</code></a>,
+a string, rather than a float64.
+</li>
+
+<li>
+The <a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> package
+has a new function,
+<a href="/pkg/encoding/xml/#EscapeText"><code>EscapeText</code></a>,
+which writes escaped XML output,
+and a method on
+<a href="/pkg/encoding/xml/#Encoder"><code>Encoder</code></a>,
+<a href="/pkg/encoding/xml/#Encoder.Indent"><code>Indent</code></a>,
+to specify indented output.
+</li>
+
+<li>
+In the <a href="/pkg/go/ast/"><code>go/ast</code></a> package, a
+new type <a href="/pkg/go/ast/#CommentMap"><code>CommentMap</code></a>
+and associated methods makes it easier to extract and process comments in Go programs.
+</li>
+
+<li>
+In the <a href="/pkg/go/doc/"><code>go/doc</code></a> package,
+the parser now keeps better track of stylized annotations such as <code>TODO(joe)</code>
+throughout the code,
+information that the <a href="/cmd/godoc/"><code>godoc</code></a>
+command can filter or present according to the value of the <code>-notes</code> flag.
+</li>
+
+<li>
+The undocumented and only partially implemented "noescape" feature of the
+<a href="/pkg/html/template/"><code>html/template</code></a>
+package has been removed; programs that depend on it will break.
+</li>
+
+<li>
+The <a href="/pkg/image/jpeg/"><code>image/jpeg</code></a> package now
+reads progressive JPEG files and handles a few more subsampling configurations.
+</li>
+
+<li>
+The <a href="/pkg/io/"><code>io</code></a> package now exports the
+<a href="/pkg/io/#ByteWriter"><code>io.ByteWriter</code></a> interface to capture the common
+functionality of writing a byte at a time.
+It also exports a new error, <a href="/pkg/io/#ErrNoProgress"><code>ErrNoProgress</code></a>,
+used to indicate a <code>Read</code> implementation is looping without delivering data.
+</li>
+
+<li>
+The <a href="/pkg/log/syslog/"><code>log/syslog</code></a> package now provides better support
+for OS-specific logging features.
+</li>
+
+<li>
+The <a href="/pkg/math/big/"><code>math/big</code></a> package's
+<a href="/pkg/math/big/#Int"><code>Int</code></a> type
+now has methods
+<a href="/pkg/math/big/#Int.MarshalJSON"><code>MarshalJSON</code></a>
+and
+<a href="/pkg/math/big/#Int.UnmarshalJSON"><code>UnmarshalJSON</code></a>
+to convert to and from a JSON representation.
+Also,
+<a href="/pkg/math/big/#Int"><code>Int</code></a>
+can now convert directly to and from a <code>uint64</code> using
+<a href="/pkg/math/big/#Int.Uint64"><code>Uint64</code></a>
+and
+<a href="/pkg/math/big/#Int.SetUint64"><code>SetUint64</code></a>,
+while
+<a href="/pkg/math/big/#Rat"><code>Rat</code></a>
+can do the same with <code>float64</code> using
+<a href="/pkg/math/big/#Rat.Float64"><code>Float64</code></a>
+and
+<a href="/pkg/math/big/#Rat.SetFloat64"><code>SetFloat64</code></a>.
+</li>
+
+<li>
+The <a href="/pkg/mime/multipart/"><code>mime/multipart</code></a> package
+has a new method for its
+<a href="/pkg/mime/multipart/#Writer"><code>Writer</code></a>,
+<a href="/pkg/mime/multipart/#Writer.SetBoundary"><code>SetBoundary</code></a>,
+to define the boundary separator used to package the output.
+The <a href="/pkg/mime/multipart/#Reader"><code>Reader</code></a> also now
+transparently decodes any <code>quoted-printable</code> parts and removes
+the <code>Content-Transfer-Encoding</code> header when doing so.
+</li>
+
+<li>
+The
+<a href="/pkg/net/"><code>net</code></a> package's
+<a href="/pkg/net/#ListenUnixgram"><code>ListenUnixgram</code></a>
+function has changed return types: it now returns a
+<a href="/pkg/net/#UnixConn"><code>UnixConn</code></a>
+rather than a
+<a href="/pkg/net/#UDPConn"><code>UDPConn</code></a>, which was
+clearly a mistake in Go 1.0.
+Since this API change fixes a bug, it is permitted by the Go 1 compatibility rules.
+</li>
+
+<li>
+The <a href="/pkg/net/"><code>net</code></a> package includes a new type,
+<a href="/pkg/net/#Dialer"><code>Dialer</code></a>, to supply options to
+<a href="/pkg/net/#Dialer.Dial"><code>Dial</code></a>.
+</li>
+
+<li>
+The <a href="/pkg/net/"><code>net</code></a> package adds support for
+link-local IPv6 addresses with zone qualifiers, such as <code>fe80::1%lo0</code>.
+The address structures <a href="/pkg/net/#IPAddr"><code>IPAddr</code></a>,
+<a href="/pkg/net/#UDPAddr"><code>UDPAddr</code></a>, and
+<a href="/pkg/net/#TCPAddr"><code>TCPAddr</code></a>
+record the zone in a new field, and functions that expect string forms of these addresses, such as
+<a href="/pkg/net/#Dial"><code>Dial</code></a>,
+<a href="/pkg/net/#ResolveIPAddr"><code>ResolveIPAddr</code></a>,
+<a href="/pkg/net/#ResolveUDPAddr"><code>ResolveUDPAddr</code></a>, and
+<a href="/pkg/net/#ResolveTCPAddr"><code>ResolveTCPAddr</code></a>,
+now accept the zone-qualified form.
+</li>
+
+<li>
+The <a href="/pkg/net/"><code>net</code></a> package adds
+<a href="/pkg/net/#LookupNS"><code>LookupNS</code></a> to its suite of resolving functions.
+<code>LookupNS</code> returns the <a href="/pkg/net/#NS">NS records</a> for a host name.
+</li>
+
+<li>
+The <a href="/pkg/net/"><code>net</code></a> package adds protocol-specific
+packet reading and writing methods to
+<a href="/pkg/net/#IPConn"><code>IPConn</code></a>
+(<a href="/pkg/net/#IPConn.ReadMsgIP"><code>ReadMsgIP</code></a>
+and <a href="/pkg/net/#IPConn.WriteMsgIP"><code>WriteMsgIP</code></a>) and
+<a href="/pkg/net/#UDPConn"><code>UDPConn</code></a>
+(<a href="/pkg/net/#UDPConn.ReadMsgUDP"><code>ReadMsgUDP</code></a> and
+<a href="/pkg/net/#UDPConn.WriteMsgUDP"><code>WriteMsgUDP</code></a>).
+These are specialized versions of <a href="/pkg/net/#PacketConn"><code>PacketConn</code></a>'s
+<code>ReadFrom</code> and <code>WriteTo</code> methods that provide access to out-of-band data associated
+with the packets.
+ </li>
+
+ <li>
+The <a href="/pkg/net/"><code>net</code></a> package adds methods to
+<a href="/pkg/net/#UnixConn"><code>UnixConn</code></a> to allow closing half of the connection
+(<a href="/pkg/net/#UnixConn.CloseRead"><code>CloseRead</code></a> and
+<a href="/pkg/net/#UnixConn.CloseWrite"><code>CloseWrite</code></a>),
+matching the existing methods of <a href="/pkg/net/#TCPConn"><code>TCPConn</code></a>.
+</li>
+
+<li>
+The <a href="/pkg/net/http/"><code>net/http</code></a> package includes several new additions.
+<a href="/pkg/net/http/#ParseTime"><code>ParseTime</code></a> parses a time string, trying
+several common HTTP time formats.
+The <a href="/pkg/net/http/#Request.PostFormValue"><code>PostFormValue</code></a> method of
+<a href="/pkg/net/http/#Request"><code>Request</code></a> is like
+<a href="/pkg/net/http/#Request.FormValue"><code>FormValue</code></a> but ignores URL parameters.
+The <a href="/pkg/net/http/#CloseNotifier"><code>CloseNotifier</code></a> interface provides a mechanism
+for a server handler to discover when a client has disconnected.
+The <code>ServeMux</code> type now has a
+<a href="/pkg/net/http/#ServeMux.Handler"><code>Handler</code></a> method to access a path's
+<code>Handler</code> without executing it.
+The <code>Transport</code> can now cancel an in-flight request with
+<a href="/pkg/net/http/#Transport.CancelRequest"><code>CancelRequest</code></a>.
+Finally, the Transport is now more aggressive at closing TCP connections when
+a <a href="/pkg/net/http/#Response"><code>Response.Body</code></a> is closed before
+being fully consumed.
+</li>
+
+<li>
+The <a href="/pkg/net/mail/"><code>net/mail</code></a> package has two new functions,
+<a href="/pkg/net/mail/#ParseAddress"><code>ParseAddress</code></a> and
+<a href="/pkg/net/mail/#ParseAddressList"><code>ParseAddressList</code></a>,
+to parse RFC 5322-formatted mail addresses into
+<a href="/pkg/net/mail/#Address"><code>Address</code></a> structures.
+</li>
+
+<li>
+The <a href="/pkg/net/smtp/"><code>net/smtp</code></a> package's
+<a href="/pkg/net/smtp/#Client"><code>Client</code></a> type has a new method,
+<a href="/pkg/net/smtp/#Client.Hello"><code>Hello</code></a>,
+which transmits a <code>HELO</code> or <code>EHLO</code> message to the server.
+</li>
+
+<li>
+The <a href="/pkg/net/textproto/"><code>net/textproto</code></a> package
+has two new functions,
+<a href="/pkg/net/textproto/#TrimBytes"><code>TrimBytes</code></a> and
+<a href="/pkg/net/textproto/#TrimString"><code>TrimString</code></a>,
+which do ASCII-only trimming of leading and trailing spaces.
+</li>
+
+<li>
+The new method <a href="/pkg/os/#FileMode.IsRegular"><code>os.FileMode.IsRegular</code></a> makes it easy to ask if a file is a plain file.
+</li>
+
+<li>
+The <a href="/pkg/os/signal/"><code>os/signal</code></a> package has a new function,
+<a href="/pkg/os/signal/#Stop"><code>Stop</code></a>, which stops the package delivering
+any further signals to the channel.
+</li>
+
+<li>
+The <a href="/pkg/regexp/"><code>regexp</code></a> package
+now supports Unix-original leftmost-longest matches through the
+<a href="/pkg/regexp/#Regexp.Longest"><code>Regexp.Longest</code></a>
+method, while
+<a href="/pkg/regexp/#Regexp.Split"><code>Regexp.Split</code></a> slices
+strings into pieces based on separators defined by the regular expression.
+</li>
+
+<li>
+The <a href="/pkg/runtime/debug/"><code>runtime/debug</code></a> package
+has three new functions regarding memory usage.
+The <a href="/pkg/runtime/debug/#FreeOSMemory"><code>FreeOSMemory</code></a>
+function triggers a run of the garbage collector and then attempts to return unused
+memory to the operating system;
+the <a href="/pkg/runtime/debug/#ReadGCStats"><code>ReadGCStats</code></a>
+function retrieves statistics about the collector; and
+<a href="/pkg/runtime/debug/#SetGCPercent"><code>SetGCPercent</code></a>
+provides a programmatic way to control how often the collector runs,
+including disabling it altogether.
+</li>
+
+<li>
+The <a href="/pkg/sort/"><code>sort</code></a> package has a new function,
+<a href="/pkg/sort/#Reverse"><code>Reverse</code></a>.
+Wrapping the argument of a call to
+<a href="/pkg/sort/#Sort"><code>sort.Sort</code></a>
+with a call to <code>Reverse</code> causes the sort order to be reversed.
+</li>
+
+<li>
+The <a href="/pkg/strings/"><code>strings</code></a> package has two new functions,
+<a href="/pkg/strings/#TrimPrefix"><code>TrimPrefix</code></a>
+and
+<a href="/pkg/strings/#TrimSuffix"><code>TrimSuffix</code></a>
+with self-evident properties, and the new method
+<a href="/pkg/strings/#Reader.WriteTo"><code>Reader.WriteTo</code></a> so the
+<a href="/pkg/strings/#Reader"><code>Reader</code></a>
+type now implements the
+<a href="/pkg/io/#WriterTo"><code>io.WriterTo</code></a> interface.
+</li>
+
+<li>
+The <a href="/pkg/syscall/"><code>syscall</code></a> package's
+<a href="/pkg/syscall/#Fchflags"><code>Fchflags</code></a> function on various BSDs
+(including Darwin) has changed signature.
+It now takes an int as the first parameter instead of a string.
+Since this API change fixes a bug, it is permitted by the Go 1 compatibility rules.
+</li>
+<li>
+The <a href="/pkg/syscall/"><code>syscall</code></a> package also has received many updates
+to make it more inclusive of constants and system calls for each supported operating system.
+</li>
+
+<li>
+The <a href="/pkg/testing/"><code>testing</code></a> package now automates the generation of allocation
+statistics in tests and benchmarks using the new
+<a href="/pkg/testing/#AllocsPerRun"><code>AllocsPerRun</code></a> function. And the
+<a href="/pkg/testing/#B.ReportAllocs"><code>ReportAllocs</code></a>
+method on <a href="/pkg/testing/#B"><code>testing.B</code></a> will enable printing of
+memory allocation statistics for the calling benchmark. It also introduces the
+<a href="/pkg/testing/#BenchmarkResult.AllocsPerOp"><code>AllocsPerOp</code></a> method of
+<a href="/pkg/testing/#BenchmarkResult"><code>BenchmarkResult</code></a>.
+There is also a new
+<a href="/pkg/testing/#Verbose"><code>Verbose</code></a> function to test the state of the <code>-v</code>
+command-line flag,
+and a new
+<a href="/pkg/testing/#B.Skip"><code>Skip</code></a> method of
+<a href="/pkg/testing/#B"><code>testing.B</code></a> and
+<a href="/pkg/testing/#T"><code>testing.T</code></a>
+to simplify skipping an inappropriate test.
+</li>
+
+<li>
+In the <a href="/pkg/text/template/"><code>text/template</code></a>
+and
+<a href="/pkg/html/template/"><code>html/template</code></a> packages,
+templates can now use parentheses to group the elements of pipelines, simplifying the construction of complex pipelines.
+Also, as part of the new parser, the
+<a href="/pkg/text/template/parse/#Node"><code>Node</code></a> interface got two new methods to provide
+better error reporting.
+Although this violates the Go 1 compatibility rules,
+no existing code should be affected because this interface is explicitly intended only to be used
+by the
+<a href="/pkg/text/template/"><code>text/template</code></a>
+and
+<a href="/pkg/html/template/"><code>html/template</code></a>
+packages and there are safeguards to guarantee that.
+</li>
+
+<li>
+The implementation of the <a href="/pkg/unicode/"><code>unicode</code></a> package has been updated to Unicode version 6.2.0.
+</li>
+
+<li>
+In the <a href="/pkg/unicode/utf8/"><code>unicode/utf8</code></a> package,
+the new function <a href="/pkg/unicode/utf8/#ValidRune"><code>ValidRune</code></a> reports whether the rune is a valid Unicode code point.
+To be valid, a rune must be in range and not be a surrogate half.
+</li>
+</ul>
diff --git a/_content/doc/go1.10.html b/_content/doc/go1.10.html
new file mode 100644
index 0000000..0445026
--- /dev/null
+++ b/_content/doc/go1.10.html
@@ -0,0 +1,1447 @@
+<!--{
+ "Title": "Go 1.10 Release Notes",
+ "Template": true
+}-->
+
+<!--
+NOTE: In this document and others in this directory, the convention is to
+set fixed-width phrases with non-fixed-width spaces, as in
+<code>hello</code> <code>world</code>.
+Do not send CLs removing the interior tags from such phrases.
+-->
+
+<style>
+ main ul li { margin: 0.5em 0; }
+</style>
+
+<h2 id="introduction">Introduction to Go 1.10</h2>
+
+<p>
+The latest Go release, version 1.10, arrives six months after <a href="go1.9">Go 1.9</a>.
+Most of its changes are in the implementation of the toolchain, runtime, and libraries.
+As always, the release maintains the Go 1 <a href="/doc/go1compat.html">promise of compatibility</a>.
+We expect almost all Go programs to continue to compile and run as before.
+</p>
+
+<p>
+This release improves <a href="#build">caching of built packages</a>,
+adds <a href="#test">caching of successful test results</a>,
+runs <a href="#test-vet">vet automatically during tests</a>,
+and
+permits <a href="#cgo">passing string values directly between Go and C using cgo</a>.
+A new <a href="#cgo">hard-coded set of safe compiler options</a> may cause
+unexpected <a href="https://golang.org/s/invalidflag"><code>invalid
+flag</code></a> errors in code that built successfully with older
+releases.
+</p>
+
+<h2 id="language">Changes to the language</h2>
+
+<p>
+There are no significant changes to the language specification.
+</p>
+
+<p><!-- CL 60230 -->
+A corner case involving shifts of untyped constants has been clarified,
+and as a result the compilers have been updated to allow the index expression
+<code>x[1.0</code> <code><<</code> <code>s]</code> where <code>s</code> is an unsigned integer;
+the <a href="/pkg/go/types/">go/types</a> package already did.
+</p>
+
+<p><!-- CL 73233 -->
+The grammar for method expressions has been updated to relax the
+syntax to allow any type expression as a receiver;
+this matches what the compilers were already implementing.
+For example, <code>struct{io.Reader}.Read</code> is a valid, if unusual,
+method expression that the compilers already accepted and is
+now permitted by the language grammar.
+</p>
+
+<h2 id="ports">Ports</h2>
+
+<p>
+There are no new supported operating systems or processor architectures in this release.
+Most of the work has focused on strengthening the support for existing ports,
+in particular <a href="#asm">new instructions in the assembler</a>
+and improvements to the code generated by the compilers.
+</p>
+
+<p id="freebsd">
+As <a href="go1.9#freebsd">announced in the Go 1.9 release notes</a>,
+Go 1.10 now requires FreeBSD 10.3 or later;
+support for FreeBSD 9.3 has been removed.
+</p>
+
+<p id="netbsd">
+Go now runs on NetBSD again but requires the unreleased NetBSD 8.
+Only <code>GOARCH</code> <code>amd64</code> and <code>386</code> have
+been fixed. The <code>arm</code> port is still broken.
+</p>
+
+<p id="mips">
+On 32-bit MIPS systems, the new environment variable settings
+<code>GOMIPS=hardfloat</code> (the default) and
+<code>GOMIPS=softfloat</code> select whether to use
+hardware instructions or software emulation for floating-point computations.
+</p>
+
+<p id="openbsd">
+Go 1.10 is the last release that will run on OpenBSD 6.0.
+Go 1.11 will require OpenBSD 6.2.
+</p>
+
+<p id="darwin">
+Go 1.10 is the last release that will run on OS X 10.8 Mountain Lion or OS X 10.9 Mavericks.
+Go 1.11 will require OS X 10.10 Yosemite or later.
+</p>
+
+<p id="windows">
+Go 1.10 is the last release that will run on Windows XP or Windows Vista.
+Go 1.11 will require Windows 7 or later.
+</p>
+
+<h2 id="tools">Tools</h2>
+
+<h3 id="goroot">Default GOROOT & GOTMPDIR</h3>
+
+<p>
+If the environment variable <code>$GOROOT</code> is unset,
+the go tool previously used the default <code>GOROOT</code>
+set during toolchain compilation.
+Now, before falling back to that default, the go tool attempts to
+deduce <code>GOROOT</code> from its own executable path.
+This allows binary distributions to be unpacked anywhere in the
+file system and then be used without setting <code>GOROOT</code>
+explicitly.
+</p>
+
+<p>
+By default, the go tool creates its temporary files and directories
+in the system temporary directory (for example, <code>$TMPDIR</code> on Unix).
+If the new environment variable <code>$GOTMPDIR</code> is set,
+the go tool will creates its temporary files and directories in that directory instead.
+</p>
+
+<h3 id="build">Build & Install</h3>
+
+<p>
+The <code>go</code> <code>build</code> command now detects out-of-date packages
+purely based on the content of source files, specified build flags, and metadata stored in the compiled packages.
+Modification times are no longer consulted or relevant.
+The old advice to add <code>-a</code> to force a rebuild in cases where
+the modification times were misleading for one reason or another
+(for example, changes in build flags) is no longer necessary:
+builds now always detect when packages must be rebuilt.
+(If you observe otherwise, please file a bug.)
+</p>
+
+<p>
+The <code>go</code> <code>build</code> <code>-asmflags</code>, <code>-gcflags</code>, <code>-gccgoflags</code>, and <code>-ldflags</code> options
+now apply by default only to the packages listed directly on the command line.
+For example, <code>go</code> <code>build</code> <code>-gcflags=-m</code> <code>mypkg</code>
+passes the compiler the <code>-m</code> flag when building <code>mypkg</code>
+but not its dependencies.
+The new, more general form <code>-asmflags=pattern=flags</code> (and similarly for the others)
+applies the <code>flags</code> only to the packages matching the pattern.
+For example: <code>go</code> <code>install</code> <code>-ldflags=cmd/gofmt=-X=main.version=1.2.3</code> <code>cmd/...</code>
+installs all the commands matching <code>cmd/...</code> but only applies the <code>-X</code> option
+to the linker flags for <code>cmd/gofmt</code>.
+For more details, see <a href="/cmd/go/#hdr-Compile_packages_and_dependencies"><code>go</code> <code>help</code> <code>build</code></a>.
+</p>
+
+<p>
+The <code>go</code> <code>build</code> command now maintains a cache of
+recently built packages, separate from the installed packages in <code>$GOROOT/pkg</code> or <code>$GOPATH/pkg</code>.
+The effect of the cache should be to speed builds that do not explicitly install packages
+or when switching between different copies of source code (for example, when changing
+back and forth between different branches in a version control system).
+The old advice to add the <code>-i</code> flag for speed, as in <code>go</code> <code>build</code> <code>-i</code>
+or <code>go</code> <code>test</code> <code>-i</code>,
+is no longer necessary: builds run just as fast without <code>-i</code>.
+For more details, see <a href="/cmd/go/#hdr-Build_and_test_caching"><code>go</code> <code>help</code> <code>cache</code></a>.
+</p>
+
+<p>
+The <code>go</code> <code>install</code> command now installs only the
+packages and commands listed directly on the command line.
+For example, <code>go</code> <code>install</code> <code>cmd/gofmt</code>
+installs the gofmt program but not any of the packages on which it depends.
+The new build cache makes future commands still run as quickly as if the
+dependencies had been installed.
+To force the installation of dependencies, use the new
+<code>go</code> <code>install</code> <code>-i</code> flag.
+Installing dependency packages should not be necessary in general,
+and the very concept of installed packages may disappear in a future release.
+</p>
+
+<p>
+Many details of the <code>go</code> <code>build</code> implementation have changed to support these improvements.
+One new requirement implied by these changes is that
+binary-only packages must now declare accurate import blocks in their
+stub source code, so that those imports can be made available when
+linking a program using the binary-only package.
+For more details, see <a href="/cmd/go/#hdr-File_types"><code>go</code> <code>help</code> <code>filetype</code></a>.
+</p>
+
+<h3 id="test">Test</h3>
+
+<p>
+The <code>go</code> <code>test</code> command now caches test results:
+if the test executable and command line match a previous run
+and the files and environment variables consulted by that run
+have not changed either, <code>go</code> <code>test</code> will print
+the previous test output, replacing the elapsed time with the string “(cached).”
+Test caching applies only to successful test results;
+only to <code>go</code> <code>test</code>
+commands with an explicit list of packages; and
+only to command lines using a subset of the
+<code>-cpu</code>, <code>-list</code>, <code>-parallel</code>,
+<code>-run</code>, <code>-short</code>, and <code>-v</code> test flags.
+The idiomatic way to bypass test caching is to use <code>-count=1</code>.
+</p>
+
+<p id="test-vet">
+The <code>go</code> <code>test</code> command now automatically runs
+<code>go</code> <code>vet</code> on the package being tested,
+to identify significant problems before running the test.
+Any such problems are treated like build errors and prevent execution of the test.
+Only a high-confidence subset of the available <code>go</code> <code>vet</code>
+checks are enabled for this automatic check.
+To disable the running of <code>go</code> <code>vet</code>, use
+<code>go</code> <code>test</code> <code>-vet=off</code>.
+</p>
+
+<p>
+The <code>go</code> <code>test</code> <code>-coverpkg</code> flag now
+interprets its argument as a comma-separated list of patterns to match against
+the dependencies of each test, not as a list of packages to load anew.
+For example, <code>go</code> <code>test</code> <code>-coverpkg=all</code>
+is now a meaningful way to run a test with coverage enabled for the test package
+and all its dependencies.
+Also, the <code>go</code> <code>test</code> <code>-coverprofile</code> option is now
+supported when running multiple tests.
+</p>
+
+<p>
+In case of failure due to timeout, tests are now more likely to write their profiles before exiting.
+</p>
+
+<p>
+The <code>go</code> <code>test</code> command now always
+merges the standard output and standard error from a given test binary execution
+and writes both to <code>go</code> <code>test</code>'s standard output.
+In past releases, <code>go</code> <code>test</code> only applied this
+merging most of the time.
+</p>
+
+<p>
+The <code>go</code> <code>test</code> <code>-v</code> output
+now includes <code>PAUSE</code> and <code>CONT</code> status update
+lines to mark when <a href="/pkg/testing/#T.Parallel">parallel tests</a> pause and continue.
+</p>
+
+<p>
+The new <code>go</code> <code>test</code> <code>-failfast</code> flag
+disables running additional tests after any test fails.
+Note that tests running in parallel with the failing test are allowed to complete.
+</p>
+
+<p>
+Finally, the new <code>go</code> <code>test</code> <code>-json</code> flag
+filters test output through the new command
+<code>go</code> <code>tool</code> <code>test2json</code>
+to produce a machine-readable JSON-formatted description of test execution.
+This allows the creation of rich presentations of test execution
+in IDEs and other tools.
+</p>
+
+
+<p>
+For more details about all these changes,
+see <a href="/cmd/go/#hdr-Test_packages"><code>go</code> <code>help</code> <code>test</code></a>
+and the <a href="/cmd/test2json/">test2json documentation</a>.
+</p>
+
+<h3 id="cgo">Cgo</h3>
+
+<p>
+Options specified by cgo using <code>#cgo CFLAGS</code> and the like
+are now checked against a list of permitted options.
+This closes a security hole in which a downloaded package uses
+compiler options like
+<span style="white-space: nowrap"><code>-fplugin</code></span>
+to run arbitrary code on the machine where it is being built.
+This can cause a build error such as <code>invalid flag in #cgo CFLAGS</code>.
+For more background, and how to handle this error, see
+<a href="https://golang.org/s/invalidflag">https://golang.org/s/invalidflag</a>.
+</p>
+
+<p>
+Cgo now implements a C typedef like “<code>typedef</code> <code>X</code> <code>Y</code>” using a Go type alias,
+so that Go code may use the types <code>C.X</code> and <code>C.Y</code> interchangeably.
+It also now supports the use of niladic function-like macros.
+Also, the documentation has been updated to clarify that
+Go structs and Go arrays are not supported in the type signatures of cgo-exported functions.
+</p>
+
+<p>
+Cgo now supports direct access to Go string values from C.
+Functions in the C preamble may use the type <code>_GoString_</code>
+to accept a Go string as an argument.
+C code may call <code>_GoStringLen</code> and <code>_GoStringPtr</code>
+for direct access to the contents of the string.
+A value of type <code>_GoString_</code>
+may be passed in a call to an exported Go function that takes an argument of Go type <code>string</code>.
+</p>
+
+<p>
+During toolchain bootstrap, the environment variables <code>CC</code> and <code>CC_FOR_TARGET</code> specify
+the default C compiler that the resulting toolchain will use for host and target builds, respectively.
+However, if the toolchain will be used with multiple targets, it may be necessary to specify a different C compiler for each
+(for example, a different compiler for <code>darwin/arm64</code> versus <code>linux/ppc64le</code>).
+The new set of environment variables <code>CC_FOR_<i>goos</i>_<i>goarch</i></code>
+allows specifying a different default C compiler for each target.
+Note that these variables only apply during toolchain bootstrap,
+to set the defaults used by the resulting toolchain.
+Later <code>go</code> <code>build</code> commands use the <code>CC</code> environment
+variable or else the built-in default.
+</p>
+
+<p>
+Cgo now translates some C types that would normally map to a pointer
+type in Go, to a <code>uintptr</code> instead. These types include
+the <code>CFTypeRef</code> hierarchy in Darwin's CoreFoundation
+framework and the <code>jobject</code> hierarchy in Java's JNI
+interface.
+</p>
+
+<p>
+These types must be <code>uintptr</code> on the Go side because they
+would otherwise confuse the Go garbage collector; they are sometimes
+not really pointers but data structures encoded in a pointer-sized integer.
+Pointers to Go memory must not be stored in these <code>uintptr</code> values.
+</p>
+
+<p>
+Because of this change, values of the affected types need to be
+zero-initialized with the constant <code>0</code> instead of the
+constant <code>nil</code>. Go 1.10 provides <code>gofix</code>
+modules to help with that rewrite:
+</p>
+
+<pre>
+go tool fix -r cftype <pkg>
+go tool fix -r jni <pkg>
+</pre>
+
+<p>
+For more details, see the <a href="/cmd/cgo/">cgo documentation</a>.
+</p>
+
+<h3 id="doc">Doc</h3>
+
+<p>
+The <code>go</code> <code>doc</code> tool now adds functions returning slices of <code>T</code> or <code>*T</code>
+to the display of type <code>T</code>, similar to the existing behavior for functions returning single <code>T</code> or <code>*T</code> results.
+For example:
+</p>
+
+<pre>
+$ go doc mail.Address
+package mail // import "net/mail"
+
+type Address struct {
+ Name string
+ Address string
+}
+ Address represents a single mail address.
+
+func ParseAddress(address string) (*Address, error)
+func ParseAddressList(list string) ([]*Address, error)
+func (a *Address) String() string
+$
+</pre>
+
+<p>
+Previously, <code>ParseAddressList</code> was only shown in the package overview (<code>go</code> <code>doc</code> <code>mail</code>).
+</p>
+
+<h3 id="fix">Fix</h3>
+
+<p>
+The <code>go</code> <code>fix</code> tool now replaces imports of <code>"golang.org/x/net/context"</code>
+with <code>"context"</code>.
+(Forwarding aliases in the former make it completely equivalent to the latter when using Go 1.9 or later.)
+</p>
+
+<h3 id="get">Get</h3>
+
+<p>
+The <code>go</code> <code>get</code> command now supports Fossil source code repositories.
+</p>
+
+<h3 id="pprof">Pprof</h3>
+
+<p>
+The blocking and mutex profiles produced by the <code>runtime/pprof</code> package
+now include symbol information, so they can be viewed
+in <code>go</code> <code>tool</code> <code>pprof</code>
+without the binary that produced the profile.
+(All other profile types were changed to include symbol information in Go 1.9.)
+</p>
+
+<p>
+The <a href="/cmd/pprof/"><code>go</code> <code>tool</code> <code>pprof</code></a>
+profile visualizer has been updated to git version 9e20b5b (2017-11-08)
+from <a href="https://github.com/google/pprof">github.com/google/pprof</a>,
+which includes an updated web interface.
+</p>
+
+<h3 id="vet">Vet</h3>
+
+<p>
+The <a href="/cmd/vet/"><code>go</code> <code>vet</code></a> command now always has access to
+complete, up-to-date type information when checking packages, even for packages using cgo or vendored imports.
+The reports should be more accurate as a result.
+Note that only <code>go</code> <code>vet</code> has access to this information;
+the more low-level <code>go</code> <code>tool</code> <code>vet</code> does not
+and should be avoided except when working on <code>vet</code> itself.
+(As of Go 1.9, <code>go</code> <code>vet</code> provides access to all the same flags as
+<code>go</code> <code>tool</code> <code>vet</code>.)
+</p>
+
+<h3 id="diag">Diagnostics</h3>
+
+<p>
+This release includes a new <a href="/doc/diagnostics.html">overview of available Go program diagnostic tools</a>.
+</p>
+
+<h3 id="gofmt">Gofmt</h3>
+
+<p>
+Two minor details of the default formatting of Go source code have changed.
+First, certain complex three-index slice expressions previously formatted like
+<code>x[i+1</code> <code>:</code> <code>j:k]</code> and now
+format with more consistent spacing: <code>x[i+1</code> <code>:</code> <code>j</code> <code>:</code> <code>k]</code>.
+Second, single-method interface literals written on a single line,
+which are sometimes used in type assertions,
+are no longer split onto multiple lines.
+</p>
+
+<p>
+Note that these kinds of minor updates to gofmt are expected from time to time.
+In general, we recommend against building systems that check that source code
+matches the output of a specific version of gofmt.
+For example, a continuous integration test that fails if any code already checked into
+a repository is not “properly formatted” is inherently fragile and not recommended.
+</p>
+
+<p>
+If multiple programs must agree about which version of gofmt is used to format a source file,
+we recommend that they do this by arranging to invoke the same gofmt binary.
+For example, in the Go open source repository, our Git pre-commit hook is written in Go
+and could import <code>go/format</code> directly, but instead it invokes the <code>gofmt</code>
+binary found in the current path, so that the pre-commit hook need not be recompiled
+each time <code>gofmt</code> changes.
+</p>
+
+<h3 id="compiler">Compiler Toolchain</h3>
+
+<p>
+The compiler includes many improvements to the performance of generated code,
+spread fairly evenly across the supported architectures.
+</p>
+
+<p>
+The DWARF debug information recorded in binaries has been improved in a few ways:
+constant values are now recorded;
+line number information is more accurate, making source-level stepping through a program work better;
+and each package is now presented as its own DWARF compilation unit.
+</p>
+
+<p>
+The various <a href="https://docs.google.com/document/d/1nr-TQHw_er6GOQRsF6T43GGhFDelrAP0NqSS_00RgZQ/edit">build modes</a>
+have been ported to more systems.
+Specifically, <code>c-shared</code> now works on <code>linux/ppc64le</code>, <code>windows/386</code>, and <code>windows/amd64</code>;
+<code>pie</code> now works on <code>darwin/amd64</code> and also forces the use of external linking on all systems;
+and <code>plugin</code> now works on <code>linux/ppc64le</code> and <code>darwin/amd64</code>.
+</p>
+
+<p>
+The <code>linux/ppc64le</code> port now requires the use of external linking
+with any programs that use cgo, even uses by the standard library.
+</p>
+
+<h3 id="asm">Assembler</h3>
+
+<p>
+For the ARM 32-bit port, the assembler now supports the instructions
+<code><small>BFC</small></code>,
+<code><small>BFI</small></code>,
+<code><small>BFX</small></code>,
+<code><small>BFXU</small></code>,
+<code><small>FMULAD</small></code>,
+<code><small>FMULAF</small></code>,
+<code><small>FMULSD</small></code>,
+<code><small>FMULSF</small></code>,
+<code><small>FNMULAD</small></code>,
+<code><small>FNMULAF</small></code>,
+<code><small>FNMULSD</small></code>,
+<code><small>FNMULSF</small></code>,
+<code><small>MULAD</small></code>,
+<code><small>MULAF</small></code>,
+<code><small>MULSD</small></code>,
+<code><small>MULSF</small></code>,
+<code><small>NMULAD</small></code>,
+<code><small>NMULAF</small></code>,
+<code><small>NMULD</small></code>,
+<code><small>NMULF</small></code>,
+<code><small>NMULSD</small></code>,
+<code><small>NMULSF</small></code>,
+<code><small>XTAB</small></code>,
+<code><small>XTABU</small></code>,
+<code><small>XTAH</small></code>,
+and
+<code><small>XTAHU</small></code>.
+</p>
+
+<p>
+For the ARM 64-bit port, the assembler now supports the
+<code><small>VADD</small></code>,
+<code><small>VADDP</small></code>,
+<code><small>VADDV</small></code>,
+<code><small>VAND</small></code>,
+<code><small>VCMEQ</small></code>,
+<code><small>VDUP</small></code>,
+<code><small>VEOR</small></code>,
+<code><small>VLD1</small></code>,
+<code><small>VMOV</small></code>,
+<code><small>VMOVI</small></code>,
+<code><small>VMOVS</small></code>,
+<code><small>VORR</small></code>,
+<code><small>VREV32</small></code>,
+and
+<code><small>VST1</small></code>
+instructions.
+</p>
+
+<p>
+For the PowerPC 64-bit port, the assembler now supports the POWER9 instructions
+<code><small>ADDEX</small></code>,
+<code><small>CMPEQB</small></code>,
+<code><small>COPY</small></code>,
+<code><small>DARN</small></code>,
+<code><small>LDMX</small></code>,
+<code><small>MADDHD</small></code>,
+<code><small>MADDHDU</small></code>,
+<code><small>MADDLD</small></code>,
+<code><small>MFVSRLD</small></code>,
+<code><small>MTVSRDD</small></code>,
+<code><small>MTVSRWS</small></code>,
+<code><small>PASTECC</small></code>,
+<code><small>VCMPNEZB</small></code>,
+<code><small>VCMPNEZBCC</small></code>,
+and
+<code><small>VMSUMUDM</small></code>.
+</p>
+
+<p>
+For the S390X port, the assembler now supports the
+<code><small>TMHH</small></code>,
+<code><small>TMHL</small></code>,
+<code><small>TMLH</small></code>,
+and
+<code><small>TMLL</small></code>
+instructions.
+</p>
+
+<p>
+For the X86 64-bit port, the assembler now supports 359 new instructions,
+including the full AVX, AVX2, BMI, BMI2, F16C, FMA3, SSE2, SSE3, SSSE3, SSE4.1, and SSE4.2 extension sets.
+The assembler also no longer implements <code><small>MOVL</small></code> <code><small>$0,</small></code> <code><small>AX</small></code>
+as an <code><small>XORL</small></code> instruction,
+to avoid clearing the condition flags unexpectedly.
+</p>
+
+<h3 id="gccgo">Gccgo</h3>
+
+<p>
+Due to the alignment of Go's semiannual release schedule with GCC's
+annual release schedule,
+GCC release 7 contains the Go 1.8.3 version of gccgo.
+We expect that the next release, GCC 8, will contain the Go 1.10
+version of gccgo.
+</p>
+
+<h2 id="runtime">Runtime</h2>
+
+<p>
+The behavior of nested calls to
+<a href="/pkg/runtime/#LockOSThread"><code>LockOSThread</code></a> and
+<a href="/pkg/runtime/#UnlockOSThread"><code>UnlockOSThread</code></a>
+has changed.
+These functions control whether a goroutine is locked to a specific operating system thread,
+so that the goroutine only runs on that thread, and the thread only runs that goroutine.
+Previously, calling <code>LockOSThread</code> more than once in a row
+was equivalent to calling it once, and a single <code>UnlockOSThread</code>
+always unlocked the thread.
+Now, the calls nest: if <code>LockOSThread</code> is called multiple times,
+<code>UnlockOSThread</code> must be called the same number of times
+in order to unlock the thread.
+Existing code that was careful not to nest these calls will remain correct.
+Existing code that incorrectly assumed the calls nested will become correct.
+Most uses of these functions in public Go source code falls into the second category.
+</p>
+
+<p>
+Because one common use of <code>LockOSThread</code> and <code>UnlockOSThread</code>
+is to allow Go code to reliably modify thread-local state (for example, Linux or Plan 9 name spaces),
+the runtime now treats locked threads as unsuitable for reuse or for creating new threads.
+</p>
+
+<p>
+Stack traces no longer include implicit wrapper functions (previously marked <code><autogenerated></code>),
+unless a fault or panic happens in the wrapper itself.
+As a result, skip counts passed to functions like <a href="/pkg/runtime/#Caller"><code>Caller</code></a>
+should now always match the structure of the code as written, rather than depending on
+optimization decisions and implementation details.
+</p>
+
+<p>
+The garbage collector has been modified to reduce its impact on allocation latency.
+It now uses a smaller fraction of the overall CPU when running, but it may run more of the time.
+The total CPU consumed by the garbage collector has not changed significantly.
+</p>
+
+<p>
+The <a href="/pkg/runtime/#GOROOT"><code>GOROOT</code></a> function
+now defaults (when the <code>$GOROOT</code> environment variable is not set)
+to the <code>GOROOT</code> or <code>GOROOT_FINAL</code> in effect
+at the time the calling program was compiled.
+Previously it used the <code>GOROOT</code> or <code>GOROOT_FINAL</code> in effect
+at the time the toolchain that compiled the calling program was compiled.
+</p>
+
+<p>
+There is no longer a limit on the <a href="/pkg/runtime/#GOMAXPROCS"><code>GOMAXPROCS</code></a> setting.
+(In Go 1.9 the limit was 1024.)
+</p>
+
+<h2 id="performance">Performance</h2>
+
+<p>
+As always, the changes are so general and varied that precise
+statements about performance are difficult to make. Most programs
+should run a bit faster, due to speedups in the garbage collector,
+better generated code, and optimizations in the core library.
+</p>
+
+<h2 id="gc">Garbage Collector</h2>
+
+<p>
+Many applications should experience significantly lower allocation latency and overall performance overhead when the garbage collector is active.
+</p>
+
+<h2 id="library">Core library</h2>
+
+<p>
+All of the changes to the standard library are minor.
+The changes in <a href="#bytes">bytes</a>
+and <a href="#net/url">net/url</a> are the most likely to require updating of existing programs.
+</p>
+
+<h3 id="minor_library_changes">Minor changes to the library</h3>
+
+<p>
+As always, there are various minor changes and updates to the library,
+made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
+in mind.
+</p>
+
+<dl id="archive/tar"><dt><a href="/pkg/archive/tar/">archive/tar</a></dt>
+<dd>
+<p>
+In general, the handling of special header formats is significantly improved and expanded.
+</p>
+<p>
+<a href="/pkg/archive/tar/#FileInfoHeader"><code>FileInfoHeader</code></a> has always
+recorded the Unix UID and GID numbers from its <a href="/pkg/os/#FileInfo"><code>os.FileInfo</code></a> argument
+(specifically, from the system-dependent information returned by the <code>FileInfo</code>'s <code>Sys</code> method)
+in the returned <a href="/pkg/archive/tar/#Header"><code>Header</code></a>.
+Now it also records the user and group names corresponding to those IDs,
+as well as the major and minor device numbers for device files.
+</p>
+<p>
+The new <a href="/pkg/archive/tar/#Header"><code>Header.Format</code></a> field
+of type <a href="/pkg/archive/tar/#Format"><code>Format</code></a>
+controls which tar header format the <a href="/pkg/archive/tar/#Writer"><code>Writer</code></a> uses.
+The default, as before, is to select the most widely-supported header type
+that can encode the fields needed by the header (USTAR if possible, or else PAX if possible, or else GNU).
+The <a href="/pkg/archive/tar/#Reader"><code>Reader</code></a> sets <code>Header.Format</code> for each header it reads.
+</p>
+<p>
+<code>Reader</code> and the <code>Writer</code> now support arbitrary PAX records,
+using the new <a href="/pkg/archive/tar/#Header"><code>Header.PAXRecords</code></a> field,
+a generalization of the existing <code>Xattrs</code> field.
+</p>
+<p>
+The <code>Reader</code> no longer insists that the file name or link name in GNU headers
+be valid UTF-8.
+</p>
+<p>
+When writing PAX- or GNU-format headers, the <code>Writer</code> now includes
+the <code>Header.AccessTime</code> and <code>Header.ChangeTime</code> fields (if set).
+When writing PAX-format headers, the times include sub-second precision.
+</p>
+</dl>
+
+<dl id="archive/zip"><dt><a href="/pkg/archive/zip/">archive/zip</a></dt>
+<dd>
+<p>
+Go 1.10 adds more complete support for times and character set encodings in ZIP archives.
+</p>
+<p>
+The original ZIP format used the standard MS-DOS encoding of year, month, day, hour, minute, and second into fields in two 16-bit values.
+That encoding cannot represent time zones or odd seconds, so multiple extensions have been
+introduced to allow richer encodings.
+In Go 1.10, the <a href="/pkg/archive/zip/#Reader"><code>Reader</code></a> and <a href="/pkg/archive/zip/#Writer"><code>Writer</code></a>
+now support the widely-understood Info-Zip extension that encodes the time separately in the 32-bit Unix “seconds since epoch” form.
+The <a href="/pkg/archive/zip/#FileHeader"><code>FileHeader</code></a>'s new <code>Modified</code> field of type <a href="/pkg/time/#Time"><code>time.Time</code></a>
+obsoletes the <code>ModifiedTime</code> and <code>ModifiedDate</code> fields, which continue to hold the MS-DOS encoding.
+The <code>Reader</code> and <code>Writer</code> now adopt the common
+convention that a ZIP archive storing a time zone-independent Unix time
+also stores the local time in the MS-DOS field,
+so that the time zone offset can be inferred.
+For compatibility, the <a href="/pkg/archive/zip/#FileHeader.ModTime"><code>ModTime</code></a> and
+<a href="/pkg/archive/zip/#FileHeader.SetModTime"><code>SetModTime</code></a> methods
+behave the same as in earlier releases; new code should use <code>Modified</code> directly.
+</p>
+<p>
+The header for each file in a ZIP archive has a flag bit indicating whether
+the name and comment fields are encoded as UTF-8, as opposed to a system-specific default encoding.
+In Go 1.8 and earlier, the <code>Writer</code> never set the UTF-8 bit.
+In Go 1.9, the <code>Writer</code> changed to set the UTF-8 bit almost always.
+This broke the creation of ZIP archives containing Shift-JIS file names.
+In Go 1.10, the <code>Writer</code> now sets the UTF-8 bit only when
+both the name and the comment field are valid UTF-8 and at least one is non-ASCII.
+Because non-ASCII encodings very rarely look like valid UTF-8, the new
+heuristic should be correct nearly all the time.
+Setting a <code>FileHeader</code>'s new <code>NonUTF8</code> field to true
+disables the heuristic entirely for that file.
+</p>
+<p>
+The <code>Writer</code> also now supports setting the end-of-central-directory record's comment field,
+by calling the <code>Writer</code>'s new <a href="/pkg/archive/zip/#Writer.SetComment"><code>SetComment</code></a> method.
+</p>
+</dl>
+
+<dl id="bufio"><dt><a href="/pkg/bufio/">bufio</a></dt>
+<dd>
+<p>
+The new <a href="/pkg/bufio/#Reader.Size"><code>Reader.Size</code></a>
+and <a href="/pkg/bufio/#Writer.Size"><code>Writer.Size</code></a>
+methods report the <code>Reader</code> or <code>Writer</code>'s underlying buffer size.
+</p>
+</dl>
+
+<dl id="bytes"><dt><a href="/pkg/bytes/">bytes</a></dt>
+<dd>
+<p>
+The
+<a href="/pkg/bytes/#Fields"><code>Fields</code></a>,
+<a href="/pkg/bytes/#FieldsFunc"><code>FieldsFunc</code></a>,
+<a href="/pkg/bytes/#Split"><code>Split</code></a>,
+and
+<a href="/pkg/bytes/#SplitAfter"><code>SplitAfter</code></a>
+functions have always returned subslices of their inputs.
+Go 1.10 changes each returned subslice to have capacity equal to its length,
+so that appending to one cannot overwrite adjacent data in the original input.
+</p>
+</dl>
+
+<dl id="crypto/cipher"><dt><a href="/pkg/crypto/cipher/">crypto/cipher</a></dt>
+<dd>
+<p>
+<a href="/pkg/crypto/cipher/#NewOFB"><code>NewOFB</code></a> now panics if given
+an initialization vector of incorrect length, like the other constructors in the
+package always have.
+(Previously it returned a nil <code>Stream</code> implementation.)
+</p>
+</dl>
+
+<dl id="crypto/tls"><dt><a href="/pkg/crypto/tls/">crypto/tls</a></dt>
+<dd>
+<p>
+The TLS server now advertises support for SHA-512 signatures when using TLS 1.2.
+The server already supported the signatures, but some clients would not select
+them unless explicitly advertised.
+</p>
+</dl>
+
+<dl id="crypto/x509"><dt><a href="/pkg/crypto/x509/">crypto/x509</a></dt>
+<dd>
+<p>
+<a href="/pkg/crypto/x509/#Certificate.Verify"><code>Certificate.Verify</code></a>
+now enforces the name constraints for all
+names contained in the certificate, not just the one name that a client has asked about.
+Extended key usage restrictions are similarly now checked all at once.
+As a result, after a certificate has been validated, now it can be trusted in its entirety.
+It is no longer necessary to revalidate the certificate for each additional name
+or key usage.
+</p>
+
+<p>
+Parsed certificates also now report URI names and IP, email, and URI constraints, using the new
+<a href="/pkg/crypto/x509/#Certificate"><code>Certificate</code></a> fields
+<code>URIs</code>, <code>PermittedIPRanges</code>, <code>ExcludedIPRanges</code>,
+<code>PermittedEmailAddresses</code>, <code>ExcludedEmailAddresses</code>,
+<code>PermittedURIDomains</code>, and <code>ExcludedURIDomains</code>. Certificates with
+invalid values for those fields are now rejected.
+</p>
+
+<p>
+The new <a href="/pkg/crypto/x509/#MarshalPKCS1PublicKey"><code>MarshalPKCS1PublicKey</code></a>
+and <a href="/pkg/crypto/x509/#ParsePKCS1PublicKey"><code>ParsePKCS1PublicKey</code></a>
+functions convert an RSA public key to and from PKCS#1-encoded form.
+</p>
+
+<p>
+The new <a href="/pkg/crypto/x509/#MarshalPKCS8PrivateKey"><code>MarshalPKCS8PrivateKey</code></a>
+function converts a private key to PKCS#8-encoded form.
+(<a href="/pkg/crypto/x509/#ParsePKCS8PrivateKey"><code>ParsePKCS8PrivateKey</code></a>
+has existed since Go 1.)
+</p>
+</dl>
+
+<dl id="crypto/x509/pkix"><dt><a href="/pkg/crypto/x509/pkix/">crypto/x509/pkix</a></dt>
+<dd>
+<p>
+<a href="/pkg/crypto/x509/pkix/#Name"><code>Name</code></a> now implements a
+<a href="/pkg/crypto/x509/pkix/#Name.String"><code>String</code></a> method that
+formats the X.509 distinguished name in the standard RFC 2253 format.
+</p>
+</dl>
+
+<dl id="database/sql/driver"><dt><a href="/pkg/database/sql/driver/">database/sql/driver</a></dt>
+<dd>
+<p>
+Drivers that currently hold on to the destination buffer provided by
+<a href="/pkg/database/sql/driver/#Rows.Next"><code>driver.Rows.Next</code></a> should ensure they no longer
+write to a buffer assigned to the destination array outside of that call.
+Drivers must be careful that underlying buffers are not modified when closing
+<a href="/pkg/database/sql/driver/#Rows"><code>driver.Rows</code></a>.
+</p>
+<p>
+Drivers that want to construct a <a href="/pkg/database/sql/#DB"><code>sql.DB</code></a> for
+their clients can now implement the <a href="/pkg/database/sql/driver/#Connector"><code>Connector</code></a> interface
+and call the new <a href="/pkg/database/sql/#OpenDB"><code>sql.OpenDB</code></a> function,
+instead of needing to encode all configuration into a string
+passed to <a href="/pkg/database/sql/#Open"><code>sql.Open</code></a>.
+</p>
+<p>
+Drivers that want to parse the configuration string only once per <code>sql.DB</code>
+instead of once per <a href="/pkg/database/sql/#Conn"><code>sql.Conn</code></a>,
+or that want access to each <code>sql.Conn</code>'s underlying context,
+can make their <a href="/pkg/database/sql/driver/#Driver"><code>Driver</code></a>
+implementations also implement <a href="/pkg/database/sql/driver/#DriverContext"><code>DriverContext</code></a>'s
+new <code>OpenConnector</code> method.
+</p>
+<p>
+Drivers that implement <a href="/pkg/database/sql/driver/#ExecerContext"><code>ExecerContext</code></a>
+no longer need to implement <a href="/pkg/database/sql/driver/#Execer"><code>Execer</code></a>;
+similarly, drivers that implement <a href="/pkg/database/sql/driver/#QueryerContext"><code>QueryerContext</code></a>
+no longer need to implement <a href="/pkg/database/sql/driver/#Queryer"><code>Queryer</code></a>.
+Previously, even if the context-based interfaces were implemented they were ignored
+unless the non-context-based interfaces were also implemented.
+</p>
+<p>
+To allow drivers to better isolate different clients using a cached driver connection in succession,
+if a <a href="/pkg/database/sql/driver/#Conn"><code>Conn</code></a> implements the new
+<a href="/pkg/database/sql/driver/#SessionResetter"><code>SessionResetter</code></a> interface,
+<code>database/sql</code> will now call <code>ResetSession</code> before
+reusing the <code>Conn</code> for a new client.
+</p>
+</dl>
+
+<dl id="debug/elf"><dt><a href="/pkg/debug/elf/">debug/elf</a></dt>
+<dd>
+<p>
+This release adds 348 new relocation constants divided between the relocation types
+<a href="/pkg/debug/elf/#R_386"><code>R_386</code></a>,
+<a href="/pkg/debug/elf/#R_AARCH64"><code>R_AARCH64</code></a>,
+<a href="/pkg/debug/elf/#R_ARM"><code>R_ARM</code></a>,
+<a href="/pkg/debug/elf/#R_PPC64"><code>R_PPC64</code></a>,
+and
+<a href="/pkg/debug/elf/#R_X86_64"><code>R_X86_64</code></a>.
+</p>
+</dl>
+
+<dl id="debug/macho"><dt><a href="/pkg/debug/macho/">debug/macho</a></dt>
+<dd>
+<p>
+Go 1.10 adds support for reading relocations from Mach-O sections,
+using the <a href="/pkg/debug/macho#Section"><code>Section</code></a> struct's new <code>Relocs</code> field
+and the new <a href="/pkg/debug/macho/#Reloc"><code>Reloc</code></a>,
+<a href="/pkg/debug/macho/#RelocTypeARM"><code>RelocTypeARM</code></a>,
+<a href="/pkg/debug/macho/#RelocTypeARM64"><code>RelocTypeARM64</code></a>,
+<a href="/pkg/debug/macho/#RelocTypeGeneric"><code>RelocTypeGeneric</code></a>,
+and
+<a href="/pkg/debug/macho/#RelocTypeX86_64"><code>RelocTypeX86_64</code></a>
+types and associated constants.
+</p>
+<p>
+Go 1.10 also adds support for the <code>LC_RPATH</code> load command,
+represented by the types
+<a href="/pkg/debug/macho/#RpathCmd"><code>RpathCmd</code></a> and
+<a href="/pkg/debug/macho/#Rpath"><code>Rpath</code></a>,
+and new <a href="/pkg/debug/macho/#pkg-constants">named constants</a>
+for the various flag bits found in headers.
+</p>
+</dl>
+
+<dl id="encoding/asn1"><dt><a href="/pkg/encoding/asn1/">encoding/asn1</a></dt>
+<dd>
+<p>
+<a href="/pkg/encoding/asn1/#Marshal"><code>Marshal</code></a> now correctly encodes
+strings containing asterisks as type UTF8String instead of PrintableString,
+unless the string is in a struct field with a tag forcing the use of PrintableString.
+<code>Marshal</code> also now respects struct tags containing <code>application</code> directives.
+</p>
+<p>
+The new <a href="/pkg/encoding/asn1/#MarshalWithParams"><code>MarshalWithParams</code></a>
+function marshals its argument as if the additional params were its associated
+struct field tag.
+</p>
+<p>
+<a href="/pkg/encoding/asn1/#Unmarshal"><code>Unmarshal</code></a> now respects
+struct field tags using the <code>explicit</code> and <code>tag</code>
+directives.
+</p>
+<p>
+Both <code>Marshal</code> and <code>Unmarshal</code> now support a new struct field tag
+<code>numeric</code>, indicating an ASN.1 NumericString.
+</p>
+</dl>
+
+<dl id="encoding/csv"><dt><a href="/pkg/encoding/csv/">encoding/csv</a></dt>
+<dd>
+<p>
+<a href="/pkg/encoding/csv/#Reader"><code>Reader</code></a> now disallows the use of
+nonsensical <code>Comma</code> and <code>Comment</code> settings,
+such as NUL, carriage return, newline, invalid runes, and the Unicode replacement character,
+or setting <code>Comma</code> and <code>Comment</code> equal to each other.
+</p>
+<p>
+In the case of a syntax error in a CSV record that spans multiple input lines, <code>Reader</code>
+now reports the line on which the record started in the <a href="/pkg/encoding/csv/#ParseError"><code>ParseError</code></a>'s new <code>StartLine</code> field.
+</p>
+</dl>
+
+<dl id="encoding/hex"><dt><a href="/pkg/encoding/hex/">encoding/hex</a></dt>
+<dd>
+<p>
+The new functions
+<a href="/pkg/encoding/hex/#NewEncoder"><code>NewEncoder</code></a>
+and
+<a href="/pkg/encoding/hex/#NewDecoder"><code>NewDecoder</code></a>
+provide streaming conversions to and from hexadecimal,
+analogous to equivalent functions already in
+<a href="/pkg/encoding/base32/">encoding/base32</a>
+and
+<a href="/pkg/encoding/base64/">encoding/base64</a>.
+</p>
+
+<p>
+When the functions
+<a href="/pkg/encoding/hex/#Decode"><code>Decode</code></a>
+and
+<a href="/pkg/encoding/hex/#DecodeString"><code>DecodeString</code></a>
+encounter malformed input,
+they now return the number of bytes already converted
+along with the error.
+Previously they always returned a count of 0 with any error.
+</p>
+</dl>
+
+<dl id="encoding/json"><dt><a href="/pkg/encoding/json/">encoding/json</a></dt>
+<dd>
+<p>
+The <a href="/pkg/encoding/json/#Decoder"><code>Decoder</code></a>
+adds a new method
+<a href="/pkg/encoding/json/#Decoder.DisallowUnknownFields"><code>DisallowUnknownFields</code></a>
+that causes it to report inputs with unknown JSON fields as a decoding error.
+(The default behavior has always been to discard unknown fields.)
+</p>
+
+<p>
+As a result of <a href="#reflect">fixing a reflect bug</a>,
+<a href="/pkg/encoding/json/#Unmarshal"><code>Unmarshal</code></a>
+can no longer decode into fields inside
+embedded pointers to unexported struct types,
+because it cannot initialize the unexported embedded pointer
+to point at fresh storage.
+<code>Unmarshal</code> now returns an error in this case.
+</p>
+</dl>
+
+<dl id="encoding/pem"><dt><a href="/pkg/encoding/pem/">encoding/pem</a></dt>
+<dd>
+<p>
+<a href="/pkg/encoding/pem/#Encode"><code>Encode</code></a>
+and
+<a href="/pkg/encoding/pem/#EncodeToMemory"><code>EncodeToMemory</code></a>
+no longer generate partial output when presented with a
+block that is impossible to encode as PEM data.
+</p>
+</dl>
+
+<dl id="encoding/xml"><dt><a href="/pkg/encoding/xml/">encoding/xml</a></dt>
+<dd>
+<p>
+The new function
+<a href="/pkg/encoding/xml/#NewTokenDecoder"><code>NewTokenDecoder</code></a>
+is like
+<a href="/pkg/encoding/xml/#NewDecoder"><code>NewDecoder</code></a>
+but creates a decoder reading from a <a href="/pkg/encoding/xml/#TokenReader"><code>TokenReader</code></a>
+instead of an XML-formatted byte stream.
+This is meant to enable the construction of XML stream transformers in client libraries.
+</p>
+</dl>
+
+<dl id="flag"><dt><a href="/pkg/flag/">flag</a></dt>
+<dd>
+<p>
+The default
+<a href="/pkg/flag/#Usage"><code>Usage</code></a> function now prints
+its first line of output to
+<code>CommandLine.Output()</code>
+instead of assuming <code>os.Stderr</code>,
+so that the usage message is properly redirected for
+clients using <code>CommandLine.SetOutput</code>.
+</p>
+<p>
+<a href="/pkg/flag/#PrintDefaults"><code>PrintDefaults</code></a> now
+adds appropriate indentation after newlines in flag usage strings,
+so that multi-line usage strings display nicely.
+</p>
+<p>
+<a href="/pkg/flag/#FlagSet"><code>FlagSet</code></a> adds new methods
+<a href="/pkg/flag/#FlagSet.ErrorHandling"><code>ErrorHandling</code></a>,
+<a href="/pkg/flag/#FlagSet.Name"><code>Name</code></a>,
+and
+<a href="/pkg/flag/#FlagSet.Output"><code>Output</code></a>,
+to retrieve the settings passed to
+<a href="/pkg/flag/#NewFlagSet"><code>NewFlagSet</code></a>
+and
+<a href="/pkg/flag/#FlagSet.SetOutput"><code>FlagSet.SetOutput</code></a>.
+</p>
+</dl>
+
+<dl id="go/doc"><dt><a href="/pkg/go/doc/">go/doc</a></dt>
+<dd>
+<p>
+To support the <a href="#doc">doc change</a> described above,
+functions returning slices of <code>T</code>, <code>*T</code>, <code>**T</code>, and so on
+are now reported in <code>T</code>'s <a href="/pkg/go/doc/#Type"><code>Type</code></a>'s <code>Funcs</code> list,
+instead of in the <a href="/pkg/go/doc/#Package"><code>Package</code></a>'s <code>Funcs</code> list.
+</p>
+</dl>
+
+<dl id="go/importer"><dt><a href="/pkg/go/importer/">go/importer</a></dt>
+<dd>
+<p>
+The <a href="/pkg/go/importer/#For"><code>For</code></a> function now accepts a non-nil lookup argument.
+</p>
+</dl>
+
+<dl id="go/printer"><dt><a href="/pkg/go/printer/">go/printer</a></dt>
+<dd>
+<p>
+The changes to the default formatting of Go source code
+discussed in the <a href="#gofmt">gofmt section</a> above
+are implemented in the <a href="/pkg/go/printer/">go/printer</a> package
+and also affect the output of the higher-level <a href="/pkg/go/format/">go/format</a> package.
+</p>
+</dl>
+
+<dl id="hash"><dt><a href="/pkg/hash/">hash</a></dt>
+<dd>
+<p>
+Implementations of the <a href="/pkg/hash/#Hash"><code>Hash</code></a> interface are now
+encouraged to implement <a href="/pkg/encoding/#BinaryMarshaler"><code>encoding.BinaryMarshaler</code></a>
+and <a href="/pkg/encoding/#BinaryUnmarshaler"><code>encoding.BinaryUnmarshaler</code></a>
+to allow saving and recreating their internal state,
+and all implementations in the standard library
+(<a href="/pkg/hash/crc32/">hash/crc32</a>, <a href="/pkg/crypto/sha256/">crypto/sha256</a>, and so on)
+now implement those interfaces.
+</p>
+</dl>
+
+<dl id="html/template"><dt><a href="/pkg/html/template/">html/template</a></dt>
+<dd>
+<p>
+The new <a href="/pkg/html/template#Srcset"><code>Srcset</code></a> content
+type allows for proper handling of values within the
+<a href="https://w3c.github.io/html/semantics-embedded-content.html#element-attrdef-img-srcset"><code>srcset</code></a>
+attribute of <code>img</code> tags.
+</p>
+</dl>
+
+<dl id="math/big"><dt><a href="/pkg/math/big/">math/big</a></dt>
+<dd>
+<p>
+<a href="/pkg/math/big/#Int"><code>Int</code></a> now supports conversions to and from bases 2 through 62
+in its <a href="/pkg/math/big/#Int.SetString"><code>SetString</code></a> and <a href="/pkg/math/big/#Text"><code>Text</code></a> methods.
+(Previously it only allowed bases 2 through 36.)
+The value of the constant <code>MaxBase</code> has been updated.
+</p>
+<p>
+<a href="/pkg/math/big/#Int"><code>Int</code></a> adds a new
+<a href="/pkg/math/big/#CmpAbs"><code>CmpAbs</code></a> method
+that is like <a href="/pkg/math/big/#Cmp"><code>Cmp</code></a> but
+compares only the absolute values (not the signs) of its arguments.
+</p>
+<p>
+<a href="/pkg/math/big/#Float"><code>Float</code></a> adds a new
+<a href="/pkg/math/big/#Float.Sqrt"><code>Sqrt</code></a> method to
+compute square roots.
+</p>
+</dl>
+
+<dl id="math/cmplx"><dt><a href="/pkg/math/cmplx/">math/cmplx</a></dt>
+<dd>
+<p>
+Branch cuts and other boundary cases in
+<a href="/pkg/math/cmplx/#Asin"><code>Asin</code></a>,
+<a href="/pkg/math/cmplx/#Asinh"><code>Asinh</code></a>,
+<a href="/pkg/math/cmplx/#Atan"><code>Atan</code></a>,
+and
+<a href="/pkg/math/cmplx/#Sqrt"><code>Sqrt</code></a>
+have been corrected to match the definitions used in the C99 standard.
+</p>
+</dl>
+
+<dl id="math/rand"><dt><a href="/pkg/math/rand/">math/rand</a></dt>
+<dd>
+<p>
+The new <a href="/pkg/math/rand/#Shuffle"><code>Shuffle</code></a> function and corresponding
+<a href="/pkg/math/rand/#Rand.Shuffle"><code>Rand.Shuffle</code></a> method
+shuffle an input sequence.
+</p>
+</dl>
+
+<dl id="math"><dt><a href="/pkg/math/">math</a></dt>
+<dd>
+<p>
+The new functions
+<a href="/pkg/math/#Round"><code>Round</code></a>
+and
+<a href="/pkg/math/#RoundToEven"><code>RoundToEven</code></a>
+round their arguments to the nearest floating-point integer;
+<code>Round</code> rounds a half-integer to its larger integer neighbor (away from zero)
+while <code>RoundToEven</code> rounds a half-integer to its even integer neighbor.
+</p>
+
+<p>
+The new functions
+<a href="/pkg/math/#Erfinv"><code>Erfinv</code></a>
+and
+<a href="/pkg/math/#Erfcinv"><code>Erfcinv</code></a>
+compute the inverse error function and the
+inverse complementary error function.
+</p>
+</dl>
+
+<dl id="mime/multipart"><dt><a href="/pkg/mime/multipart/">mime/multipart</a></dt>
+<dd>
+<p>
+<a href="/pkg/mime/multipart/#Reader"><code>Reader</code></a>
+now accepts parts with empty filename attributes.
+</p>
+</dl>
+
+<dl id="mime"><dt><a href="/pkg/mime/">mime</a></dt>
+<dd>
+<p>
+<a href="/pkg/mime/#ParseMediaType"><code>ParseMediaType</code></a> now discards
+invalid attribute values; previously it returned those values as empty strings.
+</p>
+</dl>
+
+<dl id="net"><dt><a href="/pkg/net/">net</a></dt>
+<dd>
+<p>
+The <a href="/pkg/net/#Conn"><code>Conn</code></a> and
+<a href="/pkg/net/#Conn"><code>Listener</code></a> implementations
+in this package now guarantee that when <code>Close</code> returns,
+the underlying file descriptor has been closed.
+(In earlier releases, if the <code>Close</code> stopped pending I/O
+in other goroutines, the closing of the file descriptor could happen in one of those
+goroutines shortly after <code>Close</code> returned.)
+</p>
+
+<p>
+<a href="/pkg/net/#TCPListener"><code>TCPListener</code></a> and
+<a href="/pkg/net/#UnixListener"><code>UnixListener</code></a>
+now implement
+<a href="/pkg/syscall/#Conn"><code>syscall.Conn</code></a>,
+to allow setting options on the underlying file descriptor
+using <a href="/pkg/syscall/#RawConn"><code>syscall.RawConn.Control</code></a>.
+</p>
+
+<p>
+The <code>Conn</code> implementations returned by <a href="/pkg/net/#Pipe"><code>Pipe</code></a>
+now support setting read and write deadlines.
+</p>
+
+<p>
+The <a href="/pkg/net/#IPConn.ReadMsgIP"><code>IPConn.ReadMsgIP</code></a>,
+<a href="/pkg/net/#IPConn.WriteMsgIP"><code>IPConn.WriteMsgIP</code></a>,
+<a href="/pkg/net/#UDPConn.ReadMsgUDP"><code>UDPConn.ReadMsgUDP</code></a>,
+and
+<a href="/pkg/net/#UDPConn.WriteMsgUDP"><code>UDPConn.WriteMsgUDP</code></a>,
+methods are now implemented on Windows.
+</p>
+</dl>
+
+<dl id="net/http"><dt><a href="/pkg/net/http/">net/http</a></dt>
+<dd>
+<p>
+On the client side, an HTTP proxy (most commonly configured by
+<a href="/pkg/net/http/#ProxyFromEnvironment"><code>ProxyFromEnvironment</code></a>)
+can now be specified as an <code>https://</code> URL,
+meaning that the client connects to the proxy over HTTPS before issuing a standard, proxied HTTP request.
+(Previously, HTTP proxy URLs were required to begin with <code>http://</code> or <code>socks5://</code>.)
+</p>
+<p>
+On the server side, <a href="/pkg/net/http/#FileServer"><code>FileServer</code></a> and its single-file equivalent <a href="/pkg/net/http/#ServeFile"><code>ServeFile</code></a>
+now apply <code>If-Range</code> checks to <code>HEAD</code> requests.
+<code>FileServer</code> also now reports directory read failures to the <a href="/pkg/net/http/#Server"><code>Server</code></a>'s <code>ErrorLog</code>.
+The content-serving handlers also now omit the <code>Content-Type</code> header when serving zero-length content.
+</p>
+<p>
+<a href="/pkg/net/http/#ResponseWriter"><code>ResponseWriter</code></a>'s <code>WriteHeader</code> method now panics
+if passed an invalid (non-3-digit) status code.
+</p>
+<p>
+<!-- CL 46631 -->
+The <code>Server</code> will no longer add an implicit Content-Type when a <code>Handler</code> does not write any output.
+</p>
+<p>
+<a href="/pkg/net/http/#Redirect"><code>Redirect</code></a> now sets the <code>Content-Type</code> header before writing its HTTP response.
+</p>
+</dl>
+
+<dl id="net/mail"><dt><a href="/pkg/net/mail/">net/mail</a></dt>
+<dd>
+<p>
+<a href="/pkg/net/mail/#ParseAddress"><code>ParseAddress</code></a> and
+<a href="/pkg/net/mail/#ParseAddressList"><code>ParseAddressList</code></a>
+now support a variety of obsolete address formats.
+</p>
+</dl>
+
+<dl id="net/smtp"><dt><a href="/pkg/net/smtp/">net/smtp</a></dt>
+<dd>
+<p>
+The <a href="/pkg/net/smtp/#Client"><code>Client</code></a> adds a new
+<a href="/pkg/net/smtp/#Client.Noop"><code>Noop</code></a> method,
+to test whether the server is still responding.
+It also now defends against possible SMTP injection in the inputs
+to the <a href="/pkg/net/smtp/#Client.Hello"><code>Hello</code></a>
+and <a href="/pkg/net/smtp/#Client.Verify"><code>Verify</code></a> methods.
+</p>
+</dl>
+
+<dl id="net/textproto"><dt><a href="/pkg/net/textproto/">net/textproto</a></dt>
+<dd>
+<p>
+<a href="/pkg/net/textproto/#ReadMIMEHeader"><code>ReadMIMEHeader</code></a>
+now rejects any header that begins with a continuation (indented) header line.
+Previously a header with an indented first line was treated as if the first line
+were not indented.
+</p>
+</dl>
+
+<dl id="net/url"><dt><a href="/pkg/net/url/">net/url</a></dt>
+<dd>
+<p>
+<a href="/pkg/net/url/#ResolveReference"><code>ResolveReference</code></a>
+now preserves multiple leading slashes in the target URL.
+Previously it rewrote multiple leading slashes to a single slash,
+which resulted in the <a href="/pkg/net/http/#Client"><code>http.Client</code></a>
+following certain redirects incorrectly.
+</p>
+<p>
+For example, this code's output has changed:
+</p>
+<pre>
+base, _ := url.Parse("http://host//path//to/page1")
+target, _ := url.Parse("page2")
+fmt.Println(base.ResolveReference(target))
+</pre>
+<p>
+Note the doubled slashes around <code>path</code>.
+In Go 1.9 and earlier, the resolved URL was <code>http://host/path//to/page2</code>:
+the doubled slash before <code>path</code> was incorrectly rewritten
+to a single slash, while the doubled slash after <code>path</code> was
+correctly preserved.
+Go 1.10 preserves both doubled slashes, resolving to <code>http://host//path//to/page2</code>
+as required by <a href="https://tools.ietf.org/html/rfc3986#section-5.2">RFC 3986</a>.
+</p>
+
+<p>This change may break existing buggy programs that unintentionally
+construct a base URL with a leading doubled slash in the path and inadvertently
+depend on <code>ResolveReference</code> to correct that mistake.
+For example, this can happen if code adds a host prefix
+like <code>http://host/</code> to a path like <code>/my/api</code>,
+resulting in a URL with a doubled slash: <code>http://host//my/api</code>.
+</p>
+
+<p>
+<a href="/pkg/net/url/#UserInfo"><code>UserInfo</code></a>'s methods
+now treat a nil receiver as equivalent to a pointer to a zero <code>UserInfo</code>.
+Previously, they panicked.
+</p>
+</dl>
+
+<dl id="os"><dt><a href="/pkg/os/">os</a></dt>
+<dd>
+<p>
+<a href="/pkg/os/#File"><code>File</code></a> adds new methods
+<a href="/pkg/os/#File.SetDeadline"><code>SetDeadline</code></a>,
+<a href="/pkg/os/#File.SetReadDeadline"><code>SetReadDeadline</code></a>,
+and
+<a href="/pkg/os/#File.SetWriteDeadline"><code>SetWriteDeadline</code></a>
+that allow setting I/O deadlines when the
+underlying file descriptor supports non-blocking I/O operations.
+The definition of these methods matches those in <a href="/pkg/net/#Conn"><code>net.Conn</code></a>.
+If an I/O method fails due to missing a deadline, it will return a
+timeout error; the
+new <a href="/pkg/os/#IsTimeout"><code>IsTimeout</code></a> function
+reports whether an error represents a timeout.
+</p>
+
+<p>
+Also matching <code>net.Conn</code>,
+<code>File</code>'s
+<a href="/pkg/os/#File.Close"><code>Close</code></a> method
+now guarantee that when <code>Close</code> returns,
+the underlying file descriptor has been closed.
+(In earlier releases,
+if the <code>Close</code> stopped pending I/O
+in other goroutines, the closing of the file descriptor could happen in one of those
+goroutines shortly after <code>Close</code> returned.)
+</p>
+
+<p>
+On BSD, macOS, and Solaris systems,
+<a href="/pkg/os/#Chtimes"><code>Chtimes</code></a>
+now supports setting file times with nanosecond precision
+(assuming the underlying file system can represent them).
+</p>
+</dl>
+
+<dl id="reflect"><dt><a href="/pkg/reflect/">reflect</a></dt>
+<dd>
+<p>
+The <a href="/pkg/reflect/#Copy"><code>Copy</code></a> function now allows copying
+from a string into a byte array or byte slice, to match the
+<a href="/pkg/builtin/#copy">built-in copy function</a>.
+</p>
+
+<p>
+In structs, embedded pointers to unexported struct types were
+previously incorrectly reported with an empty <code>PkgPath</code>
+in the corresponding <a href="/pkg/reflect/#StructField">StructField</a>,
+with the result that for those fields,
+and <a href="/pkg/reflect/#Value.CanSet"><code>Value.CanSet</code></a>
+incorrectly returned true and
+<a href="/pkg/reflect/#Value.Set"><code>Value.Set</code></a>
+incorrectly succeeded.
+The underlying metadata has been corrected;
+for those fields,
+<code>CanSet</code> now correctly returns false
+and <code>Set</code> now correctly panics.
+This may affect reflection-based unmarshalers
+that could previously unmarshal into such fields
+but no longer can.
+For example, see the <a href="#encoding/json"><code>encoding/json</code> notes</a>.
+</p>
+</dl>
+
+<dl id="runtime/pprof"><dt><a href="/pkg/runtime/pprof/">runtime/pprof</a></dt>
+<dd>
+<p>
+As <a href="#pprof">noted above</a>, the blocking and mutex profiles
+now include symbol information so that they can be viewed without needing
+the binary that generated them.
+</p>
+</dl>
+
+<dl id="strconv"><dt><a href="/pkg/strconv/">strconv</a></dt>
+<dd>
+<p>
+<a href="/pkg/strconv/#ParseUint"><code>ParseUint</code></a> now returns
+the maximum magnitude integer of the appropriate size
+with any <code>ErrRange</code> error, as it was already documented to do.
+Previously it returned 0 with <code>ErrRange</code> errors.
+</p>
+</dl>
+
+<dl id="strings"><dt><a href="/pkg/strings/">strings</a></dt>
+<dd>
+<p>
+A new type
+<a href="/pkg/strings/#Builder"><code>Builder</code></a> is a replacement for
+<a href="/pkg/bytes/#Buffer"><code>bytes.Buffer</code></a> for the use case of
+accumulating text into a <code>string</code> result.
+The <code>Builder</code>'s API is a restricted subset of <code>bytes.Buffer</code>'s
+that allows it to safely avoid making a duplicate copy of the data
+during the <a href="/pkg/strings/#Builder.String"><code>String</code></a> method.
+</p>
+</dl>
+
+<dl id="syscall"><dt><a href="/pkg/syscall/">syscall</a></dt>
+<dd>
+<p>
+On Windows,
+the new <a href="/pkg/syscall/#SysProcAttr"><code>SysProcAttr</code></a> field <code>Token</code>,
+of type <a href="/pkg/syscall/#Token"><code>Token</code></a> allows the creation of a process that
+runs as another user during <a href="/pkg/syscall/#StartProcess"><code>StartProcess</code></a>
+(and therefore also during <a href="/pkg/os/#StartProcess"><code>os.StartProcess</code></a> and
+<a href="/pkg/os/exec/#Cmd.Start"><code>exec.Cmd.Start</code></a>).
+The new function <a href="/pkg/syscall/#CreateProcessAsUser"><code>CreateProcessAsUser</code></a>
+gives access to the underlying system call.
+</p>
+
+<p>
+On BSD, macOS, and Solaris systems, <a href="/pkg/syscall/#UtimesNano"><code>UtimesNano</code></a>
+is now implemented.
+</p>
+</dl>
+
+<dl id="time"><dt><a href="/pkg/time/">time</a></dt>
+<dd>
+<p>
+<a href="/pkg/time/#LoadLocation"><code>LoadLocation</code></a> now uses the directory
+or uncompressed zip file named by the <code>$ZONEINFO</code>
+environment variable before looking in the default system-specific list of
+known installation locations or in <code>$GOROOT/lib/time/zoneinfo.zip</code>.
+</p>
+<p>
+The new function <a href="/pkg/time/#LoadLocationFromTZData"><code>LoadLocationFromTZData</code></a>
+allows conversion of IANA time zone file data to a <a href="/pkg/time/#Location"><code>Location</code></a>.
+</p>
+</dl>
+
+<dl id="unicode"><dt><a href="/pkg/unicode/">unicode</a></dt>
+<dd>
+<p>
+The <a href="/pkg/unicode/"><code>unicode</code></a> package and associated
+support throughout the system has been upgraded from Unicode 9.0 to
+<a href="http://www.unicode.org/versions/Unicode10.0.0/">Unicode 10.0</a>,
+which adds 8,518 new characters, including four new scripts, one new property,
+a Bitcoin currency symbol, and 56 new emoji.
+</p>
+</dl>
diff --git a/_content/doc/go1.11.html b/_content/doc/go1.11.html
new file mode 100644
index 0000000..fad1e0d
--- /dev/null
+++ b/_content/doc/go1.11.html
@@ -0,0 +1,933 @@
+<!--{
+ "Title": "Go 1.11 Release Notes",
+ "Template": true
+}-->
+
+<!--
+NOTE: In this document and others in this directory, the convention is to
+set fixed-width phrases with non-fixed-width spaces, as in
+<code>hello</code> <code>world</code>.
+Do not send CLs removing the interior tags from such phrases.
+-->
+
+<style>
+ main ul li { margin: 0.5em 0; }
+</style>
+
+<h2 id="introduction">Introduction to Go 1.11</h2>
+
+<p>
+ The latest Go release, version 1.11, arrives six months after <a href="go1.10">Go 1.10</a>.
+ Most of its changes are in the implementation of the toolchain, runtime, and libraries.
+ As always, the release maintains the Go 1 <a href="/doc/go1compat.html">promise of compatibility</a>.
+ We expect almost all Go programs to continue to compile and run as before.
+</p>
+
+<h2 id="language">Changes to the language</h2>
+
+<p>
+ There are no changes to the language specification.
+</p>
+
+<h2 id="ports">Ports</h2>
+
+<p> <!-- CL 94255, CL 115038, etc -->
+ As <a href="go1.10#ports">announced in the Go 1.10 release notes</a>, Go 1.11 now requires
+ OpenBSD 6.2 or later, macOS 10.10 Yosemite or later, or Windows 7 or later;
+ support for previous versions of these operating systems has been removed.
+</p>
+
+<p> <!-- CL 121657 -->
+ Go 1.11 supports the upcoming OpenBSD 6.4 release. Due to changes in
+ the OpenBSD kernel, older versions of Go will not work on OpenBSD 6.4.
+</p>
+
+<p>
+ There are <a href="https://golang.org/issue/25206">known issues</a> with NetBSD on i386 hardware.
+</p>
+
+<p><!-- CL 107935 -->
+ The race detector is now supported on <code>linux/ppc64le</code>
+ and, to a lesser extent, on <code>netbsd/amd64</code>. The NetBSD race detector support
+ has <a href="https://golang.org/issue/26403">known issues</a>.
+</p>
+
+<p><!-- CL 109255 -->
+ The memory sanitizer (<code>-msan</code>) is now supported on <code>linux/arm64</code>.
+</p>
+
+<p><!-- CL 93875 -->
+ The build modes <code>c-shared</code> and <code>c-archive</code> are now supported on
+ <code>freebsd/amd64</code>.
+</p>
+
+<p id="mips"><!-- CL 108475 -->
+ On 64-bit MIPS systems, the new environment variable settings
+ <code>GOMIPS64=hardfloat</code> (the default) and
+ <code>GOMIPS64=softfloat</code> select whether to use
+ hardware instructions or software emulation for floating-point computations.
+ For 32-bit systems, the environment variable is still <code>GOMIPS</code>,
+ as <a href="go1.10#mips">added in Go 1.10</a>.
+</p>
+
+<p><!-- CL 107475 -->
+ On soft-float ARM systems (<code>GOARM=5</code>), Go now uses a more
+ efficient software floating point interface. This is transparent to
+ Go code, but ARM assembly that uses floating-point instructions not
+ guarded on GOARM will break and must be ported to
+ the <a href="https://golang.org/cl/107475">new interface</a>.
+</p>
+
+<p><!-- CL 94076 -->
+ Go 1.11 on ARMv7 no longer requires a Linux kernel configured
+ with <code>KUSER_HELPERS</code>. This setting is enabled in default
+ kernel configurations, but is sometimes disabled in stripped-down
+ configurations.
+</p>
+
+<h3 id="wasm">WebAssembly</h3>
+<p>
+ Go 1.11 adds an experimental port to <a href="https://webassembly.org">WebAssembly</a>
+ (<code>js/wasm</code>).
+</p>
+<p>
+ Go programs currently compile to one WebAssembly module that
+ includes the Go runtime for goroutine scheduling, garbage
+ collection, maps, etc.
+ As a result, the resulting size is at minimum around
+ 2 MB, or 500 KB compressed. Go programs can call into JavaScript
+ using the new experimental
+ <a href="/pkg/syscall/js/"><code>syscall/js</code></a> package.
+ Binary size and interop with other languages has not yet been a
+ priority but may be addressed in future releases.
+</p>
+<p>
+ As a result of the addition of the new <code>GOOS</code> value
+ "<code>js</code>" and <code>GOARCH</code> value "<code>wasm</code>",
+ Go files named <code>*_js.go</code> or <code>*_wasm.go</code> will
+ now be <a href="/pkg/go/build/#hdr-Build_Constraints">ignored by Go
+ tools</a> except when those GOOS/GOARCH values are being used.
+ If you have existing filenames matching those patterns, you will need to rename them.
+</p>
+<p>
+ More information can be found on the
+ <a href="https://golang.org/wiki/WebAssembly">WebAssembly wiki page</a>.
+</p>
+
+<h3 id="riscv">RISC-V GOARCH values reserved</h3>
+<p><!-- CL 106256 -->
+ The main Go compiler does not yet support the RISC-V architecture <!-- is gonna change everything -->
+ but we've reserved the <code>GOARCH</code> values
+ "<code>riscv</code>" and "<code>riscv64</code>", as used by Gccgo,
+ which does support RISC-V. This means that Go files
+ named <code>*_riscv.go</code> will now also
+ be <a href="/pkg/go/build/#hdr-Build_Constraints">ignored by Go
+ tools</a> except when those GOOS/GOARCH values are being used.
+</p>
+
+<h2 id="tools">Tools</h2>
+
+<h3 id="modules">Modules, package versioning, and dependency management</h3>
+<p>
+ Go 1.11 adds preliminary support for a <a href="/cmd/go/#hdr-Modules__module_versions__and_more">new concept called “modules,”</a>
+ an alternative to GOPATH with integrated support for versioning and
+ package distribution.
+ Using modules, developers are no longer confined to working inside GOPATH,
+ version dependency information is explicit yet lightweight,
+ and builds are more reliable and reproducible.
+</p>
+
+<p>
+ Module support is considered experimental.
+ Details are likely to change in response to feedback from Go 1.11 users,
+ and we have more tools planned.
+ Although the details of module support may change, projects that convert
+ to modules using Go 1.11 will continue to work with Go 1.12 and later.
+ If you encounter bugs using modules,
+ please <a href="https://golang.org/issue/new">file issues</a>
+ so we can fix them. For more information, see the
+ <a href="/cmd/go#hdr-Modules__module_versions__and_more"><code>go</code> command documentation</a>.
+</p>
+
+<h3 id="importpath">Import path restriction</h3>
+
+<p>
+ Because Go module support assigns special meaning to the
+ <code>@</code> symbol in command line operations,
+ the <code>go</code> command now disallows the use of
+ import paths containing <code>@</code> symbols.
+ Such import paths were never allowed by <code>go</code> <code>get</code>,
+ so this restriction can only affect users building
+ custom GOPATH trees by other means.
+</p>
+
+<h3 id="gopackages">Package loading</h3>
+
+<p>
+ The new package
+ <a href="https://godoc.org/golang.org/x/tools/go/packages"><code>golang.org/x/tools/go/packages</code></a>
+ provides a simple API for locating and loading packages of Go source code.
+ Although not yet part of the standard library, for many tasks it
+ effectively replaces the <a href="/pkg/go/build"><code>go/build</code></a>
+ package, whose API is unable to fully support modules.
+ Because it runs an external query command such as
+ <a href="/cmd/go/#hdr-List_packages"><code>go list</code></a>
+ to obtain information about Go packages, it enables the construction of
+ analysis tools that work equally well with alternative build systems
+ such as <a href="https://bazel.build">Bazel</a>
+ and <a href="https://buckbuild.com">Buck</a>.
+</p>
+
+<h3 id="gocache">Build cache requirement</h3>
+
+<p>
+ Go 1.11 will be the last release to support setting the environment
+ variable <code>GOCACHE=off</code> to disable the
+ <a href="/cmd/go/#hdr-Build_and_test_caching">build cache</a>,
+ introduced in Go 1.10.
+ Starting in Go 1.12, the build cache will be required,
+ as a step toward eliminating <code>$GOPATH/pkg</code>.
+ The module and package loading support described above
+ already require that the build cache be enabled.
+ If you have disabled the build cache to avoid problems you encountered,
+ please <a href="https://golang.org/issue/new">file an issue</a> to let us know about them.
+</p>
+
+<h3 id="compiler">Compiler toolchain</h3>
+
+<p><!-- CL 109918 -->
+ More functions are now eligible for inlining by default, including
+ functions that call <code>panic</code>.
+</p>
+
+<p><!-- CL 97375 -->
+ The compiler toolchain now supports column information
+ in <a href="/cmd/compile/#hdr-Compiler_Directives">line
+ directives</a>.
+</p>
+
+<p><!-- CL 106797 -->
+ A new package export data format has been introduced.
+ This should be transparent to end users, except for speeding up
+ build times for large Go projects.
+ If it does cause problems, it can be turned off again by
+ passing <code>-gcflags=all=-iexport=false</code> to
+ the <code>go</code> tool when building a binary.
+</p>
+
+<p><!-- CL 100459 -->
+ The compiler now rejects unused variables declared in a type switch
+ guard, such as <code>x</code> in the following example:
+</p>
+<pre>
+func f(v interface{}) {
+ switch x := v.(type) {
+ }
+}
+</pre>
+<p>
+ This was already rejected by both <code>gccgo</code>
+ and <a href="/pkg/go/types/">go/types</a>.
+</p>
+
+<h3 id="assembler">Assembler</h3>
+
+<p><!-- CL 113315 -->
+ The assembler for <code>amd64</code> now accepts AVX512 instructions.
+</p>
+
+<h3 id="debugging">Debugging</h3>
+
+<p><!-- CL 100738, CL 93664 -->
+ The compiler now produces significantly more accurate debug
+ information for optimized binaries, including variable location
+ information, line numbers, and breakpoint locations.
+
+ This should make it possible to debug binaries
+ compiled <em>without</em> <code>-N</code> <code>-l</code>.
+
+ There are still limitations to the quality of the debug information,
+ some of which are fundamental, and some of which will continue to
+ improve with future releases.
+</p>
+
+<p><!-- CL 118276 -->
+ DWARF sections are now compressed by default because of the expanded
+ and more accurate debug information produced by the compiler.
+
+ This is transparent to most ELF tools (such as debuggers on Linux
+ and *BSD) and is supported by the Delve debugger on all platforms,
+ but has limited support in the native tools on macOS and Windows.
+
+ To disable DWARF compression,
+ pass <code>-ldflags=-compressdwarf=false</code> to
+ the <code>go</code> tool when building a binary.
+</p>
+
+<p><!-- CL 109699 -->
+ Go 1.11 adds experimental support for calling Go functions from
+ within a debugger.
+
+ This is useful, for example, to call <code>String</code> methods
+ when paused at a breakpoint.
+
+ This is currently only supported by Delve (version 1.1.0 and up).
+</p>
+
+<h3 id="test">Test</h3>
+
+<p>
+ Since Go 1.10, the <code>go</code> <code>test</code> command runs
+ <code>go</code> <code>vet</code> on the package being tested,
+ to identify problems before running the test. Since <code>vet</code>
+ typechecks the code with <a href="/pkg/go/types/">go/types</a>
+ before running, tests that do not typecheck will now fail.
+
+ In particular, tests that contain an unused variable inside a
+ closure compiled with Go 1.10, because the Go compiler incorrectly
+ accepted them (<a href="https://golang.org/issues/3059">Issue #3059</a>),
+ but will now fail, since <code>go/types</code> correctly reports an
+ "unused variable" error in this case.
+</p>
+
+<p><!-- CL 102696 -->
+ The <code>-memprofile</code> flag
+ to <code>go</code> <code>test</code> now defaults to the
+ "allocs" profile, which records the total bytes allocated since the
+ test began (including garbage-collected bytes).
+</p>
+
+<h3 id="vet">Vet</h3>
+
+<p><!-- CL 108555 -->
+ The <a href="/cmd/vet/"><code>go</code> <code>vet</code></a>
+ command now reports a fatal error when the package under analysis
+ does not typecheck. Previously, a type checking error simply caused
+ a warning to be printed, and <code>vet</code> to exit with status 1.
+</p>
+
+<p><!-- CL 108559 -->
+ Additionally, <a href="/cmd/vet"><code>go</code> <code>vet</code></a>
+ has become more robust when format-checking <code>printf</code> wrappers.
+ Vet now detects the mistake in this example:
+</p>
+
+<pre>
+func wrapper(s string, args ...interface{}) {
+ fmt.Printf(s, args...)
+}
+
+func main() {
+ wrapper("%s", 42)
+}
+</pre>
+
+<h3 id="trace">Trace</h3>
+
+<p><!-- CL 63274 -->
+ With the new <code>runtime/trace</code>
+ package's <a href="/pkg/runtime/trace/#hdr-User_annotation">user
+ annotation API</a>, users can record application-level information
+ in execution traces and create groups of related goroutines.
+ The <code>go</code> <code>tool</code> <code>trace</code>
+ command visualizes this information in the trace view and the new
+ user task/region analysis page.
+</p>
+
+<h3 id="cgo">Cgo</h3>
+
+<p>
+Since Go 1.10, cgo has translated some C pointer types to the Go
+type <code>uintptr</code>. These types include
+the <code>CFTypeRef</code> hierarchy in Darwin's CoreFoundation
+framework and the <code>jobject</code> hierarchy in Java's JNI
+interface. In Go 1.11, several improvements have been made to the code
+that detects these types. Code that uses these types may need some
+updating. See the <a href="go1.10.html#cgo">Go 1.10 release notes</a> for
+details. <!-- CL 126275, CL 127156, CL 122217, CL 122575, CL 123177 -->
+</p>
+
+<h3 id="go_command">Go command</h3>
+
+<p><!-- CL 126656 -->
+ The environment variable <code>GOFLAGS</code> may now be used
+ to set default flags for the <code>go</code> command.
+ This is useful in certain situations.
+ Linking can be noticeably slower on underpowered systems due to DWARF,
+ and users may want to set <code>-ldflags=-w</code> by default.
+ For modules, some users and CI systems will want vendoring always,
+ so they should set <code>-mod=vendor</code> by default.
+ For more information, see the <a href="/cmd/go/#hdr-Environment_variables"><code>go</code>
+ command documentation</a>.
+</p>
+
+<h3 id="godoc">Godoc</h3>
+
+<p>
+ Go 1.11 will be the last release to support <code>godoc</code>'s command-line interface.
+ In future releases, <code>godoc</code> will only be a web server. Users should use
+ <code>go</code> <code>doc</code> for command-line help output instead.
+</p>
+
+<p><!-- CL 85396, CL 124495 -->
+ The <code>godoc</code> web server now shows which version of Go introduced
+ new API features. The initial Go version of types, funcs, and methods are shown
+ right-aligned. For example, see <a href="/pkg/os/#UserCacheDir"><code>UserCacheDir</code></a>, with "1.11"
+ on the right side. For struct fields, inline comments are added when the struct field was
+ added in a Go version other than when the type itself was introduced.
+ For a struct field example, see
+ <a href="/pkg/net/http/httptrace/#ClientTrace.Got1xxResponse"><code>ClientTrace.Got1xxResponse</code></a>.
+</p>
+
+<h3 id="gofmt">Gofmt</h3>
+
+<p>
+ One minor detail of the default formatting of Go source code has changed.
+ When formatting expression lists with inline comments, the comments were
+ aligned according to a heuristic.
+ However, in some cases the alignment would be split up too easily, or
+ introduce too much whitespace.
+ The heuristic has been changed to behave better for human-written code.
+</p>
+
+<p>
+ Note that these kinds of minor updates to gofmt are expected from time to
+ time.
+ In general, systems that need consistent formatting of Go source code should
+ use a specific version of the <code>gofmt</code> binary.
+ See the <a href="/pkg/go/format/">go/format</a> package documentation for more
+ information.
+</p>
+
+<h3 id="run">Run</h3>
+
+<p>
+ <!-- CL 109341 -->
+ The <a href="/cmd/go/"><code>go</code> <code>run</code></a>
+ command now allows a single import path, a directory name or a
+ pattern matching a single package.
+ This allows <code>go</code> <code>run</code> <code>pkg</code> or <code>go</code> <code>run</code> <code>dir</code>, most importantly <code>go</code> <code>run</code> <code>.</code>
+</p>
+
+<h2 id="runtime">Runtime</h2>
+
+<p><!-- CL 85887 -->
+ The runtime now uses a sparse heap layout so there is no longer a
+ limit to the size of the Go heap (previously, the limit was 512GiB).
+ This also fixes rare "address space conflict" failures in mixed Go/C
+ binaries or binaries compiled with <code>-race</code>.
+</p>
+
+<p><!-- CL 108679, CL 106156 -->
+ On macOS and iOS, the runtime now uses <code>libSystem.dylib</code> instead of
+ calling the kernel directly. This should make Go binaries more
+ compatible with future versions of macOS and iOS.
+ The <a href="/pkg/syscall">syscall</a> package still makes direct
+ system calls; fixing this is planned for a future release.
+</p>
+
+<h2 id="performance">Performance</h2>
+
+<p>
+As always, the changes are so general and varied that precise
+statements about performance are difficult to make. Most programs
+should run a bit faster, due to better generated code and
+optimizations in the core library.
+</p>
+
+<p><!-- CL 74851 -->
+There were multiple performance changes to the <code>math/big</code>
+package as well as many changes across the tree specific to <code>GOARCH=arm64</code>.
+</p>
+
+<h3 id="performance-compiler">Compiler toolchain</h3>
+
+<p><!-- CL 110055 -->
+ The compiler now optimizes map clearing operations of the form:
+</p>
+<pre>
+for k := range m {
+ delete(m, k)
+}
+</pre>
+
+<p><!-- CL 109517 -->
+ The compiler now optimizes slice extension of the form
+ <code>append(s,</code> <code>make([]T,</code> <code>n)...)</code>.
+</p>
+
+<p><!-- CL 100277, CL 105635, CL 109776 -->
+ The compiler now performs significantly more aggressive bounds-check
+ and branch elimination. Notably, it now recognizes transitive
+ relations, so if <code>i<j</code> and <code>j<len(s)</code>,
+ it can use these facts to eliminate the bounds check
+ for <code>s[i]</code>. It also understands simple arithmetic such
+ as <code>s[i-10]</code> and can recognize more inductive cases in
+ loops. Furthermore, the compiler now uses bounds information to more
+ aggressively optimize shift operations.
+</p>
+
+<h2 id="library">Core library</h2>
+
+<p>
+ All of the changes to the standard library are minor.
+</p>
+
+<h3 id="minor_library_changes">Minor changes to the library</h3>
+
+<p>
+ As always, there are various minor changes and updates to the library,
+ made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
+ in mind.
+</p>
+
+<!-- CL 115095: https://golang.org/cl/115095: yes (`go test pkg` now always builds pkg even if there are no test files): cmd/go: output coverage report even if there are no test files -->
+<!-- CL 110395: https://golang.org/cl/110395: cmd/go, cmd/compile: use Windows response files to avoid arg length limits -->
+<!-- CL 112436: https://golang.org/cl/112436: cmd/pprof: add readline support similar to upstream -->
+
+
+<dl id="crypto"><dt><a href="/pkg/crypto/">crypto</a></dt>
+ <dd>
+ <p><!-- CL 64451 -->
+ Certain crypto operations, including
+ <a href="/pkg/crypto/ecdsa/#Sign"><code>ecdsa.Sign</code></a>,
+ <a href="/pkg/crypto/rsa/#EncryptPKCS1v15"><code>rsa.EncryptPKCS1v15</code></a> and
+ <a href="/pkg/crypto/rsa/#GenerateKey"><code>rsa.GenerateKey</code></a>,
+ now randomly read an extra byte of randomness to ensure tests don't rely on internal behavior.
+ </p>
+
+</dl><!-- crypto -->
+
+<dl id="crypto/cipher"><dt><a href="/pkg/crypto/cipher/">crypto/cipher</a></dt>
+ <dd>
+ <p><!-- CL 48510, CL 116435 -->
+ The new function <a href="/pkg/crypto/cipher/#NewGCMWithTagSize"><code>NewGCMWithTagSize</code></a>
+ implements Galois Counter Mode with non-standard tag lengths for compatibility with existing cryptosystems.
+ </p>
+
+</dl><!-- crypto/cipher -->
+
+<dl id="crypto/rsa"><dt><a href="/pkg/crypto/rsa/">crypto/rsa</a></dt>
+ <dd>
+ <p><!-- CL 103876 -->
+ <a href="/pkg/crypto/rsa/#PublicKey"><code>PublicKey</code></a> now implements a
+ <a href="/pkg/crypto/rsa/#PublicKey.Size"><code>Size</code></a> method that
+ returns the modulus size in bytes.
+ </p>
+
+</dl><!-- crypto/rsa -->
+
+<dl id="crypto/tls"><dt><a href="/pkg/crypto/tls/">crypto/tls</a></dt>
+ <dd>
+ <p><!-- CL 85115 -->
+ <a href="/pkg/crypto/tls/#ConnectionState"><code>ConnectionState</code></a>'s new
+ <a href="/pkg/crypto/tls/#ConnectionState.ExportKeyingMaterial"><code>ExportKeyingMaterial</code></a>
+ method allows exporting keying material bound to the
+ connection according to RFC 5705.
+ </p>
+
+</dl><!-- crypto/tls -->
+
+<dl id="crypto/x509"><dt><a href="/pkg/crypto/x509/">crypto/x509</a></dt>
+ <dd>
+ <p><!-- CL 123355, CL 123695 -->
+ The deprecated, legacy behavior of treating the <code>CommonName</code> field as
+ a hostname when no Subject Alternative Names are present is now disabled when the CN is not a
+ valid hostname.
+ The <code>CommonName</code> can be completely ignored by adding the experimental value
+ <code>x509ignoreCN=1</code> to the <code>GODEBUG</code> environment variable.
+ When the CN is ignored, certificates without SANs validate under chains with name constraints
+ instead of returning <code>NameConstraintsWithoutSANs</code>.
+ </p>
+
+ <p><!-- CL 113475 -->
+ Extended key usage restrictions are again checked only if they appear in the <code>KeyUsages</code>
+ field of <a href="/pkg/crypto/x509/#VerifyOptions"><code>VerifyOptions</code></a>, instead of always being checked.
+ This matches the behavior of Go 1.9 and earlier.
+ </p>
+
+ <p><!-- CL 102699 -->
+ The value returned by <a href="/pkg/crypto/x509/#SystemCertPool"><code>SystemCertPool</code></a>
+ is now cached and might not reflect system changes between invocations.
+ </p>
+
+</dl><!-- crypto/x509 -->
+
+<dl id="debug/elf"><dt><a href="/pkg/debug/elf/">debug/elf</a></dt>
+ <dd>
+ <p><!-- CL 112115 -->
+ More <a href="/pkg/debug/elf/#ELFOSABI_NONE"><code>ELFOSABI</code></a>
+ and <a href="/pkg/debug/elf/#EM_NONE"><code>EM</code></a>
+ constants have been added.
+ </p>
+
+</dl><!-- debug/elf -->
+
+<dl id="encoding/asn1"><dt><a href="/pkg/encoding/asn1/">encoding/asn1</a></dt>
+ <dd>
+ <p><!-- CL 110561 -->
+ <code>Marshal</code> and <code><a href="/pkg/encoding/asn1/#Unmarshal">Unmarshal</a></code>
+ now support "private" class annotations for fields.
+ </p>
+
+</dl><!-- encoding/asn1 -->
+
+<dl id="encoding/base32"><dt><a href="/pkg/encoding/base32/">encoding/base32</a></dt>
+ <dd>
+ <p><!-- CL 112516 -->
+ The decoder now consistently
+ returns <code>io.ErrUnexpectedEOF</code> for an incomplete
+ chunk. Previously it would return <code>io.EOF</code> in some
+ cases.
+ </p>
+
+</dl><!-- encoding/base32 -->
+
+<dl id="encoding/csv"><dt><a href="/pkg/encoding/csv/">encoding/csv</a></dt>
+ <dd>
+ <p><!-- CL 99696 -->
+ The <code>Reader</code> now rejects attempts to set
+ the <a href="/pkg/encoding/csv/#Reader.Comma"><code>Comma</code></a>
+ field to a double-quote character, as double-quote characters
+ already have a special meaning in CSV.
+ </p>
+
+</dl><!-- encoding/csv -->
+
+<!-- CL 100235 was reverted -->
+
+<dl id="html/template"><dt><a href="/pkg/html/template/">html/template</a></dt>
+ <dd>
+ <p><!-- CL 121815 -->
+ The package has changed its behavior when a typed interface
+ value is passed to an implicit escaper function. Previously such
+ a value was written out as (an escaped form)
+ of <code><nil></code>. Now such values are ignored, just
+ as an untyped <code>nil</code> value is (and always has been)
+ ignored.
+ </p>
+
+</dl><!-- html/template -->
+
+<dl id="image/gif"><dt><a href="/pkg/image/gif/">image/gif</a></dt>
+ <dd>
+ <p><!-- CL 93076 -->
+ Non-looping animated GIFs are now supported. They are denoted by having a
+ <code><a href="/pkg/image/gif/#GIF.LoopCount">LoopCount</a></code> of -1.
+ </p>
+
+</dl><!-- image/gif -->
+
+<dl id="io/ioutil"><dt><a href="/pkg/io/ioutil/">io/ioutil</a></dt>
+ <dd>
+ <p><!-- CL 105675 -->
+ The <code><a href="/pkg/io/ioutil/#TempFile">TempFile</a></code>
+ function now supports specifying where the random characters in
+ the filename are placed. If the <code>prefix</code> argument
+ includes a "<code>*</code>", the random string replaces the
+ "<code>*</code>". For example, a <code>prefix</code> argument of "<code>myname.*.bat</code>" will
+ result in a random filename such as
+ "<code>myname.123456.bat</code>". If no "<code>*</code>" is
+ included the old behavior is retained, and the random digits are
+ appended to the end.
+ </p>
+
+</dl><!-- io/ioutil -->
+
+<dl id="math/big"><dt><a href="/pkg/math/big/">math/big</a></dt>
+ <dd>
+
+ <p><!-- CL 108996 -->
+ <a href="/pkg/math/big/#Int.ModInverse"><code>ModInverse</code></a> now returns nil when g and n are not relatively prime. The result was previously undefined.
+ </p>
+
+</dl><!-- math/big -->
+
+<dl id="mime/multipart"><dt><a href="/pkg/mime/multipart/">mime/multipart</a></dt>
+ <dd>
+ <p><!-- CL 121055 -->
+ The handling of form-data with missing/empty file names has been
+ restored to the behavior in Go 1.9: in the
+ <a href="/pkg/mime/multipart/#Form"><code>Form</code></a> for
+ the form-data part the value is available in
+ the <code>Value</code> field rather than the <code>File</code>
+ field. In Go releases 1.10 through 1.10.3 a form-data part with
+ a missing/empty file name and a non-empty "Content-Type" field
+ was stored in the <code>File</code> field. This change was a
+ mistake in 1.10 and has been reverted to the 1.9 behavior.
+ </p>
+
+</dl><!-- mime/multipart -->
+
+<dl id="mime/quotedprintable"><dt><a href="/pkg/mime/quotedprintable/">mime/quotedprintable</a></dt>
+ <dd>
+ <p><!-- CL 121095 -->
+ To support invalid input found in the wild, the package now
+ permits non-ASCII bytes but does not validate their encoding.
+ </p>
+
+</dl><!-- mime/quotedprintable -->
+
+<dl id="net"><dt><a href="/pkg/net/">net</a></dt>
+ <dd>
+ <p><!-- CL 72810 -->
+ The new <a href="/pkg/net/#ListenConfig"><code>ListenConfig</code></a> type and the new
+ <a href="/pkg/net/#Dialer.Control"><code>Dialer.Control</code></a> field permit
+ setting socket options before accepting and creating connections, respectively.
+ </p>
+
+ <p><!-- CL 76391 -->
+ The <a href="/pkg/syscall/#RawConn"><code>syscall.RawConn</code></a> <code>Read</code>
+ and <code>Write</code> methods now work correctly on Windows.
+ </p>
+
+ <p><!-- CL 107715 -->
+ The <code>net</code> package now automatically uses the
+ <a href="http://man7.org/linux/man-pages/man2/splice.2.html"><code>splice</code> system call</a>
+ on Linux when copying data between TCP connections in
+ <a href="/pkg/net/#TCPConn.ReadFrom"><code>TCPConn.ReadFrom</code></a>, as called by
+ <a href="/pkg/io/#Copy"><code>io.Copy</code></a>. The result is faster, more efficient TCP proxying.
+ </p>
+
+ <p><!-- CL 108297 -->
+ The <a href="/pkg/net/#TCPConn.File"><code>TCPConn.File</code></a>,
+ <a href="/pkg/net/#UDPConn.File"><code>UDPConn.File</code></a>,
+ <a href="/pkg/net/#UnixCOnn.File"><code>UnixConn.File</code></a>,
+ and <a href="/pkg/net/#IPConn.File"><code>IPConn.File</code></a>
+ methods no longer put the returned <code>*os.File</code> into
+ blocking mode.
+ </p>
+
+</dl><!-- net -->
+
+<dl id="net/http"><dt><a href="/pkg/net/http/">net/http</a></dt>
+ <dd>
+ <p><!-- CL 71272 -->
+ The <a href="/pkg/net/http/#Transport"><code>Transport</code></a> type has a
+ new <a href="/pkg/net/http/#Transport.MaxConnsPerHost"><code>MaxConnsPerHost</code></a>
+ option that permits limiting the maximum number of connections
+ per host.
+ </p>
+
+ <p><!-- CL 79919 -->
+ The <a href="/pkg/net/http/#Cookie"><code>Cookie</code></a> type has a new
+ <a href="/pkg/net/http/#Cookie.SameSite"><code>SameSite</code></a> field
+ (of new type also named
+ <a href="/pkg/net/http/#SameSite"><code>SameSite</code></a>) to represent the new cookie attribute recently supported by most browsers.
+ The <code>net/http</code>'s <code>Transport</code> does not use the <code>SameSite</code>
+ attribute itself, but the package supports parsing and serializing the
+ attribute for browsers to use.
+ </p>
+
+ <p><!-- CL 81778 -->
+ It is no longer allowed to reuse a <a href="/pkg/net/http/#Server"><code>Server</code></a>
+ after a call to
+ <a href="/pkg/net/http/#Server.Shutdown"><code>Shutdown</code></a> or
+ <a href="/pkg/net/http/#Server.Close"><code>Close</code></a>. It was never officially supported
+ in the past and had often surprising behavior. Now, all future calls to the server's <code>Serve</code>
+ methods will return errors after a shutdown or close.
+ </p>
+
+ <!-- CL 89275 was reverted before Go 1.11 -->
+
+ <p><!-- CL 93296 -->
+ The constant <code>StatusMisdirectedRequest</code> is now defined for HTTP status code 421.
+ </p>
+
+ <p><!-- CL 123875 -->
+ The HTTP server will no longer cancel contexts or send on
+ <a href="/pkg/net/http/#CloseNotifier"><code>CloseNotifier</code></a>
+ channels upon receiving pipelined HTTP/1.1 requests. Browsers do
+ not use HTTP pipelining, but some clients (such as
+ Debian's <code>apt</code>) may be configured to do so.
+ </p>
+
+ <p><!-- CL 115255 -->
+ <a href="/pkg/net/http/#ProxyFromEnvironment"><code>ProxyFromEnvironment</code></a>, which is used by the
+ <a href="/pkg/net/http/#DefaultTransport"><code>DefaultTransport</code></a>, now
+ supports CIDR notation and ports in the <code>NO_PROXY</code> environment variable.
+ </p>
+
+</dl><!-- net/http -->
+
+<dl id="net/http/httputil"><dt><a href="/pkg/net/http/httputil/">net/http/httputil</a></dt>
+ <dd>
+ <p><!-- CL 77410 -->
+ The
+ <a href="/pkg/net/http/httputil/#ReverseProxy"><code>ReverseProxy</code></a>
+ has a new
+ <a href="/pkg/net/http/httputil/#ReverseProxy.ErrorHandler"><code>ErrorHandler</code></a>
+ option to permit changing how errors are handled.
+ </p>
+
+ <p><!-- CL 115135 -->
+ The <code>ReverseProxy</code> now also passes
+ "<code>TE:</code> <code>trailers</code>" request headers
+ through to the backend, as required by the gRPC protocol.
+ </p>
+
+</dl><!-- net/http/httputil -->
+
+<dl id="os"><dt><a href="/pkg/os/">os</a></dt>
+ <dd>
+ <p><!-- CL 78835 -->
+ The new <a href="/pkg/os/#UserCacheDir"><code>UserCacheDir</code></a> function
+ returns the default root directory to use for user-specific cached data.
+ </p>
+
+ <p><!-- CL 94856 -->
+ The new <a href="/pkg/os/#ModeIrregular"><code>ModeIrregular</code></a>
+ is a <a href="/pkg/os/#FileMode"><code>FileMode</code></a> bit to represent
+ that a file is not a regular file, but nothing else is known about it, or that
+ it's not a socket, device, named pipe, symlink, or other file type for which
+ Go has a defined mode bit.
+ </p>
+
+ <p><!-- CL 99337 -->
+ <a href="/pkg/os/#Symlink"><code>Symlink</code></a> now works
+ for unprivileged users on Windows 10 on machines with Developer
+ Mode enabled.
+ </p>
+
+ <p><!-- CL 100077 -->
+ When a non-blocking descriptor is passed
+ to <a href="/pkg/os#NewFile"><code>NewFile</code></a>, the
+ resulting <code>*File</code> will be kept in non-blocking
+ mode. This means that I/O for that <code>*File</code> will use
+ the runtime poller rather than a separate thread, and that
+ the <a href="/pkg/os/#File.SetDeadline"><code>SetDeadline</code></a>
+ methods will work.
+ </p>
+
+</dl><!-- os -->
+
+<dl id="os/signal"><dt><a href="/pkg/os/signal/">os/signal</a></dt>
+ <dd>
+ <p><!-- CL 108376 -->
+ The new <a href="/pkg/os/signal/#Ignored"><code>Ignored</code></a> function reports
+ whether a signal is currently ignored.
+ </p>
+
+</dl><!-- os/signal -->
+
+<dl id="os/user"><dt><a href="/pkg/os/user/">os/user</a></dt>
+ <dd>
+ <p><!-- CL 92456 -->
+ The <code>os/user</code> package can now be built in pure Go
+ mode using the build tag "<code>osusergo</code>",
+ independent of the use of the environment
+ variable <code>CGO_ENABLED=0</code>. Previously the only way to use
+ the package's pure Go implementation was to disable <code>cgo</code>
+ support across the entire program.
+ </p>
+
+</dl><!-- os/user -->
+
+<!-- CL 101715 was reverted -->
+
+<dl id="pkg-runtime"><dt id="runtime-again"><a href="/pkg/runtime/">runtime</a></dt>
+ <dd>
+
+ <p><!-- CL 70993 -->
+ Setting the <code>GODEBUG=tracebackancestors=<em>N</em></code>
+ environment variable now extends tracebacks with the stacks at
+ which goroutines were created, where <em>N</em> limits the
+ number of ancestor goroutines to report.
+ </p>
+
+</dl><!-- runtime -->
+
+<dl id="runtime/pprof"><dt><a href="/pkg/runtime/pprof/">runtime/pprof</a></dt>
+ <dd>
+ <p><!-- CL 102696 -->
+ This release adds a new "allocs" profile type that profiles
+ total number of bytes allocated since the program began
+ (including garbage-collected bytes). This is identical to the
+ existing "heap" profile viewed in <code>-alloc_space</code> mode.
+ Now <code>go test -memprofile=...</code> reports an "allocs" profile
+ instead of "heap" profile.
+ </p>
+
+</dl><!-- runtime/pprof -->
+
+<dl id="sync"><dt><a href="/pkg/sync/">sync</a></dt>
+ <dd>
+ <p><!-- CL 87095 -->
+ The mutex profile now includes reader/writer contention
+ for <a href="/pkg/sync/#RWMutex"><code>RWMutex</code></a>.
+ Writer/writer contention was already included in the mutex
+ profile.
+ </p>
+
+</dl><!-- sync -->
+
+<dl id="syscall"><dt><a href="/pkg/syscall/">syscall</a></dt>
+ <dd>
+ <p><!-- CL 106275 -->
+ On Windows, several fields were changed from <code>uintptr</code> to a new
+ <a href="/pkg/syscall/?GOOS=windows&GOARCH=amd64#Pointer"><code>Pointer</code></a>
+ type to avoid problems with Go's garbage collector. The same change was made
+ to the <a href="https://godoc.org/golang.org/x/sys/windows"><code>golang.org/x/sys/windows</code></a>
+ package. For any code affected, users should first migrate away from the <code>syscall</code>
+ package to the <code>golang.org/x/sys/windows</code> package, and then change
+ to using the <code>Pointer</code>, while obeying the
+ <a href="/pkg/unsafe/#Pointer"><code>unsafe.Pointer</code> conversion rules</a>.
+ </p>
+
+ <p><!-- CL 118658 -->
+ On Linux, the <code>flags</code> parameter to
+ <a href="/pkg/syscall/?GOOS=linux&GOARCH=amd64#Faccessat"><code>Faccessat</code></a>
+ is now implemented just as in glibc. In earlier Go releases the
+ flags parameter was ignored.
+ </p>
+
+ <p><!-- CL 118658 -->
+ On Linux, the <code>flags</code> parameter to
+ <a href="/pkg/syscall/?GOOS=linux&GOARCH=amd64#Fchmodat"><code>Fchmodat</code></a>
+ is now validated. Linux's <code>fchmodat</code> doesn't support the <code>flags</code> parameter
+ so we now mimic glibc's behavior and return an error if it's non-zero.
+ </p>
+
+</dl><!-- syscall -->
+
+<dl id="text/scanner"><dt><a href="/pkg/text/scanner/">text/scanner</a></dt>
+ <dd>
+ <p><!-- CL 112037 -->
+ The <a href="/pkg/text/scanner/#Scanner.Scan"><code>Scanner.Scan</code></a> method now returns
+ the <a href="/pkg/text/scanner/#RawString"><code>RawString</code></a> token
+ instead of <a href="/pkg/text/scanner/#String"><code>String</code></a>
+ for raw string literals.
+ </p>
+
+</dl><!-- text/scanner -->
+
+<dl id="text/template"><dt><a href="/pkg/text/template/">text/template</a></dt>
+ <dd>
+ <p><!-- CL 84480 -->
+ Modifying template variables via assignments is now permitted via the <code>=</code> token:
+ </p>
+ <pre>
+ {{"{{"}} $v := "init" {{"}}"}}
+ {{"{{"}} if true {{"}}"}}
+ {{"{{"}} $v = "changed" {{"}}"}}
+ {{"{{"}} end {{"}}"}}
+ v: {{"{{"}} $v {{"}}"}} {{"{{"}}/* "changed" */{{"}}"}}</pre>
+
+ <p><!-- CL 95215 -->
+ In previous versions untyped <code>nil</code> values passed to
+ template functions were ignored. They are now passed as normal
+ arguments.
+ </p>
+
+</dl><!-- text/template -->
+
+<dl id="time"><dt><a href="/pkg/time/">time</a></dt>
+ <dd>
+ <p><!-- CL 98157 -->
+ Parsing of timezones denoted by sign and offset is now
+ supported. In previous versions, numeric timezone names
+ (such as <code>+03</code>) were not considered valid, and only
+ three-letter abbreviations (such as <code>MST</code>) were accepted
+ when expecting a timezone name.
+ </p>
+</dl><!-- time -->
diff --git a/_content/doc/go1.12.html b/_content/doc/go1.12.html
new file mode 100644
index 0000000..c3181e0
--- /dev/null
+++ b/_content/doc/go1.12.html
@@ -0,0 +1,948 @@
+<!--{
+ "Title": "Go 1.12 Release Notes",
+ "Template": true
+}-->
+
+<!--
+NOTE: In this document and others in this directory, the convention is to
+set fixed-width phrases with non-fixed-width spaces, as in
+<code>hello</code> <code>world</code>.
+Do not send CLs removing the interior tags from such phrases.
+-->
+
+<style>
+ main ul li { margin: 0.5em 0; }
+</style>
+
+<h2 id="introduction">Introduction to Go 1.12</h2>
+
+<p>
+ The latest Go release, version 1.12, arrives six months after <a href="go1.11">Go 1.11</a>.
+ Most of its changes are in the implementation of the toolchain, runtime, and libraries.
+ As always, the release maintains the Go 1 <a href="/doc/go1compat">promise of compatibility</a>.
+ We expect almost all Go programs to continue to compile and run as before.
+</p>
+
+<h2 id="language">Changes to the language</h2>
+
+<p>
+ There are no changes to the language specification.
+</p>
+
+<h2 id="ports">Ports</h2>
+
+<p><!-- CL 138675 -->
+ The race detector is now supported on <code>linux/arm64</code>.
+</p>
+
+<p id="freebsd">
+ Go 1.12 is the last release that is supported on FreeBSD 10.x, which has
+ already reached end-of-life. Go 1.13 will require FreeBSD 11.2+ or FreeBSD
+ 12.0+.
+ FreeBSD 12.0+ requires a kernel with the COMPAT_FREEBSD11 option set (this is the default).
+</p>
+
+<p><!-- CL 146898 -->
+ cgo is now supported on <code>linux/ppc64</code>.
+</p>
+
+<p id="hurd"><!-- CL 146023 -->
+ <code>hurd</code> is now a recognized value for <code>GOOS</code>, reserved
+ for the GNU/Hurd system for use with <code>gccgo</code>.
+</p>
+
+<h3 id="windows">Windows</h3>
+
+<p>
+ Go's new <code>windows/arm</code> port supports running Go on Windows 10
+ IoT Core on 32-bit ARM chips such as the Raspberry Pi 3.
+</p>
+
+<h3 id="aix">AIX</h3>
+
+<p>
+ Go now supports AIX 7.2 and later on POWER8 architectures (<code>aix/ppc64</code>). External linking, cgo, pprof and the race detector aren't yet supported.
+</p>
+
+<h3 id="darwin">Darwin</h3>
+
+<p>
+ Go 1.12 is the last release that will run on macOS 10.10 Yosemite.
+ Go 1.13 will require macOS 10.11 El Capitan or later.
+</p>
+
+<p><!-- CL 141639 -->
+ <code>libSystem</code> is now used when making syscalls on Darwin,
+ ensuring forward-compatibility with future versions of macOS and iOS.
+ <!-- CL 153338 -->
+ The switch to <code>libSystem</code> triggered additional App Store
+ checks for private API usage. Since it is considered private,
+ <code>syscall.Getdirentries</code> now always fails with
+ <code>ENOSYS</code> on iOS.
+ Additionally, <a href="/pkg/syscall/#Setrlimit"><code>syscall.Setrlimit</code></a>
+ reports <code>invalid</code> <code>argument</code> in places where it historically
+ succeeded. These consequences are not specific to Go and users should expect
+ behavioral parity with <code>libSystem</code>'s implementation going forward.
+</p>
+
+<h2 id="tools">Tools</h2>
+
+<h3 id="vet"><code>go tool vet</code> no longer supported</h3>
+
+<p>
+ The <code>go vet</code> command has been rewritten to serve as the
+ base for a range of different source code analysis tools. See
+ the <a href="https://godoc.org/golang.org/x/tools/go/analysis">golang.org/x/tools/go/analysis</a>
+ package for details. A side-effect is that <code>go tool vet</code>
+ is no longer supported. External tools that use <code>go tool
+ vet</code> must be changed to use <code>go
+ vet</code>. Using <code>go vet</code> instead of <code>go tool
+ vet</code> should work with all supported versions of Go.
+</p>
+
+<p>
+ As part of this change, the experimental <code>-shadow</code> option
+ is no longer available with <code>go vet</code>. Checking for
+ variable shadowing may now be done using
+<pre>
+go get -u golang.org/x/tools/go/analysis/passes/shadow/cmd/shadow
+go vet -vettool=$(which shadow)
+</pre>
+</p>
+
+<h3 id="tour">Tour</h3>
+
+<p> <!-- CL 152657 -->
+The Go tour is no longer included in the main binary distribution. To
+run the tour locally, instead of running <code>go</code> <code>tool</code> <code>tour</code>,
+manually install it:
+<pre>
+go get -u golang.org/x/tour
+tour
+</pre>
+</p>
+
+<h3 id="gocache">Build cache requirement</h3>
+
+<p>
+ The <a href="/cmd/go/#hdr-Build_and_test_caching">build cache</a> is now
+ required as a step toward eliminating
+ <code>$GOPATH/pkg</code>. Setting the environment variable
+ <code>GOCACHE=off</code> will cause <code>go</code> commands that write to the
+ cache to fail.
+</p>
+
+<h3 id="binary-only">Binary-only packages</h3>
+
+<p>
+ Go 1.12 is the last release that will support binary-only packages.
+</p>
+
+<h3 id="cgo">Cgo</h3>
+
+<p>
+ Go 1.12 will translate the C type <code>EGLDisplay</code> to the Go type <code>uintptr</code>.
+ This change is similar to how Go 1.10 and newer treats Darwin's CoreFoundation
+ and Java's JNI types. See the
+ <a href="/cmd/cgo/#hdr-Special_cases">cgo documentation</a>
+ for more information.
+</p>
+
+<p><!-- CL 152657 -->
+ Mangled C names are no longer accepted in packages that use Cgo. Use the Cgo
+ names instead. For example, use the documented cgo name <code>C.char</code>
+ rather than the mangled name <code>_Ctype_char</code> that cgo generates.
+</p>
+
+<h3 id="modules">Modules</h3>
+
+<p><!-- CL 148517 -->
+ When <code>GO111MODULE</code> is set to <code>on</code>, the <code>go</code>
+ command now supports module-aware operations outside of a module directory,
+ provided that those operations do not need to resolve import paths relative to
+ the current directory or explicitly edit the <code>go.mod</code> file.
+ Commands such as <code>go</code> <code>get</code>,
+ <code>go</code> <code>list</code>, and
+ <code>go</code> <code>mod</code> <code>download</code> behave as if in a
+ module with initially-empty requirements.
+ In this mode, <code>go</code> <code>env</code> <code>GOMOD</code> reports
+ the system's null device (<code>/dev/null</code> or <code>NUL</code>).
+</p>
+
+<p><!-- CL 146382 -->
+ <code>go</code> commands that download and extract modules are now safe to
+ invoke concurrently.
+ The module cache (<code>GOPATH/pkg/mod</code>) must reside in a filesystem that
+ supports file locking.
+</p>
+
+<p><!-- CL 147282, 147281 -->
+ The <code>go</code> directive in a <code>go.mod</code> file now indicates the
+ version of the language used by the files within that module.
+ It will be set to the current release
+ (<code>go</code> <code>1.12</code>) if no existing version is
+ present.
+ If the <code>go</code> directive for a module specifies a
+ version <em>newer</em> than the toolchain in use, the <code>go</code> command
+ will attempt to build the packages regardless, and will note the mismatch only if
+ that build fails.
+</p>
+
+<p><!-- CL 147282, 147281 -->
+ This changed use of the <code>go</code> directive means that if you
+ use Go 1.12 to build a module, thus recording <code>go 1.12</code>
+ in the <code>go.mod</code> file, you will get an error when
+ attempting to build the same module with Go 1.11 through Go 1.11.3.
+ Go 1.11.4 or later will work fine, as will releases older than Go 1.11.
+ If you must use Go 1.11 through 1.11.3, you can avoid the problem by
+ setting the language version to 1.11, using the Go 1.12 go tool,
+ via <code>go mod edit -go=1.11</code>.
+</p>
+
+<p><!-- CL 152739 -->
+ When an import cannot be resolved using the active modules,
+ the <code>go</code> command will now try to use the modules mentioned in the
+ main module's <code>replace</code> directives before consulting the module
+ cache and the usual network sources.
+ If a matching replacement is found but the <code>replace</code> directive does
+ not specify a version, the <code>go</code> command uses a pseudo-version
+ derived from the zero <code>time.Time</code> (such
+ as <code>v0.0.0-00010101000000-000000000000</code>).
+</p>
+
+<h3 id="compiler">Compiler toolchain</h3>
+
+<p><!-- CL 134155, 134156 -->
+ The compiler's live variable analysis has improved. This may mean that
+ finalizers will be executed sooner in this release than in previous
+ releases. If that is a problem, consider the appropriate addition of a
+ <a href="/pkg/runtime/#KeepAlive"><code>runtime.KeepAlive</code></a> call.
+</p>
+
+<p><!-- CL 147361 -->
+ More functions are now eligible for inlining by default, including
+ functions that do nothing but call another function.
+ This extra inlining makes it additionally important to use
+ <a href="/pkg/runtime/#CallersFrames"><code>runtime.CallersFrames</code></a>
+ instead of iterating over the result of
+ <a href="/pkg/runtime/#Callers"><code>runtime.Callers</code></a> directly.
+<pre>
+// Old code which no longer works correctly (it will miss inlined call frames).
+var pcs [10]uintptr
+n := runtime.Callers(1, pcs[:])
+for _, pc := range pcs[:n] {
+ f := runtime.FuncForPC(pc)
+ if f != nil {
+ fmt.Println(f.Name())
+ }
+}
+</pre>
+<pre>
+// New code which will work correctly.
+var pcs [10]uintptr
+n := runtime.Callers(1, pcs[:])
+frames := runtime.CallersFrames(pcs[:n])
+for {
+ frame, more := frames.Next()
+ fmt.Println(frame.Function)
+ if !more {
+ break
+ }
+}
+</pre>
+</p>
+
+<p><!-- CL 153477 -->
+ Wrappers generated by the compiler to implement method expressions
+ are no longer reported
+ by <a href="/pkg/runtime/#CallersFrames"><code>runtime.CallersFrames</code></a>
+ and <a href="/pkg/runtime/#Stack"><code>runtime.Stack</code></a>. They
+ are also not printed in panic stack traces.
+
+ This change aligns the <code>gc</code> toolchain to match
+ the <code>gccgo</code> toolchain, which already elided such wrappers
+ from stack traces.
+
+ Clients of these APIs might need to adjust for the missing
+ frames. For code that must interoperate between 1.11 and 1.12
+ releases, you can replace the method expression <code>x.M</code>
+ with the function literal <code>func (...) { x.M(...) } </code>.
+</p>
+
+<p><!-- CL 144340 -->
+ The compiler now accepts a <code>-lang</code> flag to set the Go language
+ version to use. For example, <code>-lang=go1.8</code> causes the compiler to
+ emit an error if the program uses type aliases, which were added in Go 1.9.
+ Language changes made before Go 1.12 are not consistently enforced.
+</p>
+
+<p><!-- CL 147160 -->
+ The compiler toolchain now uses different conventions to call Go
+ functions and assembly functions. This should be invisible to users,
+ except for calls that simultaneously cross between Go and
+ assembly <em>and</em> cross a package boundary. If linking results
+ in an error like "relocation target not defined for ABIInternal (but
+ is defined for ABI0)", please refer to the
+ <a href="https://github.com/golang/proposal/blob/master/design/27539-internal-abi.md#compatibility">compatibility section</a>
+ of the ABI design document.
+</p>
+
+<p><!-- CL 145179 -->
+ There have been many improvements to the DWARF debug information
+ produced by the compiler, including improvements to argument
+ printing and variable location information.
+</p>
+
+<p><!-- CL 61511 -->
+ Go programs now also maintain stack frame pointers on <code>linux/arm64</code>
+ for the benefit of profiling tools like <code>perf</code>. The frame pointer
+ maintenance has a small run-time overhead that varies but averages around 3%.
+ To build a toolchain that does not use frame pointers, set
+ <code>GOEXPERIMENT=noframepointer</code> when running <code>make.bash</code>.
+</p>
+
+<p><!-- CL 142717 -->
+ The obsolete "safe" compiler mode (enabled by the <code>-u</code> gcflag) has been removed.
+</p>
+
+<h3 id="godoc"><code>godoc</code> and <code>go</code> <code>doc</code></h3>
+
+<p>
+ In Go 1.12, <code>godoc</code> no longer has a command-line interface and
+ is only a web server. Users should use <code>go</code> <code>doc</code>
+ for command-line help output instead. Go 1.12 is the last release that will
+ include the <code>godoc</code> webserver; in Go 1.13 it will be available
+ via <code>go</code> <code>get</code>.
+</p>
+
+<p><!-- CL 141977 -->
+ <code>go</code> <code>doc</code> now supports the <code>-all</code> flag,
+ which will cause it to print all exported APIs and their documentation,
+ as the <code>godoc</code> command line used to do.
+</p>
+
+<p><!-- CL 140959 -->
+ <code>go</code> <code>doc</code> also now includes the <code>-src</code> flag,
+ which will show the target's source code.
+</p>
+
+<h3 id="trace">Trace</h3>
+
+<p><!-- CL 60790 -->
+ The trace tool now supports plotting mutator utilization curves,
+ including cross-references to the execution trace. These are useful
+ for analyzing the impact of the garbage collector on application
+ latency and throughput.
+</p>
+
+<h3 id="assembler">Assembler</h3>
+
+<p><!-- CL 147218 -->
+ On <code>arm64</code>, the platform register was renamed from
+ <code>R18</code> to <code>R18_PLATFORM</code> to prevent accidental
+ use, as the OS could choose to reserve this register.
+</p>
+
+<h2 id="runtime">Runtime</h2>
+
+<p><!-- CL 138959 -->
+ Go 1.12 significantly improves the performance of sweeping when a
+ large fraction of the heap remains live. This reduces allocation
+ latency immediately following a garbage collection.
+</p>
+
+<p><!-- CL 139719 -->
+ The Go runtime now releases memory back to the operating system more
+ aggressively, particularly in response to large allocations that
+ can't reuse existing heap space.
+</p>
+
+<p><!-- CL 146342, CL 146340, CL 146345, CL 146339, CL 146343, CL 146337, CL 146341, CL 146338 -->
+ The Go runtime's timer and deadline code is faster and scales better
+ with higher numbers of CPUs. In particular, this improves the
+ performance of manipulating network connection deadlines.
+</p>
+
+<p><!-- CL 135395 -->
+ On Linux, the runtime now uses <code>MADV_FREE</code> to release unused
+ memory. This is more efficient but may result in higher reported
+ RSS. The kernel will reclaim the unused data when it is needed.
+ To revert to the Go 1.11 behavior (<code>MADV_DONTNEED</code>), set the
+ environment variable <code>GODEBUG=madvdontneed=1</code>.
+</p>
+
+<p><!-- CL 149578 -->
+ Adding cpu.<em>extension</em>=off to the
+ <a href="/doc/diagnostics.html#godebug">GODEBUG</a> environment
+ variable now disables the use of optional CPU instruction
+ set extensions in the standard library and runtime. This is not
+ yet supported on Windows.
+</p>
+
+<p><!-- CL 158337 -->
+ Go 1.12 improves the accuracy of memory profiles by fixing
+ overcounting of large heap allocations.
+</p>
+
+<p><!-- CL 159717 -->
+ Tracebacks, <code>runtime.Caller</code>,
+ and <code>runtime.Callers</code> no longer include
+ compiler-generated initialization functions. Doing a traceback
+ during the initialization of a global variable will now show a
+ function named <code>PKG.init.ializers</code>.
+</p>
+
+<h2 id="library">Core library</h2>
+
+<h3 id="tls_1_3">TLS 1.3</h3>
+
+<p>
+ Go 1.12 adds opt-in support for TLS 1.3 in the <code>crypto/tls</code> package as
+ specified by <a href="https://www.rfc-editor.org/info/rfc8446">RFC 8446</a>. It can
+ be enabled by adding the value <code>tls13=1</code> to the <code>GODEBUG</code>
+ environment variable. It will be enabled by default in Go 1.13.
+</p>
+
+<p>
+ To negotiate TLS 1.3, make sure you do not set an explicit <code>MaxVersion</code> in
+ <a href="/pkg/crypto/tls/#Config"><code>Config</code></a> and run your program with
+ the environment variable <code>GODEBUG=tls13=1</code> set.
+</p>
+
+<p>
+ All TLS 1.2 features except <code>TLSUnique</code> in
+ <a href="/pkg/crypto/tls/#ConnectionState"><code>ConnectionState</code></a>
+ and renegotiation are available in TLS 1.3 and provide equivalent or
+ better security and performance. Note that even though TLS 1.3 is backwards
+ compatible with previous versions, certain legacy systems might not work
+ correctly when attempting to negotiate it. RSA certificate keys too small
+ to be secure (including 512-bit keys) will not work with TLS 1.3.
+</p>
+
+<p>
+ TLS 1.3 cipher suites are not configurable. All supported cipher suites are
+ safe, and if <code>PreferServerCipherSuites</code> is set in
+ <a href="/pkg/crypto/tls/#Config"><code>Config</code></a> the preference order
+ is based on the available hardware.
+</p>
+
+<p>
+ Early data (also called "0-RTT mode") is not currently supported as a
+ client or server. Additionally, a Go 1.12 server does not support skipping
+ unexpected early data if a client sends it. Since TLS 1.3 0-RTT mode
+ involves clients keeping state regarding which servers support 0-RTT,
+ a Go 1.12 server cannot be part of a load-balancing pool where some other
+ servers do support 0-RTT. If switching a domain from a server that supported
+ 0-RTT to a Go 1.12 server, 0-RTT would have to be disabled for at least the
+ lifetime of the issued session tickets before the switch to ensure
+ uninterrupted operation.
+</p>
+
+<p>
+ In TLS 1.3 the client is the last one to speak in the handshake, so if it causes
+ an error to occur on the server, it will be returned on the client by the first
+ <a href="/pkg/crypto/tls/#Conn.Read"><code>Read</code></a>, not by
+ <a href="/pkg/crypto/tls/#Conn.Handshake"><code>Handshake</code></a>. For
+ example, that will be the case if the server rejects the client certificate.
+ Similarly, session tickets are now post-handshake messages, so are only
+ received by the client upon its first
+ <a href="/pkg/crypto/tls/#Conn.Read"><code>Read</code></a>.
+</p>
+
+<h3 id="minor_library_changes">Minor changes to the library</h3>
+
+<p>
+ As always, there are various minor changes and updates to the library,
+ made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
+ in mind.
+</p>
+
+<!-- TODO: CL 115677: https://golang.org/cl/115677: cmd/vet: check embedded field tags too -->
+
+<dl id="bufio"><dt><a href="/pkg/bufio/">bufio</a></dt>
+ <dd>
+ <p><!-- CL 149297 -->
+ <code>Reader</code>'s <a href="/pkg/bufio/#Reader.UnreadRune"><code>UnreadRune</code></a> and
+ <a href="/pkg/bufio/#Reader.UnreadByte"><code>UnreadByte</code></a> methods will now return an error
+ if they are called after <a href="/pkg/bufio/#Reader.Peek"><code>Peek</code></a>.
+ </p>
+
+</dl><!-- bufio -->
+
+<dl id="bytes"><dt><a href="/pkg/bytes/">bytes</a></dt>
+ <dd>
+ <p><!-- CL 137855 -->
+ The new function <a href="/pkg/bytes/#ReplaceAll"><code>ReplaceAll</code></a> returns a copy of
+ a byte slice with all non-overlapping instances of a value replaced by another.
+ </p>
+
+ <p><!-- CL 145098 -->
+ A pointer to a zero-value <a href="/pkg/bytes/#Reader"><code>Reader</code></a> is now
+ functionally equivalent to <a href="/pkg/bytes/#NewReader"><code>NewReader</code></a><code>(nil)</code>.
+ Prior to Go 1.12, the former could not be used as a substitute for the latter in all cases.
+ </p>
+
+</dl><!-- bytes -->
+
+<dl id="crypto/rand"><dt><a href="/pkg/crypto/rand/">crypto/rand</a></dt>
+ <dd>
+ <p><!-- CL 139419 -->
+ A warning will now be printed to standard error the first time
+ <code>Reader.Read</code> is blocked for more than 60 seconds waiting
+ to read entropy from the kernel.
+ </p>
+
+ <p><!-- CL 120055 -->
+ On FreeBSD, <code>Reader</code> now uses the <code>getrandom</code>
+ system call if available, <code>/dev/urandom</code> otherwise.
+ </p>
+
+</dl><!-- crypto/rand -->
+
+<dl id="crypto/rc4"><dt><a href="/pkg/crypto/rc4/">crypto/rc4</a></dt>
+ <dd>
+ <p><!-- CL 130397 -->
+ This release removes the assembly implementations, leaving only
+ the pure Go version. The Go compiler generates code that is
+ either slightly better or slightly worse, depending on the exact
+ CPU. RC4 is insecure and should only be used for compatibility
+ with legacy systems.
+ </p>
+
+</dl><!-- crypto/rc4 -->
+
+<dl id="crypto/tls"><dt><a href="/pkg/crypto/tls/">crypto/tls</a></dt>
+ <dd>
+ <p><!-- CL 143177 -->
+ If a client sends an initial message that does not look like TLS, the server
+ will no longer reply with an alert, and it will expose the underlying
+ <code>net.Conn</code> in the new field <code>Conn</code> of
+ <a href="/pkg/crypto/tls/#RecordHeaderError"><code>RecordHeaderError</code></a>.
+ </p>
+
+</dl><!-- crypto/tls -->
+
+<dl id="database/sql"><dt><a href="/pkg/database/sql/">database/sql</a></dt>
+ <dd>
+ <p><!-- CL 145738 -->
+ A query cursor can now be obtained by passing a
+ <a href="/pkg/database/sql/#Rows"><code>*Rows</code></a>
+ value to the <a href="/pkg/database/sql/#Row.Scan"><code>Row.Scan</code></a> method.
+ </p>
+
+</dl><!-- database/sql -->
+
+<dl id="expvar"><dt><a href="/pkg/expvar/">expvar</a></dt>
+ <dd>
+ <p><!-- CL 139537 -->
+ The new <a href="/pkg/expvar/#Map.Delete"><code>Delete</code></a> method allows
+ for deletion of key/value pairs from a <a href="/pkg/expvar/#Map"><code>Map</code></a>.
+ </p>
+
+</dl><!-- expvar -->
+
+<dl id="fmt"><dt><a href="/pkg/fmt/">fmt</a></dt>
+ <dd>
+ <p><!-- CL 142737 -->
+ Maps are now printed in key-sorted order to ease testing. The ordering rules are:
+ <ul>
+ <li>When applicable, nil compares low
+ <li>ints, floats, and strings order by <
+ <li>NaN compares less than non-NaN floats
+ <li>bool compares false before true
+ <li>Complex compares real, then imaginary
+ <li>Pointers compare by machine address
+ <li>Channel values compare by machine address
+ <li>Structs compare each field in turn
+ <li>Arrays compare each element in turn
+ <li>Interface values compare first by <code>reflect.Type</code> describing the concrete type
+ and then by concrete value as described in the previous rules.
+ </ul>
+ </p>
+
+ <p><!-- CL 129777 -->
+ When printing maps, non-reflexive key values like <code>NaN</code> were previously
+ displayed as <code><nil></code>. As of this release, the correct values are printed.
+ </p>
+
+</dl><!-- fmt -->
+
+<dl id="go/doc"><dt><a href="/pkg/go/doc/">go/doc</a></dt>
+ <dd>
+ <p><!-- CL 140958 -->
+ To address some outstanding issues in <a href="/cmd/doc/"><code>cmd/doc</code></a>,
+ this package has a new <a href="/pkg/go/doc/#Mode"><code>Mode</code></a> bit,
+ <code>PreserveAST</code>, which controls whether AST data is cleared.
+ </p>
+
+</dl><!-- go/doc -->
+
+<dl id="go/token"><dt><a href="/pkg/go/token/">go/token</a></dt>
+ <dd>
+ <p><!-- CL 134075 -->
+ The <a href="/pkg/go/token#File"><code>File</code></a> type has a new
+ <a href="/pkg/go/token#File.LineStart"><code>LineStart</code></a> field,
+ which returns the position of the start of a given line. This is especially useful
+ in programs that occasionally handle non-Go files, such as assembly, but wish to use
+ the <code>token.Pos</code> mechanism to identify file positions.
+ </p>
+
+</dl><!-- go/token -->
+
+<dl id="image"><dt><a href="/pkg/image/">image</a></dt>
+ <dd>
+ <p><!-- CL 118755 -->
+ The <a href="/pkg/image/#RegisterFormat"><code>RegisterFormat</code></a> function is now safe for concurrent use.
+ </p>
+
+</dl><!-- image -->
+
+<dl id="image/png"><dt><a href="/pkg/image/png/">image/png</a></dt>
+ <dd>
+ <p><!-- CL 134235 -->
+ Paletted images with fewer than 16 colors now encode to smaller outputs.
+ </p>
+
+</dl><!-- image/png -->
+
+<dl id="io"><dt><a href="/pkg/io/">io</a></dt>
+ <dd>
+ <p><!-- CL 139457 -->
+ The new <a href="/pkg/io#StringWriter"><code>StringWriter</code></a> interface wraps the
+ <a href="/pkg/io/#WriteString"><code>WriteString</code></a> function.
+ </p>
+
+</dl><!-- io -->
+
+<dl id="math"><dt><a href="/pkg/math/">math</a></dt>
+ <dd>
+ <p><!-- CL 153059 -->
+ The functions
+ <a href="/pkg/math/#Sin"><code>Sin</code></a>,
+ <a href="/pkg/math/#Cos"><code>Cos</code></a>,
+ <a href="/pkg/math/#Tan"><code>Tan</code></a>,
+ and <a href="/pkg/math/#Sincos"><code>Sincos</code></a> now
+ apply Payne-Hanek range reduction to huge arguments. This
+ produces more accurate answers, but they will not be bit-for-bit
+ identical with the results in earlier releases.
+ </p>
+</dl><!-- math -->
+
+<dl id="math/bits"><dt><a href="/pkg/math/bits/">math/bits</a></dt>
+ <dd>
+ <p><!-- CL 123157 -->
+ New extended precision operations <a href="/pkg/math/bits/#Add"><code>Add</code></a>, <a href="/pkg/math/bits/#Sub"><code>Sub</code></a>, <a href="/pkg/math/bits/#Mul"><code>Mul</code></a>, and <a href="/pkg/math/bits/#Div"><code>Div</code></a> are available in <code>uint</code>, <code>uint32</code>, and <code>uint64</code> versions.
+ </p>
+
+</dl><!-- math/bits -->
+
+<dl id="net"><dt><a href="/pkg/net/">net</a></dt>
+ <dd>
+ <p><!-- CL 146659 -->
+ The
+ <a href="/pkg/net/#Dialer.DualStack"><code>Dialer.DualStack</code></a> setting is now ignored and deprecated;
+ RFC 6555 Fast Fallback ("Happy Eyeballs") is now enabled by default. To disable, set
+ <a href="/pkg/net/#Dialer.FallbackDelay"><code>Dialer.FallbackDelay</code></a> to a negative value.
+ </p>
+
+ <p><!-- CL 107196 -->
+ Similarly, TCP keep-alives are now enabled by default if
+ <a href="/pkg/net/#Dialer.KeepAlive"><code>Dialer.KeepAlive</code></a> is zero.
+ To disable, set it to a negative value.
+ </p>
+
+ <p><!-- CL 113997 -->
+ On Linux, the <a href="http://man7.org/linux/man-pages/man2/splice.2.html"><code>splice</code> system call</a> is now used when copying from a
+ <a href="/pkg/net/#UnixConn"><code>UnixConn</code></a> to a
+ <a href="/pkg/net/#TCPConn"><code>TCPConn</code></a>.
+ </p>
+</dl><!-- net -->
+
+<dl id="net/http"><dt><a href="/pkg/net/http/">net/http</a></dt>
+ <dd>
+ <p><!-- CL 143177 -->
+ The HTTP server now rejects misdirected HTTP requests to HTTPS servers with a plaintext "400 Bad Request" response.
+ </p>
+
+ <p><!-- CL 130115 -->
+ The new <a href="/pkg/net/http/#Client.CloseIdleConnections"><code>Client.CloseIdleConnections</code></a>
+ method calls the <code>Client</code>'s underlying <code>Transport</code>'s <code>CloseIdleConnections</code>
+ if it has one.
+ </p>
+
+ <p><!-- CL 145398 -->
+ The <a href="/pkg/net/http/#Transport"><code>Transport</code></a> no longer rejects HTTP responses which declare
+ HTTP Trailers but don't use chunked encoding. Instead, the declared trailers are now just ignored.
+ </p>
+
+ <p><!-- CL 152080 --> <!-- CL 151857 -->
+ The <a href="/pkg/net/http/#Transport"><code>Transport</code></a> no longer handles <code>MAX_CONCURRENT_STREAMS</code> values
+ advertised from HTTP/2 servers as strictly as it did during Go 1.10 and Go 1.11. The default behavior is now back
+ to how it was in Go 1.9: each connection to a server can have up to <code>MAX_CONCURRENT_STREAMS</code> requests
+ active and then new TCP connections are created as needed. In Go 1.10 and Go 1.11 the <code>http2</code> package
+ would block and wait for requests to finish instead of creating new connections.
+ To get the stricter behavior back, import the
+ <a href="https://godoc.org/golang.org/x/net/http2"><code>golang.org/x/net/http2</code></a> package
+ directly and set
+ <a href="https://godoc.org/golang.org/x/net/http2#Transport.StrictMaxConcurrentStreams"><code>Transport.StrictMaxConcurrentStreams</code></a> to
+ <code>true</code>.
+ </p>
+
+</dl><!-- net/http -->
+
+<dl id="net/url"><dt><a href="/pkg/net/url/">net/url</a></dt>
+ <dd>
+ <p><!-- CL 159157, CL 160178 -->
+ <a href="/pkg/net/url/#Parse"><code>Parse</code></a>,
+ <a href="/pkg/net/url/#ParseRequestURI"><code>ParseRequestURI</code></a>,
+ and
+ <a href="/pkg/net/url/#URL.Parse"><code>URL.Parse</code></a>
+ now return an
+ error for URLs containing ASCII control characters, which includes NULL,
+ tab, and newlines.
+ </p>
+
+</dl><!-- net/url -->
+
+<dl id="net/http/httputil"><dt><a href="/pkg/net/http/httputil/">net/http/httputil</a></dt>
+ <dd>
+ <p><!-- CL 146437 -->
+ The <a href="/pkg/net/http/httputil/#ReverseProxy"><code>ReverseProxy</code></a> now automatically
+ proxies WebSocket requests.
+ </p>
+
+</dl><!-- net/http/httputil -->
+
+<dl id="os"><dt><a href="/pkg/os/">os</a></dt>
+ <dd>
+ <p><!-- CL 125443 -->
+ The new <a href="/pkg/os/#ProcessState.ExitCode"><code>ProcessState.ExitCode</code></a> method
+ returns the process's exit code.
+ </p>
+
+ <p><!-- CL 135075 -->
+ <code>ModeCharDevice</code> has been added to the <code>ModeType</code> bitmask, allowing for
+ <code>ModeDevice | ModeCharDevice</code> to be recovered when masking a
+ <a href="/pkg/os/#FileMode"><code>FileMode</code></a> with <code>ModeType</code>.
+ </p>
+
+ <p><!-- CL 139418 -->
+ The new function <a href="/pkg/os/#UserHomeDir"><code>UserHomeDir</code></a> returns the
+ current user's home directory.
+ </p>
+
+ <p><!-- CL 146020 -->
+ <a href="/pkg/os/#RemoveAll"><code>RemoveAll</code></a> now supports paths longer than 4096 characters
+ on most Unix systems.
+ </p>
+
+ <p><!-- CL 130676 -->
+ <a href="/pkg/os/#File.Sync"><code>File.Sync</code></a> now uses <code>F_FULLFSYNC</code> on macOS
+ to correctly flush the file contents to permanent storage.
+ This may cause the method to run more slowly than in previous releases.
+ </p>
+
+ <p><!--CL 155517 -->
+ <a href="/pkg/os/#File"><code>File</code></a> now supports
+ a <a href="/pkg/os/#File.SyscallConn"><code>SyscallConn</code></a>
+ method returning
+ a <a href="/pkg/syscall/#RawConn"><code>syscall.RawConn</code></a>
+ interface value. This may be used to invoke system-specific
+ operations on the underlying file descriptor.
+ </p>
+
+</dl><!-- os -->
+
+<dl id="path/filepath"><dt><a href="/pkg/path/filepath/">path/filepath</a></dt>
+ <dd>
+ <p><!-- CL 145220 -->
+ The <a href="/pkg/path/filepath/#IsAbs"><code>IsAbs</code></a> function now returns true when passed
+ a reserved filename on Windows such as <code>NUL</code>.
+ <a href="https://docs.microsoft.com/en-us/windows/desktop/fileio/naming-a-file#naming-conventions">List of reserved names.</a>
+ </p>
+
+</dl><!-- path/filepath -->
+
+<dl id="reflect"><dt><a href="/pkg/reflect/">reflect</a></dt>
+ <dd>
+ <p><!-- CL 33572 -->
+ A new <a href="/pkg/reflect#MapIter"><code>MapIter</code></a> type is
+ an iterator for ranging over a map. This type is exposed through the
+ <a href="/pkg/reflect#Value"><code>Value</code></a> type's new
+ <a href="/pkg/reflect#Value.MapRange"><code>MapRange</code></a> method.
+ This follows the same iteration semantics as a range statement, with <code>Next</code>
+ to advance the iterator, and <code>Key</code>/<code>Value</code> to access each entry.
+ </p>
+
+</dl><!-- reflect -->
+
+<dl id="regexp"><dt><a href="/pkg/regexp/">regexp</a></dt>
+ <dd>
+ <p><!-- CL 139784 -->
+ <a href="/pkg/regexp/#Regexp.Copy"><code>Copy</code></a> is no longer necessary
+ to avoid lock contention, so it has been given a partial deprecation comment.
+ <a href="/pkg/regexp/#Regexp.Copy"><code>Copy</code></a>
+ may still be appropriate if the reason for its use is to make two copies with
+ different <a href="/pkg/regexp/#Regexp.Longest"><code>Longest</code></a> settings.
+ </p>
+
+</dl><!-- regexp -->
+
+<dl id="runtime/debug"><dt><a href="/pkg/runtime/debug/">runtime/debug</a></dt>
+ <dd>
+ <p><!-- CL 144220 -->
+ A new <a href="/pkg/runtime/debug/#BuildInfo"><code>BuildInfo</code></a> type
+ exposes the build information read from the running binary, available only in
+ binaries built with module support. This includes the main package path, main
+ module information, and the module dependencies. This type is given through the
+ <a href="/pkg/runtime/debug/#ReadBuildInfo"><code>ReadBuildInfo</code></a> function
+ on <a href="/pkg/runtime/debug/#BuildInfo"><code>BuildInfo</code></a>.
+ </p>
+
+</dl><!-- runtime/debug -->
+
+<dl id="strings"><dt><a href="/pkg/strings/">strings</a></dt>
+ <dd>
+ <p><!-- CL 137855 -->
+ The new function <a href="/pkg/strings/#ReplaceAll"><code>ReplaceAll</code></a> returns a copy of
+ a string with all non-overlapping instances of a value replaced by another.
+ </p>
+
+ <p><!-- CL 145098 -->
+ A pointer to a zero-value <a href="/pkg/strings/#Reader"><code>Reader</code></a> is now
+ functionally equivalent to <a href="/pkg/strings/#NewReader"><code>NewReader</code></a><code>(nil)</code>.
+ Prior to Go 1.12, the former could not be used as a substitute for the latter in all cases.
+ </p>
+
+ <p><!-- CL 122835 -->
+ The new <a href="/pkg/strings/#Builder.Cap"><code>Builder.Cap</code></a> method returns the capacity of the builder's underlying byte slice.
+ </p>
+
+ <p><!-- CL 131495 -->
+ The character mapping functions <a href="/pkg/strings/#Map"><code>Map</code></a>,
+ <a href="/pkg/strings/#Title"><code>Title</code></a>,
+ <a href="/pkg/strings/#ToLower"><code>ToLower</code></a>,
+ <a href="/pkg/strings/#ToLowerSpecial"><code>ToLowerSpecial</code></a>,
+ <a href="/pkg/strings/#ToTitle"><code>ToTitle</code></a>,
+ <a href="/pkg/strings/#ToTitleSpecial"><code>ToTitleSpecial</code></a>,
+ <a href="/pkg/strings/#ToUpper"><code>ToUpper</code></a>, and
+ <a href="/pkg/strings/#ToUpperSpecial"><code>ToUpperSpecial</code></a>
+ now always guarantee to return valid UTF-8. In earlier releases, if the input was invalid UTF-8 but no character replacements
+ needed to be applied, these routines incorrectly returned the invalid UTF-8 unmodified.
+ </p>
+
+</dl><!-- strings -->
+
+<dl id="syscall"><dt><a href="/pkg/syscall/">syscall</a></dt>
+ <dd>
+ <p><!-- CL 138595 -->
+ 64-bit inodes are now supported on FreeBSD 12. Some types have been adjusted accordingly.
+ </p>
+
+ <p><!-- CL 125456 -->
+ The Unix socket
+ (<a href="https://blogs.msdn.microsoft.com/commandline/2017/12/19/af_unix-comes-to-windows/"><code>AF_UNIX</code></a>)
+ address family is now supported for compatible versions of Windows.
+ </p>
+
+ <p><!-- CL 147117 -->
+ The new function <a href="/pkg/syscall/?GOOS=windows&GOARCH=amd64#Syscall18"><code>Syscall18</code></a>
+ has been introduced for Windows, allowing for calls with up to 18 arguments.
+ </p>
+
+</dl><!-- syscall -->
+
+<dl id="syscall/js"><dt><a href="/pkg/syscall/js/">syscall/js</a></dt>
+ <dd>
+ <p><!-- CL 153559 -->
+ <p>
+ The <code>Callback</code> type and <code>NewCallback</code> function have been renamed;
+ they are now called
+ <a href="/pkg/syscall/js/?GOOS=js&GOARCH=wasm#Func"><code>Func</code></a> and
+ <a href="/pkg/syscall/js/?GOOS=js&GOARCH=wasm#FuncOf"><code>FuncOf</code></a>, respectively.
+ This is a breaking change, but WebAssembly support is still experimental
+ and not yet subject to the
+ <a href="/doc/go1compat">Go 1 compatibility promise</a>. Any code using the
+ old names will need to be updated.
+ </p>
+
+ <p><!-- CL 141644 -->
+ If a type implements the new
+ <a href="/pkg/syscall/js/?GOOS=js&GOARCH=wasm#Wrapper"><code>Wrapper</code></a>
+ interface,
+ <a href="/pkg/syscall/js/?GOOS=js&GOARCH=wasm#ValueOf"><code>ValueOf</code></a>
+ will use it to return the JavaScript value for that type.
+ </p>
+
+ <p><!-- CL 143137 -->
+ The meaning of the zero
+ <a href="/pkg/syscall/js/?GOOS=js&GOARCH=wasm#Value"><code>Value</code></a>
+ has changed. It now represents the JavaScript <code>undefined</code> value
+ instead of the number zero.
+ This is a breaking change, but WebAssembly support is still experimental
+ and not yet subject to the
+ <a href="/doc/go1compat">Go 1 compatibility promise</a>. Any code relying on
+ the zero <a href="/pkg/syscall/js/?GOOS=js&GOARCH=wasm#Value"><code>Value</code></a>
+ to mean the number zero will need to be updated.
+ </p>
+
+ <p><!-- CL 144384 -->
+ The new
+ <a href="/pkg/syscall/js/?GOOS=js&GOARCH=wasm#Value.Truthy"><code>Value.Truthy</code></a>
+ method reports the
+ <a href="https://developer.mozilla.org/en-US/docs/Glossary/Truthy">JavaScript "truthiness"</a>
+ of a given value.
+ </p>
+
+</dl><!-- syscall/js -->
+
+<dl id="testing"><dt><a href="/pkg/testing/">testing</a></dt>
+ <dd>
+ <p><!-- CL 139258 -->
+ The <a href="/cmd/go/#hdr-Testing_flags"><code>-benchtime</code></a> flag now supports setting an explicit iteration count instead of a time when the value ends with an "<code>x</code>". For example, <code>-benchtime=100x</code> runs the benchmark 100 times.
+ </p>
+
+</dl><!-- testing -->
+
+<dl id="text/template"><dt><a href="/pkg/text/template/">text/template</a></dt>
+ <dd>
+ <p><!-- CL 142217 -->
+ When executing a template, long context values are no longer truncated in errors.
+ </p>
+ <p>
+ <code>executing "tmpl" at <.very.deep.context.v...>: map has no entry for key "notpresent"</code>
+ </p>
+ <p>
+ is now
+ </p>
+ <p>
+ <code>executing "tmpl" at <.very.deep.context.value.notpresent>: map has no entry for key "notpresent"</code>
+ </p>
+
+ <dd>
+ <p><!-- CL 143097 -->
+ If a user-defined function called by a template panics, the
+ panic is now caught and returned as an error by
+ the <code>Execute</code> or <code>ExecuteTemplate</code> method.
+ </p>
+</dl><!-- text/template -->
+
+<dl id="time"><dt><a href="/pkg/time/">time</a></dt>
+ <dd>
+ <p><!-- CL 151299 -->
+ The time zone database in <code>$GOROOT/lib/time/zoneinfo.zip</code>
+ has been updated to version 2018i. Note that this ZIP file is
+ only used if a time zone database is not provided by the operating
+ system.
+ </p>
+
+</dl><!-- time -->
+
+<dl id="unsafe"><dt><a href="/pkg/unsafe/">unsafe</a></dt>
+ <dd>
+ <p><!-- CL 146058 -->
+ It is invalid to convert a nil <code>unsafe.Pointer</code> to <code>uintptr</code> and back with arithmetic.
+ (This was already invalid, but will now cause the compiler to misbehave.)
+ </p>
+
+</dl><!-- unsafe -->
diff --git a/_content/doc/go1.13.html b/_content/doc/go1.13.html
new file mode 100644
index 0000000..6bbc84e
--- /dev/null
+++ b/_content/doc/go1.13.html
@@ -0,0 +1,1065 @@
+<!--{
+ "Title": "Go 1.13 Release Notes",
+ "Template": true
+}-->
+
+<!--
+NOTE: In this document and others in this directory, the convention is to
+set fixed-width phrases with non-fixed-width spaces, as in
+<code>hello</code> <code>world</code>.
+Do not send CLs removing the interior tags from such phrases.
+-->
+
+<style>
+ main ul li { margin: 0.5em 0; }
+</style>
+
+<h2 id="introduction">Introduction to Go 1.13</h2>
+
+<p>
+ The latest Go release, version 1.13, arrives six months after <a href="go1.12">Go 1.12</a>.
+ Most of its changes are in the implementation of the toolchain, runtime, and libraries.
+ As always, the release maintains the Go 1 <a href="/doc/go1compat.html">promise of compatibility</a>.
+ We expect almost all Go programs to continue to compile and run as before.
+</p>
+
+<p>
+ As of Go 1.13, the go command by default downloads and authenticates
+ modules using the Go module mirror and Go checksum database run by Google. See
+ <a href="https://proxy.golang.org/privacy">https://proxy.golang.org/privacy</a>
+ for privacy information about these services and the
+ <a href="/cmd/go/#hdr-Module_downloading_and_verification">go command documentation</a>
+ for configuration details including how to disable the use of these servers or use
+ different ones. If you depend on non-public modules, see the
+ <a href="/cmd/go/#hdr-Module_configuration_for_non_public_modules">documentation for configuring your environment</a>.
+</p>
+
+<h2 id="language">Changes to the language</h2>
+
+<p>
+ Per the <a href="https://github.com/golang/proposal/blob/master/design/19308-number-literals.md">number literal proposal</a>,
+ Go 1.13 supports a more uniform and modernized set of number literal prefixes.
+ <ul>
+ <li>
+ <a href="/ref/spec#Integer_literals">Binary integer literals</a>:
+ The prefix <code>0b</code> or <code>0B</code> indicates a binary integer literal
+ such as <code>0b1011</code>.
+ </li>
+
+ <li>
+ <a href="/ref/spec#Integer_literals">Octal integer literals</a>:
+ The prefix <code>0o</code> or <code>0O</code> indicates an octal integer literal
+ such as <code>0o660</code>.
+ The existing octal notation indicated by a leading <code>0</code> followed by
+ octal digits remains valid.
+ </li>
+
+ <li>
+ <a href="/ref/spec#Floating-point_literals">Hexadecimal floating point literals</a>:
+ The prefix <code>0x</code> or <code>0X</code> may now be used to express the mantissa of a
+ floating-point number in hexadecimal format such as <code>0x1.0p-1021</code>.
+ A hexadecimal floating-point number must always have an exponent, written as the letter
+ <code>p</code> or <code>P</code> followed by an exponent in decimal. The exponent scales
+ the mantissa by 2 to the power of the exponent.
+ </li>
+
+ <li>
+ <a href="/ref/spec#Imaginary_literals">Imaginary literals</a>:
+ The imaginary suffix <code>i</code> may now be used with any (binary, decimal, hexadecimal)
+ integer or floating-point literal.
+ </li>
+
+ <li>
+ Digit separators:
+ The digits of any number literal may now be separated (grouped) using underscores, such as
+ in <code>1_000_000</code>, <code>0b_1010_0110</code>, or <code>3.1415_9265</code>.
+ An underscore may appear between any two digits or the literal prefix and the first digit.
+ </li>
+ </ul>
+</p>
+
+<p>
+ Per the <a href="https://github.com/golang/proposal/blob/master/design/19113-signed-shift-counts.md">signed shift counts proposal</a>
+ Go 1.13 removes the restriction that a <a href="/ref/spec#Operators">shift count</a>
+ must be unsigned. This change eliminates the need for many artificial <code>uint</code> conversions,
+ solely introduced to satisfy this (now removed) restriction of the <code><<</code> and <code>>></code> operators.
+</p>
+
+<p>
+ These language changes were implemented by changes to the compiler, and corresponding internal changes to the library
+ packages <code><a href="#go/scanner">go/scanner</a></code> and
+ <code><a href="#text/scanner">text/scanner</a></code> (number literals),
+ and <code><a href="#go/types">go/types</a></code> (signed shift counts).
+</p>
+
+<p>
+ If your code uses modules and your <code>go.mod</code> files specifies a language version, be sure
+ it is set to at least <code>1.13</code> to get access to these language changes.
+ You can do this by editing the <code>go.mod</code> file directly, or you can run
+ <code>go mod edit -go=1.13</code>.
+</p>
+
+<h2 id="ports">Ports</h2>
+
+<p id="nacl">
+ Go 1.13 is the last release that will run on Native Client (NaCl).
+</p>
+
+<p><!-- CL 170119, CL 168882 -->
+ For <code>GOARCH=wasm</code>, the new environment variable <code>GOWASM</code> takes a comma-separated list of experimental features that the binary gets compiled with.
+ The valid values are documented <a href="/cmd/go/#hdr-Environment_variables">here</a>.
+</p>
+
+<h3 id="aix">AIX</h3>
+
+<p><!-- CL 164003, CL 169120 -->
+ AIX on PPC64 (<code>aix/ppc64</code>) now supports cgo, external
+ linking, and the <code>c-archive</code> and <code>pie</code> build
+ modes.
+</p>
+
+<h3 id="android">Android</h3>
+
+<p><!-- CL 170127 -->
+ Go programs are now compatible with Android 10.
+</p>
+
+<h3 id="darwin">Darwin</h3>
+
+<p>
+ As <a href="go1.12#darwin">announced</a> in the Go 1.12 release notes,
+ Go 1.13 now requires macOS 10.11 El Capitan or later;
+ support for previous versions has been discontinued.
+</p>
+
+<h3 id="freebsd">FreeBSD</h3>
+
+<p>
+ As <a href="go1.12#freebsd">announced</a> in the Go 1.12 release notes,
+ Go 1.13 now requires FreeBSD 11.2 or later;
+ support for previous versions has been discontinued.
+ FreeBSD 12.0 or later requires a kernel with the <code>COMPAT_FREEBSD11</code>
+ option set (this is the default).
+</p>
+
+<h3 id="illumos">Illumos</h3>
+
+<p><!-- CL 174457 -->
+ Go now supports Illumos with <code>GOOS=illumos</code>.
+ The <code>illumos</code> build tag implies the <code>solaris</code>
+ build tag.
+</p>
+
+<h3 id="windows">Windows</h3>
+
+<p><!-- CL 178977 -->
+ The Windows version specified by internally-linked Windows binaries
+ is now Windows 7 rather than NT 4.0. This was already the minimum
+ required version for Go, but can affect the behavior of system calls
+ that have a backwards-compatibility mode. These will now behave as
+ documented. Externally-linked binaries (any program using cgo) have
+ always specified a more recent Windows version.
+</p>
+
+<h2 id="tools">Tools</h2>
+
+<h3 id="modules">Modules</h3>
+
+<h4 id="proxy-vars">Environment variables</h4>
+
+<p><!-- CL 176580 -->
+ The <a href="/cmd/go/#hdr-Module_support"><code>GO111MODULE</code></a>
+ environment variable continues to default to <code>auto</code>, but
+ the <code>auto</code> setting now activates the module-aware mode of
+ the <code>go</code> command whenever the current working directory contains,
+ or is below a directory containing, a <code>go.mod</code> file — even if the
+ current directory is within <code>GOPATH/src</code>. This change simplifies
+ the migration of existing code within <code>GOPATH/src</code> and the ongoing
+ maintenance of module-aware packages alongside non-module-aware importers.
+</p>
+
+<p><!-- CL 181719 -->
+ The new
+ <a href="/cmd/go/#hdr-Module_configuration_for_non_public_modules"><code>GOPRIVATE</code></a>
+ environment variable indicates module paths that are not publicly available.
+ It serves as the default value for the lower-level <code>GONOPROXY</code>
+ and <code>GONOSUMDB</code> variables, which provide finer-grained control over
+ which modules are fetched via proxy and verified using the checksum database.
+</p>
+
+<p><!-- CL 173441, CL 177958 -->
+ The <a href="/cmd/go/#hdr-Module_downloading_and_verification"><code>GOPROXY</code>
+ environment variable</a> may now be set to a comma-separated list of proxy
+ URLs or the special token <code>direct</code>, and
+ its <a href="#introduction">default value</a> is
+ now <code>https://proxy.golang.org,direct</code>. When resolving a package
+ path to its containing module, the <code>go</code> command will try all
+ candidate module paths on each proxy in the list in succession. An unreachable
+ proxy or HTTP status code other than 404 or 410 terminates the search without
+ consulting the remaining proxies.
+</p>
+
+<p>
+ The new
+ <a href="/cmd/go/#hdr-Module_authentication_failures"><code>GOSUMDB</code></a>
+ environment variable identifies the name, and optionally the public key and
+ server URL, of the database to consult for checksums of modules that are not
+ yet listed in the main module's <code>go.sum</code> file.
+ If <code>GOSUMDB</code> does not include an explicit URL, the URL is chosen by
+ probing the <code>GOPROXY</code> URLs for an endpoint indicating support for
+ the checksum database, falling back to a direct connection to the named
+ database if it is not supported by any proxy. If <code>GOSUMDB</code> is set
+ to <code>off</code>, the checksum database is not consulted and only the
+ existing checksums in the <code>go.sum</code> file are verified.
+</p>
+
+<p>
+ Users who cannot reach the default proxy and checksum database (for example,
+ due to a firewalled or sandboxed configuration) may disable their use by
+ setting <code>GOPROXY</code> to <code>direct</code>, and/or
+ <code>GOSUMDB</code> to <code>off</code>.
+ <a href="#go-env-w"><code>go</code> <code>env</code> <code>-w</code></a>
+ can be used to set the default values for these variables independent of
+ platform:
+</p>
+<pre>
+go env -w GOPROXY=direct
+go env -w GOSUMDB=off
+</pre>
+
+<h4 id="go-get"><code>go</code> <code>get</code></h4>
+
+<p><!-- CL 174099 -->
+ In module-aware mode,
+ <a href="/cmd/go/#hdr-Add_dependencies_to_current_module_and_install_them"><code>go</code> <code>get</code></a>
+ with the <code>-u</code> flag now updates a smaller set of modules that is
+ more consistent with the set of packages updated by
+ <code>go</code> <code>get</code> <code>-u</code> in GOPATH mode.
+ <code>go</code> <code>get</code> <code>-u</code> continues to update the
+ modules and packages named on the command line, but additionally updates only
+ the modules containing the packages <em>imported by</em> the named packages,
+ rather than the transitive module requirements of the modules containing the
+ named packages.
+</p>
+
+<p>
+ Note in particular that <code>go</code> <code>get</code> <code>-u</code>
+ (without additional arguments) now updates only the transitive imports of the
+ package in the current directory. To instead update all of the packages
+ transitively imported by the main module (including test dependencies), use
+ <code>go</code> <code>get</code> <code>-u</code> <code>all</code>.
+</p>
+
+<p><!-- CL 177879 -->
+ As a result of the above changes to
+ <code>go</code> <code>get</code> <code>-u</code>, the
+ <code>go</code> <code>get</code> subcommand no longer supports
+ the <code>-m</code> flag, which caused <code>go</code> <code>get</code> to
+ stop before loading packages. The <code>-d</code> flag remains supported, and
+ continues to cause <code>go</code> <code>get</code> to stop after downloading
+ the source code needed to build dependencies of the named packages.
+</p>
+
+<p><!-- CL 177677 -->
+ By default, <code>go</code> <code>get</code> <code>-u</code> in module mode
+ upgrades only non-test dependencies, as in GOPATH mode. It now also accepts
+ the <code>-t</code> flag, which (as in GOPATH mode)
+ causes <code>go</code> <code>get</code> to include the packages imported
+ by <em>tests of</em> the packages named on the command line.
+</p>
+
+<p><!-- CL 167747 -->
+ In module-aware mode, the <code>go</code> <code>get</code> subcommand now
+ supports the version suffix <code>@patch</code>. The <code>@patch</code>
+ suffix indicates that the named module, or module containing the named
+ package, should be updated to the highest patch release with the same
+ major and minor versions as the version found in the build list.
+</p>
+
+<p><!-- CL 184440 -->
+ If a module passed as an argument to <code>go</code> <code>get</code>
+ without a version suffix is already required at a newer version than the
+ latest released version, it will remain at the newer version. This is
+ consistent with the behavior of the <code>-u</code> flag for module
+ dependencies. This prevents unexpected downgrades from pre-release versions.
+ The new version suffix <code>@upgrade</code> explicitly requests this
+ behavior. <code>@latest</code> explicitly requests the latest version
+ regardless of the current version.
+</p>
+
+<h4 id="version-validation">Version validation</h4><!-- CL 181881 -->
+
+<p>
+ When extracting a module from a version control system, the <code>go</code>
+ command now performs additional validation on the requested version string.
+</p>
+
+<p>
+ The <code>+incompatible</code> version annotation bypasses the requirement
+ of <a href="/cmd/go/#hdr-Module_compatibility_and_semantic_versioning">semantic
+ import versioning</a> for repositories that predate the introduction of
+ modules. The <code>go</code> command now verifies that such a version does not
+ include an explicit <code>go.mod</code> file.
+</p>
+
+<p>
+ The <code>go</code> command now verifies the mapping
+ between <a href="/cmd/go/#hdr-Pseudo_versions">pseudo-versions</a> and
+ version-control metadata. Specifically:
+ <ul>
+ <li>The version prefix must be of the form <code>vX.0.0</code>, or derived
+ from a tag on an ancestor of the named revision, or derived from a tag that
+ includes <a href="https://semver.org/#spec-item-10">build metadata</a> on
+ the named revision itself.</li>
+
+ <li>The date string must match the UTC timestamp of the revision.</li>
+
+ <li>The short name of the revision must use the same number of characters as
+ what the <code>go</code> command would generate. (For SHA-1 hashes as used
+ by <code>git</code>, a 12-digit prefix.)</li>
+ </ul>
+</p>
+
+<p>
+ If a <code>require</code> directive in the
+ <a href="/cmd/go/#hdr-The_main_module_and_the_build_list">main module</a> uses
+ an invalid pseudo-version, it can usually be corrected by redacting the
+ version to just the commit hash and re-running a <code>go</code> command, such
+ as <code>go</code> <code>list</code> <code>-m</code> <code>all</code>
+ or <code>go</code> <code>mod</code> <code>tidy</code>. For example,
+</p>
+<pre>require github.com/docker/docker v1.14.0-0.20190319215453-e7b5f7dbe98c</pre>
+<p>can be redacted to</p>
+<pre>require github.com/docker/docker e7b5f7dbe98c</pre>
+<p>which currently resolves to</p>
+<pre>require github.com/docker/docker v0.7.3-0.20190319215453-e7b5f7dbe98c</pre>
+
+<p>
+ If one of the transitive dependencies of the main module requires an invalid
+ version or pseudo-version, the invalid version can be replaced with a valid
+ one using a
+ <a href="/cmd/go/#hdr-The_go_mod_file"><code>replace</code> directive</a> in
+ the <code>go.mod</code> file of the main module. If the replacement is a
+ commit hash, it will be resolved to the appropriate pseudo-version as above.
+ For example,
+</p>
+<pre>replace github.com/docker/docker v1.14.0-0.20190319215453-e7b5f7dbe98c => github.com/docker/docker e7b5f7dbe98c</pre>
+<p>currently resolves to</p>
+<pre>replace github.com/docker/docker v1.14.0-0.20190319215453-e7b5f7dbe98c => github.com/docker/docker v0.7.3-0.20190319215453-e7b5f7dbe98c</pre>
+
+<h3 id="go-command">Go command</h3>
+
+<p id="go-env-w"><!-- CL 171137 -->
+ The <a href="/cmd/go/#hdr-Environment_variables"><code>go</code> <code>env</code></a>
+ command now accepts a <code>-w</code> flag to set the per-user default value
+ of an environment variable recognized by the
+ <code>go</code> command, and a corresponding <code>-u</code> flag to unset a
+ previously-set default. Defaults set via
+ <code>go</code> <code>env</code> <code>-w</code> are stored in the
+ <code>go/env</code> file within
+ <a href="/pkg/os/#UserConfigDir"><code>os.UserConfigDir()</code></a>.
+</p>
+
+<p id="go-version-exe"><!-- CL 173343 -->
+ The <a href="/cmd/go/#hdr-Print_Go_version">
+ <code>go</code> <code>version</code></a> command now accepts arguments naming
+ executables and directories. When invoked on an executable,
+ <code>go</code> <code>version</code> prints the version of Go used to build
+ the executable. If the <code>-m</code> flag is used,
+ <code>go</code> <code>version</code> prints the executable's embedded module
+ version information, if available. When invoked on a directory,
+ <code>go</code> <code>version</code> prints information about executables
+ contained in the directory and its subdirectories.
+</p>
+
+<p id="trimpath"><!-- CL 173345 -->
+ The new <a href="/cmd/go/#hdr-Compile_packages_and_dependencies"><code>go</code>
+ <code>build</code> flag</a> <code>-trimpath</code> removes all file system paths
+ from the compiled executable, to improve build reproducibility.
+</p>
+
+<p id="o-dir"><!-- CL 167679 -->
+ If the <code>-o</code> flag passed to <code>go</code> <code>build</code>
+ refers to an existing directory, <code>go</code> <code>build</code> will now
+ write executable files within that directory for <code>main</code> packages
+ matching its package arguments.
+</p>
+
+<p id="comma-separated-tags"><!-- CL 173438 -->
+ The <code>go</code> <code>build</code> flag <code>-tags</code> now takes a
+ comma-separated list of build tags, to allow for multiple tags in
+ <a href="/cmd/go/#hdr-Environment_variables"><code>GOFLAGS</code></a>. The
+ space-separated form is deprecated but still recognized and will be maintained.
+</p>
+
+<p id="go-generate-tag"><!-- CL 175983 -->
+ <a href="/cmd/go/#hdr-Generate_Go_files_by_processing_source"><code>go</code>
+ <code>generate</code></a> now sets the <code>generate</code> build tag so that
+ files may be searched for directives but ignored during build.
+</p>
+
+<p id="binary-only"><!-- CL 165746 -->
+ As <a href="/doc/go1.12#binary-only">announced</a> in the Go 1.12 release
+ notes, binary-only packages are no longer supported. Building a binary-only
+ package (marked with a <code>//go:binary-only-package</code> comment) now
+ results in an error.
+</p>
+
+<h3 id="compiler">Compiler toolchain</h3>
+
+<p><!-- CL 170448 -->
+ The compiler has a new implementation of escape analysis that is
+ more precise. For most Go code should be an improvement (in other
+ words, more Go variables and expressions allocated on the stack
+ instead of heap). However, this increased precision may also break
+ invalid code that happened to work before (for example, code that
+ violates
+ the <a href="/pkg/unsafe/#Pointer"><code>unsafe.Pointer</code>
+ safety rules</a>). If you notice any regressions that appear
+ related, the old escape analysis pass can be re-enabled
+ with <code>go</code> <code>build</code> <code>-gcflags=all=-newescape=false</code>.
+ The option to use the old escape analysis will be removed in a
+ future release.
+</p>
+
+<p><!-- CL 161904 -->
+ The compiler no longer emits floating point or complex constants
+ to <code>go_asm.h</code> files. These have always been emitted in a
+ form that could not be used as numeric constant in assembly code.
+</p>
+
+<h3 id="assembler">Assembler</h3>
+
+<p><!-- CL 157001 -->
+ The assembler now supports many of the atomic instructions
+ introduced in ARM v8.1.
+</p>
+
+<h3 id="gofmt">gofmt</h3>
+
+<p>
+ <code>gofmt</code> (and with that <code>go fmt</code>) now canonicalizes
+ number literal prefixes and exponents to use lower-case letters, but
+ leaves hexadecimal digits alone. This improves readability when using the new octal prefix
+ (<code>0O</code> becomes <code>0o</code>), and the rewrite is applied consistently.
+ <code>gofmt</code> now also removes unnecessary leading zeroes from a decimal integer
+ imaginary literal. (For backwards-compatibility, an integer imaginary literal
+ starting with <code>0</code> is considered a decimal, not an octal number.
+ Removing superfluous leading zeroes avoids potential confusion.)
+ For instance, <code>0B1010</code>, <code>0XabcDEF</code>, <code>0O660</code>,
+ <code>1.2E3</code>, and <code>01i</code> become <code>0b1010</code>, <code>0xabcDEF</code>,
+ <code>0o660</code>, <code>1.2e3</code>, and <code>1i</code> after applying <code>gofmt</code>.
+</p>
+
+<h3 id="godoc"><code>godoc</code> and <code>go</code> <code>doc</code></h3>
+
+<p><!-- CL 174322 -->
+ The <code>godoc</code> webserver is no longer included in the main binary distribution.
+ To run the <code>godoc</code> webserver locally, manually install it first:
+<pre>
+go get golang.org/x/tools/cmd/godoc
+godoc
+</pre>
+</p>
+
+<p><!-- CL 177797 -->
+ The
+ <a href="/cmd/go/#hdr-Show_documentation_for_package_or_symbol"><code>go</code> <code>doc</code></a>
+ command now always includes the package clause in its output, except for
+ commands. This replaces the previous behavior where a heuristic was used,
+ causing the package clause to be omitted under certain conditions.
+</p>
+
+<h2 id="runtime">Runtime</h2>
+
+<p><!-- CL 161477 -->
+ Out of range panic messages now include the index that was out of
+ bounds and the length (or capacity) of the slice. For
+ example, <code>s[3]</code> on a slice of length 1 will panic with
+ "runtime error: index out of range [3] with length 1".
+</p>
+
+<p><!-- CL 171758 -->
+ This release improves performance of most uses of <code>defer</code>
+ by 30%.
+</p>
+
+<p><!-- CL 142960 -->
+ The runtime is now more aggressive at returning memory to the
+ operating system to make it available to co-tenant applications.
+ Previously, the runtime could retain memory for five or more minutes
+ following a spike in the heap size. It will now begin returning it
+ promptly after the heap shrinks. However, on many OSes, including
+ Linux, the OS itself reclaims memory lazily, so process RSS will not
+ decrease until the system is under memory pressure.
+</p>
+
+<h2 id="library">Core library</h2>
+
+<h3 id="tls_1_3">TLS 1.3</h3>
+
+<p>
+ As announced in Go 1.12, Go 1.13 enables support for TLS 1.3 in the
+ <code>crypto/tls</code> package by default. It can be disabled by adding the
+ value <code>tls13=0</code> to the <code>GODEBUG</code>
+ environment variable. The opt-out will be removed in Go 1.14.
+</p>
+
+<p>
+ See <a href="/doc/go1.12#tls_1_3">the Go 1.12 release notes</a> for important
+ compatibility information.
+</p>
+
+<h3 id="crypto/ed25519"><a href="/pkg/crypto/ed25519/">crypto/ed25519</a></h3>
+
+<p><!-- CL 174945, 182698 -->
+ The new <a href="/pkg/crypto/ed25519/"><code>crypto/ed25519</code></a>
+ package implements the Ed25519 signature
+ scheme. This functionality was previously provided by the
+ <a href="https://godoc.org/golang.org/x/crypto/ed25519"><code>golang.org/x/crypto/ed25519</code></a>
+ package, which becomes a wrapper for
+ <code>crypto/ed25519</code> when used with Go 1.13+.
+</p>
+
+<h3 id="error_wrapping">Error wrapping</h3>
+
+<p><!-- CL 163558, 176998 -->
+ Go 1.13 contains support for error wrapping, as first proposed in
+ the <a href="https://go.googlesource.com/proposal/+/master/design/29934-error-values.md">
+ Error Values proposal</a> and discussed on <a href="https://golang.org/issue/29934">the
+ associated issue</a>.
+</p>
+<p>
+ An error <code>e</code> can <em>wrap</em> another error <code>w</code> by providing
+ an <code>Unwrap</code> method that returns <code>w</code>. Both <code>e</code>
+ and <code>w</code> are available to programs, allowing <code>e</code> to provide
+ additional context to <code>w</code> or to reinterpret it while still allowing
+ programs to make decisions based on <code>w</code>.
+</p>
+<p>
+ To support wrapping, <a href="#fmt"><code>fmt.Errorf</code></a> now has a <code>%w</code>
+ verb for creating wrapped errors, and three new functions in
+ the <a href="#errors"><code>errors</code></a> package (
+ <a href="/pkg/errors/#Unwrap"><code>errors.Unwrap</code></a>,
+ <a href="/pkg/errors/#Is"><code>errors.Is</code></a> and
+ <a href="/pkg/errors/#As"><code>errors.As</code></a>) simplify unwrapping
+ and inspecting wrapped errors.
+</p>
+<p>
+ For more information, read the <a href="/pkg/errors/"><code>errors</code> package
+ documentation</a>, or see
+ the <a href="https://golang.org/wiki/ErrorValueFAQ">Error Value FAQ</a>.
+ There will soon be a blog post as well.
+</p>
+
+<h3 id="minor_library_changes">Minor changes to the library</h3>
+
+<p>
+ As always, there are various minor changes and updates to the library,
+ made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
+ in mind.
+</p>
+
+<dl id="bytes"><dt><a href="/pkg/bytes/">bytes</a></dt>
+ <dd>
+ <p>
+ The new <a href="/pkg/bytes/#ToValidUTF8"><code>ToValidUTF8</code></a> function returns a
+ copy of a given byte slice with each run of invalid UTF-8 byte sequences replaced by a given slice.
+ </p>
+
+</dl><!-- bytes -->
+
+<dl id="context"><dt><a href="/pkg/context/">context</a></dt>
+ <dd>
+ <p><!-- CL 169080 -->
+ The formatting of contexts returned by <a href="/pkg/context/#WithValue"><code>WithValue</code></a> no longer depends on <code>fmt</code> and will not stringify in the same way. Code that depends on the exact previous stringification might be affected.
+ </p>
+
+</dl><!-- context -->
+
+<dl id="crypto/tls"><dt><a href="/pkg/crypto/tls/">crypto/tls</a></dt>
+ <dd>
+ <p>
+ Support for SSL version 3.0 (SSLv3) <a href="https://golang.org/issue/32716">
+ is now deprecated and will be removed in Go 1.14</a>. Note that SSLv3 is the
+ <a href="https://tools.ietf.org/html/rfc7568">cryptographically broken</a>
+ protocol predating TLS.
+ </p>
+
+ <p>
+ SSLv3 was always disabled by default, other than in Go 1.12, when it was
+ mistakenly enabled by default server-side. It is now again disabled by
+ default. (SSLv3 was never supported client-side.)
+ </p>
+
+ <p><!-- CL 177698 -->
+ Ed25519 certificates are now supported in TLS versions 1.2 and 1.3.
+ </p>
+
+</dl><!-- crypto/tls -->
+
+<dl id="crypto/x509"><dt><a href="/pkg/crypto/x509/">crypto/x509</a></dt>
+ <dd>
+ <p><!-- CL 175478 -->
+ Ed25519 keys are now supported in certificates and certificate requests
+ according to <a href="https://www.rfc-editor.org/info/rfc8410">RFC 8410</a>, as well as by the
+ <a href="/pkg/crypto/x509/#ParsePKCS8PrivateKey"><code>ParsePKCS8PrivateKey</code></a>,
+ <a href="/pkg/crypto/x509/#MarshalPKCS8PrivateKey"><code>MarshalPKCS8PrivateKey</code></a>,
+ and <a href="/pkg/crypto/x509/#ParsePKIXPublicKey"><code>ParsePKIXPublicKey</code></a> functions.
+ </p>
+
+ <p><!-- CL 169238 -->
+ The paths searched for system roots now include <code>/etc/ssl/cert.pem</code>
+ to support the default location in Alpine Linux 3.7+.
+ </p>
+
+</dl><!-- crypto/x509 -->
+
+<dl id="database/sql"><dt><a href="/pkg/database/sql/">database/sql</a></dt>
+ <dd>
+ <p><!-- CL 170699 -->
+ The new <a href="/pkg/database/sql/#NullTime"><code>NullTime</code></a> type represents a <code>time.Time</code> that may be null.
+ </p>
+
+ <p><!-- CL 174178 -->
+ The new <a href="/pkg/database/sql/#NullInt32"><code>NullInt32</code></a> type represents an <code>int32</code> that may be null.
+ </p>
+
+</dl><!-- database/sql -->
+
+<dl id="debug/dwarf"><dt><a href="/pkg/debug/dwarf/">debug/dwarf</a></dt>
+ <dd>
+ <p><!-- CL 158797 -->
+ The <a href="/pkg/debug/dwarf/#Data.Type"><code>Data.Type</code></a>
+ method no longer panics if it encounters an unknown DWARF tag in
+ the type graph. Instead, it represents that component of the
+ type with
+ an <a href="/pkg/debug/dwarf/#UnsupportedType"><code>UnsupportedType</code></a>
+ object.
+ </p>
+
+</dl><!-- debug/dwarf -->
+
+<dl id="errors"><dt><a href="/pkg/errors/">errors</a></dt>
+ <dd>
+ <!-- CL 163558 -->
+ <p>
+ The new function <a href="/pkg/errors/#As"><code>As</code></a> finds the first
+ error in a given error’s chain (sequence of wrapped errors)
+ that matches a given target’s type, and if so, sets the target to that error value.
+ </p>
+ <p>
+ The new function <a href="/pkg/errors/#Is"><code>Is</code></a> reports whether a given error value matches an
+ error in another’s chain.
+ </p>
+ <p>
+ The new function <a href="/pkg/errors/#Unwrap"><code>Unwrap</code></a> returns the result of calling
+ <code>Unwrap</code> on a given error, if one exists.
+ </p>
+
+</dl><!-- errors -->
+
+<dl id="fmt"><dt><a href="/pkg/fmt/">fmt</a></dt>
+ <dd>
+ <!-- CL 160245 -->
+ <p>
+ The printing verbs <code>%x</code> and <code>%X</code> now format floating-point and
+ complex numbers in hexadecimal notation, in lower-case and upper-case respectively.
+ </p>
+
+ <!-- CL 160246 -->
+ <p>
+ The new printing verb <code>%O</code> formats integers in base 8, emitting the <code>0o</code> prefix.
+ </p>
+
+ <!-- CL 160247 -->
+ <p>
+ The scanner now accepts hexadecimal floating-point values, digit-separating underscores
+ and leading <code>0b</code> and <code>0o</code> prefixes.
+ See the <a href="#language">Changes to the language</a> for details.
+ </p>
+
+ <!-- CL 176998 -->
+ <p>The <a href="/pkg/fmt/#Errorf"><code>Errorf</code></a> function
+ has a new verb, <code>%w</code>, whose operand must be an error.
+ The error returned from <code>Errorf</code> will have an
+ <code>Unwrap</code> method which returns the operand of <code>%w</code>.
+ </p>
+
+</dl><!-- fmt -->
+
+
+<dl id="go/scanner"><dt><a href="/pkg/go/scanner/">go/scanner</a></dt>
+ <dd>
+ <p><!-- CL 175218 -->
+ The scanner has been updated to recognize the new Go number literals, specifically
+ binary literals with <code>0b</code>/<code>0B</code> prefix, octal literals with <code>0o</code>/<code>0O</code> prefix,
+ and floating-point numbers with hexadecimal mantissa. The imaginary suffix <code>i</code> may now be used with any number
+ literal, and underscores may used as digit separators for grouping.
+ See the <a href="#language">Changes to the language</a> for details.
+ </p>
+
+ </dl><!-- go/scanner -->
+
+<dl id="go/types"><dt><a href="/pkg/go/types/">go/types</a></dt>
+ <dd>
+ <p>
+ The type-checker has been updated to follow the new rules for integer shifts.
+ See the <a href="#language">Changes to the language</a> for details.
+ </p>
+
+</dl><!-- go/types -->
+
+
+
+<dl id="html/template"><dt><a href="/pkg/html/template/">html/template</a></dt>
+ <dd>
+ <p><!-- CL 175218 -->
+ When using a <code><script></code> tag with "module" set as the
+ type attribute, code will now be interpreted as <a href="https://html.spec.whatwg.org/multipage/scripting.html#the-script-element:module-script-2">JavaScript module script</a>.
+ </p>
+
+</dl><!-- html/template -->
+
+<dl id="log"><dt><a href="/pkg/log/">log</a></dt>
+ <dd>
+ <p><!-- CL 168920 -->
+ The new <a href="/pkg/log/#Writer"><code>Writer</code></a> function returns the output destination for the standard logger.
+ </p>
+
+</dl><!-- log -->
+
+<dl id="math/big"><dt><a href="/pkg/math/big/">math/big</a></dt>
+ <dd>
+ <p><!-- CL 160682 -->
+ The new <a href="/pkg/math/big/#Rat.SetUint64"><code>Rat.SetUint64</code></a> method sets the <code>Rat</code> to a <code>uint64</code> value.
+ </p>
+
+ <p><!-- CL 166157 -->
+ For <a href="/pkg/math/big/#Float.Parse"><code>Float.Parse</code></a>, if base is 0, underscores
+ may be used between digits for readability.
+ See the <a href="#language">Changes to the language</a> for details.
+ </p>
+
+ <p><!-- CL 166157 -->
+ For <a href="/pkg/math/big/#Int.SetString"><code>Int.SetString</code></a>, if base is 0, underscores
+ may be used between digits for readability.
+ See the <a href="#language">Changes to the language</a> for details.
+ </p>
+
+ <p><!-- CL 168237 -->
+ <a href="/pkg/math/big/#Rat.SetString"><code>Rat.SetString</code></a> now accepts non-decimal floating point representations.
+ </p>
+
+</dl><!-- math/big -->
+
+<dl id="math/bits"><dt><a href="/pkg/math/bits/">math/bits</a></dt>
+ <dd>
+ <p><!-- CL 178177 -->
+ The execution time of <a href="/pkg/math/bits/#Add"><code>Add</code></a>,
+ <a href="/pkg/math/bits/#Sub"><code>Sub</code></a>,
+ <a href="/pkg/math/bits/#Mul"><code>Mul</code></a>,
+ <a href="/pkg/math/bits/#RotateLeft"><code>RotateLeft</code></a>, and
+ <a href="/pkg/math/bits/#ReverseBytes"><code>ReverseBytes</code></a> is now
+ guaranteed to be independent of the inputs.
+ </p>
+
+</dl><!-- math/bits -->
+
+<dl id="net"><dt><a href="/pkg/net/">net</a></dt>
+ <dd>
+ <p><!-- CL 156366 -->
+ On Unix systems where <code>use-vc</code> is set in <code>resolv.conf</code>, TCP is used for DNS resolution.
+ </p>
+
+ <p><!-- CL 170678 -->
+ The new field <a href="/pkg/net/#ListenConfig.KeepAlive"><code>ListenConfig.KeepAlive</code></a>
+ specifies the keep-alive period for network connections accepted by the listener.
+ If this field is 0 (the default) TCP keep-alives will be enabled.
+ To disable them, set it to a negative value.
+ </p>
+ <p>
+ Note that the error returned from I/O on a connection that was
+ closed by a keep-alive timeout will have a
+ <code>Timeout</code> method that returns <code>true</code> if called.
+ This can make a keep-alive error difficult to distinguish from
+ an error returned due to a missed deadline as set by the
+ <a href="/pkg/net/#Conn"><code>SetDeadline</code></a>
+ method and similar methods.
+ Code that uses deadlines and checks for them with
+ the <code>Timeout</code> method or
+ with <a href="/pkg/os/#IsTimeout"><code>os.IsTimeout</code></a>
+ may want to disable keep-alives, or
+ use <code>errors.Is(syscall.ETIMEDOUT)</code> (on Unix systems)
+ which will return true for a keep-alive timeout and false for a
+ deadline timeout.
+ </p>
+
+</dl><!-- net -->
+
+<dl id="net/http"><dt><a href="/pkg/net/http/">net/http</a></dt>
+ <dd>
+ <p><!-- CL 76410 -->
+ The new fields <a href="/pkg/net/http/#Transport.WriteBufferSize"><code>Transport.WriteBufferSize</code></a>
+ and <a href="/pkg/net/http/#Transport.ReadBufferSize"><code>Transport.ReadBufferSize</code></a>
+ allow one to specify the sizes of the write and read buffers for a <a href="/pkg/net/http/#Transport"><code>Transport</code></a>.
+ If either field is zero, a default size of 4KB is used.
+ </p>
+
+ <p><!-- CL 130256 -->
+ The new field <a href="/pkg/net/http/#Transport.ForceAttemptHTTP2"><code>Transport.ForceAttemptHTTP2</code></a>
+ controls whether HTTP/2 is enabled when a non-zero <code>Dial</code>, <code>DialTLS</code>, or <code>DialContext</code>
+ func or <code>TLSClientConfig</code> is provided.
+ </p>
+
+ <p><!-- CL 140357 -->
+ <a href="/pkg/net/http/#Transport.MaxConnsPerHost"><code>Transport.MaxConnsPerHost</code></a> now works
+ properly with HTTP/2.
+ </p>
+
+ <p><!-- CL 154383 -->
+ <a href="/pkg/net/http/#TimeoutHandler"><code>TimeoutHandler</code></a>'s
+ <a href="/pkg/net/http/#ResponseWriter"><code>ResponseWriter</code></a> now implements the
+ <a href="/pkg/net/http/#Pusher"><code>Pusher</code></a> interface.
+ </p>
+
+ <p><!-- CL 157339 -->
+ The <code>StatusCode</code> <code>103</code> <code>"Early Hints"</code> has been added.
+ </p>
+
+ <p><!-- CL 163599 -->
+ <a href="/pkg/net/http/#Transport"><code>Transport</code></a> now uses the <a href="/pkg/net/http/#Request.Body"><code>Request.Body</code></a>'s
+ <a href="/pkg/io/#ReaderFrom"><code>io.ReaderFrom</code></a> implementation if available, to optimize writing the body.
+ </p>
+
+ <p><!-- CL 167017 -->
+ On encountering unsupported transfer-encodings, <a href="/pkg/net/http/#Server"><code>http.Server</code></a> now
+ returns a "501 Unimplemented" status as mandated by the HTTP specification <a href="https://tools.ietf.org/html/rfc7230#section-3.3.1">RFC 7230 Section 3.3.1</a>.
+ </p>
+
+ <p><!-- CL 167681 -->
+ The new <a href="/pkg/net/http/#Server"><code>Server</code></a> fields
+ <a href="/pkg/net/http/#Server.BaseContext"><code>BaseContext</code></a> and
+ <a href="/pkg/net/http/#Server.ConnContext"><code>ConnContext</code></a>
+ allow finer control over the <a href="/pkg/context/#Context"><code>Context</code></a> values provided to requests and connections.
+ </p>
+
+ <p><!-- CL 167781 -->
+ <a href="/pkg/net/http/#DetectContentType"><code>http.DetectContentType</code></a> now correctly detects RAR signatures, and can now also detect RAR v5 signatures.
+ </p>
+
+ <p><!-- CL 173658 -->
+ The new <a href="/pkg/net/http/#Header"><code>Header</code></a> method
+ <a href="/pkg/net/http/#Header.Clone"><code>Clone</code></a> returns a copy of the receiver.
+ </p>
+
+ <p><!-- CL 174324 -->
+ A new function <a href="/pkg/net/http/#NewRequestWithContext"><code>NewRequestWithContext</code></a> has been added and it
+ accepts a <a href="/pkg/context/#Context"><code>Context</code></a> that controls the entire lifetime of
+ the created outgoing <a href="/pkg/net/http/#Request"><code>Request</code></a>, suitable for use with
+ <a href="/pkg/net/http/#Client.Do"><code>Client.Do</code></a> and <a href="/pkg/net/http/#Transport.RoundTrip"><code>Transport.RoundTrip</code></a>.
+ </p>
+
+ <p><!-- CL 179457 -->
+ The <a href="/pkg/net/http/#Transport"><code>Transport</code></a> no longer logs errors when servers
+ gracefully shut down idle connections using a <code>"408 Request Timeout"</code> response.
+ </p>
+
+</dl><!-- net/http -->
+
+<dl id="os"><dt><a href="/pkg/os/">os</a></dt>
+ <dd>
+ <p><!-- CL 160877 -->
+ The new <a href="/pkg/os/#UserConfigDir"><code>UserConfigDir</code></a> function
+ returns the default directory to use for user-specific configuration data.
+ </p>
+
+ <p><!-- CL 166578 -->
+ If a <a href="/pkg/os/#File"><code>File</code></a> is opened using the O_APPEND flag, its
+ <a href="/pkg/os/#File.WriteAt"><code>WriteAt</code></a> method will always return an error.
+ </p>
+
+</dl><!-- os -->
+
+<dl id="os/exec"><dt><a href="/pkg/os/exec/">os/exec</a></dt>
+ <dd>
+ <p><!-- CL 174318 -->
+ On Windows, the environment for a <a href="/pkg/os/exec/#Cmd"><code>Cmd</code></a> always inherits the
+ <code>%SYSTEMROOT%</code> value of the parent process unless the
+ <a href="/pkg/os/exec/#Cmd.Env"><code>Cmd.Env</code></a> field includes an explicit value for it.
+ </p>
+
+</dl><!-- os/exec -->
+
+<dl id="reflect"><dt><a href="/pkg/reflect/">reflect</a></dt>
+ <dd>
+ <p><!-- CL 171337 -->
+ The new <a href="/pkg/reflect/#Value.IsZero"><code>Value.IsZero</code></a> method reports whether a <code>Value</code> is the zero value for its type.
+ </p>
+
+ <p><!-- CL 174531 -->
+ The <a href="/pkg/reflect/#MakeFunc"><code>MakeFunc</code></a> function now allows assignment conversions on returned values, instead of requiring exact type match. This is particularly useful when the type being returned is an interface type, but the value actually returned is a concrete value implementing that type.
+ </p>
+
+</dl><!-- reflect -->
+
+<dl id="pkg-runtime"><dt><a href="/pkg/runtime/">runtime</a></dt>
+ <dd>
+ <p> <!-- CL 167780 -->
+ Tracebacks, <a href="/pkg/runtime/#Caller"><code>runtime.Caller</code></a>,
+ and <a href="/pkg/runtime/#Callers"><code>runtime.Callers</code></a> now refer to the function that
+ initializes the global variables of <code>PKG</code>
+ as <code>PKG.init</code> instead of <code>PKG.init.ializers</code>.
+ </p>
+
+</dl><!-- runtime -->
+
+<dl id="strconv"><dt><a href="/pkg/strconv/">strconv</a></dt>
+ <dd>
+ <p><!-- CL 160243 -->
+ For <a href="/pkg/strconv/#ParseFloat"><code>strconv.ParseFloat</code></a>,
+ <a href="/pkg/strconv/#ParseInt"><code>strconv.ParseInt</code></a>
+ and <a href="/pkg/strconv/#ParseUint"><code>strconv.ParseUint</code></a>,
+ if base is 0, underscores may be used between digits for readability.
+ See the <a href="#language">Changes to the language</a> for details.
+ </p>
+
+</dl><!-- strconv -->
+
+<dl id="strings"><dt><a href="/pkg/strings/">strings</a></dt>
+ <dd>
+ <p><!-- CL 142003 -->
+ The new <a href="/pkg/strings/#ToValidUTF8"><code>ToValidUTF8</code></a> function returns a
+ copy of a given string with each run of invalid UTF-8 byte sequences replaced by a given string.
+ </p>
+
+</dl><!-- strings -->
+
+<dl id="sync"><dt><a href="/pkg/sync/">sync</a></dt>
+ <dd>
+ <p><!-- CL 148958, CL 148959, CL 152697, CL 152698 -->
+ The fast paths of <a href="/pkg/sync/#Mutex.Lock"><code>Mutex.Lock</code></a>, <a href="/pkg/sync/#Mutex.Unlock"><code>Mutex.Unlock</code></a>,
+ <a href="/pkg/sync/#RWMutex.Lock"><code>RWMutex.Lock</code></a>, <a href="/pkg/sync/#Mutex.RUnlock"><code>RWMutex.RUnlock</code></a>, and
+ <a href="/pkg/sync/#Once.Do"><code>Once.Do</code></a> are now inlined in their callers.
+ For the uncontended cases on amd64, these changes make <a href="/pkg/sync/#Once.Do"><code>Once.Do</code></a> twice as fast, and the
+ <a href="/pkg/sync/#Mutex"><code>Mutex</code></a>/<a href="/pkg/sync/#RWMutex"><code>RWMutex</code></a> methods up to 10% faster.
+ </p>
+
+ <p><!-- CL 166960 -->
+ Large <a href="/pkg/sync/#Pool"><code>Pool</code></a> no longer increase stop-the-world pause times.
+ </p>
+
+ <p><!-- CL 166961 -->
+ <code>Pool</code> no longer needs to be completely repopulated after every GC. It now retains some objects across GCs,
+ as opposed to releasing all objects, reducing load spikes for heavy users of <code>Pool</code>.
+ </p>
+
+</dl><!-- sync -->
+
+<dl id="syscall"><dt><a href="/pkg/syscall/">syscall</a></dt>
+ <dd>
+ <p><!-- CL 168479 -->
+ Uses of <code>_getdirentries64</code> have been removed from
+ Darwin builds, to allow Go binaries to be uploaded to the macOS
+ App Store.
+ </p>
+
+ <p><!-- CL 174197 -->
+ The new <code>ProcessAttributes</code> and <code>ThreadAttributes</code> fields in
+ <a href="/pkg/syscall/?GOOS=windows#SysProcAttr"><code>SysProcAttr</code></a> have been introduced for Windows,
+ exposing security settings when creating new processes.
+ </p>
+
+ <p><!-- CL 174320 -->
+ <code>EINVAL</code> is no longer returned in zero
+ <a href="/pkg/syscall/?GOOS=windows#Chmod"><code>Chmod</code></a> mode on Windows.
+ </p>
+
+ <p><!-- CL 191337 -->
+ Values of type <code>Errno</code> can be tested against error values in
+ the <code>os</code> package,
+ like <a href="/pkg/os/#ErrExist"><code>ErrExist</code></a>, using
+ <a href="/pkg/errors/#Is"><code>errors.Is</code></a>.
+ </p>
+
+</dl><!-- syscall -->
+
+<dl id="syscall/js"><dt><a href="/pkg/syscall/js/">syscall/js</a></dt>
+ <dd>
+ <p><!-- CL 177537 -->
+ <code>TypedArrayOf</code> has been replaced by
+ <a href="/pkg/syscall/js/#CopyBytesToGo"><code>CopyBytesToGo</code></a> and
+ <a href="/pkg/syscall/js/#CopyBytesToJS"><code>CopyBytesToJS</code></a> for copying bytes
+ between a byte slice and a <code>Uint8Array</code>.
+ </p>
+
+</dl><!-- syscall/js -->
+
+<dl id="testing"><dt><a href="/pkg/testing/">testing</a></dt>
+ <dd>
+ <p><!-- CL 112155 -->
+ When running benchmarks, <a href="/pkg/testing/#B.N"><code>B.N</code></a> is no longer rounded.
+ </p>
+
+ <p><!-- CL 166717 -->
+ The new method <a href="/pkg/testing/#B.ReportMetric"><code>B.ReportMetric</code></a> lets users report
+ custom benchmark metrics and override built-in metrics.
+ </p>
+
+ <p><!-- CL 173722 -->
+ Testing flags are now registered in the new <a href="/pkg/testing/#Init"><code>Init</code></a> function,
+ which is invoked by the generated <code>main</code> function for the test.
+ As a result, testing flags are now only registered when running a test binary,
+ and packages that call <code>flag.Parse</code> during package initialization may cause tests to fail.
+ </p>
+
+</dl><!-- testing -->
+
+<dl id="text/scanner"><dt><a href="/pkg/text/scanner/">text/scanner</a></dt>
+ <dd>
+ <p><!-- CL 183077 -->
+ The scanner has been updated to recognize the new Go number literals, specifically
+ binary literals with <code>0b</code>/<code>0B</code> prefix, octal literals with <code>0o</code>/<code>0O</code> prefix,
+ and floating-point numbers with hexadecimal mantissa.
+ Also, the new <a href="/pkg/text/scanner/#AllowDigitSeparators"><code>AllowDigitSeparators</code></a>
+ mode allows number literals to contain underscores as digit separators (off by default for backwards-compatibility).
+ See the <a href="#language">Changes to the language</a> for details.
+ </p>
+
+</dl><!-- text/scanner -->
+
+<dl id="text/template"><dt><a href="/pkg/text/template/">text/template</a></dt>
+ <dd>
+ <p><!-- CL 161762 -->
+ The new <a href="/pkg/text/template/#hdr-Functions">slice function</a>
+ returns the result of slicing its first argument by the following arguments.
+ </p>
+
+</dl><!-- text/template -->
+
+<dl id="time"><dt><a href="/pkg/time/">time</a></dt>
+ <dd>
+ <p><!-- CL 122876 -->
+ Day-of-year is now supported by <a href="/pkg/time/#Time.Format"><code>Format</code></a>
+ and <a href="/pkg/time/#Parse"><code>Parse</code></a>.
+ </p>
+
+ <p><!-- CL 167387 -->
+ The new <a href="/pkg/time/#Duration"><code>Duration</code></a> methods
+ <a href="/pkg/time/#Duration.Microseconds"><code>Microseconds</code></a> and
+ <a href="/pkg/time/#Duration.Milliseconds"><code>Milliseconds</code></a> return
+ the duration as an integer count of their respectively named units.
+ </p>
+
+</dl><!-- time -->
+
+<dl id="unicode"><dt><a href="/pkg/unicode/">unicode</a></dt>
+ <dd>
+ <p>
+ The <a href="/pkg/unicode/"><code>unicode</code></a> package and associated
+ support throughout the system has been upgraded from Unicode 10.0 to
+ <a href="http://www.unicode.org/versions/Unicode11.0.0/">Unicode 11.0</a>,
+ which adds 684 new characters, including seven new scripts, and 66 new emoji.
+ </p>
+
+</dl><!-- unicode -->
diff --git a/_content/doc/go1.14.html b/_content/doc/go1.14.html
new file mode 100644
index 0000000..35b6947
--- /dev/null
+++ b/_content/doc/go1.14.html
@@ -0,0 +1,923 @@
+<!--{
+ "Title": "Go 1.14 Release Notes"
+}-->
+
+<!--
+NOTE: In this document and others in this directory, the convention is to
+set fixed-width phrases with non-fixed-width spaces, as in
+<code>hello</code> <code>world</code>.
+Do not send CLs removing the interior tags from such phrases.
+-->
+
+<style>
+ main ul li { margin: 0.5em 0; }
+</style>
+
+<h2 id="introduction">Introduction to Go 1.14</h2>
+
+<p>
+ The latest Go release, version 1.14, arrives six months after <a href="go1.13">Go 1.13</a>.
+ Most of its changes are in the implementation of the toolchain, runtime, and libraries.
+ As always, the release maintains the Go 1 <a href="/doc/go1compat.html">promise of compatibility</a>.
+ We expect almost all Go programs to continue to compile and run as before.
+</p>
+
+<p>
+ Module support in the <code>go</code> command is now ready for production use,
+ and we encourage all users to <a href="https://blog.golang.org/migrating-to-go-modules">migrate to Go
+ modules for dependency management</a>. If you are unable to migrate due to a problem in the Go
+ toolchain, please ensure that the problem has an
+ <a href="https://golang.org/issue?q=is%3Aissue+is%3Aopen+label%3Amodules">open issue</a>
+ filed. (If the issue is not on the <code>Go1.15</code> milestone, please let us
+ know why it prevents you from migrating so that we can prioritize it
+ appropriately.)
+</p>
+
+<h2 id="language">Changes to the language</h2>
+
+<p>
+ Per the <a href="https://github.com/golang/proposal/blob/master/design/6977-overlapping-interfaces.md">overlapping interfaces proposal</a>,
+ Go 1.14 now permits embedding of interfaces with overlapping method sets:
+ methods from an embedded interface may have the same names and identical signatures
+ as methods already present in the (embedding) interface. This solves problems that typically
+ (but not exclusively) occur with diamond-shaped embedding graphs.
+ Explicitly declared methods in an interface must remain
+ <a href="https://tip.golang.org/ref/spec#Uniqueness_of_identifiers">unique</a>, as before.
+</p>
+
+<h2 id="ports">Ports</h2>
+
+<h3 id="darwin">Darwin</h3>
+
+<p>
+ Go 1.14 is the last release that will run on macOS 10.11 El Capitan.
+ Go 1.15 will require macOS 10.12 Sierra or later.
+</p>
+
+<p><!-- golang.org/issue/34749 -->
+ Go 1.14 is the last Go release to support 32-bit binaries on
+ macOS (the <code>darwin/386</code> port). They are no longer
+ supported by macOS, starting with macOS 10.15 (Catalina).
+ Go continues to support the 64-bit <code>darwin/amd64</code> port.
+</p>
+
+<p><!-- golang.org/issue/34751 -->
+ Go 1.14 will likely be the last Go release to support 32-bit
+ binaries on iOS, iPadOS, watchOS, and tvOS
+ (the <code>darwin/arm</code> port). Go continues to support the
+ 64-bit <code>darwin/arm64</code> port.
+</p>
+
+<h3 id="windows">Windows</h3>
+
+<p><!-- CL 203601 -->
+ Go binaries on Windows now
+ have <a href="https://docs.microsoft.com/en-us/windows/win32/memory/data-execution-prevention">DEP
+ (Data Execution Prevention)</a> enabled.
+</p>
+
+<p><!-- CL 202439 -->
+ On Windows, creating a file
+ via <a href="/pkg/os#CreateFile"><code>os.OpenFile</code></a> with
+ the <a href="/pkg/os/#O_CREATE"><code>os.O_CREATE</code></a> flag, or
+ via <a href="/pkg/syscall#Open"><code>syscall.Open</code></a> with
+ the <a href="/pkg/syscall#O_CREAT"><code>syscall.O_CREAT</code></a>
+ flag, will now create the file as read-only if the
+ bit <code>0o200</code> (owner write permission) is not set in the
+ permission argument. This makes the behavior on Windows more like
+ that on Unix systems.
+</p>
+
+<h3 id="wasm">WebAssembly</h3>
+
+<p><!-- CL 203600 -->
+ JavaScript values referenced from Go via <code>js.Value</code>
+ objects can now be garbage collected.
+</p>
+
+<p><!-- CL 203600 -->
+ <code>js.Value</code> values can no longer be compared using
+ the <code>==</code> operator, and instead must be compared using
+ their <code>Equal</code> method.
+</p>
+
+<p><!-- CL 203600 -->
+ <code>js.Value</code> now
+ has <code>IsUndefined</code>, <code>IsNull</code>,
+ and <code>IsNaN</code> methods.
+</p>
+
+<h3 id="riscv">RISC-V</h3>
+
+<p><!-- Issue 27532 -->
+ Go 1.14 contains experimental support for 64-bit RISC-V on Linux
+ (<code>GOOS=linux</code>, <code>GOARCH=riscv64</code>). Be aware
+ that performance, assembly syntax stability, and possibly
+ correctness are a work in progress.
+</p>
+
+<h3 id="freebsd">FreeBSD</h3>
+
+<p><!-- CL 199919 -->
+ Go now supports the 64-bit ARM architecture on FreeBSD 12.0 or later (the
+ <code>freebsd/arm64</code> port).
+</p>
+
+<h3 id="nacl">Native Client (NaCl)</h3>
+
+<p><!-- golang.org/issue/30439 -->
+ As <a href="go1.13#ports">announced</a> in the Go 1.13 release notes,
+ Go 1.14 drops support for the Native Client platform (<code>GOOS=nacl</code>).
+</p>
+
+<h3 id="illumos">Illumos</h3>
+
+<p><!-- CL 203758 -->
+ The runtime now respects zone CPU caps
+ (the <code>zone.cpu-cap</code> resource control)
+ for <code>runtime.NumCPU</code> and the default value
+ of <code>GOMAXPROCS</code>.
+</p>
+
+<h2 id="tools">Tools</h2>
+
+<h3 id="go-command">Go command</h3>
+
+<h4 id="vendor">Vendoring</h4>
+<!-- golang.org/issue/33848 -->
+
+<p>
+ When the main module contains a top-level <code>vendor</code> directory and
+ its <code>go.mod</code> file specifies <code>go</code> <code>1.14</code> or
+ higher, the <code>go</code> command now defaults to <code>-mod=vendor</code>
+ for operations that accept that flag. A new value for that flag,
+ <code>-mod=mod</code>, causes the <code>go</code> command to instead load
+ modules from the module cache (as when no <code>vendor</code> directory is
+ present).
+</p>
+
+<p>
+ When <code>-mod=vendor</code> is set (explicitly or by default), the
+ <code>go</code> command now verifies that the main module's
+ <code>vendor/modules.txt</code> file is consistent with its
+ <code>go.mod</code> file.
+</p>
+
+<p>
+ <code>go</code> <code>list</code> <code>-m</code> no longer silently omits
+ transitive dependencies that do not provide packages in
+ the <code>vendor</code> directory. It now fails explicitly if
+ <code>-mod=vendor</code> is set and information is requested for a module not
+ mentioned in <code>vendor/modules.txt</code>.
+</p>
+
+<h4 id="go-flags">Flags</h4>
+
+<p><!-- golang.org/issue/32502, golang.org/issue/30345 -->
+ The <code>go</code> <code>get</code> command no longer accepts
+ the <code>-mod</code> flag. Previously, the flag's setting either
+ <a href="https://golang.org/issue/30345">was ignored</a> or
+ <a href="https://golang.org/issue/32502">caused the build to fail</a>.
+</p>
+
+<p><!-- golang.org/issue/33326 -->
+ <code>-mod=readonly</code> is now set by default when the <code>go.mod</code>
+ file is read-only and no top-level <code>vendor</code> directory is present.
+</p>
+
+<p><!-- golang.org/issue/31481 -->
+ <code>-modcacherw</code> is a new flag that instructs the <code>go</code>
+ command to leave newly-created directories in the module cache at their
+ default permissions rather than making them read-only.
+ The use of this flag makes it more likely that tests or other tools will
+ accidentally add files not included in the module's verified checksum.
+ However, it allows the use of <code>rm</code> <code>-rf</code>
+ (instead of <code>go</code> <code>clean</code> <code>-modcache</code>)
+ to remove the module cache.
+</p>
+
+<p><!-- golang.org/issue/34506 -->
+ <code>-modfile=file</code> is a new flag that instructs the <code>go</code>
+ command to read (and possibly write) an alternate <code>go.mod</code> file
+ instead of the one in the module root directory. A file
+ named <code>go.mod</code> must still be present in order to determine the
+ module root directory, but it is not accessed. When <code>-modfile</code> is
+ specified, an alternate <code>go.sum</code> file is also used: its path is
+ derived from the <code>-modfile</code> flag by trimming the <code>.mod</code>
+ extension and appending <code>.sum</code>.
+</p>
+
+<h4 id="go-env-vars">Environment variables</h4>
+
+<p><!-- golang.org/issue/32966 -->
+ <code>GOINSECURE</code> is a new environment variable that instructs
+ the <code>go</code> command to not require an HTTPS connection, and to skip
+ certificate validation, when fetching certain modules directly from their
+ origins. Like the existing <code>GOPRIVATE</code> variable, the value
+ of <code>GOINSECURE</code> is a comma-separated list of glob patterns.
+</p>
+
+<h4 id="commands-outside-modules">Commands outside modules</h4>
+
+<p><!-- golang.org/issue/32027 -->
+ When module-aware mode is enabled explicitly (by setting
+ <code>GO111MODULE=on</code>), most module commands have more
+ limited functionality if no <code>go.mod</code> file is present. For
+ example, <code>go</code> <code>build</code>,
+ <code>go</code> <code>run</code>, and other build commands can only build
+ packages in the standard library and packages specified as <code>.go</code>
+ files on the command line.
+</p>
+
+<p>
+ Previously, the <code>go</code> command would resolve each package path
+ to the latest version of a module but would not record the module path
+ or version. This resulted in <a href="https://golang.org/issue/32027">slow,
+ non-reproducible builds</a>.
+</p>
+
+<p>
+ <code>go</code> <code>get</code> continues to work as before, as do
+ <code>go</code> <code>mod</code> <code>download</code> and
+ <code>go</code> <code>list</code> <code>-m</code> with explicit versions.
+</p>
+
+<h4 id="incompatible-versions"><code>+incompatible</code> versions</h4>
+<!-- golang.org/issue/34165 -->
+
+<p>
+ If the latest version of a module contains a <code>go.mod</code> file,
+ <code>go</code> <code>get</code> will no longer upgrade to an
+ <a href="/cmd/go/#hdr-Module_compatibility_and_semantic_versioning">incompatible</a>
+ major version of that module unless such a version is requested explicitly
+ or is already required.
+ <code>go</code> <code>list</code> also omits incompatible major versions
+ for such a module when fetching directly from version control, but may
+ include them if reported by a proxy.
+</p>
+
+
+<h4 id="go.mod"><code>go.mod</code> file maintenance</h4>
+<!-- golang.org/issue/34822 -->
+
+<p>
+ <code>go</code> commands other than
+ <code>go</code> <code>mod</code> <code>tidy</code> no longer
+ remove a <code>require</code> directive that specifies a version of an indirect dependency
+ that is already implied by other (transitive) dependencies of the main
+ module.
+</p>
+
+<p>
+ <code>go</code> commands other than
+ <code>go</code> <code>mod</code> <code>tidy</code> no longer
+ edit the <code>go.mod</code> file if the changes are only cosmetic.
+</p>
+
+<p>
+ When <code>-mod=readonly</code> is set, <code>go</code> commands will no
+ longer fail due to a missing <code>go</code> directive or an erroneous
+ <code>// indirect</code> comment.
+</p>
+
+<h4 id="module-downloading">Module downloading</h4>
+
+<p><!-- golang.org/issue/26092 -->
+ The <code>go</code> command now supports Subversion repositories in module mode.
+</p>
+
+<p><!-- golang.org/issue/30748 -->
+ The <code>go</code> command now includes snippets of plain-text error messages
+ from module proxies and other HTTP servers.
+ An error message will only be shown if it is valid UTF-8 and consists of only
+ graphic characters and spaces.
+</p>
+
+<h4 id="go-test">Testing</h4>
+
+<p><!-- golang.org/issue/24929 -->
+ <code>go test -v</code> now streams <code>t.Log</code> output as it happens,
+ rather than at the end of all tests.
+</p>
+
+<h2 id="runtime">Runtime</h2>
+
+<p><!-- CL 190098 -->
+ This release improves the performance of most uses
+ of <code>defer</code> to incur almost zero overhead compared to
+ calling the deferred function directly.
+ As a result, <code>defer</code> can now be used in
+ performance-critical code without overhead concerns.
+</p>
+
+<p><!-- CL 201760, CL 201762 and many others -->
+ Goroutines are now asynchronously preemptible.
+ As a result, loops without function calls no longer potentially
+ deadlock the scheduler or significantly delay garbage collection.
+ This is supported on all platforms except <code>windows/arm</code>,
+ <code>darwin/arm</code>, <code>js/wasm</code>, and
+ <code>plan9/*</code>.
+</p>
+
+<p>
+ A consequence of the implementation of preemption is that on Unix
+ systems, including Linux and macOS systems, programs built with Go
+ 1.14 will receive more signals than programs built with earlier
+ releases.
+ This means that programs that use packages
+ like <a href="/pkg/syscall/"><code>syscall</code></a>
+ or <a href="https://godoc.org/golang.org/x/sys/unix"><code>golang.org/x/sys/unix</code></a>
+ will see more slow system calls fail with <code>EINTR</code> errors.
+ Those programs will have to handle those errors in some way, most
+ likely looping to try the system call again. For more
+ information about this
+ see <a href="http://man7.org/linux/man-pages/man7/signal.7.html"><code>man
+ 7 signal</code></a> for Linux systems or similar documentation for
+ other systems.
+</p>
+
+<p><!-- CL 201765, CL 195701 and many others -->
+ The page allocator is more efficient and incurs significantly less
+ lock contention at high values of <code>GOMAXPROCS</code>.
+ This is most noticeable as lower latency and higher throughput for
+ large allocations being done in parallel and at a high rate.
+</p>
+
+<p><!-- CL 171844 and many others -->
+ Internal timers, used by
+ <a href="/pkg/time/#After"><code>time.After</code></a>,
+ <a href="/pkg/time/#Tick"><code>time.Tick</code></a>,
+ <a href="/pkg/net/#Conn"><code>net.Conn.SetDeadline</code></a>,
+ and friends, are more efficient, with less lock contention and fewer
+ context switches.
+ This is a performance improvement that should not cause any user
+ visible changes.
+</p>
+
+<h2 id="compiler">Compiler</h2>
+
+<p><!-- CL 162237 -->
+ This release adds <code>-d=checkptr</code> as a compile-time option
+ for adding instrumentation to check that Go code is following
+ <code>unsafe.Pointer</code> safety rules dynamically.
+ This option is enabled by default (except on Windows) with
+ the <code>-race</code> or <code>-msan</code> flags, and can be
+ disabled with <code>-gcflags=all=-d=checkptr=0</code>.
+ Specifically, <code>-d=checkptr</code> checks the following:
+</p>
+
+<ol>
+ <li>
+ When converting <code>unsafe.Pointer</code> to <code>*T</code>,
+ the resulting pointer must be aligned appropriately
+ for <code>T</code>.
+ </li>
+ <li>
+ If the result of pointer arithmetic points into a Go heap object,
+ one of the <code>unsafe.Pointer</code>-typed operands must point
+ into the same object.
+ </li>
+</ol>
+
+<p>
+ Using <code>-d=checkptr</code> is not currently recommended on
+ Windows because it causes false alerts in the standard library.
+</p>
+
+<p><!-- CL 204338 -->
+ The compiler can now emit machine-readable logs of key optimizations
+ using the <code>-json</code> flag, including inlining, escape
+ analysis, bounds-check elimination, and nil-check elimination.
+</p>
+
+<p><!-- CL 196959 -->
+ Detailed escape analysis diagnostics (<code>-m=2</code>) now work again.
+ This had been dropped from the new escape analysis implementation in
+ the previous release.
+</p>
+
+<p><!-- CL 196217 -->
+ All Go symbols in macOS binaries now begin with an underscore,
+ following platform conventions.
+</p>
+
+<p><!-- CL 202117 -->
+ This release includes experimental support for compiler-inserted
+ coverage instrumentation for fuzzing.
+ See <a href="https://golang.org/issue/14565">issue 14565</a> for more
+ details.
+ This API may change in future releases.
+</p>
+
+<p><!-- CL 174704 --><!-- CL 196784 -->
+ Bounds check elimination now uses information from slice creation and can
+ eliminate checks for indexes with types smaller than <code>int</code>.
+</p>
+
+<h2 id="library">Core library</h2>
+
+<h3 id="hash/maphash">New byte sequence hashing package</h3>
+
+<p> <!-- golang.org/issue/28322, CL 186877 -->
+ Go 1.14 includes a new package,
+ <a href="/pkg/hash/maphash/"><code>hash/maphash</code></a>,
+ which provides hash functions on byte sequences.
+ These hash functions are intended to be used to implement hash tables or
+ other data structures that need to map arbitrary strings or byte
+ sequences to a uniform distribution on unsigned 64-bit integers.
+</p>
+<p>
+ The hash functions are collision-resistant but not cryptographically secure.
+</p>
+<p>
+ The hash value of a given byte sequence is consistent within a
+ single process, but will be different in different processes.
+</p>
+
+<h3 id="minor_library_changes">Minor changes to the library</h3>
+
+<p>
+ As always, there are various minor changes and updates to the library,
+ made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
+ in mind.
+</p>
+
+<dl id="crypto/tls"><dt><a href="/pkg/crypto/tls/">crypto/tls</a></dt>
+ <dd>
+ <p><!-- CL 191976 -->
+ Support for SSL version 3.0 (SSLv3) has been removed. Note that SSLv3 is the
+ <a href="https://tools.ietf.org/html/rfc7568">cryptographically broken</a>
+ protocol predating TLS.
+ </p>
+
+ <p><!-- CL 191999 -->
+ TLS 1.3 can't be disabled via the <code>GODEBUG</code> environment
+ variable anymore. Use the
+ <a href="/pkg/crypto/tls/#Config.MaxVersion"><code>Config.MaxVersion</code></a>
+ field to configure TLS versions.
+ </p>
+
+ <p><!-- CL 205059 -->
+ When multiple certificate chains are provided through the
+ <a href="/pkg/crypto/tls/#Config.Certificates"><code>Config.Certificates</code></a>
+ field, the first one compatible with the peer is now automatically
+ selected. This allows for example providing an ECDSA and an RSA
+ certificate, and letting the package automatically select the best one.
+ Note that the performance of this selection is going to be poor unless the
+ <a href="/pkg/crypto/tls/#Certificate.Leaf"><code>Certificate.Leaf</code></a>
+ field is set. The
+ <a href="/pkg/crypto/tls/#Config.NameToCertificate"><code>Config.NameToCertificate</code></a>
+ field, which only supports associating a single certificate with
+ a give name, is now deprecated and should be left as <code>nil</code>.
+ Similarly the
+ <a href="/pkg/crypto/tls/#Config.BuildNameToCertificate"><code>Config.BuildNameToCertificate</code></a>
+ method, which builds the <code>NameToCertificate</code> field
+ from the leaf certificates, is now deprecated and should not be
+ called.
+ </p>
+
+ <p><!-- CL 175517 -->
+ The new <a href="/pkg/crypto/tls/#CipherSuites"><code>CipherSuites</code></a>
+ and <a href="/pkg/crypto/tls/#InsecureCipherSuites"><code>InsecureCipherSuites</code></a>
+ functions return a list of currently implemented cipher suites.
+ The new <a href="/pkg/crypto/tls/#CipherSuiteName"><code>CipherSuiteName</code></a>
+ function returns a name for a cipher suite ID.
+ </p>
+
+ <p><!-- CL 205058, 205057 -->
+ The new <a href="/pkg/crypto/tls/#ClientHelloInfo.SupportsCertificate">
+ <code>(*ClientHelloInfo).SupportsCertificate</code></a> and
+ <a href="/pkg/crypto/tls/#CertificateRequestInfo.SupportsCertificate">
+ <code>(*CertificateRequestInfo).SupportsCertificate</code></a>
+ methods expose whether a peer supports a certain certificate.
+ </p>
+
+ <p><!-- CL 174329 -->
+ The <code>tls</code> package no longer supports the legacy Next Protocol
+ Negotiation (NPN) extension and now only supports ALPN. In previous
+ releases it supported both. There are no API changes and applications
+ should function identically as before. Most other clients and servers have
+ already removed NPN support in favor of the standardized ALPN.
+ </p>
+
+ <p><!-- CL 205063, 205062 -->
+ RSA-PSS signatures are now used when supported in TLS 1.2 handshakes. This
+ won't affect most applications, but custom
+ <a href="/pkg/crypto/tls/#Certificate.PrivateKey"><code>Certificate.PrivateKey</code></a>
+ implementations that don't support RSA-PSS signatures will need to use the new
+ <a href="/pkg/crypto/tls/#Certificate.SupportedSignatureAlgorithms">
+ <code>Certificate.SupportedSignatureAlgorithms</code></a>
+ field to disable them.
+ </p>
+
+ <p><!-- CL 205059, 205059 -->
+ <a href="/pkg/crypto/tls/#Config.Certificates"><code>Config.Certificates</code></a> and
+ <a href="/pkg/crypto/tls/#Config.GetCertificate"><code>Config.GetCertificate</code></a>
+ can now both be nil if
+ <a href="/pkg/crypto/tls/#Config.GetConfigForClient"><code>Config.GetConfigForClient</code></a>
+ is set. If the callbacks return neither certificates nor an error, the
+ <code>unrecognized_name</code> is now sent.
+ </p>
+
+ <p><!-- CL 205058 -->
+ The new <a href="/pkg/crypto/tls/#CertificateRequestInfo.Version"><code>CertificateRequestInfo.Version</code></a>
+ field provides the TLS version to client certificates callbacks.
+ </p>
+
+ <p><!-- CL 205068 -->
+ The new <code>TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256</code> and
+ <code>TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256</code> constants use
+ the final names for the cipher suites previously referred to as
+ <code>TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305</code> and
+ <code>TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305</code>.
+ </p>
+ </dd>
+</dl><!-- crypto/tls -->
+
+<dl id="crypto/x509"><dt><a href="/pkg/crypto/x509/">crypto/x509</a></dt>
+ <dd>
+ <p><!-- CL 204046 -->
+ <a href="/pkg/crypto/x509/#Certificate.CreateCRL"><code>Certificate.CreateCRL</code></a>
+ now supports Ed25519 issuers.
+ </p>
+ </dd>
+</dl>
+
+<dl id="debug/dwarf"><dt><a href="/pkg/debug/dwarf/">debug/dwarf</a></dt>
+ <dd>
+ <p><!-- CL 175138 -->
+ The <code>debug/dwarf</code> package now supports reading DWARF
+ version 5.
+ </p>
+ <p>
+ The new
+ method <a href="/pkg/debug/dwarf/#Data.AddSection"><code>(*Data).AddSection</code></a>
+ supports adding arbitrary new DWARF sections from the input file
+ to the DWARF <code>Data</code>.
+ </p>
+
+ <p><!-- CL 192698 -->
+ The new
+ method <a href="/pkg/debug/dwarf/#Reader.ByteOrder"><code>(*Reader).ByteOrder</code></a>
+ returns the byte order of the current compilation unit.
+ This may be used to interpret attributes that are encoded in the
+ native ordering, such as location descriptions.
+ </p>
+
+ <p><!-- CL 192699 -->
+ The new
+ method <a href="/pkg/debug/dwarf/#LineReader.Files"><code>(*LineReader).Files</code></a>
+ returns the file name table from a line reader.
+ This may be used to interpret the value of DWARF attributes such
+ as <code>AttrDeclFile</code>.
+ </p>
+ </dd>
+</dl><!-- debug/dwarf -->
+
+<dl id="encoding/asn1"><dt><a href="/pkg/encoding/asn1/">encoding/asn1</a></dt>
+ <dd>
+ <p><!-- CL 126624 -->
+ <a href="/pkg/encoding/asn1/#Unmarshal"><code>Unmarshal</code></a>
+ now supports ASN.1 string type BMPString, represented by the new
+ <a href="/pkg/encoding/asn1/#TagBMPString"><code>TagBMPString</code></a>
+ constant.
+ </p>
+ </dd>
+</dl><!-- encoding/asn1 -->
+
+<dl id="encoding/json"><dt><a href="/pkg/encoding/json/">encoding/json</a></dt>
+ <dd>
+ <p><!-- CL 200677 -->
+ The <a href="/pkg/encoding/json/#Decoder"><code>Decoder</code></a>
+ type supports a new
+ method <a href="/pkg/encoding/json/#Decoder.InputOffset"><code>InputOffset</code></a>
+ that returns the input stream byte offset of the current
+ decoder position.
+ </p>
+
+ <p><!-- CL 200217 -->
+ <a href="/pkg/encoding/json/#Compact"><code>Compact</code></a> no longer
+ escapes the <code>U+2028</code> and <code>U+2029</code> characters, which
+ was never a documented feature. For proper escaping, see <a
+ href="/pkg/encoding/json/#HTMLEscape"><code>HTMLEscape</code></a>.
+ </p>
+
+ <p><!-- CL 195045 -->
+ <a href="/pkg/encoding/json/#Number"><code>Number</code></a> no longer
+ accepts invalid numbers, to follow the documented behavior more closely.
+ If a program needs to accept invalid numbers like the empty string,
+ consider wrapping the type with <a href="/pkg/encoding/json/#Unmarshaler"><code>Unmarshaler</code></a>.
+ </p>
+
+ <p><!-- CL 200237 -->
+ <a href="/pkg/encoding/json/#Unmarshal"><code>Unmarshal</code></a>
+ can now support map keys with string underlying type which implement
+ <a href="/pkg/encoding/#TextUnmarshaler"><code>encoding.TextUnmarshaler</code></a>.
+ </p>
+ </dd>
+</dl><!-- encoding/json -->
+
+<dl id="go/build"><dt><a href="/pkg/go/build/">go/build</a></dt>
+ <dd>
+ <p><!-- CL 203820, 211657 -->
+ The <a href="/pkg/go/build/#Context"><code>Context</code></a>
+ type has a new field <code>Dir</code> which may be used to set
+ the working directory for the build.
+ The default is the current directory of the running process.
+ In module mode, this is used to locate the main module.
+ </p>
+ </dd>
+</dl><!-- go/build -->
+
+<dl id="go/doc"><dt><a href="/pkg/go/doc/">go/doc</a></dt>
+ <dd>
+ <p><!-- CL 204830 -->
+ The new
+ function <a href="/pkg/go/doc/#NewFromFiles"><code>NewFromFiles</code></a>
+ computes package documentation from a list
+ of <code>*ast.File</code>'s and associates examples with the
+ appropriate package elements.
+ The new information is available in a new <code>Examples</code>
+ field
+ in the <a href="/pkg/go/doc/#Package"><code>Package</code></a>, <a href="/pkg/go/doc/#Type"><code>Type</code></a>,
+ and <a href="/pkg/go/doc/#Func"><code>Func</code></a> types, and a
+ new <a href="/pkg/go/doc/#Example.Suffix"><code>Suffix</code></a>
+ field in
+ the <a href="/pkg/go/doc/#Example"><code>Example</code></a>
+ type.
+ </p>
+ </dd>
+</dl><!-- go/doc -->
+
+<dl id="io/ioutil"><dt><a href="/pkg/io/ioutil/">io/ioutil</a></dt>
+ <dd>
+ <p><!-- CL 198488 -->
+ <a href="/pkg/io/ioutil/#TempDir"><code>TempDir</code></a> can now create directories
+ whose names have predictable prefixes and suffixes.
+ As with <a href="/pkg/io/ioutil/#TempFile"><code>TempFile</code></a>, if the pattern
+ contains a '*', the random string replaces the last '*'.
+ </p>
+ </dd>
+</dl>
+
+<dl id="log"><dt><a href="/pkg/log/">log</a></dt>
+ <dd>
+ <p><!-- CL 186182 -->
+ The
+ new <a href="https://tip.golang.org/pkg/log/#pkg-constants"><code>Lmsgprefix</code></a>
+ flag may be used to tell the logging functions to emit the
+ optional output prefix immediately before the log message rather
+ than at the start of the line.
+ </p>
+ </dd>
+</dl><!-- log -->
+
+<dl id="math"><dt><a href="/pkg/math/">math</a></dt>
+ <dd>
+ <p><!-- CL 127458 -->
+ The new <a href="/pkg/math/#FMA"><code>FMA</code></a> function
+ computes <code>x*y+z</code> in floating point with no
+ intermediate rounding of the <code>x*y</code>
+ computation. Several architectures implement this computation
+ using dedicated hardware instructions for additional performance.
+ </p>
+ </dd>
+</dl><!-- math -->
+
+<dl id="math/big"><dt><a href="/pkg/math/big/">math/big</a></dt>
+ <dd>
+ <p><!-- CL 164972 -->
+ The <a href="/pkg/math/big/#Int.GCD"><code>GCD</code></a> method
+ now allows the inputs <code>a</code> and <code>b</code> to be
+ zero or negative.
+ </p>
+ </dd>
+</dl><!-- math/big -->
+
+<dl id="math/bits"><dt><a href="/pkg/math/bits/">math/bits</a></dt>
+ <dd>
+ <p><!-- CL 197838 -->
+ The new functions
+ <a href="/pkg/math/bits/#Rem"><code>Rem</code></a>,
+ <a href="/pkg/math/bits/#Rem32"><code>Rem32</code></a>, and
+ <a href="/pkg/math/bits/#Rem64"><code>Rem64</code></a>
+ support computing a remainder even when the quotient overflows.
+ </p>
+ </dd>
+</dl><!-- math/bits -->
+
+<dl id="mime"><dt><a href="/pkg/mime/">mime</a></dt>
+ <dd>
+ <p><!-- CL 186927 -->
+ The default type of <code>.js</code> and <code>.mjs</code> files
+ is now <code>text/javascript</code> rather
+ than <code>application/javascript</code>.
+ This is in accordance
+ with <a href="https://datatracker.ietf.org/doc/draft-ietf-dispatch-javascript-mjs/">an
+ IETF draft</a> that treats <code>application/javascript</code> as obsolete.
+ </p>
+ </dd>
+</dl><!-- mime -->
+
+<dl id="mime/multipart"><dt><a href="/pkg/mime/multipart/">mime/multipart</a></dt>
+ <dd>
+ <p>
+ The
+ new <a href="/pkg/mime/multipart/#Reader"><code>Reader</code></a>
+ method <a href="/pkg/mime/multipart/#Reader.NextRawPart"><code>NextRawPart</code></a>
+ supports fetching the next MIME part without transparently
+ decoding <code>quoted-printable</code> data.
+ </p>
+ </dd>
+</dl><!-- mime/multipart -->
+
+<dl id="net/http"><dt><a href="/pkg/net/http/">net/http</a></dt>
+ <dd>
+ <p><!-- CL 200760 -->
+ The new <a href="/pkg/net/http/#Header"><code>Header</code></a>
+ method <a href="/pkg/net/http/#Header.Values"><code>Values</code></a>
+ can be used to fetch all values associated with a
+ canonicalized key.
+ </p>
+
+ <p><!-- CL 61291 -->
+ The
+ new <a href="/pkg/net/http/#Transport"><code>Transport</code></a>
+ field <a href="/pkg/net/http/#Transport.DialTLSContext"><code>DialTLSContext</code></a>
+ can be used to specify an optional dial function for creating
+ TLS connections for non-proxied HTTPS requests.
+ This new field can be used instead
+ of <a href="/pkg/net/http/#Transport.DialTLS"><code>DialTLS</code></a>,
+ which is now considered deprecated; <code>DialTLS</code> will
+ continue to work, but new code should
+ use <code>DialTLSContext</code>, which allows the transport to
+ cancel dials as soon as they are no longer needed.
+ </p>
+
+ <p><!-- CL 192518, CL 194218 -->
+ On Windows, <a href="/pkg/net/http/#ServeFile"><code>ServeFile</code></a> now correctly
+ serves files larger than 2GB.
+ </p>
+ </dd>
+</dl><!-- net/http -->
+
+<dl id="net/http/httptest"><dt><a href="/pkg/net/http/httptest/">net/http/httptest</a></dt>
+ <dd>
+ <p><!-- CL 201557 -->
+ The
+ new <a href="/pkg/net/http/httptest/#Server"><code>Server</code></a>
+ field <a href="/pkg/net/http/httptest/#Server.EnableHTTP2"><code>EnableHTTP2</code></a>
+ supports enabling HTTP/2 on the test server.
+ </p>
+ </dd>
+</dl><!-- net/http/httptest -->
+
+<dl id="net/textproto"><dt><a href="/pkg/net/textproto/">net/textproto</a></dt>
+ <dd>
+ <p><!-- CL 200760 -->
+ The
+ new <a href="/pkg/net/textproto/#MIMEHeader"><code>MIMEHeader</code></a>
+ method <a href="/pkg/net/textproto/#MIMEHeader.Values"><code>Values</code></a>
+ can be used to fetch all values associated with a canonicalized
+ key.
+ </p>
+ </dd>
+</dl><!-- net/textproto -->
+
+<dl id="net/url"><dt><a href="/pkg/net/url/">net/url</a></dt>
+ <dd>
+ <p><!-- CL 185117 -->
+ When parsing of a URL fails
+ (for example by <a href="/pkg/net/url/#Parse"><code>Parse</code></a>
+ or <a href="/pkg/net/url/#ParseRequestURI"><code>ParseRequestURI</code></a>),
+ the resulting <a href="/pkg/net/url/#Error.Error"><code>Error</code></a> message
+ will now quote the unparsable URL.
+ This provides clearer structure and consistency with other parsing errors.
+ </p>
+ </dd>
+</dl><!-- net/url -->
+
+<dl id="os/signal"><dt><a href="/pkg/os/signal/">os/signal</a></dt>
+ <dd>
+ <p><!-- CL 187739 -->
+ On Windows,
+ the <code>CTRL_CLOSE_EVENT</code>, <code>CTRL_LOGOFF_EVENT</code>,
+ and <code>CTRL_SHUTDOWN_EVENT</code> events now generate
+ a <code>syscall.SIGTERM</code> signal, similar to how Control-C
+ and Control-Break generate a <code>syscall.SIGINT</code> signal.
+ </p>
+ </dd>
+</dl><!-- os/signal -->
+
+<dl id="plugin"><dt><a href="/pkg/plugin/">plugin</a></dt>
+ <dd>
+ <p><!-- CL 191617 -->
+ The <code>plugin</code> package now supports <code>freebsd/amd64</code>.
+ </p>
+ </dd>
+</dl><!-- plugin -->
+
+<dl id="reflect"><dt><a href="/pkg/reflect/">reflect</a></dt>
+ <dd>
+ <p><!-- CL 85661 -->
+ <a href="/pkg/reflect#StructOf"><code>StructOf</code></a> now
+ supports creating struct types with unexported fields, by
+ setting the <code>PkgPath</code> field in
+ a <code>StructField</code> element.
+ </p>
+ </dd>
+</dl><!-- reflect -->
+
+<dl id="pkg-runtime"><dt><a href="/pkg/runtime/">runtime</a></dt>
+ <dd>
+ <p><!-- CL 200081 -->
+ <code>runtime.Goexit</code> can no longer be aborted by a
+ recursive <code>panic</code>/<code>recover</code>.
+ </p>
+
+ <p><!-- CL 188297, CL 191785 -->
+ On macOS, <code>SIGPIPE</code> is no longer forwarded to signal
+ handlers installed before the Go runtime is initialized.
+ This is necessary because macOS delivers <code>SIGPIPE</code>
+ <a href="https://golang.org/issue/33384">to the main thread</a>
+ rather than the thread writing to the closed pipe.
+ </p>
+ </dd>
+</dl><!-- runtime -->
+
+<dl id="runtime/pprof"><dt><a href="/pkg/runtime/pprof/">runtime/pprof</a></dt>
+ <dd>
+ <p><!-- CL 204636, 205097 -->
+ The generated profile no longer includes the pseudo-PCs used for inline
+ marks. Symbol information of inlined functions is encoded in
+ <a href="https://github.com/google/pprof/blob/5e96527/proto/profile.proto#L177-L184">the format</a>
+ the pprof tool expects. This is a fix for the regression introduced
+ during recent releases.
+ </p>
+ </dd>
+</dl><!-- runtime/pprof -->
+
+<dl id="strconv"><dt><a href="/pkg/strconv/">strconv</a></dt>
+ <dd>
+ <p>
+ The <a href="/pkg/strconv/#NumError"><code>NumError</code></a>
+ type now has
+ an <a href="/pkg/strconv/#NumError.Unwrap"><code>Unwrap</code></a>
+ method that may be used to retrieve the reason that a conversion
+ failed.
+ This supports using <code>NumError</code> values
+ with <a href="/pkg/errors/#Is"><code>errors.Is</code></a> to see
+ if the underlying error
+ is <a href="/pkg/strconv/#pkg-variables"><code>strconv.ErrRange</code></a>
+ or <a href="/pkg/strconv/#pkg-variables"><code>strconv.ErrSyntax</code></a>.
+ </p>
+ </dd>
+</dl><!-- strconv -->
+
+<dl id="sync"><dt><a href="/pkg/sync/">sync</a></dt>
+ <dd>
+ <p><!-- CL 200577 -->
+ Unlocking a highly contended <code>Mutex</code> now directly
+ yields the CPU to the next goroutine waiting for
+ that <code>Mutex</code>. This significantly improves the
+ performance of highly contended mutexes on high CPU count
+ machines.
+ </p>
+ </dd>
+</dl><!-- sync -->
+
+<dl id="testing"><dt><a href="/pkg/testing/">testing</a></dt>
+ <dd>
+ <p><!-- CL 201359 -->
+ The testing package now supports cleanup functions, called after
+ a test or benchmark has finished, by calling
+ <a href="/pkg/testing#T.Cleanup"><code>T.Cleanup</code></a> or
+ <a href="/pkg/testing#B.Cleanup"><code>B.Cleanup</code></a> respectively.
+ </p>
+ </dd>
+</dl><!-- testing -->
+
+<dl id="text/template"><dt><a href="/pkg/text/template/">text/template</a></dt>
+ <dd>
+ <p><!-- CL 206124 -->
+ The text/template package now correctly reports errors when a
+ parenthesized argument is used as a function.
+ This most commonly shows up in erroneous cases like
+ <code>{{if (eq .F "a") or (eq .F "b")}}</code>.
+ This should be written as <code>{{if or (eq .F "a") (eq .F "b")}}</code>.
+ The erroneous case never worked as expected, and will now be
+ reported with an error <code>can't give argument to non-function</code>.
+ </p>
+ </dd>
+</dl><!-- text/template -->
+
+<dl id="unicode"><dt><a href="/pkg/unicode/">unicode</a></dt>
+ <dd>
+ <p>
+ The <a href="/pkg/unicode/"><code>unicode</code></a> package and associated
+ support throughout the system has been upgraded from Unicode 11.0 to
+ <a href="https://www.unicode.org/versions/Unicode12.0.0/">Unicode 12.0</a>,
+ which adds 554 new characters, including four new scripts, and 61 new emoji.
+ </p>
+ </dd>
+</dl><!-- unicode -->
diff --git a/_content/doc/go1.15.html b/_content/doc/go1.15.html
new file mode 100644
index 0000000..3e8214d
--- /dev/null
+++ b/_content/doc/go1.15.html
@@ -0,0 +1,1063 @@
+<!--{
+ "Title": "Go 1.15 Release Notes"
+}-->
+
+<!--
+NOTE: In this document and others in this directory, the convention is to
+set fixed-width phrases with non-fixed-width spaces, as in
+<code>hello</code> <code>world</code>.
+Do not send CLs removing the interior tags from such phrases.
+-->
+
+<style>
+ main ul li { margin: 0.5em 0; }
+</style>
+
+<h2 id="introduction">Introduction to Go 1.15</h2>
+
+<p>
+ The latest Go release, version 1.15, arrives six months after <a href="go1.14">Go 1.14</a>.
+ Most of its changes are in the implementation of the toolchain, runtime, and libraries.
+ As always, the release maintains the Go 1 <a href="/doc/go1compat.html">promise of compatibility</a>.
+ We expect almost all Go programs to continue to compile and run as before.
+</p>
+
+<p>
+ Go 1.15 includes <a href="#linker">substantial improvements to the linker</a>,
+ improves <a href="#runtime">allocation for small objects at high core counts</a>, and
+ deprecates <a href="#commonname">X.509 CommonName</a>.
+ <code>GOPROXY</code> now supports skipping proxies that return errors and
+ a new <a href="#time/tzdata">embedded tzdata package</a> has been added.
+</p>
+
+<h2 id="language">Changes to the language</h2>
+
+<p>
+ There are no changes to the language.
+</p>
+
+<h2 id="ports">Ports</h2>
+
+<h3 id="darwin">Darwin</h3>
+
+<p>
+ As <a href="go1.14#darwin">announced</a> in the Go 1.14 release
+ notes, Go 1.15 requires macOS 10.12 Sierra or later; support for
+ previous versions has been discontinued.
+</p>
+
+<p> <!-- golang.org/issue/37610, golang.org/issue/37611, CL 227582, and CL 227198 -->
+ As <a href="/doc/go1.14#darwin">announced</a> in the Go 1.14 release
+ notes, Go 1.15 drops support for 32-bit binaries on macOS, iOS,
+ iPadOS, watchOS, and tvOS (the <code>darwin/386</code>
+ and <code>darwin/arm</code> ports). Go continues to support the
+ 64-bit <code>darwin/amd64</code> and <code>darwin/arm64</code> ports.
+</p>
+
+<h3 id="windows">Windows</h3>
+
+<p> <!-- CL 214397 and CL 230217 -->
+ Go now generates Windows ASLR executables when <code>-buildmode=pie</code>
+ cmd/link flag is provided. Go command uses <code>-buildmode=pie</code>
+ by default on Windows.
+</p>
+
+<p><!-- CL 227003 -->
+ The <code>-race</code> and <code>-msan</code> flags now always
+ enable <code>-d=checkptr</code>, which checks uses
+ of <code>unsafe.Pointer</code>. This was previously the case on all
+ OSes except Windows.
+</p>
+
+<p><!-- CL 211139 -->
+ Go-built DLLs no longer cause the process to exit when it receives a
+ signal (such as Ctrl-C at a terminal).
+</p>
+
+<h3 id="android">Android</h3>
+
+<p> <!-- CL 235017, golang.org/issue/38838 -->
+ When linking binaries for Android, Go 1.15 explicitly selects
+ the <code>lld</code> linker available in recent versions of the NDK.
+ The <code>lld</code> linker avoids crashes on some devices, and is
+ planned to become the default NDK linker in a future NDK version.
+</p>
+
+<h3 id="openbsd">OpenBSD</h3>
+
+<p><!-- CL 234381 -->
+ Go 1.15 adds support for OpenBSD 6.7 on <code>GOARCH=arm</code>
+ and <code>GOARCH=arm64</code>. Previous versions of Go already
+ supported OpenBSD 6.7 on <code>GOARCH=386</code>
+ and <code>GOARCH=amd64</code>.
+</p>
+
+<h3 id="riscv">RISC-V</h3>
+
+<p> <!-- CL 226400, CL 226206, and others -->
+ There has been progress in improving the stability and performance
+ of the 64-bit RISC-V port on Linux (<code>GOOS=linux</code>,
+ <code>GOARCH=riscv64</code>). It also now supports asynchronous
+ preemption.
+</p>
+
+<h3 id="386">386</h3>
+
+<p><!-- golang.org/issue/40255 -->
+ Go 1.15 is the last release to support x87-only floating-point
+ hardware (<code>GO386=387</code>). Future releases will require at
+ least SSE2 support on 386, raising Go's
+ minimum <code>GOARCH=386</code> requirement to the Intel Pentium 4
+ (released in 2000) or AMD Opteron/Athlon 64 (released in 2003).
+</p>
+
+<h2 id="tools">Tools</h2>
+
+<h3 id="go-command">Go command</h3>
+
+<p><!-- golang.org/issue/37367 -->
+ The <code>GOPROXY</code> environment variable now supports skipping proxies
+ that return errors. Proxy URLs may now be separated with either commas
+ (<code>,</code>) or pipe characters (<code>|</code>). If a proxy URL is
+ followed by a comma, the <code>go</code> command will only try the next proxy
+ in the list after a 404 or 410 HTTP response. If a proxy URL is followed by a
+ pipe character, the <code>go</code> command will try the next proxy in the
+ list after any error. Note that the default value of <code>GOPROXY</code>
+ remains <code>https://proxy.golang.org,direct</code>, which does not fall
+ back to <code>direct</code> in case of errors.
+</p>
+
+<h4 id="go-test"><code>go</code> <code>test</code></h4>
+
+<p><!-- https://golang.org/issue/36134 -->
+ Changing the <code>-timeout</code> flag now invalidates cached test results. A
+ cached result for a test run with a long timeout will no longer count as
+ passing when <code>go</code> <code>test</code> is re-invoked with a short one.
+</p>
+
+<h4 id="go-flag-parsing">Flag parsing</h4>
+
+<p><!-- https://golang.org/cl/211358 -->
+ Various flag parsing issues in <code>go</code> <code>test</code> and
+ <code>go</code> <code>vet</code> have been fixed. Notably, flags specified
+ in <code>GOFLAGS</code> are handled more consistently, and
+ the <code>-outputdir</code> flag now interprets relative paths relative to the
+ working directory of the <code>go</code> command (rather than the working
+ directory of each individual test).
+</p>
+
+<h4 id="module-cache">Module cache</h4>
+
+<p><!-- https://golang.org/cl/219538 -->
+ The location of the module cache may now be set with
+ the <code>GOMODCACHE</code> environment variable. The default value of
+ <code>GOMODCACHE</code> is <code>GOPATH[0]/pkg/mod</code>, the location of the
+ module cache before this change.
+</p>
+
+<p><!-- https://golang.org/cl/221157 -->
+ A workaround is now available for Windows "Access is denied" errors in
+ <code>go</code> commands that access the module cache, caused by external
+ programs concurrently scanning the file system (see
+ <a href="https://golang.org/issue/36568">issue #36568</a>). The workaround is
+ not enabled by default because it is not safe to use when Go versions lower
+ than 1.14.2 and 1.13.10 are running concurrently with the same module cache.
+ It can be enabled by explicitly setting the environment variable
+ <code>GODEBUG=modcacheunzipinplace=1</code>.
+</p>
+
+<h3 id="vet">Vet</h3>
+
+<h4 id="vet-string-int">New warning for string(x)</h4>
+
+<p><!-- CL 212919, 232660 -->
+ The vet tool now warns about conversions of the
+ form <code>string(x)</code> where <code>x</code> has an integer type
+ other than <code>rune</code> or <code>byte</code>.
+ Experience with Go has shown that many conversions of this form
+ erroneously assume that <code>string(x)</code> evaluates to the
+ string representation of the integer <code>x</code>.
+ It actually evaluates to a string containing the UTF-8 encoding of
+ the value of <code>x</code>.
+ For example, <code>string(9786)</code> does not evaluate to the
+ string <code>"9786"</code>; it evaluates to the
+ string <code>"\xe2\x98\xba"</code>, or <code>"☺"</code>.
+</p>
+
+<p>
+ Code that is using <code>string(x)</code> correctly can be rewritten
+ to <code>string(rune(x))</code>.
+ Or, in some cases, calling <code>utf8.EncodeRune(buf, x)</code> with
+ a suitable byte slice <code>buf</code> may be the right solution.
+ Other code should most likely use <code>strconv.Itoa</code>
+ or <code>fmt.Sprint</code>.
+</p>
+
+<p>
+ This new vet check is enabled by default when
+ using <code>go</code> <code>test</code>.
+</p>
+
+<p>
+ We are considering prohibiting the conversion in a future release of Go.
+ That is, the language would change to only
+ permit <code>string(x)</code> for integer <code>x</code> when the
+ type of <code>x</code> is <code>rune</code> or <code>byte</code>.
+ Such a language change would not be backward compatible.
+ We are using this vet check as a first trial step toward changing
+ the language.
+</p>
+
+<h4 id="vet-impossible-interface">New warning for impossible interface conversions</h4>
+
+<p><!-- CL 218779, 232660 -->
+ The vet tool now warns about type assertions from one interface type
+ to another interface type when the type assertion will always fail.
+ This will happen if both interface types implement a method with the
+ same name but with a different type signature.
+</p>
+
+<p>
+ There is no reason to write a type assertion that always fails, so
+ any code that triggers this vet check should be rewritten.
+</p>
+
+<p>
+ This new vet check is enabled by default when
+ using <code>go</code> <code>test</code>.
+</p>
+
+<p>
+ We are considering prohibiting impossible interface type assertions
+ in a future release of Go.
+ Such a language change would not be backward compatible.
+ We are using this vet check as a first trial step toward changing
+ the language.
+</p>
+
+<h2 id="runtime">Runtime</h2>
+
+<p><!-- CL 221779 -->
+ If <code>panic</code> is invoked with a value whose type is derived from any
+ of: <code>bool</code>, <code>complex64</code>, <code>complex128</code>, <code>float32</code>, <code>float64</code>,
+ <code>int</code>, <code>int8</code>, <code>int16</code>, <code>int32</code>, <code>int64</code>, <code>string</code>,
+ <code>uint</code>, <code>uint8</code>, <code>uint16</code>, <code>uint32</code>, <code>uint64</code>, <code>uintptr</code>,
+ then the value will be printed, instead of just its address.
+ Previously, this was only true for values of exactly these types.
+</p>
+
+<p><!-- CL 228900 -->
+ On a Unix system, if the <code>kill</code> command
+ or <code>kill</code> system call is used to send
+ a <code>SIGSEGV</code>, <code>SIGBUS</code>,
+ or <code>SIGFPE</code> signal to a Go program, and if the signal
+ is not being handled via
+ <a href="/pkg/os/signal/#Notify"><code>os/signal.Notify</code></a>,
+ the Go program will now reliably crash with a stack trace.
+ In earlier releases the behavior was unpredictable.
+</p>
+
+<p><!-- CL 221182, CL 229998 -->
+ Allocation of small objects now performs much better at high core
+ counts, and has lower worst-case latency.
+</p>
+
+<p><!-- CL 216401 -->
+ Converting a small integer value into an interface value no longer
+ causes allocation.
+</p>
+
+<p><!-- CL 216818 -->
+ Non-blocking receives on closed channels now perform as well as
+ non-blocking receives on open channels.
+</p>
+
+<h2 id="compiler">Compiler</h2>
+
+<p><!-- CL 229578 -->
+ Package <code>unsafe</code>'s <a href="/pkg/unsafe/#Pointer">safety
+ rules</a> allow converting an <code>unsafe.Pointer</code>
+ into <code>uintptr</code> when calling certain
+ functions. Previously, in some cases, the compiler allowed multiple
+ chained conversions (for example, <code>syscall.Syscall(…,</code>
+ <code>uintptr(uintptr(ptr)),</code> <code>…)</code>). The compiler
+ now requires exactly one conversion. Code that used multiple
+ conversions should be updated to satisfy the safety rules.
+</p>
+
+<p><!-- CL 230544, CL 231397 -->
+ Go 1.15 reduces typical binary sizes by around 5% compared to Go
+ 1.14 by eliminating certain types of GC metadata and more
+ aggressively eliminating unused type metadata.
+</p>
+
+<p><!-- CL 219357, CL 231600 -->
+ The toolchain now mitigates
+ <a href="https://www.intel.com/content/www/us/en/support/articles/000055650/processors.html">Intel
+ CPU erratum SKX102</a> on <code>GOARCH=amd64</code> by aligning
+ functions to 32 byte boundaries and padding jump instructions. While
+ this padding increases binary sizes, this is more than made up for
+ by the binary size improvements mentioned above.
+</p>
+
+<p><!-- CL 222661 -->
+ Go 1.15 adds a <code>-spectre</code> flag to both the
+ compiler and the assembler, to allow enabling Spectre mitigations.
+ These should almost never be needed and are provided mainly as a
+ “defense in depth” mechanism.
+ See the <a href="https://github.com/golang/go/wiki/Spectre">Spectre wiki page</a> for details.
+</p>
+
+<p><!-- CL 228578 -->
+ The compiler now rejects <code>//go:</code> compiler directives that
+ have no meaning for the declaration they are applied to with a
+ "misplaced compiler directive" error. Such misapplied directives
+ were broken before, but were silently ignored by the compiler.
+</p>
+
+<p><!-- CL 206658, CL 205066 -->
+ The compiler's <code>-json</code> optimization logging now reports
+ large (>= 128 byte) copies and includes explanations of escape
+ analysis decisions.
+</p>
+
+<h2 id="linker">Linker</h2>
+
+<p>
+ This release includes substantial improvements to the Go linker,
+ which reduce linker resource usage (both time and memory) and
+ improve code robustness/maintainability.
+</p>
+
+<p>
+ For a representative set of large Go programs, linking is 20% faster
+ and requires 30% less memory on average, for <code>ELF</code>-based
+ OSes (Linux, FreeBSD, NetBSD, OpenBSD, Dragonfly, and Solaris)
+ running on <code>amd64</code> architectures, with more modest
+ improvements for other architecture/OS combinations.
+</p>
+
+<p>
+ The key contributors to better linker performance are a newly
+ redesigned object file format, and a revamping of internal
+ phases to increase concurrency (for example, applying relocations to
+ symbols in parallel). Object files in Go 1.15 are slightly larger
+ than their 1.14 equivalents.
+</p>
+
+<p>
+ These changes are part of a multi-release project
+ to <a href="https://golang.org/s/better-linker">modernize the Go
+ linker</a>, meaning that there will be additional linker
+ improvements expected in future releases.
+</p>
+
+<p><!-- CL 207877 -->
+ The linker now defaults to internal linking mode
+ for <code>-buildmode=pie</code> on
+ <code>linux/amd64</code> and <code>linux/arm64</code>, so these
+ configurations no longer require a C linker. External linking
+ mode (which was the default in Go 1.14 for
+ <code>-buildmode=pie</code>) can still be requested with
+ <code>-ldflags=-linkmode=external</code> flag.
+</p>
+
+<h2 id="objdump">Objdump</h2>
+
+<p><!-- CL 225459 -->
+ The <a href="/cmd/objdump/">objdump</a> tool now supports
+ disassembling in GNU assembler syntax with the <code>-gnu</code>
+ flag.
+</p>
+
+<h2 id="library">Core library</h2>
+
+<h3 id="time/tzdata">New embedded tzdata package</h3>
+
+<p> <!-- CL 224588 -->
+ Go 1.15 includes a new package,
+ <a href="/pkg/time/tzdata/"><code>time/tzdata</code></a>,
+ that permits embedding the timezone database into a program.
+ Importing this package (as <code>import _ "time/tzdata"</code>)
+ permits the program to find timezone information even if the
+ timezone database is not available on the local system.
+ You can also embed the timezone database by building
+ with <code>-tags timetzdata</code>.
+ Either approach increases the size of the program by about 800 KB.
+</p>
+
+<h3 id="cgo">Cgo</h3>
+
+<p><!-- CL 235817 -->
+ Go 1.15 will translate the C type <code>EGLConfig</code> to the
+ Go type <code>uintptr</code>. This change is similar to how Go
+ 1.12 and newer treats <code>EGLDisplay</code>, Darwin's CoreFoundation and
+ Java's JNI types. See the <a href="/cmd/cgo/#hdr-Special_cases">cgo
+ documentation</a> for more information.
+</p>
+
+<p><!-- CL 250940 -->
+ In Go 1.15.3 and later, cgo will not permit Go code to allocate an
+ undefined struct type (a C struct defined as just <code>struct
+ S;</code> or similar) on the stack or heap.
+ Go code will only be permitted to use pointers to those types.
+ Allocating an instance of such a struct and passing a pointer, or a
+ full struct value, to C code was always unsafe and unlikely to work
+ correctly; it is now forbidden.
+ The fix is to either rewrite the Go code to use only pointers, or to
+ ensure that the Go code sees the full definition of the struct by
+ including the appropriate C header file.
+</p>
+
+<h3 id="commonname">X.509 CommonName deprecation</h3>
+
+<p><!-- CL 231379 -->
+ The deprecated, legacy behavior of treating the <code>CommonName</code>
+ field on X.509 certificates as a host name when no Subject Alternative Names
+ are present is now disabled by default. It can be temporarily re-enabled by
+ adding the value <code>x509ignoreCN=0</code> to the <code>GODEBUG</code>
+ environment variable.
+</p>
+
+<p>
+ Note that if the <code>CommonName</code> is an invalid host name, it's always
+ ignored, regardless of <code>GODEBUG</code> settings. Invalid names include
+ those with any characters other than letters, digits, hyphens and underscores,
+ and those with empty labels or trailing dots.
+</p>
+
+<h3 id="minor_library_changes">Minor changes to the library</h3>
+
+<p>
+ As always, there are various minor changes and updates to the library,
+ made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
+ in mind.
+</p>
+
+<dl id="bufio"><dt><a href="/pkg/bufio/">bufio</a></dt>
+ <dd>
+ <p><!-- CL 225357, CL 225557 -->
+ When a <a href="/pkg/bufio/#Scanner"><code>Scanner</code></a> is
+ used with an invalid
+ <a href="/pkg/io/#Reader"><code>io.Reader</code></a> that
+ incorrectly returns a negative number from <code>Read</code>,
+ the <code>Scanner</code> will no longer panic, but will instead
+ return the new error
+ <a href="/pkg/bufio/#ErrBadReadCount"><code>ErrBadReadCount</code></a>.
+ </p>
+ </dd>
+</dl><!-- bufio -->
+
+<dl id="context"><dt><a href="/pkg/context/">context</a></dt>
+ <dd>
+ <p><!-- CL 223777 -->
+ Creating a derived <code>Context</code> using a nil parent is now explicitly
+ disallowed. Any attempt to do so with the
+ <a href="/pkg/context/#WithValue"><code>WithValue</code></a>,
+ <a href="/pkg/context/#WithDeadline"><code>WithDeadline</code></a>, or
+ <a href="/pkg/context/#WithCancel"><code>WithCancel</code></a> functions
+ will cause a panic.
+ </p>
+ </dd>
+</dl><!-- context -->
+
+<dl id="crypto"><dt><a href="/pkg/crypto/">crypto</a></dt>
+ <dd>
+ <p><!-- CL 231417, CL 225460 -->
+ The <code>PrivateKey</code> and <code>PublicKey</code> types in the
+ <a href="/pkg/crypto/rsa/"><code>crypto/rsa</code></a>,
+ <a href="/pkg/crypto/ecdsa/"><code>crypto/ecdsa</code></a>, and
+ <a href="/pkg/crypto/ed25519/"><code>crypto/ed25519</code></a> packages
+ now have an <code>Equal</code> method to compare keys for equivalence
+ or to make type-safe interfaces for public keys. The method signature
+ is compatible with
+ <a href="https://pkg.go.dev/github.com/google/go-cmp/cmp#Equal"><code>go-cmp</code>'s
+ definition of equality</a>.
+ </p>
+
+ <p><!-- CL 224937 -->
+ <a href="/pkg/crypto/#Hash"><code>Hash</code></a> now implements
+ <a href="/pkg/fmt/#Stringer"><code>fmt.Stringer</code></a>.
+ </p>
+ </dd>
+</dl><!-- crypto -->
+
+<dl id="crypto/ecdsa"><dt><a href="/pkg/crypto/ecdsa/">crypto/ecdsa</a></dt>
+ <dd>
+ <p><!-- CL 217940 -->
+ The new <a href="/pkg/crypto/ecdsa/#SignASN1"><code>SignASN1</code></a>
+ and <a href="/pkg/crypto/ecdsa/#VerifyASN1"><code>VerifyASN1</code></a>
+ functions allow generating and verifying ECDSA signatures in the standard
+ ASN.1 DER encoding.
+ </p>
+ </dd>
+</dl><!-- crypto/ecdsa -->
+
+<dl id="crypto/elliptic"><dt><a href="/pkg/crypto/elliptic/">crypto/elliptic</a></dt>
+ <dd>
+ <p><!-- CL 202819 -->
+ The new <a href="/pkg/crypto/elliptic/#MarshalCompressed"><code>MarshalCompressed</code></a>
+ and <a href="/pkg/crypto/elliptic/#UnmarshalCompressed"><code>UnmarshalCompressed</code></a>
+ functions allow encoding and decoding NIST elliptic curve points in compressed format.
+ </p>
+ </dd>
+</dl><!-- crypto/elliptic -->
+
+<dl id="crypto/rsa"><dt><a href="/pkg/crypto/rsa/">crypto/rsa</a></dt>
+ <dd>
+ <p><!-- CL 226203 -->
+ <a href="/pkg/crypto/rsa/#VerifyPKCS1v15"><code>VerifyPKCS1v15</code></a>
+ now rejects invalid short signatures with missing leading zeroes, according to RFC 8017.
+ </p>
+ </dd>
+</dl><!-- crypto/rsa -->
+
+<dl id="crypto/tls"><dt><a href="/pkg/crypto/tls/">crypto/tls</a></dt>
+ <dd>
+ <p><!-- CL 214977 -->
+ The new
+ <a href="/pkg/crypto/tls/#Dialer"><code>Dialer</code></a>
+ type and its
+ <a href="/pkg/crypto/tls/#Dialer.DialContext"><code>DialContext</code></a>
+ method permit using a context to both connect and handshake with a TLS server.
+ </p>
+
+ <p><!-- CL 229122 -->
+ The new
+ <a href="/pkg/crypto/tls/#Config.VerifyConnection"><code>VerifyConnection</code></a>
+ callback on the <a href="/pkg/crypto/tls/#Config"><code>Config</code></a> type
+ allows custom verification logic for every connection. It has access to the
+ <a href="/pkg/crypto/tls/#ConnectionState"><code>ConnectionState</code></a>
+ which includes peer certificates, SCTs, and stapled OCSP responses.
+ </p>
+
+ <p><!-- CL 230679 -->
+ Auto-generated session ticket keys are now automatically rotated every 24 hours,
+ with a lifetime of 7 days, to limit their impact on forward secrecy.
+ </p>
+
+ <p><!-- CL 231317 -->
+ Session ticket lifetimes in TLS 1.2 and earlier, where the session keys
+ are reused for resumed connections, are now limited to 7 days, also to
+ limit their impact on forward secrecy.
+ </p>
+
+ <p><!-- CL 231038 -->
+ The client-side downgrade protection checks specified in RFC 8446 are now
+ enforced. This has the potential to cause connection errors for clients
+ encountering middleboxes that behave like unauthorized downgrade attacks.
+ </p>
+
+ <p><!-- CL 208226 -->
+ <a href="/pkg/crypto/tls/#SignatureScheme"><code>SignatureScheme</code></a>,
+ <a href="/pkg/crypto/tls/#CurveID"><code>CurveID</code></a>, and
+ <a href="/pkg/crypto/tls/#ClientAuthType"><code>ClientAuthType</code></a>
+ now implement <a href="/pkg/fmt/#Stringer"><code>fmt.Stringer</code></a>.
+ </p>
+
+ <p><!-- CL 236737 -->
+ The <a href="/pkg/crypto/tls/#ConnectionState"><code>ConnectionState</code></a>
+ fields <code>OCSPResponse</code> and <code>SignedCertificateTimestamps</code>
+ are now repopulated on client-side resumed connections.
+ </p>
+
+ <p><!-- CL 227840 -->
+ <a href="/pkg/crypto/tls/#Conn"><code>tls.Conn</code></a>
+ now returns an opaque error on permanently broken connections, wrapping
+ the temporary
+ <a href="/pkg/net/http/#Error"><code>net.Error</code></a>. To access the
+ original <code>net.Error</code>, use
+ <a href="/pkg/errors/#As"><code>errors.As</code></a> (or
+ <a href="/pkg/errors/#Unwrap"><code>errors.Unwrap</code></a>) instead of a
+ type assertion.
+ </p>
+ </dd>
+</dl><!-- crypto/tls -->
+
+<dl id="crypto/x509"><dt><a href="/pkg/crypto/x509/">crypto/x509</a></dt>
+ <dd>
+ <p><!-- CL 231378, CL 231380, CL 231381 -->
+ If either the name on the certificate or the name being verified (with
+ <a href="/pkg/crypto/x509/#VerifyOptions.DNSName"><code>VerifyOptions.DNSName</code></a>
+ or <a href="/pkg/crypto/x509/#Certificate.VerifyHostname"><code>VerifyHostname</code></a>)
+ are invalid, they will now be compared case-insensitively without further
+ processing (without honoring wildcards or stripping trailing dots).
+ Invalid names include those with any characters other than letters,
+ digits, hyphens and underscores, those with empty labels, and names on
+ certificates with trailing dots.
+ </p>
+
+ <p><!-- CL 217298 -->
+ The new <a href="/pkg/crypto/x509/#CreateRevocationList"><code>CreateRevocationList</code></a>
+ function and <a href="/pkg/crypto/x509/#RevocationList"><code>RevocationList</code></a> type
+ allow creating RFC 5280-compliant X.509 v2 Certificate Revocation Lists.
+ </p>
+
+ <p><!-- CL 227098 -->
+ <a href="/pkg/crypto/x509/#CreateCertificate"><code>CreateCertificate</code></a>
+ now automatically generates the <code>SubjectKeyId</code> if the template
+ is a CA and doesn't explicitly specify one.
+ </p>
+
+ <p><!-- CL 228777 -->
+ <a href="/pkg/crypto/x509/#CreateCertificate"><code>CreateCertificate</code></a>
+ now returns an error if the template specifies <code>MaxPathLen</code> but is not a CA.
+ </p>
+
+ <p><!-- CL 205237 -->
+ On Unix systems other than macOS, the <code>SSL_CERT_DIR</code>
+ environment variable can now be a colon-separated list.
+ </p>
+
+ <p><!-- CL 227037 -->
+ On macOS, binaries are now always linked against
+ <code>Security.framework</code> to extract the system trust roots,
+ regardless of whether cgo is available. The resulting behavior should be
+ more consistent with the OS verifier.
+ </p>
+ </dd>
+</dl><!-- crypto/x509 -->
+
+<dl id="crypto/x509/pkix"><dt><a href="/pkg/crypto/x509/pkix/">crypto/x509/pkix</a></dt>
+ <dd>
+ <p><!-- CL 229864, CL 240543 -->
+ <a href="/pkg/crypto/x509/pkix/#Name.String"><code>Name.String</code></a>
+ now prints non-standard attributes from
+ <a href="/pkg/crypto/x509/pkix/#Name.Names"><code>Names</code></a> if
+ <a href="/pkg/crypto/x509/pkix/#Name.ExtraNames"><code>ExtraNames</code></a> is nil.
+ </p>
+ </dd>
+</dl><!-- crypto/x509/pkix -->
+
+<dl id="database/sql"><dt><a href="/pkg/database/sql/">database/sql</a></dt>
+ <dd>
+ <p><!-- CL 145758 -->
+ The new <a href="/pkg/database/sql/#DB.SetConnMaxIdleTime"><code>DB.SetConnMaxIdleTime</code></a>
+ method allows removing a connection from the connection pool after
+ it has been idle for a period of time, without regard to the total
+ lifespan of the connection. The <a href="/pkg/database/sql/#DBStats.MaxIdleTimeClosed"><code>DBStats.MaxIdleTimeClosed</code></a>
+ field shows the total number of connections closed due to
+ <code>DB.SetConnMaxIdleTime</code>.
+ </p>
+
+ <p><!-- CL 214317 -->
+ The new <a href="/pkg/database/sql/#Row.Err"><code>Row.Err</code></a> getter
+ allows checking for query errors without calling
+ <code>Row.Scan</code>.
+ </p>
+ </dd>
+</dl><!-- database/sql -->
+
+<dl id="database/sql/driver"><dt><a href="/pkg/database/sql/driver/">database/sql/driver</a></dt>
+ <dd>
+ <p><!-- CL 174122 -->
+ The new <a href="/pkg/database/sql/driver/#Validator"><code>Validator</code></a>
+ interface may be implemented by <code>Conn</code> to allow drivers
+ to signal if a connection is valid or if it should be discarded.
+ </p>
+ </dd>
+</dl><!-- database/sql/driver -->
+
+<dl id="debug/pe"><dt><a href="/pkg/debug/pe/">debug/pe</a></dt>
+ <dd>
+ <p><!-- CL 222637 -->
+ The package now defines the
+ <code>IMAGE_FILE</code>, <code>IMAGE_SUBSYSTEM</code>,
+ and <code>IMAGE_DLLCHARACTERISTICS</code> constants used by the
+ PE file format.
+ </p>
+ </dd>
+</dl><!-- debug/pe -->
+
+<dl id="encoding/asn1"><dt><a href="/pkg/encoding/asn1/">encoding/asn1</a></dt>
+ <dd>
+ <p><!-- CL 226984 -->
+ <a href="/pkg/encoding/asn1/#Marshal"><code>Marshal</code></a> now sorts the components
+ of SET OF according to X.690 DER.
+ </p>
+
+ <p><!-- CL 227320 -->
+ <a href="/pkg/encoding/asn1/#Unmarshal"><code>Unmarshal</code></a> now rejects tags and
+ Object Identifiers which are not minimally encoded according to X.690 DER.
+ </p>
+ </dd>
+</dl><!-- encoding/asn1 -->
+
+<dl id="encoding/json"><dt><a href="/pkg/encoding/json/">encoding/json</a></dt>
+ <dd>
+ <p><!-- CL 199837 -->
+ The package now has an internal limit to the maximum depth of
+ nesting when decoding. This reduces the possibility that a
+ deeply nested input could use large quantities of stack memory,
+ or even cause a "goroutine stack exceeds limit" panic.
+ </p>
+ </dd>
+</dl><!-- encoding/json -->
+
+<dl id="flag"><dt><a href="/pkg/flag/">flag</a></dt>
+ <dd>
+ <p><!-- CL 221427 -->
+ When the <code>flag</code> package sees <code>-h</code> or <code>-help</code>,
+ and those flags are not defined, it now prints a usage message.
+ If the <a href="/pkg/flag/#FlagSet"><code>FlagSet</code></a> was created with
+ <a href="/pkg/flag/#ExitOnError"><code>ExitOnError</code></a>,
+ <a href="/pkg/flag/#FlagSet.Parse"><code>FlagSet.Parse</code></a> would then
+ exit with a status of 2. In this release, the exit status for <code>-h</code>
+ or <code>-help</code> has been changed to 0. In particular, this applies to
+ the default handling of command line flags.
+ </p>
+ </dd>
+</dl>
+
+<dl id="fmt"><dt><a href="/pkg/fmt/">fmt</a></dt>
+ <dd>
+ <p><!-- CL 215001 -->
+ The printing verbs <code>%#g</code> and <code>%#G</code> now preserve
+ trailing zeros for floating-point values.
+ </p>
+ </dd>
+</dl><!-- fmt -->
+
+<dl id="go/format"><dt><a href="/pkg/go/format/">go/format</a></dt>
+ <dd>
+ <p><!-- golang.org/issue/37476, CL 231461, CL 240683 -->
+ The <a href="/pkg/go/format/#Source"><code>Source</code></a> and
+ <a href="/pkg/go/format/#Node"><code>Node</code></a> functions
+ now canonicalize number literal prefixes and exponents as part
+ of formatting Go source code. This matches the behavior of the
+ <a href="/pkg/cmd/gofmt/"><code>gofmt</code></a> command as it
+ was implemented <a href="/doc/go1.13#gofmt">since Go 1.13</a>.
+ </p>
+ </dd>
+</dl><!-- go/format -->
+
+<dl id="html/template"><dt><a href="/pkg/html/template/">html/template</a></dt>
+ <dd>
+ <p><!-- CL 226097 -->
+ The package now uses Unicode escapes (<code>\uNNNN</code>) in all
+ JavaScript and JSON contexts. This fixes escaping errors in
+ <code>application/ld+json</code> and <code>application/json</code>
+ contexts.
+ </p>
+ </dd>
+</dl><!-- html/template -->
+
+<dl id="io/ioutil"><dt><a href="/pkg/io/ioutil/">io/ioutil</a></dt>
+ <dd>
+ <p><!-- CL 212597 -->
+ <a href="/pkg/io/ioutil/#TempDir"><code>TempDir</code></a> and
+ <a href="/pkg/io/ioutil/#TempFile"><code>TempFile</code></a>
+ now reject patterns that contain path separators.
+ That is, calls such as <code>ioutil.TempFile("/tmp",</code> <code>"../base*")</code> will no longer succeed.
+ This prevents unintended directory traversal.
+ </p>
+ </dd>
+</dl><!-- io/ioutil -->
+
+<dl id="math/big"><dt><a href="/pkg/math/big/">math/big</a></dt>
+ <dd>
+ <p><!-- CL 230397 -->
+ The new <a href="/pkg/math/big/#Int.FillBytes"><code>Int.FillBytes</code></a>
+ method allows serializing to fixed-size pre-allocated byte slices.
+ </p>
+ </dd>
+</dl><!-- math/big -->
+
+<dl id="math/cmplx"><dt><a href="/pkg/math/cmplx/">math/cmplx</a></dt>
+ <dd>
+ <p><!-- CL 220689 -->
+ The functions in this package were updated to conform to the C99 standard
+ (Annex G IEC 60559-compatible complex arithmetic) with respect to handling
+ of special arguments such as infinity, NaN and signed zero.
+ </p>
+ </dd>
+</dl><!-- math/cmplx-->
+
+<dl id="net"><dt><a href="/pkg/net/">net</a></dt>
+ <dd>
+ <p><!-- CL 228645 -->
+ If an I/O operation exceeds a deadline set by
+ the <a href="/pkg/net/#Conn"><code>Conn.SetDeadline</code></a>,
+ <code>Conn.SetReadDeadline</code>,
+ or <code>Conn.SetWriteDeadline</code> methods, it will now
+ return an error that is or wraps
+ <a href="/pkg/os/#ErrDeadlineExceeded"><code>os.ErrDeadlineExceeded</code></a>.
+ This may be used to reliably detect whether an error is due to
+ an exceeded deadline.
+ Earlier releases recommended calling the <code>Timeout</code>
+ method on the error, but I/O operations can return errors for
+ which <code>Timeout</code> returns <code>true</code> although a
+ deadline has not been exceeded.
+ </p>
+
+ <p><!-- CL 228641 -->
+ The new <a href="/pkg/net/#Resolver.LookupIP"><code>Resolver.LookupIP</code></a>
+ method supports IP lookups that are both network-specific and accept a context.
+ </p>
+ </dd>
+</dl>
+
+<dl id="net/http"><dt><a href="/pkg/net/http/">net/http</a></dt>
+ <dd>
+ <p><!-- CL 231418, CL 231419 -->
+ Parsing is now stricter as a hardening measure against request smuggling attacks:
+ non-ASCII white space is no longer trimmed like SP and HTAB, and support for the
+ "<code>identity</code>" <code>Transfer-Encoding</code> was dropped.
+ </p>
+ </dd>
+</dl><!-- net/http -->
+
+<dl id="net/http/httputil"><dt><a href="/pkg/net/http/httputil/">net/http/httputil</a></dt>
+ <dd>
+ <p><!-- CL 230937 -->
+ <a href="/pkg/net/http/httputil/#ReverseProxy"><code>ReverseProxy</code></a>
+ now supports not modifying the <code>X-Forwarded-For</code>
+ header when the incoming <code>Request.Header</code> map entry
+ for that field is <code>nil</code>.
+ </p>
+
+ <p><!-- CL 224897 -->
+ When a Switching Protocol (like WebSocket) request handled by
+ <a href="/pkg/net/http/httputil/#ReverseProxy"><code>ReverseProxy</code></a>
+ is canceled, the backend connection is now correctly closed.
+ </p>
+ </dd>
+</dl>
+
+<dl id="net/http/pprof"><dt><a href="/pkg/net/http/pprof/">net/http/pprof</a></dt>
+ <dd>
+ <p><!-- CL 147598, CL 229537 -->
+ All profile endpoints now support a "<code>seconds</code>" parameter. When present,
+ the endpoint profiles for the specified number of seconds and reports the difference.
+ The meaning of the "<code>seconds</code>" parameter in the <code>cpu</code> profile and
+ the trace endpoints is unchanged.
+ </p>
+ </dd>
+</dl>
+
+<dl id="net/url"><dt><a href="/pkg/net/url/">net/url</a></dt>
+ <dd>
+ <p><!-- CL 227645 -->
+ The new <a href="/pkg/net/url/#URL"><code>URL</code></a> field
+ <code>RawFragment</code> and method <a href="/pkg/net/url/#URL.EscapedFragment"><code>EscapedFragment</code></a>
+ provide detail about and control over the exact encoding of a particular fragment.
+ These are analogous to
+ <code>RawPath</code> and <a href="/pkg/net/url/#URL.EscapedPath"><code>EscapedPath</code></a>.
+ </p>
+ <p><!-- CL 207082 -->
+ The new <a href="/pkg/net/url/#URL"><code>URL</code></a>
+ method <a href="/pkg/net/url/#URL.Redacted"><code>Redacted</code></a>
+ returns the URL in string form with any password replaced with <code>xxxxx</code>.
+ </p>
+ </dd>
+</dl>
+
+<dl id="os"><dt><a href="/pkg/os/">os</a></dt>
+ <dd>
+ <p><!-- CL -->
+ If an I/O operation exceeds a deadline set by
+ the <a href="/pkg/os/#File.SetDeadline"><code>File.SetDeadline</code></a>,
+ <a href="/pkg/os/#File.SetReadDeadline"><code>File.SetReadDeadline</code></a>,
+ or <a href="/pkg/os/#File.SetWriteDeadline"><code>File.SetWriteDeadline</code></a>
+ methods, it will now return an error that is or wraps
+ <a href="/pkg/os/#ErrDeadlineExceeded"><code>os.ErrDeadlineExceeded</code></a>.
+ This may be used to reliably detect whether an error is due to
+ an exceeded deadline.
+ Earlier releases recommended calling the <code>Timeout</code>
+ method on the error, but I/O operations can return errors for
+ which <code>Timeout</code> returns <code>true</code> although a
+ deadline has not been exceeded.
+ </p>
+
+ <p><!-- CL 232862 -->
+ Packages <code>os</code> and <code>net</code> now automatically
+ retry system calls that fail with <code>EINTR</code>. Previously
+ this led to spurious failures, which became more common in Go
+ 1.14 with the addition of asynchronous preemption. Now this is
+ handled transparently.
+ </p>
+
+ <p><!-- CL 229101 -->
+ The <a href="/pkg/os/#File"><code>os.File</code></a> type now
+ supports a <a href="/pkg/os/#File.ReadFrom"><code>ReadFrom</code></a>
+ method. This permits the use of the <code>copy_file_range</code>
+ system call on some systems when using
+ <a href="/pkg/io/#Copy"><code>io.Copy</code></a> to copy data
+ from one <code>os.File</code> to another. A consequence is that
+ <a href="/pkg/io/#CopyBuffer"><code>io.CopyBuffer</code></a>
+ will not always use the provided buffer when copying to a
+ <code>os.File</code>. If a program wants to force the use of
+ the provided buffer, it can be done by writing
+ <code>io.CopyBuffer(struct{ io.Writer }{dst}, src, buf)</code>.
+ </p>
+ </dd>
+</dl>
+
+<dl id="plugin"><dt><a href="/pkg/plugin/">plugin</a></dt>
+ <dd>
+ <p><!-- CL 182959 -->
+ DWARF generation is now supported (and enabled by default) for <code>-buildmode=plugin</code> on macOS.
+ </p>
+ </dd>
+ <dd>
+ <p><!-- CL 191617 -->
+ Building with <code>-buildmode=plugin</code> is now supported on <code>freebsd/amd64</code>.
+ </p>
+ </dd>
+</dl>
+
+<dl id="reflect"><dt><a href="/pkg/reflect/">reflect</a></dt>
+ <dd>
+ <p><!-- CL 228902 -->
+ Package <code>reflect</code> now disallows accessing methods of all
+ non-exported fields, whereas previously it allowed accessing
+ those of non-exported, embedded fields. Code that relies on the
+ previous behavior should be updated to instead access the
+ corresponding promoted method of the enclosing variable.
+ </p>
+ </dd>
+</dl>
+
+<dl id="regexp"><dt><a href="/pkg/regexp/">regexp</a></dt>
+ <dd>
+ <p><!-- CL 187919 -->
+ The new <a href="/pkg/regexp/#Regexp.SubexpIndex"><code>Regexp.SubexpIndex</code></a>
+ method returns the index of the first subexpression with the given name
+ within the regular expression.
+ </p>
+ </dd>
+</dl><!-- regexp -->
+
+<dl id="pkg-runtime"><dt><a href="/pkg/runtime/">runtime</a></dt>
+ <dd>
+ <p><!-- CL 216557 -->
+ Several functions, including
+ <a href="/pkg/runtime/#ReadMemStats"><code>ReadMemStats</code></a>
+ and
+ <a href="/pkg/runtime/#GoroutineProfile"><code>GoroutineProfile</code></a>,
+ no longer block if a garbage collection is in progress.
+ </p>
+ </dd>
+</dl>
+
+<dl id="pkg-runtime-pprof"><dt><a href="/pkg/runtime/pprof/">runtime/pprof</a></dt>
+ <dd>
+ <p><!-- CL 189318 -->
+ The goroutine profile now includes the profile labels associated with each
+ goroutine at the time of profiling. This feature is not yet implemented for
+ the profile reported with <code>debug=2</code>.
+ </p>
+ </dd>
+</dl>
+
+<dl id="strconv"><dt><a href="/pkg/strconv/">strconv</a></dt>
+ <dd>
+ <p><!-- CL 216617 -->
+ <a href="/pkg/strconv/#FormatComplex"><code>FormatComplex</code></a> and <a href="/pkg/strconv/#ParseComplex"><code>ParseComplex</code></a> are added for working with complex numbers.
+ </p>
+ <p>
+ <a href="/pkg/strconv/#FormatComplex"><code>FormatComplex</code></a> converts a complex number into a string of the form (a+bi), where a and b are the real and imaginary parts.
+ </p>
+ <p>
+ <a href="/pkg/strconv/#ParseComplex"><code>ParseComplex</code></a> converts a string into a complex number of a specified precision. <code>ParseComplex</code> accepts complex numbers in the format <code>N+Ni</code>.
+ </p>
+ </dd>
+</dl><!-- strconv -->
+
+<dl id="sync"><dt><a href="/pkg/sync/">sync</a></dt>
+ <dd>
+ <p><!-- CL 205899, golang.org/issue/33762 -->
+ The new method
+ <a href="/pkg/sync/#Map.LoadAndDelete"><code>Map.LoadAndDelete</code></a>
+ atomically deletes a key and returns the previous value if present.
+ </p>
+ <p><!-- CL 205899 -->
+ The method
+ <a href="/pkg/sync/#Map.Delete"><code>Map.Delete</code></a>
+ is more efficient.
+ </p>
+ </dd>
+</dl><!-- sync -->
+
+<dl id="syscall"><dt><a href="/pkg/syscall/">syscall</a></dt>
+ <dd>
+ <p><!-- CL 231638 -->
+ On Unix systems, functions that use
+ <a href="/pkg/syscall/#SysProcAttr"><code>SysProcAttr</code></a>
+ will now reject attempts to set both the <code>Setctty</code>
+ and <code>Foreground</code> fields, as they both use
+ the <code>Ctty</code> field but do so in incompatible ways.
+ We expect that few existing programs set both fields.
+ </p>
+ <p>
+ Setting the <code>Setctty</code> field now requires that the
+ <code>Ctty</code> field be set to a file descriptor number in the
+ child process, as determined by the <code>ProcAttr.Files</code> field.
+ Using a child descriptor always worked, but there were certain
+ cases where using a parent file descriptor also happened to work.
+ Some programs that set <code>Setctty</code> will need to change
+ the value of <code>Ctty</code> to use a child descriptor number.
+ </p>
+
+ <p><!-- CL 220578 -->
+ It is <a href="/pkg/syscall/#Proc.Call">now possible</a> to call
+ system calls that return floating point values
+ on <code>windows/amd64</code>.
+ </p>
+ </dd>
+</dl>
+
+<dl id="testing"><dt><a href="/pkg/testing/">testing</a></dt>
+ <dd>
+ <p><!-- golang.org/issue/28135 -->
+ The <code>testing.T</code> type now has a
+ <a href="/pkg/testing/#T.Deadline"><code>Deadline</code></a> method
+ that reports the time at which the test binary will have exceeded its
+ timeout.
+ </p>
+
+ <p><!-- golang.org/issue/34129 -->
+ A <code>TestMain</code> function is no longer required to call
+ <code>os.Exit</code>. If a <code>TestMain</code> function returns,
+ the test binary will call <code>os.Exit</code> with the value returned
+ by <code>m.Run</code>.
+ </p>
+
+ <p><!-- CL 226877, golang.org/issue/35998 -->
+ The new methods
+ <a href="/pkg/testing/#T.TempDir"><code>T.TempDir</code></a> and
+ <a href="/pkg/testing/#B.TempDir"><code>B.TempDir</code></a>
+ return temporary directories that are automatically cleaned up
+ at the end of the test.
+ </p>
+
+ <p><!-- CL 229085 -->
+ <code>go</code> <code>test</code> <code>-v</code> now groups output by
+ test name, rather than printing the test name on each line.
+ </p>
+ </dd>
+</dl><!-- testing -->
+
+<dl id="text/template"><dt><a href="/pkg/text/template/">text/template</a></dt>
+ <dd>
+ <p><!-- CL 226097 -->
+ <a href="/pkg/text/template/#JSEscape"><code>JSEscape</code></a> now
+ consistently uses Unicode escapes (<code>\u00XX</code>), which are
+ compatible with JSON.
+ </p>
+ </dd>
+</dl><!-- text/template -->
+
+<dl id="time"><dt><a href="/pkg/time/">time</a></dt>
+ <dd>
+ <p><!-- CL 220424, CL 217362, golang.org/issue/33184 -->
+ The new method
+ <a href="/pkg/time/#Ticker.Reset"><code>Ticker.Reset</code></a>
+ supports changing the duration of a ticker.
+ </p>
+
+ <p><!-- CL 227878 -->
+ When returning an error, <a href="/pkg/time/#ParseDuration"><code>ParseDuration</code></a> now quotes the original value.
+ </p>
+ </dd>
+</dl><!-- time -->
diff --git a/_content/doc/go1.16.html b/_content/doc/go1.16.html
new file mode 100644
index 0000000..79528d8
--- /dev/null
+++ b/_content/doc/go1.16.html
@@ -0,0 +1,1237 @@
+<!--{
+ "Title": "Go 1.16 Release Notes"
+}-->
+
+<!--
+NOTE: In this document and others in this directory, the convention is to
+set fixed-width phrases with non-fixed-width spaces, as in
+<code>hello</code> <code>world</code>.
+Do not send CLs removing the interior tags from such phrases.
+-->
+
+<style>
+ main ul li { margin: 0.5em 0; }
+</style>
+
+<h2 id="introduction">Introduction to Go 1.16</h2>
+
+<p>
+ The latest Go release, version 1.16, arrives six months after <a href="/doc/go1.15">Go 1.15</a>.
+ Most of its changes are in the implementation of the toolchain, runtime, and libraries.
+ As always, the release maintains the Go 1 <a href="/doc/go1compat.html">promise of compatibility</a>.
+ We expect almost all Go programs to continue to compile and run as before.
+</p>
+
+<h2 id="language">Changes to the language</h2>
+
+<p>
+ There are no changes to the language.
+</p>
+
+<h2 id="ports">Ports</h2>
+
+<h3 id="darwin">Darwin and iOS</h3>
+
+<p><!-- golang.org/issue/38485, golang.org/issue/41385, CL 266373, more CLs -->
+ Go 1.16 adds support of 64-bit ARM architecture on macOS (also known as
+ Apple Silicon) with <code>GOOS=darwin</code>, <code>GOARCH=arm64</code>.
+ Like the <code>darwin/amd64</code> port, the <code>darwin/arm64</code>
+ port supports cgo, internal and external linking, <code>c-archive</code>,
+ <code>c-shared</code>, and <code>pie</code> build modes, and the race
+ detector.
+</p>
+
+<p><!-- CL 254740 -->
+ The iOS port, which was previously <code>darwin/arm64</code>, has
+ been renamed to <code>ios/arm64</code>. <code>GOOS=ios</code>
+ implies the
+ <code>darwin</code> build tag, just as <code>GOOS=android</code>
+ implies the <code>linux</code> build tag. This change should be
+ transparent to anyone using gomobile to build iOS apps.
+</p>
+
+<p>
+ The introduction of <code>GOOS=ios</code> means that file names
+ like <code>x_ios.go</code> will now only be built for
+ <code>GOOS=ios</code>; see
+ <a href="/cmd/go/#hdr-Build_constraints"><code>go</code>
+ <code>help</code> <code>buildconstraint</code></a> for details.
+ Existing packages that use file names of this form will have to
+ rename the files.
+</p>
+
+<p><!-- golang.org/issue/42100, CL 263798 -->
+ Go 1.16 adds an <code>ios/amd64</code> port, which targets the iOS
+ simulator running on AMD64-based macOS. Previously this was
+ unofficially supported through <code>darwin/amd64</code> with
+ the <code>ios</code> build tag set. See also
+ <a href="/misc/ios/README"><code>misc/ios/README</code></a> for
+ details about how to build programs for iOS and iOS simulator.
+</p>
+
+<p><!-- golang.org/issue/23011 -->
+ Go 1.16 is the last release that will run on macOS 10.12 Sierra.
+ Go 1.17 will require macOS 10.13 High Sierra or later.
+</p>
+
+<h3 id="netbsd">NetBSD</h3>
+
+<p><!-- golang.org/issue/30824 -->
+ Go now supports the 64-bit ARM architecture on NetBSD (the
+ <code>netbsd/arm64</code> port).
+</p>
+
+<h3 id="openbsd">OpenBSD</h3>
+
+<p><!-- golang.org/issue/40995 -->
+ Go now supports the MIPS64 architecture on OpenBSD
+ (the <code>openbsd/mips64</code> port). This port does not yet
+ support cgo.
+</p>
+
+<p><!-- golang.org/issue/36435, many CLs -->
+ On the 64-bit x86 and 64-bit ARM architectures on OpenBSD (the
+ <code>openbsd/amd64</code> and <code>openbsd/arm64</code> ports), system
+ calls are now made through <code>libc</code>, instead of directly using
+ the <code>SYSCALL</code>/<code>SVC</code> instruction. This ensures
+ forward-compatibility with future versions of OpenBSD. In particular,
+ OpenBSD 6.9 onwards will require system calls to be made through
+ <code>libc</code> for non-static Go binaries.
+</p>
+
+<h3 id="386">386</h3>
+
+<p><!-- golang.org/issue/40255, golang.org/issue/41848, CL 258957, and CL 260017 -->
+ As <a href="go1.15#386">announced</a> in the Go 1.15 release notes,
+ Go 1.16 drops support for x87 mode compilation (<code>GO386=387</code>).
+ Support for non-SSE2 processors is now available using soft float
+ mode (<code>GO386=softfloat</code>).
+ Users running on non-SSE2 processors should replace <code>GO386=387</code>
+ with <code>GO386=softfloat</code>.
+</p>
+
+<h3 id="riscv">RISC-V</h3>
+
+<p><!-- golang.org/issue/36641, CL 267317 -->
+ The <code>linux/riscv64</code> port now supports cgo and
+ <code>-buildmode=pie</code>. This release also includes performance
+ optimizations and code generation improvements for RISC-V.
+</p>
+
+<h2 id="tools">Tools</h2>
+
+<h3 id="go-command">Go command</h3>
+
+<h4 id="modules">Modules</h4>
+
+<p><!-- golang.org/issue/41330 -->
+ Module-aware mode is enabled by default, regardless of whether a
+ <code>go.mod</code> file is present in the current working directory or a
+ parent directory. More precisely, the <code>GO111MODULE</code> environment
+ variable now defaults to <code>on</code>. To switch to the previous behavior,
+ set <code>GO111MODULE</code> to <code>auto</code>.
+</p>
+
+<p><!-- golang.org/issue/40728 -->
+ Build commands like <code>go</code> <code>build</code> and <code>go</code>
+ <code>test</code> no longer modify <code>go.mod</code> and <code>go.sum</code>
+ by default. Instead, they report an error if a module requirement or checksum
+ needs to be added or updated (as if the <code>-mod=readonly</code> flag were
+ used). Module requirements and sums may be adjusted with <code>go</code>
+ <code>mod</code> <code>tidy</code> or <code>go</code> <code>get</code>.
+</p>
+
+<p><!-- golang.org/issue/40276 -->
+ <code>go</code> <code>install</code> now accepts arguments with
+ version suffixes (for example, <code>go</code> <code>install</code>
+ <code>example.com/cmd@v1.0.0</code>). This causes <code>go</code>
+ <code>install</code> to build and install packages in module-aware mode,
+ ignoring the <code>go.mod</code> file in the current directory or any parent
+ directory, if there is one. This is useful for installing executables without
+ affecting the dependencies of the main module.
+</p>
+
+<p><!-- golang.org/issue/40276 -->
+ <code>go</code> <code>install</code>, with or without a version suffix (as
+ described above), is now the recommended way to build and install packages in
+ module mode. <code>go</code> <code>get</code> should be used with the
+ <code>-d</code> flag to adjust the current module's dependencies without
+ building packages, and use of <code>go</code> <code>get</code> to build and
+ install packages is deprecated. In a future release, the <code>-d</code> flag
+ will always be enabled.
+</p>
+
+<p><!-- golang.org/issue/24031 -->
+ <code>retract</code> directives may now be used in a <code>go.mod</code> file
+ to indicate that certain published versions of the module should not be used
+ by other modules. A module author may retract a version after a severe problem
+ is discovered or if the version was published unintentionally.
+</p>
+
+<p><!-- golang.org/issue/26603 -->
+ The <code>go</code> <code>mod</code> <code>vendor</code>
+ and <code>go</code> <code>mod</code> <code>tidy</code> subcommands now accept
+ the <code>-e</code> flag, which instructs them to proceed despite errors in
+ resolving missing packages.
+</p>
+
+<p><!-- golang.org/issue/36465 -->
+ The <code>go</code> command now ignores requirements on module versions
+ excluded by <code>exclude</code> directives in the main module. Previously,
+ the <code>go</code> command used the next version higher than an excluded
+ version, but that version could change over time, resulting in
+ non-reproducible builds.
+</p>
+
+<p><!-- golang.org/issue/43052, golang.org/issue/43985 -->
+ In module mode, the <code>go</code> command now disallows import paths that
+ include non-ASCII characters or path elements with a leading dot character
+ (<code>.</code>). Module paths with these characters were already disallowed
+ (see <a href="/ref/mod#go-mod-file-ident">Module paths and versions</a>),
+ so this change affects only paths within module subdirectories.
+</p>
+
+<h4 id="embed">Embedding Files</h4>
+
+<p>
+ The <code>go</code> command now supports including
+ static files and file trees as part of the final executable,
+ using the new <code>//go:embed</code> directive.
+ See the documentation for the new
+ <a href="/pkg/embed/"><code>embed</code></a>
+ package for details.
+</p>
+
+<h4 id="go-test"><code>go</code> <code>test</code></h4>
+
+<p><!-- golang.org/issue/29062 -->
+ When using <code>go</code> <code>test</code>, a test that
+ calls <code>os.Exit(0)</code> during execution of a test function
+ will now be considered to fail.
+ This will help catch cases in which a test calls code that calls
+ <code>os.Exit(0)</code> and thereby stops running all future tests.
+ If a <code>TestMain</code> function calls <code>os.Exit(0)</code>
+ that is still considered to be a passing test.
+</p>
+
+<p><!-- golang.org/issue/39484 -->
+ <code>go</code> <code>test</code> reports an error when the <code>-c</code>
+ or <code>-i</code> flags are used together with unknown flags. Normally,
+ unknown flags are passed to tests, but when <code>-c</code> or <code>-i</code>
+ are used, tests are not run.
+</p>
+
+<h4 id="go-get"><code>go</code> <code>get</code></h4>
+
+<p><!-- golang.org/issue/37519 -->
+ The <code>go</code> <code>get</code> <code>-insecure</code> flag is
+ deprecated and will be removed in a future version. This flag permits
+ fetching from repositories and resolving custom domains using insecure
+ schemes such as HTTP, and also bypasses module sum validation using the
+ checksum database. To permit the use of insecure schemes, use the
+ <code>GOINSECURE</code> environment variable instead. To bypass module
+ sum validation, use <code>GOPRIVATE</code> or <code>GONOSUMDB</code>.
+ See <code>go</code> <code>help</code> <code>environment</code> for details.
+</p>
+
+<p><!-- golang.org/cl/263267 -->
+ <code>go</code> <code>get</code> <code>example.com/mod@patch</code> now
+ requires that some version of <code>example.com/mod</code> already be
+ required by the main module.
+ (However, <code>go</code> <code>get</code> <code>-u=patch</code> continues
+ to patch even newly-added dependencies.)
+</p>
+
+<h4 id="govcs"><code>GOVCS</code> environment variable</h4>
+
+<p><!-- golang.org/issue/266420 -->
+ <code>GOVCS</code> is a new environment variable that limits which version
+ control tools the <code>go</code> command may use to download source code.
+ This mitigates security issues with tools that are typically used in trusted,
+ authenticated environments. By default, <code>git</code> and <code>hg</code>
+ may be used to download code from any repository. <code>svn</code>,
+ <code>bzr</code>, and <code>fossil</code> may only be used to download code
+ from repositories with module paths or package paths matching patterns in
+ the <code>GOPRIVATE</code> environment variable. See
+ <a href="/cmd/go/#hdr-Controlling_version_control_with_GOVCS"><code>go</code>
+ <code>help</code> <code>vcs</code></a> for details.
+</p>
+
+<h4 id="all-pattern">The <code>all</code> pattern</h4>
+
+<p><!-- golang.org/cl/240623 -->
+ When the main module's <code>go.mod</code> file
+ declares <code>go</code> <code>1.16</code> or higher, the <code>all</code>
+ package pattern now matches only those packages that are transitively imported
+ by a package or test found in the main module. (Packages imported by <em>tests
+ of</em> packages imported by the main module are no longer included.) This is
+ the same set of packages retained
+ by <code>go</code> <code>mod</code> <code>vendor</code> since Go 1.11.
+</p>
+
+<h4 id="toolexec">The <code>-toolexec</code> build flag</h4>
+
+<p><!-- golang.org/cl/263357 -->
+ When the <code>-toolexec</code> build flag is specified to use a program when
+ invoking toolchain programs like compile or asm, the environment variable
+ <code>TOOLEXEC_IMPORTPATH</code> is now set to the import path of the package
+ being built.
+</p>
+
+<h4 id="i-flag">The <code>-i</code> build flag</h4>
+
+<p><!-- golang.org/issue/41696 -->
+ The <code>-i</code> flag accepted by <code>go</code> <code>build</code>,
+ <code>go</code> <code>install</code>, and <code>go</code> <code>test</code> is
+ now deprecated. The <code>-i</code> flag instructs the <code>go</code> command
+ to install packages imported by packages named on the command line. Since
+ the build cache was introduced in Go 1.10, the <code>-i</code> flag no longer
+ has a significant effect on build times, and it causes errors when the install
+ directory is not writable.
+</p>
+
+<h4 id="list-buildid">The <code>list</code> command</h4>
+
+<p><!-- golang.org/cl/263542 -->
+ When the <code>-export</code> flag is specified, the <code>BuildID</code>
+ field is now set to the build ID of the compiled package. This is equivalent
+ to running <code>go</code> <code>tool</code> <code>buildid</code> on
+ <code>go</code> <code>list</code> <code>-exported</code> <code>-f</code> <code>{{.Export}}</code>,
+ but without the extra step.
+</p>
+
+<h4 id="overlay-flag">The <code>-overlay</code> flag</h4>
+
+<p><!-- golang.org/issue/39958 -->
+ The <code>-overlay</code> flag specifies a JSON configuration file containing
+ a set of file path replacements. The <code>-overlay</code> flag may be used
+ with all build commands and <code>go</code> <code>mod</code> subcommands.
+ It is primarily intended to be used by editor tooling such as gopls to
+ understand the effects of unsaved changes to source files. The config file
+ maps actual file paths to replacement file paths and the <code>go</code>
+ command and its builds will run as if the actual file paths exist with the
+ contents given by the replacement file paths, or don't exist if the replacement
+ file paths are empty.
+</p>
+
+<h3 id="cgo">Cgo</h3>
+
+<p><!-- CL 252378 -->
+ The <a href="/cmd/cgo">cgo</a> tool will no longer try to translate
+ C struct bitfields into Go struct fields, even if their size can be
+ represented in Go. The order in which C bitfields appear in memory
+ is implementation dependent, so in some cases the cgo tool produced
+ results that were silently incorrect.
+</p>
+
+<h3 id="vet">Vet</h3>
+
+<h4 id="vet-testing-T">New warning for invalid testing.T use in
+goroutines</h4>
+
+<p><!-- CL 235677 -->
+ The vet tool now warns about invalid calls to the <code>testing.T</code>
+ method <code>Fatal</code> from within a goroutine created during the test.
+ This also warns on calls to <code>Fatalf</code>, <code>FailNow</code>, and
+ <code>Skip{,f,Now}</code> methods on <code>testing.T</code> tests or
+ <code>testing.B</code> benchmarks.
+</p>
+
+<p>
+ Calls to these methods stop the execution of the created goroutine and not
+ the <code>Test*</code> or <code>Benchmark*</code> function. So these are
+ <a href="/pkg/testing/#T.FailNow">required</a> to be called by the goroutine
+ running the test or benchmark function. For example:
+</p>
+
+<pre>
+func TestFoo(t *testing.T) {
+ go func() {
+ if condition() {
+ t.Fatal("oops") // This exits the inner func instead of TestFoo.
+ }
+ ...
+ }()
+}
+</pre>
+
+<p>
+ Code calling <code>t.Fatal</code> (or a similar method) from a created
+ goroutine should be rewritten to signal the test failure using
+ <code>t.Error</code> and exit the goroutine early using an alternative
+ method, such as using a <code>return</code> statement. The previous example
+ could be rewritten as:
+</p>
+
+<pre>
+func TestFoo(t *testing.T) {
+ go func() {
+ if condition() {
+ t.Error("oops")
+ return
+ }
+ ...
+ }()
+}
+</pre>
+
+<h4 id="vet-frame-pointer">New warning for frame pointer</h4>
+
+<p><!-- CL 248686, CL 276372 -->
+ The vet tool now warns about amd64 assembly that clobbers the BP
+ register (the frame pointer) without saving and restoring it,
+ contrary to the calling convention. Code that doesn't preserve the
+ BP register must be modified to either not use BP at all or preserve
+ BP by saving and restoring it. An easy way to preserve BP is to set
+ the frame size to a nonzero value, which causes the generated
+ prologue and epilogue to preserve the BP register for you.
+ See <a href="https://golang.org/cl/248260">CL 248260</a> for example
+ fixes.
+</p>
+
+<h4 id="vet-asn1-unmarshal">New warning for asn1.Unmarshal</h4>
+
+<p><!-- CL 243397 -->
+ The vet tool now warns about incorrectly passing a non-pointer or nil argument to
+ <a href="/pkg/encoding/asn1/#Unmarshal"><code>asn1.Unmarshal</code></a>.
+ This is like the existing checks for
+ <a href="/pkg/encoding/json/#Unmarshal"><code>encoding/json.Unmarshal</code></a>
+ and <a href="/pkg/encoding/xml/#Unmarshal"><code>encoding/xml.Unmarshal</code></a>.
+</p>
+
+<h2 id="runtime">Runtime</h2>
+
+<p>
+ The new <a href="/pkg/runtime/metrics/"><code>runtime/metrics</code></a> package
+ introduces a stable interface for reading
+ implementation-defined metrics from the Go runtime.
+ It supersedes existing functions like
+ <a href="/pkg/runtime/#ReadMemStats"><code>runtime.ReadMemStats</code></a>
+ and
+ <a href="/pkg/runtime/debug/#GCStats"><code>debug.GCStats</code></a>
+ and is significantly more general and efficient.
+ See the package documentation for more details.
+</p>
+
+<p><!-- CL 254659 -->
+ Setting the <code>GODEBUG</code> environment variable
+ to <code>inittrace=1</code> now causes the runtime to emit a single
+ line to standard error for each package <code>init</code>,
+ summarizing its execution time and memory allocation. This trace can
+ be used to find bottlenecks or regressions in Go startup
+ performance.
+ The <a href="/pkg/runtime/#hdr-Environment_Variables"><code>GODEBUG</code>
+ documentation</a> describes the format.
+</p>
+
+<p><!-- CL 267100 -->
+ On Linux, the runtime now defaults to releasing memory to the
+ operating system promptly (using <code>MADV_DONTNEED</code>), rather
+ than lazily when the operating system is under memory pressure
+ (using <code>MADV_FREE</code>). This means process-level memory
+ statistics like RSS will more accurately reflect the amount of
+ physical memory being used by Go processes. Systems that are
+ currently using <code>GODEBUG=madvdontneed=1</code> to improve
+ memory monitoring behavior no longer need to set this environment
+ variable.
+</p>
+
+<p><!-- CL 220419, CL 271987 -->
+ Go 1.16 fixes a discrepancy between the race detector and
+ the <a href="/ref/mem">Go memory model</a>. The race detector now
+ more precisely follows the channel synchronization rules of the
+ memory model. As a result, the detector may now report races it
+ previously missed.
+</p>
+
+<h2 id="compiler">Compiler</h2>
+
+<p><!-- CL 256459, CL 264837, CL 266203, CL 256460 -->
+ The compiler can now inline functions with
+ non-labeled <code>for</code> loops, method values, and type
+ switches. The inliner can also detect more indirect calls where
+ inlining is possible.
+</p>
+
+<h2 id="linker">Linker</h2>
+
+<p><!-- CL 248197 -->
+ This release includes additional improvements to the Go linker,
+ reducing linker resource usage (both time and memory) and improving
+ code robustness/maintainability. These changes form the second half
+ of a two-release project to
+ <a href="https://golang.org/s/better-linker">modernize the Go
+ linker</a>.
+</p>
+
+<p>
+ The linker changes in 1.16 extend the 1.15 improvements to all
+ supported architecture/OS combinations (the 1.15 performance improvements
+ were primarily focused on <code>ELF</code>-based OSes and
+ <code>amd64</code> architectures). For a representative set of
+ large Go programs, linking is 20-25% faster than 1.15 and requires
+ 5-15% less memory on average for <code>linux/amd64</code>, with larger
+ improvements for other architectures and OSes. Most binaries are
+ also smaller as a result of more aggressive symbol pruning.
+</p>
+
+<p><!-- CL 255259 -->
+ On Windows, <code>go build -buildmode=c-shared</code> now generates Windows
+ ASLR DLLs by default. ASLR can be disabled with <code>--ldflags=-aslr=false</code>.
+</p>
+
+<h2 id="library">Core library</h2>
+
+<h3 id="library-embed">Embedded Files</h3>
+
+<p>
+ The new <a href="/pkg/embed/"><code>embed</code></a> package
+ provides access to files embedded in the program during compilation
+ using the new <a href="#embed"><code>//go:embed</code> directive</a>.
+</p>
+
+<h3 id="fs">File Systems</h3>
+
+<p>
+ The new <a href="/pkg/io/fs/"><code>io/fs</code></a> package
+ defines the <a href="/pkg/io/fs/#FS"><code>fs.FS</code></a> interface,
+ an abstraction for read-only trees of files.
+ The standard library packages have been adapted to make use
+ of the interface as appropriate.
+</p>
+
+<p>
+ On the producer side of the interface,
+ the new <a href="/pkg/embed/#FS"><code>embed.FS</code></a> type
+ implements <code>fs.FS</code>, as does
+ <a href="/pkg/archive/zip/#Reader"><code>zip.Reader</code></a>.
+ The new <a href="/pkg/os/#DirFS"><code>os.DirFS</code></a> function
+ provides an implementation of <code>fs.FS</code> backed by a tree
+ of operating system files.
+</p>
+
+<p>
+ On the consumer side,
+ the new <a href="/pkg/net/http/#FS"><code>http.FS</code></a>
+ function converts an <code>fs.FS</code> to an
+ <a href="/pkg/net/http/#FileSystem"><code>http.FileSystem</code></a>.
+ Also, the <a href="/pkg/html/template/"><code>html/template</code></a>
+ and <a href="/pkg/text/template/"><code>text/template</code></a>
+ packages’ <a href="/pkg/html/template/#ParseFS"><code>ParseFS</code></a>
+ functions and methods read templates from an <code>fs.FS</code>.
+</p>
+
+<p>
+ For testing code that implements <code>fs.FS</code>,
+ the new <a href="/pkg/testing/fstest/"><code>testing/fstest</code></a>
+ package provides a <a href="/pkg/testing/fstest/#TestFS"><code>TestFS</code></a>
+ function that checks for and reports common mistakes.
+ It also provides a simple in-memory file system implementation,
+ <a href="/pkg/testing/fstest/#MapFS"><code>MapFS</code></a>,
+ which can be useful for testing code that accepts <code>fs.FS</code>
+ implementations.
+</p>
+
+<h3 id="ioutil">Deprecation of io/ioutil</h3>
+
+<p>
+ The <a href="/pkg/io/ioutil/"><code>io/ioutil</code></a> package has
+ turned out to be a poorly defined and hard to understand collection
+ of things. All functionality provided by the package has been moved
+ to other packages. The <code>io/ioutil</code> package remains and
+ will continue to work as before, but we encourage new code to use
+ the new definitions in the <a href="/pkg/io/"><code>io</code></a> and
+ <a href="/pkg/os/"><code>os</code></a> packages.
+
+ Here is a list of the new locations of the names exported
+ by <code>io/ioutil</code>:
+ <ul>
+ <li><a href="/pkg/io/ioutil/#Discard"><code>Discard</code></a>
+ => <a href="/pkg/io/#Discard"><code>io.Discard</code></a></li>
+ <li><a href="/pkg/io/ioutil/#NopCloser"><code>NopCloser</code></a>
+ => <a href="/pkg/io/#NopCloser"><code>io.NopCloser</code></a></li>
+ <li><a href="/pkg/io/ioutil/#ReadAll"><code>ReadAll</code></a>
+ => <a href="/pkg/io/#ReadAll"><code>io.ReadAll</code></a></li>
+ <li><a href="/pkg/io/ioutil/#ReadDir"><code>ReadDir</code></a>
+ => <a href="/pkg/os/#ReadDir"><code>os.ReadDir</code></a>
+ (note: returns a slice of
+ <a href="/pkg/os/#DirEntry"><code>os.DirEntry</code></a>
+ rather than a slice of
+ <a href="/pkg/io/fs/#FileInfo"><code>fs.FileInfo</code></a>)
+ </li>
+ <li><a href="/pkg/io/ioutil/#ReadFile"><code>ReadFile</code></a>
+ => <a href="/pkg/os/#ReadFile"><code>os.ReadFile</code></a></li>
+ <li><a href="/pkg/io/ioutil/#TempDir"><code>TempDir</code></a>
+ => <a href="/pkg/os/#MkdirTemp"><code>os.MkdirTemp</code></a></li>
+ <li><a href="/pkg/io/ioutil/#TempFile"><code>TempFile</code></a>
+ => <a href="/pkg/os/#CreateTemp"><code>os.CreateTemp</code></a></li>
+ <li><a href="/pkg/io/ioutil/#WriteFile"><code>WriteFile</code></a>
+ => <a href="/pkg/os/#WriteFile"><code>os.WriteFile</code></a></li>
+ </ul>
+</p>
+
+<h3 id="minor_library_changes">Minor changes to the library</h3>
+
+<p>
+ As always, there are various minor changes and updates to the library,
+ made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
+ in mind.
+</p>
+
+<dl id="archive/zip"><dt><a href="/pkg/archive/zip/">archive/zip</a></dt>
+ <dd>
+ <p><!-- CL 243937 -->
+ The new <a href="/pkg/archive/zip/#Reader.Open"><code>Reader.Open</code></a>
+ method implements the <a href="/pkg/io/fs/#FS"><code>fs.FS</code></a>
+ interface.
+ </p>
+ </dd>
+</dl>
+
+<dl id="crypto/dsa"><dt><a href="/pkg/crypto/dsa/">crypto/dsa</a></dt>
+ <dd>
+ <p><!-- CL 257939 -->
+ The <a href="/pkg/crypto/dsa/"><code>crypto/dsa</code></a> package is now deprecated.
+ See <a href="https://golang.org/issue/40337">issue #40337</a>.
+ </p>
+ </dd>
+</dl><!-- crypto/dsa -->
+
+<dl id="crypto/hmac"><dt><a href="/pkg/crypto/hmac/">crypto/hmac</a></dt>
+ <dd>
+ <p><!-- CL 261960 -->
+ <a href="/pkg/crypto/hmac/#New"><code>New</code></a> will now panic if
+ separate calls to the hash generation function fail to return new values.
+ Previously, the behavior was undefined and invalid outputs were sometimes
+ generated.
+ </p>
+ </dd>
+</dl><!-- crypto/hmac -->
+
+<dl id="crypto/tls"><dt><a href="/pkg/crypto/tls/">crypto/tls</a></dt>
+ <dd>
+ <p><!-- CL 256897 -->
+ I/O operations on closing or closed TLS connections can now be detected
+ using the new <a href="/pkg/net/#ErrClosed"><code>net.ErrClosed</code></a>
+ error. A typical use would be <code>errors.Is(err, net.ErrClosed)</code>.
+ </p>
+
+ <p><!-- CL 266037 -->
+ A default write deadline is now set in
+ <a href="/pkg/crypto/tls/#Conn.Close"><code>Conn.Close</code></a>
+ before sending the "close notify" alert, in order to prevent blocking
+ indefinitely.
+ </p>
+
+ <p><!-- CL 239748 -->
+ Clients now return a handshake error if the server selects
+ <a href="/pkg/crypto/tls/#ConnectionState.NegotiatedProtocol">
+ an ALPN protocol</a> that was not in
+ <a href="/pkg/crypto/tls/#Config.NextProtos">
+ the list advertised by the client</a>.
+ </p>
+
+ <p><!-- CL 262857 -->
+ Servers will now prefer other available AEAD cipher suites (such as ChaCha20Poly1305)
+ over AES-GCM cipher suites if either the client or server doesn't have AES hardware
+ support, unless both <a href="/pkg/crypto/tls/#Config.PreferServerCipherSuites">
+ <code>Config.PreferServerCipherSuites</code></a>
+ and <a href="/pkg/crypto/tls/#Config.CipherSuites"><code>Config.CipherSuites</code></a>
+ are set. The client is assumed not to have AES hardware support if it does
+ not signal a preference for AES-GCM cipher suites.
+ </p>
+
+ <p><!-- CL 246637 -->
+ <a href="/pkg/crypto/tls/#Config.Clone"><code>Config.Clone</code></a> now
+ returns nil if the receiver is nil, rather than panicking.
+ </p>
+ </dd>
+</dl><!-- crypto/tls -->
+
+<dl id="crypto/x509"><dt><a href="/pkg/crypto/x509/">crypto/x509</a></dt>
+ <dd>
+ <p>
+ The <code>GODEBUG=x509ignoreCN=0</code> flag will be removed in Go 1.17.
+ It enables the legacy behavior of treating the <code>CommonName</code>
+ field on X.509 certificates as a host name when no Subject Alternative
+ Names are present.
+ </p>
+
+ <p><!-- CL 235078 -->
+ <a href="/pkg/crypto/x509/#ParseCertificate"><code>ParseCertificate</code></a> and
+ <a href="/pkg/crypto/x509/#CreateCertificate"><code>CreateCertificate</code></a>
+ now enforce string encoding restrictions for the <code>DNSNames</code>,
+ <code>EmailAddresses</code>, and <code>URIs</code> fields. These fields
+ can only contain strings with characters within the ASCII range.
+ </p>
+
+ <p><!-- CL 259697 -->
+ <a href="/pkg/crypto/x509/#CreateCertificate"><code>CreateCertificate</code></a>
+ now verifies the generated certificate's signature using the signer's
+ public key. If the signature is invalid, an error is returned, instead of
+ a malformed certificate.
+ </p>
+
+ <p><!-- CL 257939 -->
+ DSA signature verification is no longer supported. Note that DSA signature
+ generation was never supported.
+ See <a href="https://golang.org/issue/40337">issue #40337</a>.
+ </p>
+
+ <p><!-- CL 257257 -->
+ On Windows, <a href="/pkg/crypto/x509/#Certificate.Verify"><code>Certificate.Verify</code></a>
+ will now return all certificate chains that are built by the platform
+ certificate verifier, instead of just the highest ranked chain.
+ </p>
+
+ <p><!-- CL 262343 -->
+ The new <a href="/pkg/crypto/x509/#SystemRootsError.Unwrap"><code>SystemRootsError.Unwrap</code></a>
+ method allows accessing the <a href="/pkg/crypto/x509/#SystemRootsError.Err"><code>Err</code></a>
+ field through the <a href="/pkg/errors"><code>errors</code></a> package functions.
+ </p>
+
+ <p><!-- CL 230025 -->
+ On Unix systems, the <code>crypto/x509</code> package is now more
+ efficient in how it stores its copy of the system cert pool.
+ Programs that use only a small number of roots will use around a
+ half megabyte less memory.
+ </p>
+
+ </dd>
+</dl><!-- crypto/x509 -->
+
+<dl id="debug/elf"><dt><a href="/pkg/debug/elf/">debug/elf</a></dt>
+ <dd>
+ <p><!-- CL 255138 -->
+ More <a href="/pkg/debug/elf/#DT_NULL"><code>DT</code></a>
+ and <a href="/pkg/debug/elf/#PT_NULL"><code>PT</code></a>
+ constants have been added.
+ </p>
+ </dd>
+</dl><!-- debug/elf -->
+
+<dl id="encoding/asn1"><dt><a href="/pkg/encoding/asn1">encoding/asn1</a></dt>
+ <dd>
+ <p><!-- CL 255881 -->
+ <a href="/pkg/encoding/asn1/#Unmarshal"><code>Unmarshal</code></a> and
+ <a href="/pkg/encoding/asn1/#UnmarshalWithParams"><code>UnmarshalWithParams</code></a>
+ now return an error instead of panicking when the argument is not
+ a pointer or is nil. This change matches the behavior of other
+ encoding packages such as <a href="/pkg/encoding/json"><code>encoding/json</code></a>.
+ </p>
+ </dd>
+</dl>
+
+<dl id="encoding/json"><dt><a href="/pkg/encoding/json/">encoding/json</a></dt>
+ <dd>
+ <p><!-- CL 234818 -->
+ The <code>json</code> struct field tags understood by
+ <a href="/pkg/encoding/json/#Marshal"><code>Marshal</code></a>,
+ <a href="/pkg/encoding/json/#Unmarshal"><code>Unmarshal</code></a>,
+ and related functionality now permit semicolon characters within
+ a JSON object name for a Go struct field.
+ </p>
+ </dd>
+</dl><!-- encoding/json -->
+
+<dl id="encoding/xml"><dt><a href="/pkg/encoding/xml/">encoding/xml</a></dt>
+ <dd>
+ <p><!-- CL 264024 -->
+ The encoder has always taken care to avoid using namespace prefixes
+ beginning with <code>xml</code>, which are reserved by the XML
+ specification.
+ Now, following the specification more closely, that check is
+ case-insensitive, so that prefixes beginning
+ with <code>XML</code>, <code>XmL</code>, and so on are also
+ avoided.
+ </p>
+ </dd>
+</dl><!-- encoding/xml -->
+
+<dl id="flag"><dt><a href="/pkg/flag/">flag</a></dt>
+ <dd>
+ <p><!-- CL 240014 -->
+ The new <a href="/pkg/flag/#Func"><code>Func</code></a> function
+ allows registering a flag implemented by calling a function,
+ as a lighter-weight alternative to implementing the
+ <a href="/pkg/flag/#Value"><code>Value</code></a> interface.
+ </p>
+ </dd>
+</dl><!-- flag -->
+
+<dl id="go/build"><dt><a href="/pkg/go/build/">go/build</a></dt>
+ <dd>
+ <p><!-- CL 243941, CL 283636 -->
+ The <a href="/pkg/go/build/#Package"><code>Package</code></a>
+ struct has new fields that report information
+ about <code>//go:embed</code> directives in the package:
+ <a href="/pkg/go/build/#Package.EmbedPatterns"><code>EmbedPatterns</code></a>,
+ <a href="/pkg/go/build/#Package.EmbedPatternPos"><code>EmbedPatternPos</code></a>,
+ <a href="/pkg/go/build/#Package.TestEmbedPatterns"><code>TestEmbedPatterns</code></a>,
+ <a href="/pkg/go/build/#Package.TestEmbedPatternPos"><code>TestEmbedPatternPos</code></a>,
+ <a href="/pkg/go/build/#Package.XTestEmbedPatterns"><code>XTestEmbedPatterns</code></a>,
+ <a href="/pkg/go/build/#Package.XTestEmbedPatternPos"><code>XTestEmbedPatternPos</code></a>.
+ </p>
+
+ <p><!-- CL 240551 -->
+ The <a href="/pkg/go/build/#Package"><code>Package</code></a> field
+ <a href="/pkg/go/build/#Package.IgnoredGoFiles"><code>IgnoredGoFiles</code></a>
+ will no longer include files that start with "_" or ".",
+ as those files are always ignored.
+ <code>IgnoredGoFiles</code> is for files ignored because of
+ build constraints.
+ </p>
+
+ <p><!-- CL 240551 -->
+ The new <a href="/pkg/go/build/#Package"><code>Package</code></a>
+ field <a href="/pkg/go/build/#Package.IgnoredOtherFiles"><code>IgnoredOtherFiles</code></a>
+ has a list of non-Go files ignored because of build constraints.
+ </p>
+ </dd>
+</dl><!-- go/build -->
+
+<dl id="go/build/constraint"><dt><a href="/pkg/go/build/constraint/">go/build/constraint</a></dt>
+ <dd>
+ <p><!-- CL 240604 -->
+ The new
+ <a href="/pkg/go/build/constraint/"><code>go/build/constraint</code></a>
+ package parses build constraint lines, both the original
+ <code>// +build</code> syntax and the <code>//go:build</code>
+ syntax that will be introduced in Go 1.17.
+ This package exists so that tools built with Go 1.16 will be able
+ to process Go 1.17 source code.
+ See <a href="https://golang.org/design/draft-gobuild">https://golang.org/design/draft-gobuild</a>
+ for details about the build constraint syntaxes and the planned
+ transition to the <code>//go:build</code> syntax.
+ Note that <code>//go:build</code> lines are <b>not</b> supported
+ in Go 1.16 and should not be introduced into Go programs yet.
+ </p>
+ </dd>
+</dl><!-- go/build/constraint -->
+
+<dl id="html/template"><dt><a href="/pkg/html/template/">html/template</a></dt>
+ <dd>
+ <p><!-- CL 243938 -->
+ The new <a href="/pkg/html/template/#ParseFS"><code>template.ParseFS</code></a>
+ function and <a href="/pkg/html/template/#Template.ParseFS"><code>template.Template.ParseFS</code></a>
+ method are like <a href="/pkg/html/template/#ParseGlob"><code>template.ParseGlob</code></a>
+ and <a href="/pkg/html/template/#Template.ParseGlob"><code>template.Template.ParseGlob</code></a>,
+ but read the templates from an <a href="/pkg/io/fs/#FS"><code>fs.FS</code></a>.
+ </p>
+ </dd>
+</dl><!-- html/template -->
+
+<dl id="io"><dt><a href="/pkg/io/">io</a></dt>
+ <dd>
+ <p><!-- CL 261577 -->
+ The package now defines a
+ <a href="/pkg/io/#ReadSeekCloser"><code>ReadSeekCloser</code></a> interface.
+ </p>
+
+ <p><!-- CL 263141 -->
+ The package now defines
+ <a href="/pkg/io/#Discard"><code>Discard</code></a>,
+ <a href="/pkg/io/#NopCloser"><code>NopCloser</code></a>, and
+ <a href="/pkg/io/#ReadAll"><code>ReadAll</code></a>,
+ to be used instead of the same names in the
+ <a href="/pkg/io/ioutil/"><code>io/ioutil</code></a> package.
+ </p>
+ </dd>
+</dl><!-- io -->
+
+<dl id="log"><dt><a href="/pkg/log/">log</a></dt>
+ <dd>
+ <p><!-- CL 264460 -->
+ The new <a href="/pkg/log/#Default"><code>Default</code></a> function
+ provides access to the default <a href="/pkg/log/#Logger"><code>Logger</code></a>.
+ </p>
+ </dd>
+</dl><!-- log -->
+
+<dl id="log/syslog"><dt><a href="/pkg/log/syslog/">log/syslog</a></dt>
+ <dd>
+ <p><!-- CL 264297 -->
+ The <a href="/pkg/log/syslog/#Writer"><code>Writer</code></a>
+ now uses the local message format
+ (omitting the host name and using a shorter time stamp)
+ when logging to custom Unix domain sockets,
+ matching the format already used for the default log socket.
+ </p>
+ </dd>
+</dl><!-- log/syslog -->
+
+<dl id="mime/multipart"><dt><a href="/pkg/mime/multipart/">mime/multipart</a></dt>
+ <dd>
+ <p><!-- CL 247477 -->
+ The <a href="/pkg/mime/multipart/#Reader"><code>Reader</code></a>'s
+ <a href="/pkg/mime/multipart/#Reader.ReadForm"><code>ReadForm</code></a>
+ method no longer rejects form data
+ when passed the maximum int64 value as a limit.
+ </p>
+ </dd>
+</dl><!-- mime/multipart -->
+
+<dl id="net"><dt><a href="/pkg/net/">net</a></dt>
+ <dd>
+ <p><!-- CL 250357 -->
+ The case of I/O on a closed network connection, or I/O on a network
+ connection that is closed before any of the I/O completes, can now
+ be detected using the new <a href="/pkg/net/#ErrClosed"><code>ErrClosed</code></a>
+ error. A typical use would be <code>errors.Is(err, net.ErrClosed)</code>.
+ In earlier releases the only way to reliably detect this case was to
+ match the string returned by the <code>Error</code> method
+ with <code>"use of closed network connection"</code>.
+ </p>
+
+ <p><!-- CL 255898 -->
+ In previous Go releases the default TCP listener backlog size on Linux systems,
+ set by <code>/proc/sys/net/core/somaxconn</code>, was limited to a maximum of <code>65535</code>.
+ On Linux kernel version 4.1 and above, the maximum is now <code>4294967295</code>.
+ </p>
+
+ <p><!-- CL 238629 -->
+ On Linux, host name lookups no longer use DNS before checking
+ <code>/etc/hosts</code> when <code>/etc/nsswitch.conf</code>
+ is missing; this is common on musl-based systems and makes
+ Go programs match the behavior of C programs on those systems.
+ </p>
+ </dd>
+</dl><!-- net -->
+
+<dl id="net/http"><dt><a href="/pkg/net/http/">net/http</a></dt>
+ <dd>
+ <p><!-- CL 233637 -->
+ In the <a href="/pkg/net/http/"><code>net/http</code></a> package, the
+ behavior of <a href="/pkg/net/http/#StripPrefix"><code>StripPrefix</code></a>
+ has been changed to strip the prefix from the request URL's
+ <code>RawPath</code> field in addition to its <code>Path</code> field.
+ In past releases, only the <code>Path</code> field was trimmed, and so if the
+ request URL contained any escaped characters the URL would be modified to
+ have mismatched <code>Path</code> and <code>RawPath</code> fields.
+ In Go 1.16, <code>StripPrefix</code> trims both fields.
+ If there are escaped characters in the prefix part of the request URL the
+ handler serves a 404 instead of its previous behavior of invoking the
+ underlying handler with a mismatched <code>Path</code>/<code>RawPath</code> pair.
+ </p>
+
+ <p><!-- CL 252497 -->
+ The <a href="/pkg/net/http/"><code>net/http</code></a> package now rejects HTTP range requests
+ of the form <code>"Range": "bytes=--N"</code> where <code>"-N"</code> is a negative suffix length, for
+ example <code>"Range": "bytes=--2"</code>. It now replies with a <code>416 "Range Not Satisfiable"</code> response.
+ </p>
+
+ <p><!-- CL 256498, golang.org/issue/36990 -->
+ Cookies set with <a href="/pkg/net/http/#SameSiteDefaultMode"><code>SameSiteDefaultMode</code></a>
+ now behave according to the current spec (no attribute is set) instead of
+ generating a SameSite key without a value.
+ </p>
+
+ <p><!-- CL 250039 -->
+ The <a href="/pkg/net/http/#Client"><code>Client</code></a> now sends
+ an explicit <code>Content-Length:</code> <code>0</code>
+ header in <code>PATCH</code> requests with empty bodies,
+ matching the existing behavior of <code>POST</code> and <code>PUT</code>.
+ </p>
+
+ <p><!-- CL 249440 -->
+ The <a href="/pkg/net/http/#ProxyFromEnvironment"><code>ProxyFromEnvironment</code></a>
+ function no longer returns the setting of the <code>HTTP_PROXY</code>
+ environment variable for <code>https://</code> URLs when
+ <code>HTTPS_PROXY</code> is unset.
+ </p>
+
+ <p><!-- 259917 -->
+ The <a href="/pkg/net/http/#Transport"><code>Transport</code></a>
+ type has a new field
+ <a href="/pkg/net/http/#Transport.GetProxyConnectHeader"><code>GetProxyConnectHeader</code></a>
+ which may be set to a function that returns headers to send to a
+ proxy during a <code>CONNECT</code> request.
+ In effect <code>GetProxyConnectHeader</code> is a dynamic
+ version of the existing field
+ <a href="/pkg/net/http/#Transport.ProxyConnectHeader"><code>ProxyConnectHeader</code></a>;
+ if <code>GetProxyConnectHeader</code> is not <code>nil</code>,
+ then <code>ProxyConnectHeader</code> is ignored.
+ </p>
+
+ <p><!-- CL 243939 -->
+ The new <a href="/pkg/net/http/#FS"><code>http.FS</code></a>
+ function converts an <a href="/pkg/io/fs/#FS"><code>fs.FS</code></a>
+ to an <a href="/pkg/net/http/#FileSystem"><code>http.FileSystem</code></a>.
+ </p>
+ </dd>
+</dl><!-- net/http -->
+
+<dl id="net/http/httputil"><dt><a href="/pkg/net/http/httputil/">net/http/httputil</a></dt>
+ <dd>
+ <p><!-- CL 260637 -->
+ <a href="/pkg/net/http/httputil/#ReverseProxy"><code>ReverseProxy</code></a>
+ now flushes buffered data more aggressively when proxying
+ streamed responses with unknown body lengths.
+ </p>
+ </dd>
+</dl><!-- net/http/httputil -->
+
+<dl id="net/smtp"><dt><a href="/pkg/net/smtp/">net/smtp</a></dt>
+ <dd>
+ <p><!-- CL 247257 -->
+ The <a href="/pkg/net/smtp/#Client"><code>Client</code></a>'s
+ <a href="/pkg/net/smtp/#Client.Mail"><code>Mail</code></a>
+ method now sends the <code>SMTPUTF8</code> directive to
+ servers that support it, signaling that addresses are encoded in UTF-8.
+ </p>
+ </dd>
+</dl><!-- net/smtp -->
+
+<dl id="os"><dt><a href="/pkg/os/">os</a></dt>
+ <dd>
+ <p><!-- CL 242998 -->
+ <a href="/pkg/os/#Process.Signal"><code>Process.Signal</code></a> now
+ returns <a href="/pkg/os/#ErrProcessDone"><code>ErrProcessDone</code></a>
+ instead of the unexported <code>errFinished</code> when the process has
+ already finished.
+ </p>
+
+ <p><!-- CL 261540 -->
+ The package defines a new type
+ <a href="/pkg/os/#DirEntry"><code>DirEntry</code></a>
+ as an alias for <a href="/pkg/io/fs/#DirEntry"><code>fs.DirEntry</code></a>.
+ The new <a href="/pkg/os/#ReadDir"><code>ReadDir</code></a>
+ function and the new
+ <a href="/pkg/os/#File.ReadDir"><code>File.ReadDir</code></a>
+ method can be used to read the contents of a directory into a
+ slice of <a href="/pkg/os/#DirEntry"><code>DirEntry</code></a>.
+ The <a href="/pkg/os/#File.Readdir"><code>File.Readdir</code></a>
+ method (note the lower case <code>d</code> in <code>dir</code>)
+ still exists, returning a slice of
+ <a href="/pkg/os/#FileInfo"><code>FileInfo</code></a>, but for
+ most programs it will be more efficient to switch to
+ <a href="/pkg/os/#File.ReadDir"><code>File.ReadDir</code></a>.
+ </p>
+
+ <p><!-- CL 263141 -->
+ The package now defines
+ <a href="/pkg/os/#CreateTemp"><code>CreateTemp</code></a>,
+ <a href="/pkg/os/#MkdirTemp"><code>MkdirTemp</code></a>,
+ <a href="/pkg/os/#ReadFile"><code>ReadFile</code></a>, and
+ <a href="/pkg/os/#WriteFile"><code>WriteFile</code></a>,
+ to be used instead of functions defined in the
+ <a href="/pkg/io/ioutil/"><code>io/ioutil</code></a> package.
+ </p>
+
+ <p><!-- CL 243906 -->
+ The types <a href="/pkg/os/#FileInfo"><code>FileInfo</code></a>,
+ <a href="/pkg/os/#FileMode"><code>FileMode</code></a>, and
+ <a href="/pkg/os/#PathError"><code>PathError</code></a>
+ are now aliases for types of the same name in the
+ <a href="/pkg/io/fs/"><code>io/fs</code></a> package.
+ Function signatures in the <a href="/pkg/os/"><code>os</code></a>
+ package have been updated to refer to the names in the
+ <a href="/pkg/io/fs/"><code>io/fs</code></a> package.
+ This should not affect any existing code.
+ </p>
+
+ <p><!-- CL 243911 -->
+ The new <a href="/pkg/os/#DirFS"><code>DirFS</code></a> function
+ provides an implementation of
+ <a href="/pkg/io/fs/#FS"><code>fs.FS</code></a> backed by a tree
+ of operating system files.
+ </p>
+ </dd>
+</dl><!-- os -->
+
+<dl id="os/signal"><dt><a href="/pkg/os/signal/">os/signal</a></dt>
+ <dd>
+ <p><!-- CL 219640 -->
+ The new
+ <a href="/pkg/os/signal/#NotifyContext"><code>NotifyContext</code></a>
+ function allows creating contexts that are canceled upon arrival of
+ specific signals.
+ </p>
+ </dd>
+</dl><!-- os/signal -->
+
+<dl id="path"><dt><a href="/pkg/path/">path</a></dt>
+ <dd>
+ <p><!-- CL 264397, golang.org/issues/28614 -->
+ The <a href="/pkg/path/#Match"><code>Match</code></a> function now
+ returns an error if the unmatched part of the pattern has a
+ syntax error. Previously, the function returned early on a failed
+ match, and thus did not report any later syntax error in the
+ pattern.
+ </p>
+ </dd>
+</dl><!-- path -->
+
+<dl id="path/filepath"><dt><a href="/pkg/path/filepath/">path/filepath</a></dt>
+ <dd>
+ <p><!-- CL 267887 -->
+ The new function
+ <a href="/pkg/path/filepath/#WalkDir"><code>WalkDir</code></a>
+ is similar to
+ <a href="/pkg/path/filepath/#Walk"><code>Walk</code></a>,
+ but is typically more efficient.
+ The function passed to <code>WalkDir</code> receives a
+ <a href="/pkg/io/fs/#DirEntry"><code>fs.DirEntry</code></a>
+ instead of a
+ <a href="/pkg/io/fs/#FileInfo"><code>fs.FileInfo</code></a>.
+ (To clarify for those who recall the <code>Walk</code> function
+ as taking an <a href="/pkg/os/#FileInfo"><code>os.FileInfo</code></a>,
+ <code>os.FileInfo</code> is now an alias for <code>fs.FileInfo</code>.)
+ </p>
+
+ <p><!-- CL 264397, golang.org/issues/28614 -->
+ The <a href="/pkg/path/filepath#Match"><code>Match</code></a> and
+ <a href="/pkg/path/filepath#Glob"><code>Glob</code></a> functions now
+ return an error if the unmatched part of the pattern has a
+ syntax error. Previously, the functions returned early on a failed
+ match, and thus did not report any later syntax error in the
+ pattern.
+ </p>
+ </dd>
+</dl><!-- path/filepath -->
+
+<dl id="reflect"><dt><a href="/pkg/reflect/">reflect</a></dt>
+ <dd>
+ <p><!-- CL 192331 -->
+ The Zero function has been optimized to avoid allocations. Code
+ which incorrectly compares the returned Value to another Value
+ using == or DeepEqual may get different results than those
+ obtained in previous Go versions. The documentation
+ for <a href="/pkg/reflect#Value"><code>reflect.Value</code></a>
+ describes how to compare two <code>Value</code>s correctly.
+ </p>
+ </dd>
+</dl><!-- reflect -->
+
+<dl id="runtime/debug"><dt><a href="/pkg/runtime/debug/">runtime/debug</a></dt>
+ <dd>
+ <p><!-- CL 249677 -->
+ The <a href="/pkg/runtime#Error"><code>runtime.Error</code></a> values
+ used when <code>SetPanicOnFault</code> is enabled may now have an
+ <code>Addr</code> method. If that method exists, it returns the memory
+ address that triggered the fault.
+ </p>
+ </dd>
+</dl><!-- runtime/debug -->
+
+<dl id="strconv"><dt><a href="/pkg/strconv/">strconv</a></dt>
+ <dd>
+ <p><!-- CL 260858 -->
+ <a href="/pkg/strconv/#ParseFloat"><code>ParseFloat</code></a> now uses
+ the <a
+ href="https://nigeltao.github.io/blog/2020/eisel-lemire.html">Eisel-Lemire
+ algorithm</a>, improving performance by up to a factor of 2. This can
+ also speed up decoding textual formats like <a
+ href="/pkg/encoding/json/"><code>encoding/json</code></a>.
+ </p>
+ </dd>
+</dl><!-- strconv -->
+
+<dl id="syscall"><dt><a href="/pkg/syscall/">syscall</a></dt>
+ <dd>
+ <p><!-- CL 263271 -->
+ <a href="/pkg/syscall/?GOOS=windows#NewCallback"><code>NewCallback</code></a>
+ and
+ <a href="/pkg/syscall/?GOOS=windows#NewCallbackCDecl"><code>NewCallbackCDecl</code></a>
+ now correctly support callback functions with multiple
+ sub-<code>uintptr</code>-sized arguments in a row. This may
+ require changing uses of these functions to eliminate manual
+ padding between small arguments.
+ </p>
+
+ <p><!-- CL 261917 -->
+ <a href="/pkg/syscall/?GOOS=windows#SysProcAttr"><code>SysProcAttr</code></a> on Windows has a new <code>NoInheritHandles</code> field that disables inheriting handles when creating a new process.
+ </p>
+
+ <p><!-- CL 269761, golang.org/issue/42584 -->
+ <a href="/pkg/syscall/?GOOS=windows#DLLError"><code>DLLError</code></a> on Windows now has an <code>Unwrap</code> method for unwrapping its underlying error.
+ </p>
+
+ <p><!-- CL 210639 -->
+ On Linux,
+ <a href="/pkg/syscall/#Setgid"><code>Setgid</code></a>,
+ <a href="/pkg/syscall/#Setuid"><code>Setuid</code></a>,
+ and related calls are now implemented.
+ Previously, they returned an <code>syscall.EOPNOTSUPP</code> error.
+ </p>
+
+ <p><!-- CL 210639 -->
+ On Linux, the new functions
+ <a href="/pkg/syscall/#AllThreadsSyscall"><code>AllThreadsSyscall</code></a>
+ and <a href="/pkg/syscall/#AllThreadsSyscall6"><code>AllThreadsSyscall6</code></a>
+ may be used to make a system call on all Go threads in the process.
+ These functions may only be used by programs that do not use cgo;
+ if a program uses cgo, they will always return
+ <a href="/pkg/syscall/#ENOTSUP"><code>syscall.ENOTSUP</code></a>.
+ </p>
+ </dd>
+</dl><!-- syscall -->
+
+<dl id="testing/iotest"><dt><a href="/pkg/testing/iotest/">testing/iotest</a></dt>
+ <dd>
+ <p><!-- CL 199501 -->
+ The new
+ <a href="/pkg/testing/iotest/#ErrReader"><code>ErrReader</code></a>
+ function returns an
+ <a href="/pkg/io/#Reader"><code>io.Reader</code></a> that always
+ returns an error.
+ </p>
+
+ <p><!-- CL 243909 -->
+ The new
+ <a href="/pkg/testing/iotest/#TestReader"><code>TestReader</code></a>
+ function tests that an <a href="/pkg/io/#Reader"><code>io.Reader</code></a>
+ behaves correctly.
+ </p>
+ </dd>
+</dl><!-- testing/iotest -->
+
+<dl id="text/template"><dt><a href="/pkg/text/template/">text/template</a></dt>
+ <dd>
+ <p><!-- CL 254257, golang.org/issue/29770 -->
+ Newlines characters are now allowed inside action delimiters,
+ permitting actions to span multiple lines.
+ </p>
+
+ <p><!-- CL 243938 -->
+ The new <a href="/pkg/text/template/#ParseFS"><code>template.ParseFS</code></a>
+ function and <a href="/pkg/text/template/#Template.ParseFS"><code>template.Template.ParseFS</code></a>
+ method are like <a href="/pkg/text/template/#ParseGlob"><code>template.ParseGlob</code></a>
+ and <a href="/pkg/text/template/#Template.ParseGlob"><code>template.Template.ParseGlob</code></a>,
+ but read the templates from an <a href="/pkg/io/fs/#FS"><code>fs.FS</code></a>.
+ </p>
+ </dd>
+</dl><!-- text/template -->
+
+<dl id="text/template/parse"><dt><a href="/pkg/text/template/parse/">text/template/parse</a></dt>
+ <dd>
+ <p><!-- CL 229398, golang.org/issue/34652 -->
+ A new <a href="/pkg/text/template/parse/#CommentNode"><code>CommentNode</code></a>
+ was added to the parse tree. The <a href="/pkg/text/template/parse/#Mode"><code>Mode</code></a>
+ field in the <code>parse.Tree</code> enables access to it.
+ </p>
+ </dd>
+</dl><!-- text/template/parse -->
+
+<dl id="time/tzdata"><dt><a href="/pkg/time/tzdata/">time/tzdata</a></dt>
+ <dd>
+ <p><!-- CL 261877 -->
+ The slim timezone data format is now used for the timezone database in
+ <code>$GOROOT/lib/time/zoneinfo.zip</code> and the embedded copy in this
+ package. This reduces the size of the timezone database by about 350 KB.
+ </p>
+ </dd>
+</dl><!-- time/tzdata -->
+
+<dl id="unicode"><dt><a href="/pkg/unicode/">unicode</a></dt>
+ <dd>
+ <p><!-- CL 248765 -->
+ The <a href="/pkg/unicode/"><code>unicode</code></a> package and associated
+ support throughout the system has been upgraded from Unicode 12.0.0 to
+ <a href="https://www.unicode.org/versions/Unicode13.0.0/">Unicode 13.0.0</a>,
+ which adds 5,930 new characters, including four new scripts, and 55 new emoji.
+ Unicode 13.0.0 also designates plane 3 (U+30000-U+3FFFF) as the tertiary
+ ideographic plane.
+ </p>
+ </dd>
+</dl><!-- unicode -->
diff --git a/_content/doc/go1.2.html b/_content/doc/go1.2.html
new file mode 100644
index 0000000..acc4436
--- /dev/null
+++ b/_content/doc/go1.2.html
@@ -0,0 +1,978 @@
+<!--{
+ "Title": "Go 1.2 Release Notes",
+ "Template": true
+}-->
+
+<h2 id="introduction">Introduction to Go 1.2</h2>
+
+<p>
+Since the release of <a href="/doc/go1.1.html">Go version 1.1</a> 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 <a href="/doc/go1compat.html">promise
+of compatibility</a>.
+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 <a href="#use_of_nil">use of nil</a>).
+</p>
+
+<h2 id="language">Changes to the language</h2>
+
+<p>
+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.
+</p>
+
+<h3 id="use_of_nil">Use of nil</h3>
+
+<p>
+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
+</p>
+
+<pre>
+type T struct {
+ X [1<<24]byte
+ Field int32
+}
+
+func main() {
+ var x *T
+ ...
+}
+</pre>
+
+<p>
+the <code>nil</code> pointer <code>x</code> could be used to access memory incorrectly:
+the expression <code>x.Field</code> could access memory at address <code>1<<24</code>.
+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.
+</p>
+
+<p>
+Further details are in the
+<a href="//golang.org/s/go12nil">design document</a>.
+</p>
+
+<p>
+<em>Updating</em>:
+Most code that depended on the old behavior is erroneous and will fail when run.
+Such programs will need to be updated by hand.
+</p>
+
+<h3 id="three_index">Three-index slices</h3>
+
+<p>
+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:
+</p>
+
+<pre>
+var array [10]int
+slice := array[2:4]
+</pre>
+
+<p>
+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 <code>slice</code> variable is 8.
+</p>
+
+<p>
+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,
+</p>
+
+<pre>
+slice = array[2:4:7]
+</pre>
+
+<p>
+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.
+</p>
+
+<p>
+In this three-index notation, a missing first index (<code>[:i:j]</code>) 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.
+</p>
+
+<p>
+Further details are in the
+<a href="//golang.org/s/go12slice">design document</a>.
+</p>
+
+<p>
+<em>Updating</em>:
+This is a backwards-compatible change that affects no existing programs.
+</p>
+
+<h2 id="impl">Changes to the implementations and tools</h2>
+
+<h3 id="preemption">Pre-emption in the scheduler</h3>
+
+<p>
+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.
+</p>
+
+<h3 id="thread_limit">Limit on the number of threads</h3>
+
+<p>
+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.
+</p>
+
+<p>
+The new <a href="/pkg/runtime/debug/#SetMaxThreads"><code>SetMaxThreads</code></a> function in the
+<a href="/pkg/runtime/debug/"><code>runtime/debug</code></a> package controls the thread count limit.
+</p>
+
+<p>
+<em>Updating</em>:
+Few functions will be affected by the limit, but if a program dies because it hits the
+limit, it could be modified to call <code>SetMaxThreads</code> to set a higher count.
+Even better would be to refactor the program to need fewer threads, reducing consumption
+of kernel resources.
+</p>
+
+<h3 id="stack_size">Stack size</h3>
+
+<p>
+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.
+</p>
+
+<p>
+At the other end, the new function <a href="/pkg/runtime/debug/#SetMaxStack"><code>SetMaxStack</code></a>
+in the <a href="/pkg/runtime/debug"><code>runtime/debug</code></a> package controls
+the <em>maximum</em> 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.
+</p>
+
+<p>
+<em>Updating</em>:
+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.
+</p>
+
+<h3 id="cgo_and_cpp">Cgo and C++</h3>
+
+<p>
+The <a href="/cmd/cgo/"><code>cgo</code></a> command will now invoke the C++
+compiler to build any pieces of the linked-to library that are written in C++;
+<a href="/cmd/cgo/">the documentation</a> has more detail.
+</p>
+
+<h3 id="go_tools_godoc">Godoc and vet moved to the go.tools subrepository</h3>
+
+<p>
+Both binaries are still included with the distribution, but the source code for the
+godoc and vet commands has moved to the
+<a href="//code.google.com/p/go.tools">go.tools</a> subrepository.
+</p>
+
+<p>
+Also, the core of the godoc program has been split into a
+<a href="https://code.google.com/p/go/source/browse/?repo=tools#hg%2Fgodoc">library</a>,
+while the command itself is in a separate
+<a href="https://code.google.com/p/go/source/browse/?repo=tools#hg%2Fcmd%2Fgodoc">directory</a>.
+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.
+</p>
+
+<p>
+<em>Updating</em>:
+Since godoc and vet are not part of the library,
+no client Go code depends on the their source and no updating is required.
+</p>
+
+<p>
+The binary distributions available from <a href="//golang.org">golang.org</a>
+include these binaries, so users of these distributions are unaffected.
+</p>
+
+<p>
+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
+<code>$GOPATH/bin</code>.)
+</p>
+
+<pre>
+$ go get code.google.com/p/go.tools/cmd/godoc
+$ go get code.google.com/p/go.tools/cmd/vet
+</pre>
+
+<h3 id="gccgo">Status of gccgo</h3>
+
+<p>
+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.
+</p>
+
+<h3 id="gc_changes">Changes to the gc compiler and linker</h3>
+
+<p>
+Go 1.2 has several semantic changes to the workings of the gc compiler suite.
+Most users will be unaffected by them.
+</p>
+
+<p>
+The <a href="/cmd/cgo/"><code>cgo</code></a> command now
+works when C++ is included in the library being linked against.
+See the <a href="/cmd/cgo/"><code>cgo</code></a> documentation
+for details.
+</p>
+
+<p>
+The gc compiler displayed a vestigial detail of its origins when
+a program had no <code>package</code> clause: it assumed
+the file was in package <code>main</code>.
+The past has been erased, and a missing <code>package</code> clause
+is now an error.
+</p>
+
+<p>
+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.
+</p>
+
+<p>
+In the runtime for the ARM, with <code>5a</code>, it used to be possible to refer
+to the runtime-internal <code>m</code> (machine) and <code>g</code>
+(goroutine) variables using <code>R9</code> and <code>R10</code> directly.
+It is now necessary to refer to them by their proper names.
+</p>
+
+<p>
+Also on the ARM, the <code>5l</code> linker (sic) now defines the
+<code>MOVBS</code> and <code>MOVHS</code> instructions
+as synonyms of <code>MOVB</code> and <code>MOVH</code>,
+to make clearer the separation between signed and unsigned
+sub-word moves; the unsigned versions already existed with a
+<code>U</code> suffix.
+</p>
+
+<h3 id="cover">Test coverage</h3>
+
+<p>
+One major new feature of <a href="/pkg/go/"><code>go test</code></a> is
+that it can now compute and, with help from a new, separately installed
+"go tool cover" program, display test coverage results.
+</p>
+
+<p>
+The cover tool is part of the
+<a href="https://code.google.com/p/go/source/checkout?repo=tools"><code>go.tools</code></a>
+subrepository.
+It can be installed by running
+</p>
+
+<pre>
+$ go get code.google.com/p/go.tools/cmd/cover
+</pre>
+
+<p>
+The cover tool does two things.
+First, when "go test" is given the <code>-cover</code> 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:
+</p>
+
+<pre>
+$ go test -cover fmt
+ok fmt 0.060s coverage: 91.4% of statements
+$
+</pre>
+
+<p>
+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.
+</p>
+
+<p>
+Details on how to generate and analyze coverage statistics can be found by running the commands
+</p>
+
+<pre>
+$ go help testflag
+$ go tool cover -help
+</pre>
+
+<h3 id="go_doc">The go doc command is deleted</h3>
+
+<p>
+The "go doc" command is deleted.
+Note that the <a href="/cmd/godoc/"><code>godoc</code></a> tool itself is not deleted,
+just the wrapping of it by the <a href="/cmd/go/"><code>go</code></a> 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.
+</p>
+
+<p>
+<em>Updating</em>: For those who still need the precise functionality of running
+</p>
+
+<pre>
+$ go doc
+</pre>
+
+<p>
+in a directory, the behavior is identical to running
+</p>
+
+<pre>
+$ godoc .
+</pre>
+
+<h3 id="gocmd">Changes to the go command</h3>
+
+<p>
+The <a href="/cmd/go/"><code>go get</code></a> command
+now has a <code>-t</code> 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.
+</p>
+
+<h2 id="performance">Performance</h2>
+
+<p>
+There are a number of significant performance improvements in the standard library; here are a few of them.
+</p>
+
+<ul>
+
+<li>
+The <a href="/pkg/compress/bzip2/"><code>compress/bzip2</code></a>
+decompresses about 30% faster.
+</li>
+
+<li>
+The <a href="/pkg/crypto/des/"><code>crypto/des</code></a> package
+is about five times faster.
+</li>
+
+<li>
+The <a href="/pkg/encoding/json/"><code>encoding/json</code></a> package
+encodes about 30% faster.
+</li>
+
+<li>
+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.
+</li>
+
+</ul>
+
+<h2 id="library">Changes to the standard library</h2>
+
+
+<h3 id="archive_tar_zip">The archive/tar and archive/zip packages</h3>
+
+<p>
+The
+<a href="/pkg/archive/tar/"><code>archive/tar</code></a>
+and
+<a href="/pkg/archive/zip/"><code>archive/zip</code></a>
+packages have had a change to their semantics that may break existing programs.
+The issue is that they both provided an implementation of the
+<a href="/pkg/os/#FileInfo"><code>os.FileInfo</code></a>
+interface that was not compliant with the specification for that interface.
+In particular, their <code>Name</code> 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).
+</p>
+
+<p>
+<em>Updating</em>: 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.
+</p>
+
+<h3 id="encoding">The new encoding package</h3>
+
+<p>
+There is a new package, <a href="/pkg/encoding/"><code>encoding</code></a>,
+that defines a set of standard encoding interfaces that may be used to
+build custom marshalers and unmarshalers for packages such as
+<a href="/pkg/encoding/xml/"><code>encoding/xml</code></a>,
+<a href="/pkg/encoding/json/"><code>encoding/json</code></a>,
+and
+<a href="/pkg/encoding/binary/"><code>encoding/binary</code></a>.
+These new interfaces have been used to tidy up some implementations in
+the standard library.
+</p>
+
+<p>
+The new interfaces are called
+<a href="/pkg/encoding/#BinaryMarshaler"><code>BinaryMarshaler</code></a>,
+<a href="/pkg/encoding/#BinaryUnmarshaler"><code>BinaryUnmarshaler</code></a>,
+<a href="/pkg/encoding/#TextMarshaler"><code>TextMarshaler</code></a>,
+and
+<a href="/pkg/encoding/#TextUnmarshaler"><code>TextUnmarshaler</code></a>.
+Full details are in the <a href="/pkg/encoding/">documentation</a> for the package
+and a separate <a href="//golang.org/s/go12encoding">design document</a>.
+</p>
+
+<h3 id="fmt_indexed_arguments">The fmt package</h3>
+
+<p>
+The <a href="/pkg/fmt/"><code>fmt</code></a> package's formatted print
+routines such as <a href="/pkg/fmt/#Printf"><code>Printf</code></a>
+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 <code>[</code><em>n</em><code>]</code>
+fetches argument <em>n</em> instead.
+The value of <em>n</em> is 1-indexed.
+After such an indexing operating, the next argument to be fetched by normal
+processing will be <em>n</em>+1.
+</p>
+
+<p>
+For example, the normal <code>Printf</code> call
+</p>
+
+<pre>
+fmt.Sprintf("%c %c %c\n", 'a', 'b', 'c')
+</pre>
+
+<p>
+would create the string <code>"a b c"</code>, but with indexing operations like this,
+</p>
+
+<pre>
+fmt.Sprintf("%[3]c %[1]c %c\n", 'a', 'b', 'c')
+</pre>
+
+<p>
+the result is "<code>"c a b"</code>. The <code>[3]</code> index accesses the third formatting
+argument, which is <code>'c'</code>, <code>[1]</code> accesses the first, <code>'a'</code>,
+and then the next fetch accesses the argument following that one, <code>'b'</code>.
+</p>
+
+<p>
+The motivation for this feature is programmable format statements to access
+the arguments in different order for localization, but it has other uses:
+</p>
+
+<pre>
+log.Printf("trace: value %v of type %[1]T\n", expensiveFunction(a.b[c]))
+</pre>
+
+<p>
+<em>Updating</em>: The change to the syntax of format specifications
+is strictly backwards compatible, so it affects no working programs.
+</p>
+
+<h3 id="text_template">The text/template and html/template packages</h3>
+
+<p>
+The
+<a href="/pkg/text/template/"><code>text/template</code></a> package
+has a couple of changes in Go 1.2, both of which are also mirrored in the
+<a href="/pkg/html/template/"><code>html/template</code></a> package.
+</p>
+
+<p>
+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.
+</p>
+
+<table cellpadding="0" summary="Template comparison functions">
+<tr>
+<th width="50"></th><th width="100">Name</th> <th width="50">Operator</th>
+</tr>
+<tr>
+<td></td><td><code>eq</code></td> <td><code>==</code></td>
+</tr>
+<tr>
+<td></td><td><code>ne</code></td> <td><code>!=</code></td>
+</tr>
+<tr>
+<td></td><td><code>lt</code></td> <td><code><</code></td>
+</tr>
+<tr>
+<td></td><td><code>le</code></td> <td><code><=</code></td>
+</tr>
+<tr>
+<td></td><td><code>gt</code></td> <td><code>></code></td>
+</tr>
+<tr>
+<td></td><td><code>ge</code></td> <td><code>>=</code></td>
+</tr>
+</table>
+
+<p>
+These functions behave slightly differently from the corresponding Go operators.
+First, they operate only on basic types (<code>bool</code>, <code>int</code>,
+<code>float64</code>, <code>string</code>, 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 <code>int8</code> and an <code>int16</code>).
+Finally, the <code>eq</code> function (only) allows comparison of the first
+argument with one or more following arguments. The template in this example,
+</p>
+
+<pre>
+{{"{{"}}if eq .A 1 2 3 {{"}}"}} equal {{"{{"}}else{{"}}"}} not equal {{"{{"}}end{{"}}"}}
+</pre>
+
+<p>
+reports "equal" if <code>.A</code> is equal to <em>any</em> of 1, 2, or 3.
+</p>
+
+<p>
+The second change is that a small addition to the grammar makes "if else if" chains easier to write.
+Instead of writing,
+</p>
+
+<pre>
+{{"{{"}}if eq .A 1{{"}}"}} X {{"{{"}}else{{"}}"}} {{"{{"}}if eq .A 2{{"}}"}} Y {{"{{"}}end{{"}}"}} {{"{{"}}end{{"}}"}}
+</pre>
+
+<p>
+one can fold the second "if" into the "else" and have only one "end", like this:
+</p>
+
+<pre>
+{{"{{"}}if eq .A 1{{"}}"}} X {{"{{"}}else if eq .A 2{{"}}"}} Y {{"{{"}}end{{"}}"}}
+</pre>
+
+<p>
+The two forms are identical in effect; the difference is just in the syntax.
+</p>
+
+<p>
+<em>Updating</em>: Neither the "else if" change nor the comparison functions
+affect existing programs. Those that
+already define functions called <code>eq</code> and so on through a function
+map are unaffected because the associated function map will override the new
+default function definitions.
+</p>
+
+<h3 id="new_packages">New packages</h3>
+
+<p>
+There are two new packages.
+</p>
+
+<ul>
+<li>
+The <a href="/pkg/encoding/"><code>encoding</code></a> package is
+<a href="#encoding">described above</a>.
+</li>
+<li>
+The <a href="/pkg/image/color/palette/"><code>image/color/palette</code></a> package
+provides standard color palettes.
+</li>
+</ul>
+
+<h3 id="minor_library_changes">Minor changes to the library</h3>
+
+<p>
+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.
+</p>
+
+<ul>
+
+<li>
+The <a href="/pkg/archive/zip/"><code>archive/zip</code></a> package
+adds the
+<a href="/pkg/archive/zip/#File.DataOffset"><code>DataOffset</code></a> accessor
+to return the offset of a file's (possibly compressed) data within the archive.
+</li>
+
+<li>
+The <a href="/pkg/bufio/"><code>bufio</code></a> package
+adds <a href="/pkg/bufio/#Reader.Reset"><code>Reset</code></a>
+methods to <a href="/pkg/bufio/#Reader"><code>Reader</code></a> and
+<a href="/pkg/bufio/#Writer"><code>Writer</code></a>.
+These methods allow the <a href="/pkg/io/#Reader"><code>Readers</code></a>
+and <a href="/pkg/io/#Writer"><code>Writers</code></a>
+to be re-used on new input and output readers and writers, saving
+allocation overhead.
+</li>
+
+<li>
+The <a href="/pkg/compress/bzip2/"><code>compress/bzip2</code></a>
+can now decompress concatenated archives.
+</li>
+
+<li>
+The <a href="/pkg/compress/flate/"><code>compress/flate</code></a>
+package adds a <a href="/pkg/compress/flate/#Writer.Reset"><code>Reset</code></a>
+method on the <a href="/pkg/compress/flate/#Writer"><code>Writer</code></a>,
+to make it possible to reduce allocation when, for instance, constructing an
+archive to hold multiple compressed files.
+</li>
+
+<li>
+The <a href="/pkg/compress/gzip/"><code>compress/gzip</code></a> package's
+<a href="/pkg/compress/gzip/#Writer"><code>Writer</code></a> type adds a
+<a href="/pkg/compress/gzip/#Writer.Reset"><code>Reset</code></a>
+so it may be reused.
+</li>
+
+<li>
+The <a href="/pkg/compress/zlib/"><code>compress/zlib</code></a> package's
+<a href="/pkg/compress/zlib/#Writer"><code>Writer</code></a> type adds a
+<a href="/pkg/compress/zlib/#Writer.Reset"><code>Reset</code></a>
+so it may be reused.
+</li>
+
+<li>
+The <a href="/pkg/container/heap/"><code>container/heap</code></a> package
+adds a <a href="/pkg/container/heap/#Fix"><code>Fix</code></a>
+method to provide a more efficient way to update an item's position in the heap.
+</li>
+
+<li>
+The <a href="/pkg/container/list/"><code>container/list</code></a> package
+adds the <a href="/pkg/container/list/#List.MoveBefore"><code>MoveBefore</code></a>
+and
+<a href="/pkg/container/list/#List.MoveAfter"><code>MoveAfter</code></a>
+methods, which implement the obvious rearrangement.
+</li>
+
+<li>
+The <a href="/pkg/crypto/cipher/"><code>crypto/cipher</code></a> package
+adds the a new GCM mode (Galois Counter Mode), which is almost always
+used with AES encryption.
+</li>
+
+<li>
+The
+<a href="/pkg/crypto/md5/"><code>crypto/md5</code></a> package
+adds a new <a href="/pkg/crypto/md5/#Sum"><code>Sum</code></a> function
+to simplify hashing without sacrificing performance.
+</li>
+
+<li>
+Similarly, the
+<a href="/pkg/crypto/md5/"><code>crypto/sha1</code></a> package
+adds a new <a href="/pkg/crypto/sha1/#Sum"><code>Sum</code></a> function.
+</li>
+
+<li>
+Also, the
+<a href="/pkg/crypto/sha256/"><code>crypto/sha256</code></a> package
+adds <a href="/pkg/crypto/sha256/#Sum256"><code>Sum256</code></a>
+and <a href="/pkg/crypto/sha256/#Sum224"><code>Sum224</code></a> functions.
+</li>
+
+<li>
+Finally, the <a href="/pkg/crypto/sha512/"><code>crypto/sha512</code></a> package
+adds <a href="/pkg/crypto/sha512/#Sum512"><code>Sum512</code></a> and
+<a href="/pkg/crypto/sha512/#Sum384"><code>Sum384</code></a> functions.
+</li>
+
+<li>
+The <a href="/pkg/crypto/x509/"><code>crypto/x509</code></a> package
+adds support for reading and writing arbitrary extensions.
+</li>
+
+<li>
+The <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package adds
+support for TLS 1.1, 1.2 and AES-GCM.
+</li>
+
+<li>
+The <a href="/pkg/database/sql/"><code>database/sql</code></a> package adds a
+<a href="/pkg/database/sql/#DB.SetMaxOpenConns"><code>SetMaxOpenConns</code></a>
+method on <a href="/pkg/database/sql/#DB"><code>DB</code></a> to limit the
+number of open connections to the database.
+</li>
+
+<li>
+The <a href="/pkg/encoding/csv/"><code>encoding/csv</code></a> package
+now always allows trailing commas on fields.
+</li>
+
+<li>
+The <a href="/pkg/encoding/gob/"><code>encoding/gob</code></a> 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 <code>BinaryMarshaler</code> and
+<code>BinaryUnmarshaler</code> interfaces of the
+<a href="/pkg/encoding/"><code>encoding</code></a> package
+described above.
+</li>
+
+<li>
+The <a href="/pkg/encoding/json/"><code>encoding/json</code></a> package
+now will always escape ampersands as "\u0026" when printing strings.
+It will now accept but correct invalid UTF-8 in
+<a href="/pkg/encoding/json/#Marshal"><code>Marshal</code></a>
+(such input was previously rejected).
+Finally, it now supports the generic encoding interfaces of the
+<a href="/pkg/encoding/"><code>encoding</code></a> package
+described above.
+</li>
+
+<li>
+The <a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> package
+now allows attributes stored in pointers to be marshaled.
+It also supports the generic encoding interfaces of the
+<a href="/pkg/encoding/"><code>encoding</code></a> package
+described above through the new
+<a href="/pkg/encoding/xml/#Marshaler"><code>Marshaler</code></a>,
+<a href="/pkg/encoding/xml/#Unmarshaler"><code>Unmarshaler</code></a>,
+and related
+<a href="/pkg/encoding/xml/#MarshalerAttr"><code>MarshalerAttr</code></a> and
+<a href="/pkg/encoding/xml/#UnmarshalerAttr"><code>UnmarshalerAttr</code></a>
+interfaces.
+The package also adds a
+<a href="/pkg/encoding/xml/#Encoder.Flush"><code>Flush</code></a> method
+to the
+<a href="/pkg/encoding/xml/#Encoder"><code>Encoder</code></a>
+type for use by custom encoders. See the documentation for
+<a href="/pkg/encoding/xml/#Encoder.EncodeToken"><code>EncodeToken</code></a>
+to see how to use it.
+</li>
+
+<li>
+The <a href="/pkg/flag/"><code>flag</code></a> package now
+has a <a href="/pkg/flag/#Getter"><code>Getter</code></a> 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
+<a href="/pkg/flag/#Value"><code>Value</code></a>
+interface, but all the existing standard flag types implement it.
+The package also now exports the <a href="/pkg/flag/#CommandLine"><code>CommandLine</code></a>
+flag set, which holds the flags from the command line.
+</li>
+
+<li>
+The <a href="/pkg/go/ast/"><code>go/ast</code></a> package's
+<a href="/pkg/go/ast/#SliceExpr"><code>SliceExpr</code></a> struct
+has a new boolean field, <code>Slice3</code>, 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.
+</li>
+
+<li>
+The <a href="/pkg/go/build/"><code>go/build</code></a> package adds
+the <code>AllTags</code> field
+to the <a href="/pkg/go/build/#Package"><code>Package</code></a> type,
+to make it easier to process build tags.
+</li>
+
+<li>
+The <a href="/pkg/image/draw/"><code>image/draw</code></a> package now
+exports an interface, <a href="/pkg/image/draw/#Drawer"><code>Drawer</code></a>,
+that wraps the standard <a href="/pkg/image/draw/#Draw"><code>Draw</code></a> 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
+<a href="/pkg/image/draw/#FloydSteinberg"><code>FloydSteinberg</code></a>
+implementation of the
+<a href="/pkg/image/draw/#Drawer"><code>Drawer</code></a>
+interface will use the Floyd-Steinberg error diffusion algorithm to draw the image.
+To create palettes suitable for such processing, the new
+<a href="/pkg/image/draw/#Quantizer"><code>Quantizer</code></a> 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.
+</li>
+
+<li>
+The <a href="/pkg/image/gif/"><code>image/gif</code></a> package
+can now create GIF files using the new
+<a href="/pkg/image/gif/#Encode"><code>Encode</code></a>
+and <a href="/pkg/image/gif/#EncodeAll"><code>EncodeAll</code></a>
+functions.
+Their options argument allows specification of an image
+<a href="/pkg/image/draw/#Quantizer"><code>Quantizer</code></a> to use;
+if it is <code>nil</code>, the generated GIF will use the
+<a href="/pkg/image/color/palette/#Plan9"><code>Plan9</code></a>
+color map (palette) defined in the new
+<a href="/pkg/image/color/palette/"><code>image/color/palette</code></a> package.
+The options also specify a
+<a href="/pkg/image/draw/#Drawer"><code>Drawer</code></a>
+to use to create the output image;
+if it is <code>nil</code>, Floyd-Steinberg error diffusion is used.
+</li>
+
+<li>
+The <a href="/pkg/io/#Copy"><code>Copy</code></a> method of the
+<a href="/pkg/io/"><code>io</code></a> package now prioritizes its
+arguments differently.
+If one argument implements <a href="/pkg/io/#WriterTo"><code>WriterTo</code></a>
+and the other implements <a href="/pkg/io/#ReaderFrom"><code>ReaderFrom</code></a>,
+<a href="/pkg/io/#Copy"><code>Copy</code></a> will now invoke
+<a href="/pkg/io/#WriterTo"><code>WriterTo</code></a> to do the work,
+so that less intermediate buffering is required in general.
+</li>
+
+<li>
+The <a href="/pkg/net/"><code>net</code></a> 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 <code>netgo</code> (off by default) allows the construction of a
+<code>net</code> package in pure Go on those systems where it is possible.
+</li>
+
+<li>
+The <a href="/pkg/net/"><code>net</code></a> package adds a new field
+<code>DualStack</code> to the <a href="/pkg/net/#Dialer"><code>Dialer</code></a>
+struct for TCP connection setup using a dual IP stack as described in
+<a href="https://tools.ietf.org/html/rfc6555">RFC 6555</a>.
+</li>
+
+<li>
+The <a href="/pkg/net/http/"><code>net/http</code></a> package will no longer
+transmit cookies that are incorrect according to
+<a href="https://tools.ietf.org/html/rfc6265">RFC 6265</a>.
+It just logs an error and sends nothing.
+Also,
+the <a href="/pkg/net/http/"><code>net/http</code></a> package's
+<a href="/pkg/net/http/#ReadResponse"><code>ReadResponse</code></a>
+function now permits the <code>*Request</code> parameter to be <code>nil</code>,
+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
+<a href="/pkg/net/http/#Handler"><code>Handler</code></a>'s
+<a href="/pkg/net/http/#ResponseWriter"><code>ResponseWriter</code></a>
+are absorbed by the
+<a href="/pkg/net/http/#Server"><code>Server</code></a>
+and the client receives an empty body as required by the HTTP specification.
+</li>
+
+<li>
+The <a href="/pkg/os/exec/"><code>os/exec</code></a> package's
+<a href="/pkg/os/exec/#Cmd.StdinPipe"><code>Cmd.StdinPipe</code></a> method
+returns an <code>io.WriteCloser</code>, but has changed its concrete
+implementation from <code>*os.File</code> to an unexported type that embeds
+<code>*os.File</code>, 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 <code>*os.File</code> can use an
+interface type assertion, such as <code>wc.(interface{ Sync() error })</code>.
+</li>
+
+<li>
+The <a href="/pkg/runtime/"><code>runtime</code></a> package relaxes
+the constraints on finalizer functions in
+<a href="/pkg/runtime/#SetFinalizer"><code>SetFinalizer</code></a>: 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.
+</li>
+
+<li>
+The <a href="/pkg/sort/"><code>sort</code></a> package has a new
+<a href="/pkg/sort/#Stable"><code>Stable</code></a> function that implements
+stable sorting. It is less efficient than the normal sort algorithm, however.
+</li>
+
+<li>
+The <a href="/pkg/strings/"><code>strings</code></a> package adds
+an <a href="/pkg/strings/#IndexByte"><code>IndexByte</code></a>
+function for consistency with the <a href="/pkg/bytes/"><code>bytes</code></a> package.
+</li>
+
+<li>
+The <a href="/pkg/sync/atomic/"><code>sync/atomic</code></a> 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
+<a href="/pkg/sync/atomic/#SwapInt32"><code>SwapInt32</code></a>,
+<a href="/pkg/sync/atomic/#SwapInt64"><code>SwapInt64</code></a>,
+<a href="/pkg/sync/atomic/#SwapUint32"><code>SwapUint32</code></a>,
+<a href="/pkg/sync/atomic/#SwapUint64"><code>SwapUint64</code></a>,
+<a href="/pkg/sync/atomic/#SwapUintptr"><code>SwapUintptr</code></a>,
+and
+<a href="/pkg/sync/atomic/#SwapPointer"><code>SwapPointer</code></a>,
+which swaps an <code>unsafe.Pointer</code>.
+</li>
+
+<li>
+The <a href="/pkg/syscall/"><code>syscall</code></a> package now implements
+<a href="/pkg/syscall/#Sendfile"><code>Sendfile</code></a> for Darwin.
+</li>
+
+<li>
+The <a href="/pkg/testing/"><code>testing</code></a> package
+now exports the <a href="/pkg/testing/#TB"><code>TB</code></a> interface.
+It records the methods in common with the
+<a href="/pkg/testing/#T"><code>T</code></a>
+and
+<a href="/pkg/testing/#B"><code>B</code></a> types,
+to make it easier to share code between tests and benchmarks.
+Also, the
+<a href="/pkg/testing/#AllocsPerRun"><code>AllocsPerRun</code></a>
+function now quantizes the return value to an integer (although it
+still has type <code>float64</code>), to round off any error caused by
+initialization and make the result more repeatable.
+</li>
+
+<li>
+The <a href="/pkg/text/template/"><code>text/template</code></a> 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".
+</li>
+
+<li>
+In the <a href="/pkg/time/"><code>time</code></a> package, the
+<a href="/pkg/time/#Parse"><code>Parse</code></a> function
+and
+<a href="/pkg/time/#Time.Format"><code>Format</code></a>
+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".
+</li>
+
+<li>
+The <a href="/pkg/unicode/"><code>unicode</code></a> package
+adds <a href="/pkg/unicode/#In"><code>In</code></a>,
+a nicer-to-use but equivalent version of the original
+<a href="/pkg/unicode/#IsOneOf"><code>IsOneOf</code></a>,
+to see whether a character is a member of a Unicode category.
+</li>
+
+</ul>
diff --git a/_content/doc/go1.3.html b/_content/doc/go1.3.html
new file mode 100644
index 0000000..57d1d7f
--- /dev/null
+++ b/_content/doc/go1.3.html
@@ -0,0 +1,607 @@
+<!--{
+ "Title": "Go 1.3 Release Notes",
+ "Template": true
+}-->
+
+<h2 id="introduction">Introduction to Go 1.3</h2>
+
+<p>
+The latest Go release, version 1.3, arrives six months after 1.2,
+and contains no language changes.
+It focuses primarily on implementation work, providing
+precise garbage collection,
+a major refactoring of the compiler toolchain that results in
+faster builds, especially for large projects,
+significant performance improvements across the board,
+and support for DragonFly BSD, Solaris, Plan 9 and Google's Native Client architecture (NaCl).
+It also has an important refinement to the memory model regarding synchronization.
+As always, Go 1.3 keeps the <a href="/doc/go1compat.html">promise
+of compatibility</a>,
+and almost everything
+will continue to compile and run without change when moved to 1.3.
+</p>
+
+<h2 id="os">Changes to the supported operating systems and architectures</h2>
+
+<h3 id="win2000">Removal of support for Windows 2000</h3>
+
+<p>
+Microsoft stopped supporting Windows 2000 in 2010.
+Since it has <a href="https://codereview.appspot.com/74790043">implementation difficulties</a>
+regarding exception handling (signals in Unix terminology),
+as of Go 1.3 it is not supported by Go either.
+</p>
+
+<h3 id="dragonfly">Support for DragonFly BSD</h3>
+
+<p>
+Go 1.3 now includes experimental support for DragonFly BSD on the <code>amd64</code> (64-bit x86) and <code>386</code> (32-bit x86) architectures.
+It uses DragonFly BSD 3.6 or above.
+</p>
+
+<h3 id="freebsd">Support for FreeBSD</h3>
+
+<p>
+It was not announced at the time, but since the release of Go 1.2, support for Go on FreeBSD
+requires FreeBSD 8 or above.
+</p>
+
+<p>
+As of Go 1.3, support for Go on FreeBSD requires that the kernel be compiled with the
+<code>COMPAT_FREEBSD32</code> flag configured.
+</p>
+
+<p>
+In concert with the switch to EABI syscalls for ARM platforms, Go 1.3 will run only on FreeBSD 10.
+The x86 platforms, 386 and amd64, are unaffected.
+</p>
+
+<h3 id="nacl">Support for Native Client</h3>
+
+<p>
+Support for the Native Client virtual machine architecture has returned to Go with the 1.3 release.
+It runs on the 32-bit Intel architectures (<code>GOARCH=386</code>) and also on 64-bit Intel, but using
+32-bit pointers (<code>GOARCH=amd64p32</code>).
+There is not yet support for Native Client on ARM.
+Note that this is Native Client (NaCl), not Portable Native Client (PNaCl).
+Details about Native Client are <a href="https://developers.google.com/native-client/dev/">here</a>;
+how to set up the Go version is described <a href="//golang.org/wiki/NativeClient">here</a>.
+</p>
+
+<h3 id="netbsd">Support for NetBSD</h3>
+
+<p>
+As of Go 1.3, support for Go on NetBSD requires NetBSD 6.0 or above.
+</p>
+
+<h3 id="openbsd">Support for OpenBSD</h3>
+
+<p>
+As of Go 1.3, support for Go on OpenBSD requires OpenBSD 5.5 or above.
+</p>
+
+<h3 id="plan9">Support for Plan 9</h3>
+
+<p>
+Go 1.3 now includes experimental support for Plan 9 on the <code>386</code> (32-bit x86) architecture.
+It requires the <code>Tsemacquire</code> syscall, which has been in Plan 9 since June, 2012.
+</p>
+
+<h3 id="solaris">Support for Solaris</h3>
+
+<p>
+Go 1.3 now includes experimental support for Solaris on the <code>amd64</code> (64-bit x86) architecture.
+It requires illumos, Solaris 11 or above.
+</p>
+
+<h2 id="memory">Changes to the memory model</h2>
+
+<p>
+The Go 1.3 memory model <a href="https://codereview.appspot.com/75130045">adds a new rule</a>
+concerning sending and receiving on buffered channels,
+to make explicit that a buffered channel can be used as a simple
+semaphore, using a send into the
+channel to acquire and a receive from the channel to release.
+This is not a language change, just a clarification about an expected property of communication.
+</p>
+
+<h2 id="impl">Changes to the implementations and tools</h2>
+
+<h3 id="stacks">Stack</h3>
+
+<p>
+Go 1.3 has changed the implementation of goroutine stacks away from the old,
+"segmented" model to a contiguous model.
+When a goroutine needs more stack
+than is available, its stack is transferred to a larger single block of memory.
+The overhead of this transfer operation amortizes well and eliminates the old "hot spot"
+problem when a calculation repeatedly steps across a segment boundary.
+Details including performance numbers are in this
+<a href="//golang.org/s/contigstacks">design document</a>.
+</p>
+
+<h3 id="garbage_collector">Changes to the garbage collector</h3>
+
+<p>
+For a while now, the garbage collector has been <em>precise</em> when examining
+values in the heap; the Go 1.3 release adds equivalent precision to values on the stack.
+This means that a non-pointer Go value such as an integer will never be mistaken for a
+pointer and prevent unused memory from being reclaimed.
+</p>
+
+<p>
+Starting with Go 1.3, the runtime assumes that values with pointer type
+contain pointers and other values do not.
+This assumption is fundamental to the precise behavior of both stack expansion
+and garbage collection.
+Programs that use <a href="/pkg/unsafe/">package unsafe</a>
+to store integers in pointer-typed values are illegal and will crash if the runtime detects the behavior.
+Programs that use <a href="/pkg/unsafe/">package unsafe</a> to store pointers
+in integer-typed values are also illegal but more difficult to diagnose during execution.
+Because the pointers are hidden from the runtime, a stack expansion or garbage collection
+may reclaim the memory they point at, creating
+<a href="//en.wikipedia.org/wiki/Dangling_pointer">dangling pointers</a>.
+</p>
+
+<p>
+<em>Updating</em>: Code that uses <code>unsafe.Pointer</code> to convert
+an integer-typed value held in memory into a pointer is illegal and must be rewritten.
+Such code can be identified by <code>go vet</code>.
+</p>
+
+<h3 id="map">Map iteration</h3>
+
+<p>
+Iterations over small maps no longer happen in a consistent order.
+Go 1 defines that “<a href="//golang.org/ref/spec#For_statements">The iteration order over maps
+is not specified and is not guaranteed to be the same from one iteration to the next.</a>”
+To keep code from depending on map iteration order,
+Go 1.0 started each map iteration at a random index in the map.
+A new map implementation introduced in Go 1.1 neglected to randomize
+iteration for maps with eight or fewer entries, although the iteration order
+can still vary from system to system.
+This has allowed people to write Go 1.1 and Go 1.2 programs that
+depend on small map iteration order and therefore only work reliably on certain systems.
+Go 1.3 reintroduces random iteration for small maps in order to flush out these bugs.
+</p>
+
+<p>
+<em>Updating</em>: If code assumes a fixed iteration order for small maps,
+it will break and must be rewritten not to make that assumption.
+Because only small maps are affected, the problem arises most often in tests.
+</p>
+
+<h3 id="liblink">The linker</h3>
+
+<p>
+As part of the general <a href="//golang.org/s/go13linker">overhaul</a> to
+the Go linker, the compilers and linkers have been refactored.
+The linker is still a C program, but now the instruction selection phase that
+was part of the linker has been moved to the compiler through the creation of a new
+library called <code>liblink</code>.
+By doing instruction selection only once, when the package is first compiled,
+this can speed up compilation of large projects significantly.
+</p>
+
+<p>
+<em>Updating</em>: Although this is a major internal change, it should have no
+effect on programs.
+</p>
+
+<h3 id="gccgo">Status of gccgo</h3>
+
+<p>
+GCC release 4.9 will contain the Go 1.2 (not 1.3) version of gccgo.
+The release schedules for the GCC and Go projects do not coincide,
+which means that 1.3 will be available in the development branch but
+that the next GCC release, 4.10, will likely have the Go 1.4 version of gccgo.
+</p>
+
+<h3 id="gocmd">Changes to the go command</h3>
+
+<p>
+The <a href="/cmd/go/"><code>cmd/go</code></a> command has several new
+features.
+The <a href="/cmd/go/"><code>go run</code></a> and
+<a href="/cmd/go/"><code>go test</code></a> subcommands
+support a new <code>-exec</code> option to specify an alternate
+way to run the resulting binary.
+Its immediate purpose is to support NaCl.
+</p>
+
+<p>
+The test coverage support of the <a href="/cmd/go/"><code>go test</code></a>
+subcommand now automatically sets the coverage mode to <code>-atomic</code>
+when the race detector is enabled, to eliminate false reports about unsafe
+access to coverage counters.
+</p>
+
+<p>
+The <a href="/cmd/go/"><code>go test</code></a> subcommand
+now always builds the package, even if it has no test files.
+Previously, it would do nothing if no test files were present.
+</p>
+
+<p>
+The <a href="/cmd/go/"><code>go build</code></a> subcommand
+supports a new <code>-i</code> option to install dependencies
+of the specified target, but not the target itself.
+</p>
+
+<p>
+Cross compiling with <a href="/cmd/cgo/"><code>cgo</code></a> enabled
+is now supported.
+The CC_FOR_TARGET and CXX_FOR_TARGET environment
+variables are used when running all.bash to specify the cross compilers
+for C and C++ code, respectively.
+</p>
+
+<p>
+Finally, the go command now supports packages that import Objective-C
+files (suffixed <code>.m</code>) through cgo.
+</p>
+
+<h3 id="cgo">Changes to cgo</h3>
+
+<p>
+The <a href="/cmd/cgo/"><code>cmd/cgo</code></a> command,
+which processes <code>import "C"</code> declarations in Go packages,
+has corrected a serious bug that may cause some packages to stop compiling.
+Previously, all pointers to incomplete struct types translated to the Go type <code>*[0]byte</code>,
+with the effect that the Go compiler could not diagnose passing one kind of struct pointer
+to a function expecting another.
+Go 1.3 corrects this mistake by translating each different
+incomplete struct to a different named type.
+</p>
+
+<p>
+Given the C declaration <code>typedef struct S T</code> for an incomplete <code>struct S</code>,
+some Go code used this bug to refer to the types <code>C.struct_S</code> and <code>C.T</code> interchangeably.
+Cgo now explicitly allows this use, even for completed struct types.
+However, some Go code also used this bug to pass (for example) a <code>*C.FILE</code>
+from one package to another.
+This is not legal and no longer works: in general Go packages
+should avoid exposing C types and names in their APIs.
+</p>
+
+<p>
+<em>Updating</em>: Code confusing pointers to incomplete types or
+passing them across package boundaries will no longer compile
+and must be rewritten.
+If the conversion is correct and must be preserved,
+use an explicit conversion via <a href="/pkg/unsafe/#Pointer"><code>unsafe.Pointer</code></a>.
+</p>
+
+<h3 id="swig">SWIG 3.0 required for programs that use SWIG</h3>
+
+<p>
+For Go programs that use SWIG, SWIG version 3.0 is now required.
+The <a href="/cmd/go"><code>cmd/go</code></a> command will now link the
+SWIG generated object files directly into the binary, rather than
+building and linking with a shared library.
+</p>
+
+<h3 id="gc_flag">Command-line flag parsing</h3>
+
+<p>
+In the gc toolchain, the assemblers now use the
+same command-line flag parsing rules as the Go flag package, a departure
+from the traditional Unix flag parsing.
+This may affect scripts that invoke the tool directly.
+For example,
+<code>go tool 6a -SDfoo</code> must now be written
+<code>go tool 6a -S -D foo</code>.
+(The same change was made to the compilers and linkers in <a href="/doc/go1.1#gc_flag">Go 1.1</a>.)
+</p>
+
+<h3 id="godoc">Changes to godoc</h3>
+<p>
+When invoked with the <code>-analysis</code> flag,
+<a href="//godoc.org/golang.org/x/tools/cmd/godoc">godoc</a>
+now performs sophisticated <a href="/lib/godoc/analysis/help.html">static
+analysis</a> of the code it indexes.
+The results of analysis are presented in both the source view and the
+package documentation view, and include the call graph of each package
+and the relationships between
+definitions and references,
+types and their methods,
+interfaces and their implementations,
+send and receive operations on channels,
+functions and their callers, and
+call sites and their callees.
+</p>
+
+<h3 id="misc">Miscellany</h3>
+
+<p>
+The program <code>misc/benchcmp</code> that compares
+performance across benchmarking runs has been rewritten.
+Once a shell and awk script in the main repository, it is now a Go program in the <code>go.tools</code> repo.
+Documentation is <a href="//godoc.org/golang.org/x/tools/cmd/benchcmp">here</a>.
+</p>
+
+<p>
+For the few of us that build Go distributions, the tool <code>misc/dist</code> has been
+moved and renamed; it now lives in <code>misc/makerelease</code>, still in the main repository.
+</p>
+
+<h2 id="performance">Performance</h2>
+
+<p>
+The performance of Go binaries for this release has improved in many cases due to changes
+in the runtime and garbage collection, plus some changes to libraries.
+Significant instances include:
+</p>
+
+<ul>
+
+<li>
+The runtime handles defers more efficiently, reducing the memory footprint by about two kilobytes
+per goroutine that calls defer.
+</li>
+
+<li>
+The garbage collector has been sped up, using a concurrent sweep algorithm,
+better parallelization, and larger pages.
+The cumulative effect can be a 50-70% reduction in collector pause time.
+</li>
+
+<li>
+The race detector (see <a href="/doc/articles/race_detector.html">this guide</a>)
+is now about 40% faster.
+</li>
+
+<li>
+The regular expression package <a href="/pkg/regexp/"><code>regexp</code></a>
+is now significantly faster for certain simple expressions due to the implementation of
+a second, one-pass execution engine.
+The choice of which engine to use is automatic;
+the details are hidden from the user.
+</li>
+
+</ul>
+
+<p>
+Also, the runtime now includes in stack dumps how long a goroutine has been blocked,
+which can be useful information when debugging deadlocks or performance issues.
+</p>
+
+<h2 id="library">Changes to the standard library</h2>
+
+<h3 id="new_packages">New packages</h3>
+
+<p>
+A new package <a href="/pkg/debug/plan9obj/"><code>debug/plan9obj</code></a> was added to the standard library.
+It implements access to Plan 9 <a href="https://9p.io/magic/man2html/6/a.out">a.out</a> object files.
+</p>
+
+<h3 id="major_library_changes">Major changes to the library</h3>
+
+<p>
+A previous bug in <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a>
+made it possible to skip verification in TLS inadvertently.
+In Go 1.3, the bug is fixed: one must specify either ServerName or
+InsecureSkipVerify, and if ServerName is specified it is enforced.
+This may break existing code that incorrectly depended on insecure
+behavior.
+</p>
+
+<p>
+There is an important new type added to the standard library: <a href="/pkg/sync/#Pool"><code>sync.Pool</code></a>.
+It provides an efficient mechanism for implementing certain types of caches whose memory
+can be reclaimed automatically by the system.
+</p>
+
+<p>
+The <a href="/pkg/testing/"><code>testing</code></a> package's benchmarking helper,
+<a href="/pkg/testing/#B"><code>B</code></a>, now has a
+<a href="/pkg/testing/#B.RunParallel"><code>RunParallel</code></a> method
+to make it easier to run benchmarks that exercise multiple CPUs.
+</p>
+
+<p>
+<em>Updating</em>: The crypto/tls fix may break existing code, but such
+code was erroneous and should be updated.
+</p>
+
+<h3 id="minor_library_changes">Minor changes to the library</h3>
+
+<p>
+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.
+</p>
+
+<ul>
+
+<li> In the <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package,
+a new <a href="/pkg/crypto/tls/#DialWithDialer"><code>DialWithDialer</code></a>
+function lets one establish a TLS connection using an existing dialer, making it easier
+to control dial options such as timeouts.
+The package also now reports the TLS version used by the connection in the
+<a href="/pkg/crypto/tls/#ConnectionState"><code>ConnectionState</code></a>
+struct.
+</li>
+
+<li> The <a href="/pkg/crypto/x509/#CreateCertificate"><code>CreateCertificate</code></a>
+function of the <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package
+now supports parsing (and elsewhere, serialization) of PKCS #10 certificate
+signature requests.
+</li>
+
+<li>
+The formatted print functions of the <code>fmt</code> package now define <code>%F</code>
+as a synonym for <code>%f</code> when printing floating-point values.
+</li>
+
+<li>
+The <a href="/pkg/math/big/"><code>math/big</code></a> package's
+<a href="/pkg/math/big/#Int"><code>Int</code></a> and
+<a href="/pkg/math/big/#Rat"><code>Rat</code></a> types
+now implement
+<a href="/pkg/encoding/#TextMarshaler"><code>encoding.TextMarshaler</code></a> and
+<a href="/pkg/encoding/#TextUnmarshaler"><code>encoding.TextUnmarshaler</code></a>.
+</li>
+
+<li>
+The complex power function, <a href="/pkg/math/cmplx/#Pow"><code>Pow</code></a>,
+now specifies the behavior when the first argument is zero.
+It was undefined before.
+The details are in the <a href="/pkg/math/cmplx/#Pow">documentation for the function</a>.
+</li>
+
+<li>
+The <a href="/pkg/net/http/"><code>net/http</code></a> package now exposes the
+properties of a TLS connection used to make a client request in the new
+<a href="/pkg/net/http/#Response"><code>Response.TLS</code></a> field.
+</li>
+
+<li>
+The <a href="/pkg/net/http/"><code>net/http</code></a> package now
+allows setting an optional server error logger
+with <a href="/pkg/net/http/#Server"><code>Server.ErrorLog</code></a>.
+The default is still that all errors go to stderr.
+</li>
+
+<li>
+The <a href="/pkg/net/http/"><code>net/http</code></a> package now
+supports disabling HTTP keep-alive connections on the server
+with <a href="/pkg/net/http/#Server.SetKeepAlivesEnabled"><code>Server.SetKeepAlivesEnabled</code></a>.
+The default continues to be that the server does keep-alive (reuses
+connections for multiple requests) by default.
+Only resource-constrained servers or those in the process of graceful
+shutdown will want to disable them.
+</li>
+
+<li>
+The <a href="/pkg/net/http/"><code>net/http</code></a> package adds an optional
+<a href="/pkg/net/http/#Transport"><code>Transport.TLSHandshakeTimeout</code></a>
+setting to cap the amount of time HTTP client requests will wait for
+TLS handshakes to complete.
+It's now also set by default
+on <a href="/pkg/net/http#DefaultTransport"><code>DefaultTransport</code></a>.
+</li>
+
+<li>
+The <a href="/pkg/net/http/"><code>net/http</code></a> package's
+<a href="/pkg/net/http/#DefaultTransport"><code>DefaultTransport</code></a>,
+used by the HTTP client code, now
+enables <a href="http://en.wikipedia.org/wiki/Keepalive#TCP_keepalive">TCP
+keep-alives</a> by default.
+Other <a href="/pkg/net/http/#Transport"><code>Transport</code></a>
+values with a nil <code>Dial</code> field continue to function the same
+as before: no TCP keep-alives are used.
+</li>
+
+<li>
+The <a href="/pkg/net/http/"><code>net/http</code></a> package
+now enables <a href="http://en.wikipedia.org/wiki/Keepalive#TCP_keepalive">TCP
+keep-alives</a> for incoming server requests when
+<a href="/pkg/net/http/#ListenAndServe"><code>ListenAndServe</code></a>
+or
+<a href="/pkg/net/http/#ListenAndServeTLS"><code>ListenAndServeTLS</code></a>
+are used.
+When a server is started otherwise, TCP keep-alives are not enabled.
+</li>
+
+<li>
+The <a href="/pkg/net/http/"><code>net/http</code></a> package now
+provides an
+optional <a href="/pkg/net/http/#Server"><code>Server.ConnState</code></a>
+callback to hook various phases of a server connection's lifecycle
+(see <a href="/pkg/net/http/#ConnState"><code>ConnState</code></a>).
+This can be used to implement rate limiting or graceful shutdown.
+</li>
+
+<li>
+The <a href="/pkg/net/http/"><code>net/http</code></a> package's HTTP
+client now has an
+optional <a href="/pkg/net/http/#Client"><code>Client.Timeout</code></a>
+field to specify an end-to-end timeout on requests made using the
+client.
+</li>
+
+<li>
+The <a href="/pkg/net/http/"><code>net/http</code></a> package's
+<a href="/pkg/net/http/#Request.ParseMultipartForm"><code>Request.ParseMultipartForm</code></a>
+method will now return an error if the body's <code>Content-Type</code>
+is not <code>multipart/form-data</code>.
+Prior to Go 1.3 it would silently fail and return <code>nil</code>.
+Code that relies on the previous behavior should be updated.
+</li>
+
+<li> In the <a href="/pkg/net/"><code>net</code></a> package,
+the <a href="/pkg/net/#Dialer"><code>Dialer</code></a> struct now
+has a <code>KeepAlive</code> option to specify a keep-alive period for the connection.
+</li>
+
+<li>
+The <a href="/pkg/net/http/"><code>net/http</code></a> package's
+<a href="/pkg/net/http/#Transport"><code>Transport</code></a>
+now closes <a href="/pkg/net/http/#Request"><code>Request.Body</code></a>
+consistently, even on error.
+</li>
+
+<li>
+The <a href="/pkg/os/exec/"><code>os/exec</code></a> package now implements
+what the documentation has always said with regard to relative paths for the binary.
+In particular, it only calls <a href="/pkg/os/exec/#LookPath"><code>LookPath</code></a>
+when the binary's file name contains no path separators.
+</li>
+
+<li>
+The <a href="/pkg/reflect/#Value.SetMapIndex"><code>SetMapIndex</code></a>
+function in the <a href="/pkg/reflect/"><code>reflect</code></a> package
+no longer panics when deleting from a <code>nil</code> map.
+</li>
+
+<li>
+If the main goroutine calls
+<a href="/pkg/runtime/#Goexit"><code>runtime.Goexit</code></a>
+and all other goroutines finish execution, the program now always crashes,
+reporting a detected deadlock.
+Earlier versions of Go handled this situation inconsistently: most instances
+were reported as deadlocks, but some trivial cases exited cleanly instead.
+</li>
+
+<li>
+The runtime/debug package now has a new function
+<a href="/pkg/runtime/debug/#WriteHeapDump"><code>debug.WriteHeapDump</code></a>
+that writes out a description of the heap.
+</li>
+
+<li>
+The <a href="/pkg/strconv/#CanBackquote"><code>CanBackquote</code></a>
+function in the <a href="/pkg/strconv/"><code>strconv</code></a> package
+now considers the <code>DEL</code> character, <code>U+007F</code>, to be
+non-printing.
+</li>
+
+<li>
+The <a href="/pkg/syscall/"><code>syscall</code></a> package now provides
+<a href="/pkg/syscall/#SendmsgN"><code>SendmsgN</code></a>
+as an alternate version of
+<a href="/pkg/syscall/#Sendmsg"><code>Sendmsg</code></a>
+that returns the number of bytes written.
+</li>
+
+<li>
+On Windows, the <a href="/pkg/syscall/"><code>syscall</code></a> package now
+supports the cdecl calling convention through the addition of a new function
+<a href="/pkg/syscall/#NewCallbackCDecl"><code>NewCallbackCDecl</code></a>
+alongside the existing function
+<a href="/pkg/syscall/#NewCallback"><code>NewCallback</code></a>.
+</li>
+
+<li>
+The <a href="/pkg/testing/"><code>testing</code></a> package now
+diagnoses tests that call <code>panic(nil)</code>, which are almost always erroneous.
+Also, tests now write profiles (if invoked with profiling flags) even on failure.
+</li>
+
+<li>
+The <a href="/pkg/unicode/"><code>unicode</code></a> package and associated
+support throughout the system has been upgraded from
+Unicode 6.2.0 to <a href="http://www.unicode.org/versions/Unicode6.3.0/">Unicode 6.3.0</a>.
+</li>
+
+</ul>
diff --git a/_content/doc/go1.4.html b/_content/doc/go1.4.html
new file mode 100644
index 0000000..0233ad4
--- /dev/null
+++ b/_content/doc/go1.4.html
@@ -0,0 +1,895 @@
+<!--{
+ "Title": "Go 1.4 Release Notes",
+ "Template": true
+}-->
+
+<h2 id="introduction">Introduction to Go 1.4</h2>
+
+<p>
+The latest Go release, version 1.4, arrives as scheduled six months after 1.3.
+</p>
+
+<p>
+It contains only one tiny language change,
+in the form of a backwards-compatible simple variant of <code>for</code>-<code>range</code> loop,
+and a possibly breaking change to the compiler involving methods on pointers-to-pointers.
+</p>
+
+<p>
+The release focuses primarily on implementation work, improving the garbage collector
+and preparing the ground for a fully concurrent collector to be rolled out in the
+next few releases.
+Stacks are now contiguous, reallocated when necessary rather than linking on new
+"segments";
+this release therefore eliminates the notorious "hot stack split" problem.
+There are some new tools available including support in the <code>go</code> command
+for build-time source code generation.
+The release also adds support for ARM processors on Android and Native Client (NaCl)
+and for AMD64 on Plan 9.
+</p>
+
+<p>
+As always, Go 1.4 keeps the <a href="/doc/go1compat.html">promise
+of compatibility</a>,
+and almost everything
+will continue to compile and run without change when moved to 1.4.
+</p>
+
+<h2 id="language">Changes to the language</h2>
+
+<h3 id="forrange">For-range loops</h3>
+<p>
+Up until Go 1.3, <code>for</code>-<code>range</code> loop had two forms
+</p>
+
+<pre>
+for i, v := range x {
+ ...
+}
+</pre>
+
+<p>
+and
+</p>
+
+<pre>
+for i := range x {
+ ...
+}
+</pre>
+
+<p>
+If one was not interested in the loop values, only the iteration itself, it was still
+necessary to mention a variable (probably the <a href="/ref/spec#Blank_identifier">blank identifier</a>, as in
+<code>for</code> <code>_</code> <code>=</code> <code>range</code> <code>x</code>), because
+the form
+</p>
+
+<pre>
+for range x {
+ ...
+}
+</pre>
+
+<p>
+was not syntactically permitted.
+</p>
+
+<p>
+This situation seemed awkward, so as of Go 1.4 the variable-free form is now legal.
+The pattern arises rarely but the code can be cleaner when it does.
+</p>
+
+<p>
+<em>Updating</em>: The change is strictly backwards compatible to existing Go
+programs, but tools that analyze Go parse trees may need to be modified to accept
+this new form as the
+<code>Key</code> field of <a href="/pkg/go/ast/#RangeStmt"><code>RangeStmt</code></a>
+may now be <code>nil</code>.
+</p>
+
+<h3 id="methodonpointertopointer">Method calls on **T</h3>
+
+<p>
+Given these declarations,
+</p>
+
+<pre>
+type T int
+func (T) M() {}
+var x **T
+</pre>
+
+<p>
+both <code>gc</code> and <code>gccgo</code> accepted the method call
+</p>
+
+<pre>
+x.M()
+</pre>
+
+<p>
+which is a double dereference of the pointer-to-pointer <code>x</code>.
+The Go specification allows a single dereference to be inserted automatically,
+but not two, so this call is erroneous according to the language definition.
+It has therefore been disallowed in Go 1.4, which is a breaking change,
+although very few programs will be affected.
+</p>
+
+<p>
+<em>Updating</em>: Code that depends on the old, erroneous behavior will no longer
+compile but is easy to fix by adding an explicit dereference.
+</p>
+
+<h2 id="os">Changes to the supported operating systems and architectures</h2>
+
+<h3 id="android">Android</h3>
+
+<p>
+Go 1.4 can build binaries for ARM processors running the Android operating system.
+It can also build a <code>.so</code> library that can be loaded by an Android application
+using the supporting packages in the <a href="https://golang.org/x/mobile">mobile</a> subrepository.
+A brief description of the plans for this experimental port are available
+<a href="https://golang.org/s/go14android">here</a>.
+</p>
+
+<h3 id="naclarm">NaCl on ARM</h3>
+
+<p>
+The previous release introduced Native Client (NaCl) support for the 32-bit x86
+(<code>GOARCH=386</code>)
+and 64-bit x86 using 32-bit pointers (GOARCH=amd64p32).
+The 1.4 release adds NaCl support for ARM (GOARCH=arm).
+</p>
+
+<h3 id="plan9amd64">Plan9 on AMD64</h3>
+
+<p>
+This release adds support for the Plan 9 operating system on AMD64 processors,
+provided the kernel supports the <code>nsec</code> system call and uses 4K pages.
+</p>
+
+<h2 id="compatibility">Changes to the compatibility guidelines</h2>
+
+<p>
+The <a href="/pkg/unsafe/"><code>unsafe</code></a> package allows one
+to defeat Go's type system by exploiting internal details of the implementation
+or machine representation of data.
+It was never explicitly specified what use of <code>unsafe</code> meant
+with respect to compatibility as specified in the
+<a href="go1compat.html">Go compatibility guidelines</a>.
+The answer, of course, is that we can make no promise of compatibility
+for code that does unsafe things.
+</p>
+
+<p>
+We have clarified this situation in the documentation included in the release.
+The <a href="go1compat.html">Go compatibility guidelines</a> and the
+docs for the <a href="/pkg/unsafe/"><code>unsafe</code></a> package
+are now explicit that unsafe code is not guaranteed to remain compatible.
+</p>
+
+<p>
+<em>Updating</em>: Nothing technical has changed; this is just a clarification
+of the documentation.
+</p>
+
+
+<h2 id="impl">Changes to the implementations and tools</h2>
+
+<h3 id="runtime">Changes to the runtime</h3>
+
+<p>
+Prior to Go 1.4, the runtime (garbage collector, concurrency support, interface management,
+maps, slices, strings, ...) was mostly written in C, with some assembler support.
+In 1.4, much of the code has been translated to Go so that the garbage collector can scan
+the stacks of programs in the runtime and get accurate information about what variables
+are active.
+This change was large but should have no semantic effect on programs.
+</p>
+
+<p>
+This rewrite allows the garbage collector in 1.4 to be fully precise,
+meaning that it is aware of the location of all active pointers in the program.
+This means the heap will be smaller as there will be no false positives keeping non-pointers alive.
+Other related changes also reduce the heap size, which is smaller by 10%-30% overall
+relative to the previous release.
+</p>
+
+<p>
+A consequence is that stacks are no longer segmented, eliminating the "hot split" problem.
+When a stack limit is reached, a new, larger stack is allocated, all active frames for
+the goroutine are copied there, and any pointers into the stack are updated.
+Performance can be noticeably better in some cases and is always more predictable.
+Details are available in <a href="https://golang.org/s/contigstacks">the design document</a>.
+</p>
+
+<p>
+The use of contiguous stacks means that stacks can start smaller without triggering performance issues,
+so the default starting size for a goroutine's stack in 1.4 has been reduced from 8192 bytes to 2048 bytes.
+</p>
+
+<p>
+As preparation for the concurrent garbage collector scheduled for the 1.5 release,
+writes to pointer values in the heap are now done by a function call,
+called a write barrier, rather than directly from the function updating the value.
+In this next release, this will permit the garbage collector to mediate writes to the heap while it is running.
+This change has no semantic effect on programs in 1.4, but was
+included in the release to test the compiler and the resulting performance.
+</p>
+
+<p>
+The implementation of interface values has been modified.
+In earlier releases, the interface contained a word that was either a pointer or a one-word
+scalar value, depending on the type of the concrete object stored.
+This implementation was problematical for the garbage collector,
+so as of 1.4 interface values always hold a pointer.
+In running programs, most interface values were pointers anyway,
+so the effect is minimal, but programs that store integers (for example) in
+interfaces will see more allocations.
+</p>
+
+<p>
+As of Go 1.3, the runtime crashes if it finds a memory word that should contain
+a valid pointer but instead contains an obviously invalid pointer (for example, the value 3).
+Programs that store integers in pointer values may run afoul of this check and crash.
+In Go 1.4, setting the <a href="/pkg/runtime/"><code>GODEBUG</code></a> variable
+<code>invalidptr=0</code> disables
+the crash as a workaround, but we cannot guarantee that future releases will be
+able to avoid the crash; the correct fix is to rewrite code not to alias integers and pointers.
+</p>
+
+<h3 id="asm">Assembly</h3>
+
+<p>
+The language accepted by the assemblers <code>cmd/5a</code>, <code>cmd/6a</code>
+and <code>cmd/8a</code> has had several changes,
+mostly to make it easier to deliver type information to the runtime.
+</p>
+
+<p>
+First, the <code>textflag.h</code> file that defines flags for <code>TEXT</code> directives
+has been copied from the linker source directory to a standard location so it can be
+included with the simple directive
+</p>
+
+<pre>
+#include "textflag.h"
+</pre>
+
+<p>
+The more important changes are in how assembler source can define the necessary
+type information.
+For most programs it will suffice to move data
+definitions (<code>DATA</code> and <code>GLOBL</code> directives)
+out of assembly into Go files
+and to write a Go declaration for each assembly function.
+The <a href="/doc/asm#runtime">assembly document</a> describes what to do.
+</p>
+
+<p>
+<em>Updating</em>:
+Assembly files that include <code>textflag.h</code> from its old
+location will still work, but should be updated.
+For the type information, most assembly routines will need no change,
+but all should be examined.
+Assembly source files that define data,
+functions with non-empty stack frames, or functions that return pointers
+need particular attention.
+A description of the necessary (but simple) changes
+is in the <a href="/doc/asm#runtime">assembly document</a>.
+</p>
+
+<p>
+More information about these changes is in the <a href="/doc/asm">assembly document</a>.
+</p>
+
+<h3 id="gccgo">Status of gccgo</h3>
+
+<p>
+The release schedules for the GCC and Go projects do not coincide.
+GCC release 4.9 contains the Go 1.2 version of gccgo.
+The next release, GCC 5, will likely have the Go 1.4 version of gccgo.
+</p>
+
+<h3 id="internalpackages">Internal packages</h3>
+
+<p>
+Go's package system makes it easy to structure programs into components with clean boundaries,
+but there are only two forms of access: local (unexported) and global (exported).
+Sometimes one wishes to have components that are not exported,
+for instance to avoid acquiring clients of interfaces to code that is part of a public repository
+but not intended for use outside the program to which it belongs.
+</p>
+
+<p>
+The Go language does not have the power to enforce this distinction, but as of Go 1.4 the
+<a href="/cmd/go/"><code>go</code></a> command introduces
+a mechanism to define "internal" packages that may not be imported by packages outside
+the source subtree in which they reside.
+</p>
+
+<p>
+To create such a package, place it in a directory named <code>internal</code> or in a subdirectory of a directory
+named internal.
+When the <code>go</code> command sees an import of a package with <code>internal</code> in its path,
+it verifies that the package doing the import
+is within the tree rooted at the parent of the <code>internal</code> directory.
+For example, a package <code>.../a/b/c/internal/d/e/f</code>
+can be imported only by code in the directory tree rooted at <code>.../a/b/c</code>.
+It cannot be imported by code in <code>.../a/b/g</code> or in any other repository.
+</p>
+
+<p>
+For Go 1.4, the internal package mechanism is enforced for the main Go repository;
+from 1.5 and onward it will be enforced for any repository.
+</p>
+
+<p>
+Full details of the mechanism are in
+<a href="https://golang.org/s/go14internal">the design document</a>.
+</p>
+
+<h3 id="canonicalimports">Canonical import paths</h3>
+
+<p>
+Code often lives in repositories hosted by public services such as <code>github.com</code>,
+meaning that the import paths for packages begin with the name of the hosting service,
+<code>github.com/rsc/pdf</code> for example.
+One can use
+<a href="/cmd/go/#hdr-Remote_import_paths">an existing mechanism</a>
+to provide a "custom" or "vanity" import path such as
+<code>rsc.io/pdf</code>, but
+that creates two valid import paths for the package.
+That is a problem: one may inadvertently import the package through the two
+distinct paths in a single program, which is wasteful;
+miss an update to a package because the path being used is not recognized to be
+out of date;
+or break clients using the old path by moving the package to a different hosting service.
+</p>
+
+<p>
+Go 1.4 introduces an annotation for package clauses in Go source that identify a canonical
+import path for the package.
+If an import is attempted using a path that is not canonical,
+the <a href="/cmd/go/"><code>go</code></a> command
+will refuse to compile the importing package.
+</p>
+
+<p>
+The syntax is simple: put an identifying comment on the package line.
+For our example, the package clause would read:
+</p>
+
+<pre>
+package pdf // import "rsc.io/pdf"
+</pre>
+
+<p>
+With this in place,
+the <code>go</code> command will
+refuse to compile a package that imports <code>github.com/rsc/pdf</code>,
+ensuring that the code can be moved without breaking users.
+</p>
+
+<p>
+The check is at build time, not download time, so if <code>go</code> <code>get</code>
+fails because of this check, the mis-imported package has been copied to the local machine
+and should be removed manually.
+</p>
+
+<p>
+To complement this new feature, a check has been added at update time to verify
+that the local package's remote repository matches that of its custom import.
+The <code>go</code> <code>get</code> <code>-u</code> command will fail to
+update a package if its remote repository has changed since it was first
+downloaded.
+The new <code>-f</code> flag overrides this check.
+</p>
+
+<p>
+Further information is in
+<a href="https://golang.org/s/go14customimport">the design document</a>.
+</p>
+
+<h3 id="subrepo">Import paths for the subrepositories</h3>
+
+<p>
+The Go project subrepositories (<code>code.google.com/p/go.tools</code> and so on)
+are now available under custom import paths replacing <code>code.google.com/p/go.</code> with <code>golang.org/x/</code>,
+as in <code>golang.org/x/tools</code>.
+We will add canonical import comments to the code around June 1, 2015,
+at which point Go 1.4 and later will stop accepting the old <code>code.google.com</code> paths.
+</p>
+
+<p>
+<em>Updating</em>: All code that imports from subrepositories should change
+to use the new <code>golang.org</code> paths.
+Go 1.0 and later can resolve and import the new paths, so updating will not break
+compatibility with older releases.
+Code that has not updated will stop compiling with Go 1.4 around June 1, 2015.
+</p>
+
+<h3 id="gogenerate">The go generate subcommand</h3>
+
+<p>
+The <a href="/cmd/go/"><code>go</code></a> command has a new subcommand,
+<a href="/cmd/go/#hdr-Generate_Go_files_by_processing_source"><code>go generate</code></a>,
+to automate the running of tools to generate source code before compilation.
+For example, it can be used to run the <a href="/cmd/yacc"><code>yacc</code></a>
+compiler-compiler on a <code>.y</code> file to produce the Go source file implementing the grammar,
+or to automate the generation of <code>String</code> methods for typed constants using the new
+<a href="https://godoc.org/golang.org/x/tools/cmd/stringer">stringer</a>
+tool in the <code>golang.org/x/tools</code> subrepository.
+</p>
+
+<p>
+For more information, see the
+<a href="https://golang.org/s/go1.4-generate">design document</a>.
+</p>
+
+<h3 id="filenames">Change to file name handling</h3>
+
+<p>
+Build constraints, also known as build tags, control compilation by including or excluding files
+(see the documentation <a href="/pkg/go/build/"><code>/go/build</code></a>).
+Compilation can also be controlled by the name of the file itself by "tagging" the file with
+a suffix (before the <code>.go</code> or <code>.s</code> extension) with an underscore
+and the name of the architecture or operating system.
+For instance, the file <code>gopher_arm.go</code> will only be compiled if the target
+processor is an ARM.
+</p>
+
+<p>
+Before Go 1.4, a file called just <code>arm.go</code> was similarly tagged, but this behavior
+can break sources when new architectures are added, causing files to suddenly become tagged.
+In 1.4, therefore, a file will be tagged in this manner only if the tag (architecture or operating
+system name) is preceded by an underscore.
+</p>
+
+<p>
+<em>Updating</em>: Packages that depend on the old behavior will no longer compile correctly.
+Files with names like <code>windows.go</code> or <code>amd64.go</code> should either
+have explicit build tags added to the source or be renamed to something like
+<code>os_windows.go</code> or <code>support_amd64.go</code>.
+</p>
+
+<h3 id="gocmd">Other changes to the go command</h3>
+
+<p>
+There were a number of minor changes to the
+<a href="/cmd/go/"><code>cmd/go</code></a>
+command worth noting.
+</p>
+
+<ul>
+
+<li>
+Unless <a href="/cmd/cgo/"><code>cgo</code></a> is being used to build the package,
+the <code>go</code> command now refuses to compile C source files,
+since the relevant C compilers
+(<a href="/cmd/6c/"><code>6c</code></a> etc.)
+are intended to be removed from the installation in some future release.
+(They are used today only to build part of the runtime.)
+It is difficult to use them correctly in any case, so any extant uses are likely incorrect,
+so we have disabled them.
+</li>
+
+<li>
+The <a href="/cmd/go/#hdr-Test_packages"><code>go</code> <code>test</code></a>
+subcommand has a new flag, <code>-o</code>, to set the name of the resulting binary,
+corresponding to the same flag in other subcommands.
+The non-functional <code>-file</code> flag has been removed.
+</li>
+
+<li>
+The <a href="/cmd/go/#hdr-Test_packages"><code>go</code> <code>test</code></a>
+subcommand will compile and link all <code>*_test.go</code> files in the package,
+even when there are no <code>Test</code> functions in them.
+It previously ignored such files.
+</li>
+
+<li>
+The behavior of the
+<a href="/cmd/go/#hdr-Test_packages"><code>go</code> <code>build</code></a>
+subcommand's
+<code>-a</code> flag has been changed for non-development installations.
+For installations running a released distribution, the <code>-a</code> flag will no longer
+rebuild the standard library and commands, to avoid overwriting the installation's files.
+</li>
+
+</ul>
+
+<h3 id="pkg">Changes to package source layout</h3>
+
+<p>
+In the main Go source repository, the source code for the packages was kept in
+the directory <code>src/pkg</code>, which made sense but differed from
+other repositories, including the Go subrepositories.
+In Go 1.4, the<code> pkg</code> level of the source tree is now gone, so for example
+the <a href="/pkg/fmt/"><code>fmt</code></a> package's source, once kept in
+directory <code>src/pkg/fmt</code>, now lives one level higher in <code>src/fmt</code>.
+</p>
+
+<p>
+<em>Updating</em>: Tools like <code>godoc</code> that discover source code
+need to know about the new location. All tools and services maintained by the Go team
+have been updated.
+</p>
+
+
+<h3 id="swig">SWIG</h3>
+
+<p>
+Due to runtime changes in this release, Go 1.4 requires SWIG 3.0.3.
+</p>
+
+<h3 id="misc">Miscellany</h3>
+
+<p>
+The standard repository's top-level <code>misc</code> directory used to contain
+Go support for editors and IDEs: plugins, initialization scripts and so on.
+Maintaining these was becoming time-consuming
+and needed external help because many of the editors listed were not used by
+members of the core team.
+It also required us to make decisions about which plugin was best for a given
+editor, even for editors we do not use.
+</p>
+
+<p>
+The Go community at large is much better suited to managing this information.
+In Go 1.4, therefore, this support has been removed from the repository.
+Instead, there is a curated, informative list of what's available on
+a <a href="//golang.org/wiki/IDEsAndTextEditorPlugins">wiki page</a>.
+</p>
+
+<h2 id="performance">Performance</h2>
+
+<p>
+Most programs will run about the same speed or slightly faster in 1.4 than in 1.3;
+some will be slightly slower.
+There are many changes, making it hard to be precise about what to expect.
+</p>
+
+<p>
+As mentioned above, much of the runtime was translated to Go from C,
+which led to some reduction in heap sizes.
+It also improved performance slightly because the Go compiler is better
+at optimization, due to things like inlining, than the C compiler used to build
+the runtime.
+</p>
+
+<p>
+The garbage collector was sped up, leading to measurable improvements for
+garbage-heavy programs.
+On the other hand, the new write barriers slow things down again, typically
+by about the same amount but, depending on their behavior, some programs
+may be somewhat slower or faster.
+</p>
+
+<p>
+Library changes that affect performance are documented below.
+</p>
+
+<h2 id="library">Changes to the standard library</h2>
+
+<h3 id="new_packages">New packages</h3>
+
+<p>
+There are no new packages in this release.
+</p>
+
+<h3 id="major_library_changes">Major changes to the library</h3>
+
+<h4 id="scanner">bufio.Scanner</h4>
+
+<p>
+The <a href="/pkg/bufio/#Scanner"><code>Scanner</code></a> type in the
+<a href="/pkg/bufio/"><code>bufio</code></a> package
+has had a bug fixed that may require changes to custom
+<a href="/pkg/bufio/#SplitFunc"><code>split functions</code></a>.
+The bug made it impossible to generate an empty token at EOF; the fix
+changes the end conditions seen by the split function.
+Previously, scanning stopped at EOF if there was no more data.
+As of 1.4, the split function will be called once at EOF after input is exhausted,
+so the split function can generate a final empty token
+as the documentation already promised.
+</p>
+
+<p>
+<em>Updating</em>: Custom split functions may need to be modified to
+handle empty tokens at EOF as desired.
+</p>
+
+<h4 id="syscall">syscall</h4>
+
+<p>
+The <a href="/pkg/syscall/"><code>syscall</code></a> package is now frozen except
+for changes needed to maintain the core repository.
+In particular, it will no longer be extended to support new or different system calls
+that are not used by the core.
+The reasons are described at length in <a href="https://golang.org/s/go1.4-syscall">a
+separate document</a>.
+</p>
+
+<p>
+A new subrepository, <a href="https://golang.org/x/sys">golang.org/x/sys</a>,
+has been created to serve as the location for new developments to support system
+calls on all kernels.
+It has a nicer structure, with three packages that each hold the implementation of
+system calls for one of
+<a href="https://godoc.org/golang.org/x/sys/unix">Unix</a>,
+<a href="https://godoc.org/golang.org/x/sys/windows">Windows</a> and
+<a href="https://godoc.org/golang.org/x/sys/plan9">Plan 9</a>.
+These packages will be curated more generously, accepting all reasonable changes
+that reflect kernel interfaces in those operating systems.
+See the documentation and the article mentioned above for more information.
+</p>
+
+<p>
+<em>Updating</em>: Existing programs are not affected as the <code>syscall</code>
+package is largely unchanged from the 1.3 release.
+Future development that requires system calls not in the <code>syscall</code> package
+should build on <code>golang.org/x/sys</code> instead.
+</p>
+
+<h3 id="minor_library_changes">Minor changes to the library</h3>
+
+<p>
+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.
+</p>
+
+<ul>
+
+<li>
+The <a href="/pkg/archive/zip/"><code>archive/zip</code></a> package's
+<a href="/pkg/archive/zip/#Writer"><code>Writer</code></a> now supports a
+<a href="/pkg/archive/zip/#Writer.Flush"><code>Flush</code></a> method.
+</li>
+
+<li>
+The <a href="/pkg/compress/flate/"><code>compress/flate</code></a>,
+<a href="/pkg/compress/gzip/"><code>compress/gzip</code></a>,
+and <a href="/pkg/compress/zlib/"><code>compress/zlib</code></a>
+packages now support a <code>Reset</code> method
+for the decompressors, allowing them to reuse buffers and improve performance.
+The <a href="/pkg/compress/gzip/"><code>compress/gzip</code></a> package also has a
+<a href="/pkg/compress/gzip/#Reader.Multistream"><code>Multistream</code></a> method to control support
+for multistream files.
+</li>
+
+<li>
+The <a href="/pkg/crypto/"><code>crypto</code></a> package now has a
+<a href="/pkg/crypto/#Signer"><code>Signer</code></a> interface, implemented by the
+<code>PrivateKey</code> types in
+<a href="/pkg/crypto/ecdsa"><code>crypto/ecdsa</code></a> and
+<a href="/pkg/crypto/rsa"><code>crypto/rsa</code></a>.
+</li>
+
+<li>
+The <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package
+now supports ALPN as defined in <a href="https://tools.ietf.org/html/rfc7301">RFC 7301</a>.
+</li>
+
+<li>
+The <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package
+now supports programmatic selection of server certificates
+through the new <a href="/pkg/crypto/tls/#Config.CertificateForName"><code>CertificateForName</code></a> function
+of the <a href="/pkg/crypto/tls/#Config"><code>Config</code></a> struct.
+</li>
+
+<li>
+Also in the crypto/tls package, the server now supports
+<a href="https://tools.ietf.org/html/draft-ietf-tls-downgrade-scsv-00">TLS_FALLBACK_SCSV</a>
+to help clients detect fallback attacks.
+(The Go client does not support fallback at all, so it is not vulnerable to
+those attacks.)
+</li>
+
+<li>
+The <a href="/pkg/database/sql/"><code>database/sql</code></a> package can now list all registered
+<a href="/pkg/database/sql/#Drivers"><code>Drivers</code></a>.
+</li>
+
+<li>
+The <a href="/pkg/debug/dwarf/"><code>debug/dwarf</code></a> package now supports
+<a href="/pkg/debug/dwarf/#UnspecifiedType"><code>UnspecifiedType</code></a>s.
+</li>
+
+<li>
+In the <a href="/pkg/encoding/asn1/"><code>encoding/asn1</code></a> package,
+optional elements with a default value will now only be omitted if they have that value.
+</li>
+
+<li>
+The <a href="/pkg/encoding/csv/"><code>encoding/csv</code></a> package no longer
+quotes empty strings but does quote the end-of-data marker <code>\.</code> (backslash dot).
+This is permitted by the definition of CSV and allows it to work better with Postgres.
+</li>
+
+<li>
+The <a href="/pkg/encoding/gob/"><code>encoding/gob</code></a> package has been rewritten to eliminate
+the use of unsafe operations, allowing it to be used in environments that do not permit use of the
+<a href="/pkg/unsafe/"><code>unsafe</code></a> package.
+For typical uses it will be 10-30% slower, but the delta is dependent on the type of the data and
+in some cases, especially involving arrays, it can be faster.
+There is no functional change.
+</li>
+
+<li>
+The <a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> package's
+<a href="/pkg/encoding/xml/#Decoder"><code>Decoder</code></a> can now report its input offset.
+</li>
+
+<li>
+In the <a href="/pkg/fmt/"><code>fmt</code></a> package,
+formatting of pointers to maps has changed to be consistent with that of pointers
+to structs, arrays, and so on.
+For instance, <code>&map[string]int{"one":</code> <code>1}</code> now prints by default as
+<code>&map[one:</code> <code>1]</code> rather than as a hexadecimal pointer value.
+</li>
+
+<li>
+The <a href="/pkg/image/"><code>image</code></a> package's
+<a href="/pkg/image/#Image"><code>Image</code></a>
+implementations like
+<a href="/pkg/image/#RGBA"><code>RGBA</code></a> and
+<a href="/pkg/image/#Gray"><code>Gray</code></a> have specialized
+<a href="/pkg/image/#RGBA.RGBAAt"><code>RGBAAt</code></a> and
+<a href="/pkg/image/#Gray.GrayAt"><code>GrayAt</code></a> methods alongside the general
+<a href="/pkg/image/#Image.At"><code>At</code></a> method.
+</li>
+
+<li>
+The <a href="/pkg/image/png/"><code>image/png</code></a> package now has an
+<a href="/pkg/image/png/#Encoder"><code>Encoder</code></a>
+type to control the compression level used for encoding.
+</li>
+
+<li>
+The <a href="/pkg/math/"><code>math</code></a> package now has a
+<a href="/pkg/math/#Nextafter32"><code>Nextafter32</code><a/> function.
+</li>
+
+<li>
+The <a href="/pkg/net/http/"><code>net/http</code></a> package's
+<a href="/pkg/net/http/#Request"><code>Request</code></a> type
+has a new <a href="/pkg/net/http/#Request.BasicAuth"><code>BasicAuth</code></a> method
+that returns the username and password from authenticated requests using the
+HTTP Basic Authentication
+Scheme.
+</li>
+
+<li>The <a href="/pkg/net/http/"><code>net/http</code></a> package's
+<a href="/pkg/net/http/#Request"><code>Transport</code></a> type
+has a new <a href="/pkg/net/http/#Transport.DialTLS"><code>DialTLS</code></a> hook
+that allows customizing the behavior of outbound TLS connections.
+</li>
+
+<li>
+The <a href="/pkg/net/http/httputil/"><code>net/http/httputil</code></a> package's
+<a href="/pkg/net/http/httputil/#ReverseProxy"><code>ReverseProxy</code></a> type
+has a new field,
+<a href="/pkg/net/http/#ReverseProxy.ErrorLog"><code>ErrorLog</code></a>, that
+provides user control of logging.
+</li>
+
+<li>
+The <a href="/pkg/os/"><code>os</code></a> package
+now implements symbolic links on the Windows operating system
+through the <a href="/pkg/os/#Symlink"><code>Symlink</code></a> function.
+Other operating systems already have this functionality.
+There is also a new <a href="/pkg/os/#Unsetenv"><code>Unsetenv</code></a> function.
+</li>
+
+<li>
+The <a href="/pkg/reflect/"><code>reflect</code></a> package's
+<a href="/pkg/reflect/#Type"><code>Type</code></a> interface
+has a new method, <a href="/pkg/reflect/#type.Comparable"><code>Comparable</code></a>,
+that reports whether the type implements general comparisons.
+</li>
+
+<li>
+Also in the <a href="/pkg/reflect/"><code>reflect</code></a> package, the
+<a href="/pkg/reflect/#Value"><code>Value</code></a> interface is now three instead of four words
+because of changes to the implementation of interfaces in the runtime.
+This saves memory but has no semantic effect.
+</li>
+
+<li>
+The <a href="/pkg/runtime/"><code>runtime</code></a> package
+now implements monotonic clocks on Windows,
+as it already did for the other systems.
+</li>
+
+<li>
+The <a href="/pkg/runtime/"><code>runtime</code></a> package's
+<a href="/pkg/runtime/#MemStats.Mallocs"><code>Mallocs</code></a> counter
+now counts very small allocations that were missed in Go 1.3.
+This may break tests using <a href="/pkg/runtime/#ReadMemStats"><code>ReadMemStats</code></a>
+or <a href="/pkg/testing/#AllocsPerRun"><code>AllocsPerRun</code></a>
+due to the more accurate answer.
+</li>
+
+<li>
+In the <a href="/pkg/runtime/"><code>runtime</code></a> package,
+an array <a href="/pkg/runtime/#MemStats.PauseEnd"><code>PauseEnd</code></a>
+has been added to the
+<a href="/pkg/runtime/#MemStats"><code>MemStats</code></a>
+and <a href="/pkg/runtime/#GCStats"><code>GCStats</code></a> structs.
+This array is a circular buffer of times when garbage collection pauses ended.
+The corresponding pause durations are already recorded in
+<a href="/pkg/runtime/#MemStats.PauseNs"><code>PauseNs</code></a>
+</li>
+
+<li>
+The <a href="/pkg/runtime/race/"><code>runtime/race</code></a> package
+now supports FreeBSD, which means the
+<a href="/pkg/cmd/go/"><code>go</code></a> command's <code>-race</code>
+flag now works on FreeBSD.
+</li>
+
+<li>
+The <a href="/pkg/sync/atomic/"><code>sync/atomic</code></a> package
+has a new type, <a href="/pkg/sync/atomic/#Value"><code>Value</code></a>.
+<code>Value</code> provides an efficient mechanism for atomic loads and
+stores of values of arbitrary type.
+</li>
+
+<li>
+In the <a href="/pkg/syscall/"><code>syscall</code></a> package's
+implementation on Linux, the
+<a href="/pkg/syscall/#Setuid"><code>Setuid</code></a>
+and <a href="/pkg/syscall/#Setgid"><code>Setgid</code></a> have been disabled
+because those system calls operate on the calling thread, not the whole process, which is
+different from other platforms and not the expected result.
+</li>
+
+<li>
+The <a href="/pkg/testing/"><code>testing</code></a> package
+has a new facility to provide more control over running a set of tests.
+If the test code contains a function
+<pre>
+func TestMain(m *<a href="/pkg/testing/#M"><code>testing.M</code></a>)
+</pre>
+
+that function will be called instead of running the tests directly.
+The <code>M</code> struct contains methods to access and run the tests.
+</li>
+
+<li>
+Also in the <a href="/pkg/testing/"><code>testing</code></a> package,
+a new <a href="/pkg/testing/#Coverage"><code>Coverage</code></a>
+function reports the current test coverage fraction,
+enabling individual tests to report how much they are contributing to the
+overall coverage.
+</li>
+
+<li>
+The <a href="/pkg/text/scanner/"><code>text/scanner</code></a> package's
+<a href="/pkg/text/scanner/#Scanner"><code>Scanner</code></a> type
+has a new function,
+<a href="/pkg/text/scanner/#Scanner.IsIdentRune"><code>IsIdentRune</code></a>,
+allowing one to control the definition of an identifier when scanning.
+</li>
+
+<li>
+The <a href="/pkg/text/template/"><code>text/template</code></a> package's boolean
+functions <code>eq</code>, <code>lt</code>, and so on have been generalized to allow comparison
+of signed and unsigned integers, simplifying their use in practice.
+(Previously one could only compare values of the same signedness.)
+All negative values compare less than all unsigned values.
+</li>
+
+<li>
+The <code>time</code> package now uses the standard symbol for the micro prefix,
+the micro symbol (U+00B5 'µ'), to print microsecond durations.
+<a href="/pkg/time/#ParseDuration"><code>ParseDuration</code></a> still accepts <code>us</code>
+but the package no longer prints microseconds as <code>us</code>.
+<br>
+<em>Updating</em>: Code that depends on the output format of durations
+but does not use ParseDuration will need to be updated.
+</li>
+
+</ul>
diff --git a/_content/doc/go1.5.html b/_content/doc/go1.5.html
new file mode 100644
index 0000000..d9529f2
--- /dev/null
+++ b/_content/doc/go1.5.html
@@ -0,0 +1,1309 @@
+<!--{
+ "Title": "Go 1.5 Release Notes",
+ "Template": true
+}-->
+
+
+<h2 id="introduction">Introduction to Go 1.5</h2>
+
+<p>
+The latest Go release, version 1.5,
+is a significant release, including major architectural changes to the implementation.
+Despite that, we expect almost all Go programs to continue to compile and run as before,
+because the release still maintains the Go 1 <a href="/doc/go1compat.html">promise
+of compatibility</a>.
+</p>
+
+<p>
+The biggest developments in the implementation are:
+</p>
+
+<ul>
+
+<li>
+The compiler and runtime are now written entirely in Go (with a little assembler).
+C is no longer involved in the implementation, and so the C compiler that was
+once necessary for building the distribution is gone.
+</li>
+
+<li>
+The garbage collector is now <a href="https://golang.org/s/go14gc">concurrent</a> and provides dramatically lower
+pause times by running, when possible, in parallel with other goroutines.
+</li>
+
+<li>
+By default, Go programs run with <code>GOMAXPROCS</code> set to the
+number of cores available; in prior releases it defaulted to 1.
+</li>
+
+<li>
+Support for <a href="https://golang.org/s/go14internal">internal packages</a>
+is now provided for all repositories, not just the Go core.
+</li>
+
+<li>
+The <code>go</code> command now provides <a href="https://golang.org/s/go15vendor">experimental
+support</a> for "vendoring" external dependencies.
+</li>
+
+<li>
+A new <code>go tool trace</code> command supports fine-grained
+tracing of program execution.
+</li>
+
+<li>
+A new <code>go doc</code> command (distinct from <code>godoc</code>)
+is customized for command-line use.
+</li>
+
+</ul>
+
+<p>
+These and a number of other changes to the implementation and tools
+are discussed below.
+</p>
+
+<p>
+The release also contains one small language change involving map literals.
+</p>
+
+<p>
+Finally, the timing of the <a href="https://golang.org/s/releasesched">release</a>
+strays from the usual six-month interval,
+both to provide more time to prepare this major release and to shift the schedule thereafter to
+time the release dates more conveniently.
+</p>
+
+<h2 id="language">Changes to the language</h2>
+
+<h3 id="map_literals">Map literals</h3>
+
+<p>
+Due to an oversight, the rule that allowed the element type to be elided from slice literals was not
+applied to map keys.
+This has been <a href="/cl/2591">corrected</a> in Go 1.5.
+An example will make this clear.
+As of Go 1.5, this map literal,
+</p>
+
+<pre>
+m := map[Point]string{
+ Point{29.935523, 52.891566}: "Persepolis",
+ Point{-25.352594, 131.034361}: "Uluru",
+ Point{37.422455, -122.084306}: "Googleplex",
+}
+</pre>
+
+<p>
+may be written as follows, without the <code>Point</code> type listed explicitly:
+</p>
+
+<pre>
+m := map[Point]string{
+ {29.935523, 52.891566}: "Persepolis",
+ {-25.352594, 131.034361}: "Uluru",
+ {37.422455, -122.084306}: "Googleplex",
+}
+</pre>
+
+<h2 id="implementation">The Implementation</h2>
+
+<h3 id="c">No more C</h3>
+
+<p>
+The compiler and runtime are now implemented in Go and assembler, without C.
+The only C source left in the tree is related to testing or to <code>cgo</code>.
+There was a C compiler in the tree in 1.4 and earlier.
+It was used to build the runtime; a custom compiler was necessary in part to
+guarantee the C code would work with the stack management of goroutines.
+Since the runtime is in Go now, there is no need for this C compiler and it is gone.
+Details of the process to eliminate C are discussed <a href="https://golang.org/s/go13compiler">elsewhere</a>.
+</p>
+
+<p>
+The conversion from C was done with the help of custom tools created for the job.
+Most important, the compiler was actually moved by automatic translation of
+the C code into Go.
+It is in effect the same program in a different language.
+It is not a new implementation
+of the compiler so we expect the process will not have introduced new compiler
+bugs.
+An overview of this process is available in the slides for
+<a href="https://talks.golang.org/2015/gogo.slide">this presentation</a>.
+</p>
+
+<h3 id="compiler_and_tools">Compiler and tools</h3>
+
+<p>
+Independent of but encouraged by the move to Go, the names of the tools have changed.
+The old names <code>6g</code>, <code>8g</code> and so on are gone; instead there
+is just one binary, accessible as <code>go</code> <code>tool</code> <code>compile</code>,
+that compiles Go source into binaries suitable for the architecture and operating system
+specified by <code>$GOARCH</code> and <code>$GOOS</code>.
+Similarly, there is now one linker (<code>go</code> <code>tool</code> <code>link</code>)
+and one assembler (<code>go</code> <code>tool</code> <code>asm</code>).
+The linker was translated automatically from the old C implementation,
+but the assembler is a new native Go implementation discussed
+in more detail below.
+</p>
+
+<p>
+Similar to the drop of the names <code>6g</code>, <code>8g</code>, and so on,
+the output of the compiler and assembler are now given a plain <code>.o</code> suffix
+rather than <code>.8</code>, <code>.6</code>, etc.
+</p>
+
+
+<h3 id="gc">Garbage collector</h3>
+
+<p>
+The garbage collector has been re-engineered for 1.5 as part of the development
+outlined in the <a href="https://golang.org/s/go14gc">design document</a>.
+Expected latencies are much lower than with the collector
+in prior releases, through a combination of advanced algorithms,
+better <a href="https://golang.org/s/go15gcpacing">scheduling</a> of the collector,
+and running more of the collection in parallel with the user program.
+The "stop the world" phase of the collector
+will almost always be under 10 milliseconds and usually much less.
+</p>
+
+<p>
+For systems that benefit from low latency, such as user-responsive web sites,
+the drop in expected latency with the new collector may be important.
+</p>
+
+<p>
+Details of the new collector were presented in a
+<a href="https://talks.golang.org/2015/go-gc.pdf">talk</a> at GopherCon 2015.
+</p>
+
+<h3 id="runtime">Runtime</h3>
+
+<p>
+In Go 1.5, the order in which goroutines are scheduled has been changed.
+The properties of the scheduler were never defined by the language,
+but programs that depend on the scheduling order may be broken
+by this change.
+We have seen a few (erroneous) programs affected by this change.
+If you have programs that implicitly depend on the scheduling
+order, you will need to update them.
+</p>
+
+<p>
+Another potentially breaking change is that the runtime now
+sets the default number of threads to run simultaneously,
+defined by <code>GOMAXPROCS</code>, to the number
+of cores available on the CPU.
+In prior releases the default was 1.
+Programs that do not expect to run with multiple cores may
+break inadvertently.
+They can be updated by removing the restriction or by setting
+<code>GOMAXPROCS</code> explicitly.
+For a more detailed discussion of this change, see
+the <a href="https://golang.org/s/go15gomaxprocs">design document</a>.
+</p>
+
+<h3 id="build">Build</h3>
+
+<p>
+Now that the Go compiler and runtime are implemented in Go, a Go compiler
+must be available to compile the distribution from source.
+Thus, to build the Go core, a working Go distribution must already be in place.
+(Go programmers who do not work on the core are unaffected by this change.)
+Any Go 1.4 or later distribution (including <code>gccgo</code>) will serve.
+For details, see the <a href="https://golang.org/s/go15bootstrap">design document</a>.
+</p>
+
+<h2 id="ports">Ports</h2>
+
+<p>
+Due mostly to the industry's move away from the 32-bit x86 architecture,
+the set of binary downloads provided is reduced in 1.5.
+A distribution for the OS X operating system is provided only for the
+<code>amd64</code> architecture, not <code>386</code>.
+Similarly, the ports for Snow Leopard (Apple OS X 10.6) still work but are no
+longer released as a download or maintained since Apple no longer maintains that version
+of the operating system.
+Also, the <code>dragonfly/386</code> port is no longer supported at all
+because DragonflyBSD itself no longer supports the 32-bit 386 architecture.
+</p>
+
+<p>
+There are however several new ports available to be built from source.
+These include <code>darwin/arm</code> and <code>darwin/arm64</code>.
+The new port <code>linux/arm64</code> is mostly in place, but <code>cgo</code>
+is only supported using external linking.
+</p>
+
+<p>
+Also available as experiments are <code>ppc64</code>
+and <code>ppc64le</code> (64-bit PowerPC, big- and little-endian).
+Both these ports support <code>cgo</code> but
+only with internal linking.
+</p>
+
+<p>
+On FreeBSD, Go 1.5 requires FreeBSD 8-STABLE+ because of its new use of the <code>SYSCALL</code> instruction.
+</p>
+
+<p>
+On NaCl, Go 1.5 requires SDK version pepper-41. Later pepper versions are not
+compatible due to the removal of the sRPC subsystem from the NaCl runtime.
+</p>
+
+<p>
+On Darwin, the use of the system X.509 certificate interface can be disabled
+with the <code>ios</code> build tag.
+</p>
+
+<p>
+The Solaris port now has full support for cgo and the packages
+<a href="/pkg/net/"><code>net</code></a> and
+<a href="/pkg/crypto/x509/"><code>crypto/x509</code></a>,
+as well as a number of other fixes and improvements.
+</p>
+
+<h2 id="tools">Tools</h2>
+
+<h3 id="translate">Translating</h3>
+
+<p>
+As part of the process to eliminate C from the tree, the compiler and
+linker were translated from C to Go.
+It was a genuine (machine assisted) translation, so the new programs are essentially
+the old programs translated rather than new ones with new bugs.
+We are confident the translation process has introduced few if any new bugs,
+and in fact uncovered a number of previously unknown bugs, now fixed.
+</p>
+
+<p>
+The assembler is a new program, however; it is described below.
+</p>
+
+<h3 id="rename">Renaming</h3>
+
+<p>
+The suites of programs that were the compilers (<code>6g</code>, <code>8g</code>, etc.),
+the assemblers (<code>6a</code>, <code>8a</code>, etc.),
+and the linkers (<code>6l</code>, <code>8l</code>, etc.)
+have each been consolidated into a single tool that is configured
+by the environment variables <code>GOOS</code> and <code>GOARCH</code>.
+The old names are gone; the new tools are available through the <code>go</code> <code>tool</code>
+mechanism as <code>go tool compile</code>,
+<code>go tool asm</code>,
+<code>and go tool link</code>.
+Also, the file suffixes <code>.6</code>, <code>.8</code>, etc. for the
+intermediate object files are also gone; now they are just plain <code>.o</code> files.
+</p>
+
+<p>
+For example, to build and link a program on amd64 for Darwin
+using the tools directly, rather than through <code>go build</code>,
+one would run:
+</p>
+
+<pre>
+$ export GOOS=darwin GOARCH=amd64
+$ go tool compile program.go
+$ go tool link program.o
+</pre>
+
+<h3 id="moving">Moving</h3>
+
+<p>
+Because the <a href="/pkg/go/types/"><code>go/types</code></a> package
+has now moved into the main repository (see below),
+the <a href="/cmd/vet"><code>vet</code></a> and
+<a href="/cmd/cover"><code>cover</code></a>
+tools have also been moved.
+They are no longer maintained in the external <code>golang.org/x/tools</code> repository,
+although (deprecated) source still resides there for compatibility with old releases.
+</p>
+
+<h3 id="compiler">Compiler</h3>
+
+<p>
+As described above, the compiler in Go 1.5 is a single Go program,
+translated from the old C source, that replaces <code>6g</code>, <code>8g</code>,
+and so on.
+Its target is configured by the environment variables <code>GOOS</code> and <code>GOARCH</code>.
+</p>
+
+<p>
+The 1.5 compiler is mostly equivalent to the old,
+but some internal details have changed.
+One significant change is that evaluation of constants now uses
+the <a href="/pkg/math/big/"><code>math/big</code></a> package
+rather than a custom (and less well tested) implementation of high precision
+arithmetic.
+We do not expect this to affect the results.
+</p>
+
+<p>
+For the amd64 architecture only, the compiler has a new option, <code>-dynlink</code>,
+that assists dynamic linking by supporting references to Go symbols
+defined in external shared libraries.
+</p>
+
+<h3 id="assembler">Assembler</h3>
+
+<p>
+Like the compiler and linker, the assembler in Go 1.5 is a single program
+that replaces the suite of assemblers (<code>6a</code>,
+<code>8a</code>, etc.) and the environment variables
+<code>GOARCH</code> and <code>GOOS</code>
+configure the architecture and operating system.
+Unlike the other programs, the assembler is a wholly new program
+written in Go.
+</p>
+
+ <p>
+The new assembler is very nearly compatible with the previous
+ones, but there are a few changes that may affect some
+assembler source files.
+See the updated <a href="/doc/asm">assembler guide</a>
+for more specific information about these changes. In summary:
+
+</p>
+
+<p>
+First, the expression evaluation used for constants is a little
+different.
+It now uses unsigned 64-bit arithmetic and the precedence
+of operators (<code>+</code>, <code>-</code>, <code><<</code>, etc.)
+comes from Go, not C.
+We expect these changes to affect very few programs but
+manual verification may be required.
+</p>
+
+<p>
+Perhaps more important is that on machines where
+<code>SP</code> or <code>PC</code> is only an alias
+for a numbered register,
+such as <code>R13</code> for the stack pointer and
+<code>R15</code> for the hardware program counter
+on ARM,
+a reference to such a register that does not include a symbol
+is now illegal.
+For example, <code>SP</code> and <code>4(SP)</code> are
+illegal but <code>sym+4(SP)</code> is fine.
+On such machines, to refer to the hardware register use its
+true <code>R</code> name.
+</p>
+
+<p>
+One minor change is that some of the old assemblers
+permitted the notation
+</p>
+
+<pre>
+constant=value
+</pre>
+
+<p>
+to define a named constant.
+Since this is always possible to do with the traditional
+C-like <code>#define</code> notation, which is still
+supported (the assembler includes an implementation
+of a simplified C preprocessor), the feature was removed.
+</p>
+
+<h3 id="link">Linker</h3>
+
+<p>
+The linker in Go 1.5 is now one Go program,
+that replaces <code>6l</code>, <code>8l</code>, etc.
+Its operating system and instruction set are specified
+by the environment variables <code>GOOS</code> and <code>GOARCH</code>.
+</p>
+
+<p>
+There are several other changes.
+The most significant is the addition of a <code>-buildmode</code> option that
+expands the style of linking; it now supports
+situations such as building shared libraries and allowing other languages
+to call into Go libraries.
+Some of these were outlined in a <a href="https://golang.org/s/execmodes">design document</a>.
+For a list of the available build modes and their use, run
+</p>
+
+<pre>
+$ go help buildmode
+</pre>
+
+<p>
+Another minor change is that the linker no longer records build time stamps in
+the header of Windows executables.
+Also, although this may be fixed, Windows cgo executables are missing some
+DWARF information.
+</p>
+
+<p>
+Finally, the <code>-X</code> flag, which takes two arguments,
+as in
+</p>
+
+<pre>
+-X importpath.name value
+</pre>
+
+<p>
+now also accepts a more common Go flag style with a single argument
+that is itself a <code>name=value</code> pair:
+</p>
+
+<pre>
+-X importpath.name=value
+</pre>
+
+<p>
+Although the old syntax still works, it is recommended that uses of this
+flag in scripts and the like be updated to the new form.
+</p>
+
+<h3 id="go_command">Go command</h3>
+
+<p>
+The <a href="/cmd/go"><code>go</code></a> command's basic operation
+is unchanged, but there are a number of changes worth noting.
+</p>
+
+<p>
+The previous release introduced the idea of a directory internal to a package
+being unimportable through the <code>go</code> command.
+In 1.4, it was tested with the introduction of some internal elements
+in the core repository.
+As suggested in the <a href="https://golang.org/s/go14internal">design document</a>,
+that change is now being made available to all repositories.
+The rules are explained in the design document, but in summary any
+package in or under a directory named <code>internal</code> may
+be imported by packages rooted in the same subtree.
+Existing packages with directory elements named <code>internal</code> may be
+inadvertently broken by this change, which was why it was advertised
+in the last release.
+</p>
+
+<p>
+Another change in how packages are handled is the experimental
+addition of support for "vendoring".
+For details, see the documentation for the <a href="/cmd/go/#hdr-Vendor_Directories"><code>go</code> command</a>
+and the <a href="https://golang.org/s/go15vendor">design document</a>.
+</p>
+
+<p>
+There have also been several minor changes.
+Read the <a href="/cmd/go">documentation</a> for full details.
+</p>
+
+<ul>
+
+<li>
+SWIG support has been updated such that
+<code>.swig</code> and <code>.swigcxx</code>
+now require SWIG 3.0.6 or later.
+</li>
+
+<li>
+The <code>install</code> subcommand now removes the
+binary created by the <code>build</code> subcommand
+in the source directory, if present,
+to avoid problems having two binaries present in the tree.
+</li>
+
+<li>
+The <code>std</code> (standard library) wildcard package name
+now excludes commands.
+A new <code>cmd</code> wildcard covers the commands.
+</li>
+
+<li>
+A new <code>-asmflags</code> build option
+sets flags to pass to the assembler.
+However,
+the <code>-ccflags</code> build option has been dropped;
+it was specific to the old, now deleted C compiler .
+</li>
+
+<li>
+A new <code>-buildmode</code> build option
+sets the build mode, described above.
+</li>
+
+<li>
+A new <code>-pkgdir</code> build option
+sets the location of installed package archives,
+to help isolate custom builds.
+</li>
+
+<li>
+A new <code>-toolexec</code> build option
+allows substitution of a different command to invoke
+the compiler and so on.
+This acts as a custom replacement for <code>go tool</code>.
+</li>
+
+<li>
+The <code>test</code> subcommand now has a <code>-count</code>
+flag to specify how many times to run each test and benchmark.
+The <a href="/pkg/testing/"><code>testing</code></a> package
+does the work here, through the <code>-test.count</code> flag.
+</li>
+
+<li>
+The <code>generate</code> subcommand has a couple of new features.
+The <code>-run</code> option specifies a regular expression to select which directives
+to execute; this was proposed but never implemented in 1.4.
+The executing pattern now has access to two new environment variables:
+<code>$GOLINE</code> returns the source line number of the directive
+and <code>$DOLLAR</code> expands to a dollar sign.
+</li>
+
+<li>
+The <code>get</code> subcommand now has a <code>-insecure</code>
+flag that must be enabled if fetching from an insecure repository, one that
+does not encrypt the connection.
+</li>
+
+</ul>
+
+<h3 id="vet_command">Go vet command</h3>
+
+<p>
+The <a href="/cmd/vet"><code>go tool vet</code></a> command now does
+more thorough validation of struct tags.
+</p>
+
+<h3 id="trace_command">Trace command</h3>
+
+<p>
+A new tool is available for dynamic execution tracing of Go programs.
+The usage is analogous to how the test coverage tool works.
+Generation of traces is integrated into <code>go test</code>,
+and then a separate execution of the tracing tool itself analyzes the results:
+</p>
+
+<pre>
+$ go test -trace=trace.out path/to/package
+$ go tool trace [flags] pkg.test trace.out
+</pre>
+
+<p>
+The flags enable the output to be displayed in a browser window.
+For details, run <code>go tool trace -help</code>.
+There is also a description of the tracing facility in this
+<a href="https://talks.golang.org/2015/dynamic-tools.slide">talk</a>
+from GopherCon 2015.
+</p>
+
+<h3 id="doc_command">Go doc command</h3>
+
+<p>
+A few releases back, the <code>go doc</code>
+command was deleted as being unnecessary.
+One could always run "<code>godoc .</code>" instead.
+The 1.5 release introduces a new <a href="/cmd/doc"><code>go doc</code></a>
+command with a more convenient command-line interface than
+<code>godoc</code>'s.
+It is designed for command-line usage specifically, and provides a more
+compact and focused presentation of the documentation for a package
+or its elements, according to the invocation.
+It also provides case-insensitive matching and
+support for showing the documentation for unexported symbols.
+For details run "<code>go help doc</code>".
+</p>
+
+<h3 id="cgo">Cgo</h3>
+
+<p>
+When parsing <code>#cgo</code> lines,
+the invocation <code>${SRCDIR}</code> is now
+expanded into the path to the source directory.
+This allows options to be passed to the
+compiler and linker that involve file paths relative to the
+source code directory. Without the expansion the paths would be
+invalid when the current working directory changes.
+</p>
+
+<p>
+Solaris now has full cgo support.
+</p>
+
+<p>
+On Windows, cgo now uses external linking by default.
+</p>
+
+<p>
+When a C struct ends with a zero-sized field, but the struct itself is
+not zero-sized, Go code can no longer refer to the zero-sized field.
+Any such references will have to be rewritten.
+</p>
+
+<h2 id="performance">Performance</h2>
+
+<p>
+As always, the changes are so general and varied that precise statements
+about performance are difficult to make.
+The changes are even broader ranging than usual in this release, which
+includes a new garbage collector and a conversion of the runtime to Go.
+Some programs may run faster, some slower.
+On average the programs in the Go 1 benchmark suite run a few percent faster in Go 1.5
+than they did in Go 1.4,
+while as mentioned above the garbage collector's pauses are
+dramatically shorter, and almost always under 10 milliseconds.
+</p>
+
+<p>
+Builds in Go 1.5 will be slower by a factor of about two.
+The automatic translation of the compiler and linker from C to Go resulted in
+unidiomatic Go code that performs poorly compared to well-written Go.
+Analysis tools and refactoring helped to improve the code, but much remains to be done.
+Further profiling and optimization will continue in Go 1.6 and future releases.
+For more details, see these <a href="https://talks.golang.org/2015/gogo.slide">slides</a>
+and associated <a href="https://www.youtube.com/watch?v=cF1zJYkBW4A">video</a>.
+</p>
+
+<h2 id="library">Core library</h2>
+
+<h3 id="flag">Flag</h3>
+
+<p>
+The flag package's
+<a href="/pkg/flag/#PrintDefaults"><code>PrintDefaults</code></a>
+function, and method on <a href="/pkg/flag/#FlagSet"><code>FlagSet</code></a>,
+have been modified to create nicer usage messages.
+The format has been changed to be more human-friendly and in the usage
+messages a word quoted with `backquotes` is taken to be the name of the
+flag's operand to display in the usage message.
+For instance, a flag created with the invocation,
+</p>
+
+<pre>
+cpuFlag = flag.Int("cpu", 1, "run `N` processes in parallel")
+</pre>
+
+<p>
+will show the help message,
+</p>
+
+<pre>
+-cpu N
+ run N processes in parallel (default 1)
+</pre>
+
+<p>
+Also, the default is now listed only when it is not the zero value for the type.
+</p>
+
+<h3 id="math_big">Floats in math/big</h3>
+
+<p>
+The <a href="/pkg/math/big/"><code>math/big</code></a> package
+has a new, fundamental data type,
+<a href="/pkg/math/big/#Float"><code>Float</code></a>,
+which implements arbitrary-precision floating-point numbers.
+A <code>Float</code> value is represented by a boolean sign,
+a variable-length mantissa, and a 32-bit fixed-size signed exponent.
+The precision of a <code>Float</code> (the mantissa size in bits)
+can be specified explicitly or is otherwise determined by the first
+operation that creates the value.
+Once created, the size of a <code>Float</code>'s mantissa may be modified with the
+<a href="/pkg/math/big/#Float.SetPrec"><code>SetPrec</code></a> method.
+<code>Floats</code> support the concept of infinities, such as are created by
+overflow, but values that would lead to the equivalent of IEEE 754 NaNs
+trigger a panic.
+<code>Float</code> operations support all IEEE-754 rounding modes.
+When the precision is set to 24 (53) bits,
+operations that stay within the range of normalized <code>float32</code>
+(<code>float64</code>)
+values produce the same results as the corresponding IEEE-754
+arithmetic on those values.
+</p>
+
+<h3 id="go_types">Go types</h3>
+
+<p>
+The <a href="/pkg/go/types/"><code>go/types</code></a> package
+up to now has been maintained in the <code>golang.org/x</code>
+repository; as of Go 1.5 it has been relocated to the main repository.
+The code at the old location is now deprecated.
+There is also a modest API change in the package, discussed below.
+</p>
+
+<p>
+Associated with this move, the
+<a href="/pkg/go/constant/"><code>go/constant</code></a>
+package also moved to the main repository;
+it was <code>golang.org/x/tools/exact</code> before.
+The <a href="/pkg/go/importer/"><code>go/importer</code></a> package
+also moved to the main repository,
+as well as some tools described above.
+</p>
+
+<h3 id="net">Net</h3>
+
+<p>
+The DNS resolver in the net package has almost always used <code>cgo</code> to access
+the system interface.
+A change in Go 1.5 means that on most Unix systems DNS resolution
+will no longer require <code>cgo</code>, which simplifies execution
+on those platforms.
+Now, if the system's networking configuration permits, the native Go resolver
+will suffice.
+The important effect of this change is that each DNS resolution occupies a goroutine
+rather than a thread,
+so a program with multiple outstanding DNS requests will consume fewer operating
+system resources.
+</p>
+
+<p>
+The decision of how to run the resolver applies at run time, not build time.
+The <code>netgo</code> build tag that has been used to enforce the use
+of the Go resolver is no longer necessary, although it still works.
+A new <code>netcgo</code> build tag forces the use of the <code>cgo</code> resolver at
+build time.
+To force <code>cgo</code> resolution at run time set
+<code>GODEBUG=netdns=cgo</code> in the environment.
+More debug options are documented <a href="https://golang.org/cl/11584">here</a>.
+</p>
+
+<p>
+This change applies to Unix systems only.
+Windows, Mac OS X, and Plan 9 systems behave as before.
+</p>
+
+<h3 id="reflect">Reflect</h3>
+
+<p>
+The <a href="/pkg/reflect/"><code>reflect</code></a> package
+has two new functions: <a href="/pkg/reflect/#ArrayOf"><code>ArrayOf</code></a>
+and <a href="/pkg/reflect/#FuncOf"><code>FuncOf</code></a>.
+These functions, analogous to the extant
+<a href="/pkg/reflect/#SliceOf"><code>SliceOf</code></a> function,
+create new types at runtime to describe arrays and functions.
+</p>
+
+<h3 id="hardening">Hardening</h3>
+
+<p>
+Several dozen bugs were found in the standard library
+through randomized testing with the
+<a href="https://github.com/dvyukov/go-fuzz"><code>go-fuzz</code></a> tool.
+Bugs were fixed in the
+<a href="/pkg/archive/tar/"><code>archive/tar</code></a>,
+<a href="/pkg/archive/zip/"><code>archive/zip</code></a>,
+<a href="/pkg/compress/flate/"><code>compress/flate</code></a>,
+<a href="/pkg/encoding/gob/"><code>encoding/gob</code></a>,
+<a href="/pkg/fmt/"><code>fmt</code></a>,
+<a href="/pkg/html/template/"><code>html/template</code></a>,
+<a href="/pkg/image/gif/"><code>image/gif</code></a>,
+<a href="/pkg/image/jpeg/"><code>image/jpeg</code></a>,
+<a href="/pkg/image/png/"><code>image/png</code></a>, and
+<a href="/pkg/text/template/"><code>text/template</code></a>,
+packages.
+The fixes harden the implementation against incorrect and malicious inputs.
+</p>
+
+<h3 id="minor_library_changes">Minor changes to the library</h3>
+
+<ul>
+
+<li>
+The <a href="/pkg/archive/zip/"><code>archive/zip</code></a> package's
+<a href="/pkg/archive/zip/#Writer"><code>Writer</code></a> type now has a
+<a href="/pkg/archive/zip/#Writer.SetOffset"><code>SetOffset</code></a>
+method to specify the location within the output stream at which to write the archive.
+</li>
+
+<li>
+The <a href="/pkg/bufio/#Reader"><code>Reader</code></a> in the
+<a href="/pkg/bufio/"><code>bufio</code></a> package now has a
+<a href="/pkg/bufio/#Reader.Discard"><code>Discard</code></a>
+method to discard data from the input.
+</li>
+
+<li>
+In the <a href="/pkg/bytes/"><code>bytes</code></a> package,
+the <a href="/pkg/bytes/#Buffer"><code>Buffer</code></a> type
+now has a <a href="/pkg/bytes/#Buffer.Cap"><code>Cap</code></a> method
+that reports the number of bytes allocated within the buffer.
+Similarly, in both the <a href="/pkg/bytes/"><code>bytes</code></a>
+and <a href="/pkg/strings/"><code>strings</code></a> packages,
+the <a href="/pkg/bytes/#Reader"><code>Reader</code></a>
+type now has a <a href="/pkg/bytes/#Reader.Size"><code>Size</code></a>
+method that reports the original length of the underlying slice or string.
+</li>
+
+<li>
+Both the <a href="/pkg/bytes/"><code>bytes</code></a> and
+<a href="/pkg/strings/"><code>strings</code></a> packages
+also now have a <a href="/pkg/bytes/#LastIndexByte"><code>LastIndexByte</code></a>
+function that locates the rightmost byte with that value in the argument.
+</li>
+
+<li>
+The <a href="/pkg/crypto/"><code>crypto</code></a> package
+has a new interface, <a href="/pkg/crypto/#Decrypter"><code>Decrypter</code></a>,
+that abstracts the behavior of a private key used in asymmetric decryption.
+</li>
+
+<li>
+In the <a href="/pkg/crypto/cipher/"><code>crypto/cipher</code></a> package,
+the documentation for the <a href="/pkg/crypto/cipher/#Stream"><code>Stream</code></a>
+interface has been clarified regarding the behavior when the source and destination are
+different lengths.
+If the destination is shorter than the source, the method will panic.
+This is not a change in the implementation, only the documentation.
+</li>
+
+<li>
+Also in the <a href="/pkg/crypto/cipher/"><code>crypto/cipher</code></a> package,
+there is now support for nonce lengths other than 96 bytes in AES's Galois/Counter mode (GCM),
+which some protocols require.
+</li>
+
+<li>
+In the <a href="/pkg/crypto/elliptic/"><code>crypto/elliptic</code></a> package,
+there is now a <code>Name</code> field in the
+<a href="/pkg/crypto/elliptic/#CurveParams"><code>CurveParams</code></a> struct,
+and the curves implemented in the package have been given names.
+These names provide a safer way to select a curve, as opposed to
+selecting its bit size, for cryptographic systems that are curve-dependent.
+</li>
+
+<li>
+Also in the <a href="/pkg/crypto/elliptic/"><code>crypto/elliptic</code></a> package,
+the <a href="/pkg/crypto/elliptic/#Unmarshal"><code>Unmarshal</code></a> function
+now verifies that the point is actually on the curve.
+(If it is not, the function returns nils).
+This change guards against certain attacks.
+</li>
+
+<li>
+The <a href="/pkg/crypto/sha512/"><code>crypto/sha512</code></a>
+package now has support for the two truncated versions of
+the SHA-512 hash algorithm, SHA-512/224 and SHA-512/256.
+</li>
+
+<li>
+The <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package
+minimum protocol version now defaults to TLS 1.0.
+The old default, SSLv3, is still available through <a href="/pkg/crypto/tls/#Config"><code>Config</code></a> if needed.
+</li>
+
+<li>
+The <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package
+now supports Signed Certificate Timestamps (SCTs) as specified in RFC 6962.
+The server serves them if they are listed in the
+<a href="/pkg/crypto/tls/#Certificate"><code>Certificate</code></a> struct,
+and the client requests them and exposes them, if present,
+in its <a href="/pkg/crypto/tls/#ConnectionState"><code>ConnectionState</code></a> struct.
+
+<li>
+The stapled OCSP response to a <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> client connection,
+previously only available via the
+<a href="/pkg/crypto/tls/#Conn.OCSPResponse"><code>OCSPResponse</code></a> method,
+is now exposed in the <a href="/pkg/crypto/tls/#ConnectionState"><code>ConnectionState</code></a> struct.
+</li>
+
+<li>
+The <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> server implementation
+will now always call the
+<code>GetCertificate</code> function in
+the <a href="/pkg/crypto/tls/#Config"><code>Config</code></a> struct
+to select a certificate for the connection when none is supplied.
+</li>
+
+<li>
+Finally, the session ticket keys in the
+<a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package
+can now be changed while the server is running.
+This is done through the new
+<a href="/pkg/crypto/tls/#Config.SetSessionTicketKeys"><code>SetSessionTicketKeys</code></a>
+method of the
+<a href="/pkg/crypto/tls/#Config"><code>Config</code></a> type.
+</li>
+
+<li>
+In the <a href="/pkg/crypto/x509/"><code>crypto/x509</code></a> package,
+wildcards are now accepted only in the leftmost label as defined in
+<a href="https://tools.ietf.org/html/rfc6125#section-6.4.3">the specification</a>.
+</li>
+
+<li>
+Also in the <a href="/pkg/crypto/x509/"><code>crypto/x509</code></a> package,
+the handling of unknown critical extensions has been changed.
+They used to cause parse errors but now they are parsed and caused errors only
+in <a href="/pkg/crypto/x509/#Certificate.Verify"><code>Verify</code></a>.
+The new field <code>UnhandledCriticalExtensions</code> of
+<a href="/pkg/crypto/x509/#Certificate"><code>Certificate</code></a> records these extensions.
+</li>
+
+<li>
+The <a href="/pkg/database/sql/#DB"><code>DB</code></a> type of the
+<a href="/pkg/database/sql/"><code>database/sql</code></a> package
+now has a <a href="/pkg/database/sql/#DB.Stats"><code>Stats</code></a> method
+to retrieve database statistics.
+</li>
+
+<li>
+The <a href="/pkg/debug/dwarf/"><code>debug/dwarf</code></a>
+package has extensive additions to better support DWARF version 4.
+See for example the definition of the new type
+<a href="/pkg/debug/dwarf/#Class"><code>Class</code></a>.
+</li>
+
+<li>
+The <a href="/pkg/debug/dwarf/"><code>debug/dwarf</code></a> package
+also now supports decoding of DWARF line tables.
+</li>
+
+<li>
+The <a href="/pkg/debug/elf/"><code>debug/elf</code></a>
+package now has support for the 64-bit PowerPC architecture.
+</li>
+
+<li>
+The <a href="/pkg/encoding/base64/"><code>encoding/base64</code></a> package
+now supports unpadded encodings through two new encoding variables,
+<a href="/pkg/encoding/base64/#RawStdEncoding"><code>RawStdEncoding</code></a> and
+<a href="/pkg/encoding/base64/#RawURLEncoding"><code>RawURLEncoding</code></a>.
+</li>
+
+<li>
+The <a href="/pkg/encoding/json/"><code>encoding/json</code></a> package
+now returns an <a href="/pkg/encoding/json/#UnmarshalTypeError"><code>UnmarshalTypeError</code></a>
+if a JSON value is not appropriate for the target variable or component
+to which it is being unmarshaled.
+</li>
+
+<li>
+The <code>encoding/json</code>'s
+<a href="/pkg/encoding/json/#Decoder"><code>Decoder</code></a>
+type has a new method that provides a streaming interface for decoding
+a JSON document:
+<a href="/pkg/encoding/json/#Decoder.Token"><code>Token</code></a>.
+It also interoperates with the existing functionality of <code>Decode</code>,
+which will continue a decode operation already started with <code>Decoder.Token</code>.
+</li>
+
+<li>
+The <a href="/pkg/flag/"><code>flag</code></a> package
+has a new function, <a href="/pkg/flag/#UnquoteUsage"><code>UnquoteUsage</code></a>,
+to assist in the creation of usage messages using the new convention
+described above.
+</li>
+
+<li>
+In the <a href="/pkg/fmt/"><code>fmt</code></a> package,
+a value of type <a href="/pkg/reflect/#Value"><code>Value</code></a> now
+prints what it holds, rather than use the <code>reflect.Value</code>'s <code>Stringer</code>
+method, which produces things like <code><int Value></code>.
+</li>
+
+<li>
+The <a href="/pkg/ast/#EmptyStmt"><code>EmptyStmt</code></a> type
+in the <a href="/pkg/go/ast/"><code>go/ast</code></a> package now
+has a boolean <code>Implicit</code> field that records whether the
+semicolon was implicitly added or was present in the source.
+</li>
+
+<li>
+For forward compatibility the <a href="/pkg/go/build/"><code>go/build</code></a> package
+reserves <code>GOARCH</code> values for a number of architectures that Go might support one day.
+This is not a promise that it will.
+Also, the <a href="/pkg/go/build/#Package"><code>Package</code></a> struct
+now has a <code>PkgTargetRoot</code> field that stores the
+architecture-dependent root directory in which to install, if known.
+</li>
+
+<li>
+The (newly migrated) <a href="/pkg/go/types/"><code>go/types</code></a>
+package allows one to control the prefix attached to package-level names using
+the new <a href="/pkg/go/types/#Qualifier"><code>Qualifier</code></a>
+function type as an argument to several functions. This is an API change for
+the package, but since it is new to the core, it is not breaking the Go 1 compatibility
+rules since code that uses the package must explicitly ask for it at its new location.
+To update, run
+<a href="https://golang.org/cmd/go/#hdr-Run_go_tool_fix_on_packages"><code>go fix</code></a> on your package.
+</li>
+
+<li>
+In the <a href="/pkg/image/"><code>image</code></a> package,
+the <a href="/pkg/image/#Rectangle"><code>Rectangle</code></a> type
+now implements the <a href="/pkg/image/#Image"><code>Image</code></a> interface,
+so a <code>Rectangle</code> can serve as a mask when drawing.
+</li>
+
+<li>
+Also in the <a href="/pkg/image/"><code>image</code></a> package,
+to assist in the handling of some JPEG images,
+there is now support for 4:1:1 and 4:1:0 YCbCr subsampling and basic
+CMYK support, represented by the new <code>image.CMYK</code> struct.
+</li>
+
+<li>
+The <a href="/pkg/image/color/"><code>image/color</code></a> package
+adds basic CMYK support, through the new
+<a href="/pkg/image/color/#CMYK"><code>CMYK</code></a> struct,
+the <a href="/pkg/image/color/#CMYKModel"><code>CMYKModel</code></a> color model, and the
+<a href="/pkg/image/color/#CMYKToRGB"><code>CMYKToRGB</code></a> function, as
+needed by some JPEG images.
+</li>
+
+<li>
+Also in the <a href="/pkg/image/color/"><code>image/color</code></a> package,
+the conversion of a <a href="/pkg/image/color/#YCbCr"><code>YCbCr</code></a>
+value to <code>RGBA</code> has become more precise.
+Previously, the low 8 bits were just an echo of the high 8 bits;
+now they contain more accurate information.
+Because of the echo property of the old code, the operation
+<code>uint8(r)</code> to extract an 8-bit red value worked, but is incorrect.
+In Go 1.5, that operation may yield a different value.
+The correct code is, and always was, to select the high 8 bits:
+<code>uint8(r>>8)</code>.
+Incidentally, the <code>image/draw</code> package
+provides better support for such conversions; see
+<a href="https://blog.golang.org/go-imagedraw-package">this blog post</a>
+for more information.
+</li>
+
+<li>
+Finally, as of Go 1.5 the closest match check in
+<a href="/pkg/image/color/#Palette.Index"><code>Index</code></a>
+now honors the alpha channel.
+</li>
+
+<li>
+The <a href="/pkg/image/gif/"><code>image/gif</code></a> package
+includes a couple of generalizations.
+A multiple-frame GIF file can now have an overall bounds different
+from all the contained single frames' bounds.
+Also, the <a href="/pkg/image/gif/#GIF"><code>GIF</code></a> struct
+now has a <code>Disposal</code> field
+that specifies the disposal method for each frame.
+</li>
+
+<li>
+The <a href="/pkg/io/"><code>io</code></a> package
+adds a <a href="/pkg/io/#CopyBuffer"><code>CopyBuffer</code></a> function
+that is like <a href="/pkg/io/#Copy"><code>Copy</code></a> but
+uses a caller-provided buffer, permitting control of allocation and buffer size.
+</li>
+
+<li>
+The <a href="/pkg/log/"><code>log</code></a> package
+has a new <a href="/pkg/log/#LUTC"><code>LUTC</code></a> flag
+that causes time stamps to be printed in the UTC time zone.
+It also adds a <a href="/pkg/log/#Logger.SetOutput"><code>SetOutput</code></a> method
+for user-created loggers.
+</li>
+
+<li>
+In Go 1.4, <a href="/pkg/math/#Max"><code>Max</code></a> was not detecting all possible NaN bit patterns.
+This is fixed in Go 1.5, so programs that use <code>math.Max</code> on data including NaNs may behave differently,
+but now correctly according to the IEEE754 definition of NaNs.
+</li>
+
+<li>
+The <a href="/pkg/math/big/"><code>math/big</code></a> package
+adds a new <a href="/pkg/math/big/#Jacobi"><code>Jacobi</code></a>
+function for integers and a new
+<a href="/pkg/math/big/#Int.ModSqrt"><code>ModSqrt</code></a>
+method for the <a href="/pkg/math/big/#Int"><code>Int</code></a> type.
+</li>
+
+<li>
+The mime package
+adds a new <a href="/pkg/mime/#WordDecoder"><code>WordDecoder</code></a> type
+to decode MIME headers containing RFC 204-encoded words.
+It also provides <a href="/pkg/mime/#BEncoding"><code>BEncoding</code></a> and
+<a href="/pkg/mime/#QEncoding"><code>QEncoding</code></a>
+as implementations of the encoding schemes of RFC 2045 and RFC 2047.
+</li>
+
+<li>
+The <a href="/pkg/mime/"><code>mime</code></a> package also adds an
+<a href="/pkg/mime/#ExtensionsByType"><code>ExtensionsByType</code></a>
+function that returns the MIME extensions know to be associated with a given MIME type.
+</li>
+
+<li>
+There is a new <a href="/pkg/mime/quotedprintable/"><code>mime/quotedprintable</code></a>
+package that implements the quoted-printable encoding defined by RFC 2045.
+</li>
+
+<li>
+The <a href="/pkg/net/"><code>net</code></a> package will now
+<a href="/pkg/net/#Dial"><code>Dial</code></a> hostnames by trying each
+IP address in order until one succeeds.
+The <code><a href="/pkg/net/#Dialer">Dialer</a>.DualStack</code>
+mode now implements Happy Eyeballs
+(<a href="https://tools.ietf.org/html/rfc6555">RFC 6555</a>) by giving the
+first address family a 300ms head start; this value can be overridden by
+the new <code>Dialer.FallbackDelay</code>.
+</li>
+
+<li>
+A number of inconsistencies in the types returned by errors in the
+<a href="/pkg/net/"><code>net</code></a> package have been
+tidied up.
+Most now return an
+<a href="/pkg/net/#OpError"><code>OpError</code></a> value
+with more information than before.
+Also, the <a href="/pkg/net/#OpError"><code>OpError</code></a>
+type now includes a <code>Source</code> field that holds the local
+network address.
+</li>
+
+<li>
+The <a href="/pkg/net/http/"><code>net/http</code></a> package now
+has support for setting trailers from a server <a href="/pkg/net/http/#Handler"><code>Handler</code></a>.
+For details, see the documentation for
+<a href="/pkg/net/http/#ResponseWriter"><code>ResponseWriter</code></a>.
+</li>
+
+<li>
+There is a new method to cancel a <a href="/pkg/net/http/"><code>net/http</code></a>
+<code>Request</code> by setting the new
+<a href="/pkg/net/http/#Request"><code>Request.Cancel</code></a>
+field.
+It is supported by <code>http.Transport</code>.
+The <code>Cancel</code> field's type is compatible with the
+<a href="https://godoc.org/golang.org/x/net/context"><code>context.Context.Done</code></a>
+return value.
+</li>
+
+<li>
+Also in the <a href="/pkg/net/http/"><code>net/http</code></a> package,
+there is code to ignore the zero <a href="/pkg/time/#Time"><code>Time</code></a> value
+in the <a href="/pkg/net/#ServeContent"><code>ServeContent</code></a> function.
+As of Go 1.5, it now also ignores a time value equal to the Unix epoch.
+</li>
+
+<li>
+The <a href="/pkg/net/http/fcgi/"><code>net/http/fcgi</code></a> package
+exports two new errors,
+<a href="/pkg/net/http/fcgi/#ErrConnClosed"><code>ErrConnClosed</code></a> and
+<a href="/pkg/net/http/fcgi/#ErrRequestAborted"><code>ErrRequestAborted</code></a>,
+to report the corresponding error conditions.
+</li>
+
+<li>
+The <a href="/pkg/net/http/cgi/"><code>net/http/cgi</code></a> package
+had a bug that mishandled the values of the environment variables
+<code>REMOTE_ADDR</code> and <code>REMOTE_HOST</code>.
+This has been fixed.
+Also, starting with Go 1.5 the package sets the <code>REMOTE_PORT</code>
+variable.
+</li>
+
+<li>
+The <a href="/pkg/net/mail/"><code>net/mail</code></a> package
+adds an <a href="/pkg/net/mail/#AddressParser"><code>AddressParser</code></a>
+type that can parse mail addresses.
+</li>
+
+<li>
+The <a href="/pkg/net/smtp/"><code>net/smtp</code></a> package
+now has a <a href="/pkg/net/smtp/#Client.TLSConnectionState"><code>TLSConnectionState</code></a>
+accessor to the <a href="/pkg/net/smtp/#Client"><code>Client</code></a>
+type that returns the client's TLS state.
+</li>
+
+<li>
+The <a href="/pkg/os/"><code>os</code></a> package
+has a new <a href="/pkg/os/#LookupEnv"><code>LookupEnv</code></a> function
+that is similar to <a href="/pkg/os/#Getenv"><code>Getenv</code></a>
+but can distinguish between an empty environment variable and a missing one.
+</li>
+
+<li>
+The <a href="/pkg/os/signal/"><code>os/signal</code></a> package
+adds new <a href="/pkg/os/signal/#Ignore"><code>Ignore</code></a> and
+<a href="/pkg/os/signal/#Reset"><code>Reset</code></a> functions.
+</li>
+
+<li>
+The <a href="/pkg/runtime/"><code>runtime</code></a>,
+<a href="/pkg/runtime/trace/"><code>runtime/trace</code></a>,
+and <a href="/pkg/net/http/pprof/"><code>net/http/pprof</code></a> packages
+each have new functions to support the tracing facilities described above:
+<a href="/pkg/runtime/#ReadTrace"><code>ReadTrace</code></a>,
+<a href="/pkg/runtime/#StartTrace"><code>StartTrace</code></a>,
+<a href="/pkg/runtime/#StopTrace"><code>StopTrace</code></a>,
+<a href="/pkg/runtime/trace/#Start"><code>Start</code></a>,
+<a href="/pkg/runtime/trace/#Stop"><code>Stop</code></a>, and
+<a href="/pkg/net/http/pprof/#Trace"><code>Trace</code></a>.
+See the respective documentation for details.
+</li>
+
+<li>
+The <a href="/pkg/runtime/pprof/"><code>runtime/pprof</code></a> package
+by default now includes overall memory statistics in all memory profiles.
+</li>
+
+<li>
+The <a href="/pkg/strings/"><code>strings</code></a> package
+has a new <a href="/pkg/strings/#Compare"><code>Compare</code></a> function.
+This is present to provide symmetry with the <a href="/pkg/bytes/"><code>bytes</code></a> package
+but is otherwise unnecessary as strings support comparison natively.
+</li>
+
+<li>
+The <a href="/pkg/sync/#WaitGroup"><code>WaitGroup</code></a> implementation in
+package <a href="/pkg/sync/"><code>sync</code></a>
+now diagnoses code that races a call to <a href="/pkg/sync/#WaitGroup.Add"><code>Add</code></a>
+against a return from <a href="/pkg/sync/#WaitGroup.Wait"><code>Wait</code></a>.
+If it detects this condition, the implementation panics.
+</li>
+
+<li>
+In the <a href="/pkg/syscall/"><code>syscall</code></a> package,
+the Linux <code>SysProcAttr</code> struct now has a
+<code>GidMappingsEnableSetgroups</code> field, made necessary
+by security changes in Linux 3.19.
+On all Unix systems, the struct also has new <code>Foreground</code> and <code>Pgid</code> fields
+to provide more control when exec'ing.
+On Darwin, there is now a <code>Syscall9</code> function
+to support calls with too many arguments.
+</li>
+
+<li>
+The <a href="/pkg/testing/quick/"><code>testing/quick</code></a> will now
+generate <code>nil</code> values for pointer types,
+making it possible to use with recursive data structures.
+Also, the package now supports generation of array types.
+</li>
+
+<li>
+In the <a href="/pkg/text/template/"><code>text/template</code></a> and
+<a href="/pkg/html/template/"><code>html/template</code></a> packages,
+integer constants too large to be represented as a Go integer now trigger a
+parse error. Before, they were silently converted to floating point, losing
+precision.
+</li>
+
+<li>
+Also in the <a href="/pkg/text/template/"><code>text/template</code></a> and
+<a href="/pkg/html/template/"><code>html/template</code></a> packages,
+a new <a href="/pkg/text/template/#Template.Option"><code>Option</code></a> method
+allows customization of the behavior of the template during execution.
+The sole implemented option allows control over how a missing key is
+handled when indexing a map.
+The default, which can now be overridden, is as before: to continue with an invalid value.
+</li>
+
+<li>
+The <a href="/pkg/time/"><code>time</code></a> package's
+<code>Time</code> type has a new method
+<a href="/pkg/time/#Time.AppendFormat"><code>AppendFormat</code></a>,
+which can be used to avoid allocation when printing a time value.
+</li>
+
+<li>
+The <a href="/pkg/unicode/"><code>unicode</code></a> package and associated
+support throughout the system has been upgraded from version 7.0 to
+<a href="http://www.unicode.org/versions/Unicode8.0.0/">Unicode 8.0</a>.
+</li>
+
+</ul>
diff --git a/_content/doc/go1.6.html b/_content/doc/go1.6.html
new file mode 100644
index 0000000..2f7093d
--- /dev/null
+++ b/_content/doc/go1.6.html
@@ -0,0 +1,922 @@
+<!--{
+ "Title": "Go 1.6 Release Notes",
+ "Template": true
+}-->
+
+<!--
+Edit .,s;^PKG:([a-z][A-Za-z0-9_/]+);<a href="/pkg/\1/"><code>\1</code></a>;g
+Edit .,s;^([a-z][A-Za-z0-9_/]+)\.([A-Z][A-Za-z0-9_]+\.)?([A-Z][A-Za-z0-9_]+)([ .',]|$);<a href="/pkg/\1/#\2\3"><code>\3</code></a>\4;g
+-->
+
+<style>
+ main ul li { margin: 0.5em 0; }
+</style>
+
+<h2 id="introduction">Introduction to Go 1.6</h2>
+
+<p>
+The latest Go release, version 1.6, arrives six months after 1.5.
+Most of its changes are in the implementation of the language, runtime, and libraries.
+There are no changes to the language specification.
+As always, the release maintains the Go 1 <a href="/doc/go1compat.html">promise of compatibility</a>.
+We expect almost all Go programs to continue to compile and run as before.
+</p>
+
+<p>
+The release adds new ports to <a href="#ports">Linux on 64-bit MIPS and Android on 32-bit x86</a>;
+defined and enforced <a href="#cgo">rules for sharing Go pointers with C</a>;
+transparent, automatic <a href="#http2">support for HTTP/2</a>;
+and a new mechanism for <a href="#template">template reuse</a>.
+</p>
+
+<h2 id="language">Changes to the language</h2>
+
+<p>
+There are no language changes in this release.
+</p>
+
+<h2 id="ports">Ports</h2>
+
+<p>
+Go 1.6 adds experimental ports to
+Linux on 64-bit MIPS (<code>linux/mips64</code> and <code>linux/mips64le</code>).
+These ports support <code>cgo</code> but only with internal linking.
+</p>
+
+<p>
+Go 1.6 also adds an experimental port to Android on 32-bit x86 (<code>android/386</code>).
+</p>
+
+<p>
+On FreeBSD, Go 1.6 defaults to using <code>clang</code>, not <code>gcc</code>, as the external C compiler.
+</p>
+
+<p>
+On Linux on little-endian 64-bit PowerPC (<code>linux/ppc64le</code>),
+Go 1.6 now supports <code>cgo</code> with external linking and
+is roughly feature complete.
+</p>
+
+<p>
+On NaCl, Go 1.5 required SDK version pepper-41.
+Go 1.6 adds support for later SDK versions.
+</p>
+
+<p>
+On 32-bit x86 systems using the <code>-dynlink</code> or <code>-shared</code> compilation modes,
+the register CX is now overwritten by certain memory references and should
+be avoided in hand-written assembly.
+See the <a href="/doc/asm#x86">assembly documentation</a> for details.
+</p>
+
+<h2 id="tools">Tools</h2>
+
+<h3 id="cgo">Cgo</h3>
+
+<p>
+There is one major change to <a href="/cmd/cgo/"><code>cgo</code></a>, along with one minor change.
+</p>
+
+<p>
+The major change is the definition of rules for sharing Go pointers with C code,
+to ensure that such C code can coexist with Go's garbage collector.
+Briefly, Go and C may share memory allocated by Go
+when a pointer to that memory is passed to C as part of a <code>cgo</code> call,
+provided that the memory itself contains no pointers to Go-allocated memory,
+and provided that C does not retain the pointer after the call returns.
+These rules are checked by the runtime during program execution:
+if the runtime detects a violation, it prints a diagnosis and crashes the program.
+The checks can be disabled by setting the environment variable
+<code>GODEBUG=cgocheck=0</code>, but note that the vast majority of
+code identified by the checks is subtly incompatible with garbage collection
+in one way or another.
+Disabling the checks will typically only lead to more mysterious failure modes.
+Fixing the code in question should be strongly preferred
+over turning off the checks.
+See the <a href="/cmd/cgo/#hdr-Passing_pointers"><code>cgo</code> documentation</a> for more details.
+</p>
+
+<p>
+The minor change is
+the addition of explicit <code>C.complexfloat</code> and <code>C.complexdouble</code> types,
+separate from Go's <code>complex64</code> and <code>complex128</code>.
+Matching the other numeric types, C's complex types and Go's complex type are
+no longer interchangeable.
+</p>
+
+<h3 id="compiler">Compiler Toolchain</h3>
+
+<p>
+The compiler toolchain is mostly unchanged.
+Internally, the most significant change is that the parser is now hand-written
+instead of generated from <a href="/cmd/yacc/">yacc</a>.
+</p>
+
+<p>
+The compiler, linker, and <code>go</code> command have a new flag <code>-msan</code>,
+analogous to <code>-race</code> and only available on linux/amd64,
+that enables interoperation with the <a href="https://clang.llvm.org/docs/MemorySanitizer.html">Clang MemorySanitizer</a>.
+Such interoperation is useful mainly for testing a program containing suspect C or C++ code.
+</p>
+
+<p>
+The linker has a new option <code>-libgcc</code> to set the expected location
+of the C compiler support library when linking <a href="/cmd/cgo/"><code>cgo</code></a> code.
+The option is only consulted when using <code>-linkmode=internal</code>,
+and it may be set to <code>none</code> to disable the use of a support library.
+</p>
+
+<p>
+The implementation of <a href="/doc/go1.5#link">build modes started in Go 1.5</a> has been expanded to more systems.
+This release adds support for the <code>c-shared</code> mode on <code>android/386</code>, <code>android/amd64</code>,
+<code>android/arm64</code>, <code>linux/386</code>, and <code>linux/arm64</code>;
+for the <code>shared</code> mode on <code>linux/386</code>, <code>linux/arm</code>, <code>linux/amd64</code>, and <code>linux/ppc64le</code>;
+and for the new <code>pie</code> mode (generating position-independent executables) on
+<code>android/386</code>, <code>android/amd64</code>, <code>android/arm</code>, <code>android/arm64</code>, <code>linux/386</code>,
+<code>linux/amd64</code>, <code>linux/arm</code>, <code>linux/arm64</code>, and <code>linux/ppc64le</code>.
+See the <a href="https://golang.org/s/execmodes">design document</a> for details.
+</p>
+
+<p>
+As a reminder, the linker's <code>-X</code> flag changed in Go 1.5.
+In Go 1.4 and earlier, it took two arguments, as in
+</p>
+
+<pre>
+-X importpath.name value
+</pre>
+
+<p>
+Go 1.5 added an alternative syntax using a single argument
+that is itself a <code>name=value</code> pair:
+</p>
+
+<pre>
+-X importpath.name=value
+</pre>
+
+<p>
+In Go 1.5 the old syntax was still accepted, after printing a warning
+suggesting use of the new syntax instead.
+Go 1.6 continues to accept the old syntax and print the warning.
+Go 1.7 will remove support for the old syntax.
+</p>
+
+<h3 id="gccgo">Gccgo</h3>
+
+<p>
+The release schedules for the GCC and Go projects do not coincide.
+GCC release 5 contains the Go 1.4 version of gccgo.
+The next release, GCC 6, will have the Go 1.6.1 version of gccgo.
+</p>
+
+<h3 id="go_command">Go command</h3>
+
+<p>
+The <a href="/cmd/go"><code>go</code></a> command's basic operation
+is unchanged, but there are a number of changes worth noting.
+</p>
+
+<p>
+Go 1.5 introduced experimental support for vendoring,
+enabled by setting the <code>GO15VENDOREXPERIMENT</code> environment variable to <code>1</code>.
+Go 1.6 keeps the vendoring support, no longer considered experimental,
+and enables it by default.
+It can be disabled explicitly by setting
+the <code>GO15VENDOREXPERIMENT</code> environment variable to <code>0</code>.
+Go 1.7 will remove support for the environment variable.
+</p>
+
+<p>
+The most likely problem caused by enabling vendoring by default happens
+in source trees containing an existing directory named <code>vendor</code> that
+does not expect to be interpreted according to new vendoring semantics.
+In this case, the simplest fix is to rename the directory to anything other
+than <code>vendor</code> and update any affected import paths.
+</p>
+
+<p>
+For details about vendoring,
+see the documentation for the <a href="/cmd/go/#hdr-Vendor_Directories"><code>go</code> command</a>
+and the <a href="https://golang.org/s/go15vendor">design document</a>.
+</p>
+
+<p>
+There is a new build flag, <code>-msan</code>,
+that compiles Go with support for the LLVM memory sanitizer.
+This is intended mainly for use when linking against C or C++ code
+that is being checked with the memory sanitizer.
+</p>
+
+<h3 id="doc_command">Go doc command</h3>
+
+<p>
+Go 1.5 introduced the
+<a href="/cmd/go/#hdr-Show_documentation_for_package_or_symbol"><code>go doc</code></a> command,
+which allows references to packages using only the package name, as in
+<code>go</code> <code>doc</code> <code>http</code>.
+In the event of ambiguity, the Go 1.5 behavior was to use the package
+with the lexicographically earliest import path.
+In Go 1.6, ambiguity is resolved by preferring import paths with
+fewer elements, breaking ties using lexicographic comparison.
+An important effect of this change is that original copies of packages
+are now preferred over vendored copies.
+Successful searches also tend to run faster.
+</p>
+
+<h3 id="vet_command">Go vet command</h3>
+
+<p>
+The <a href="/cmd/vet"><code>go vet</code></a> command now diagnoses
+passing function or method values as arguments to <code>Printf</code>,
+such as when passing <code>f</code> where <code>f()</code> was intended.
+</p>
+
+<h2 id="performance">Performance</h2>
+
+<p>
+As always, the changes are so general and varied that precise statements
+about performance are difficult to make.
+Some programs may run faster, some slower.
+On average the programs in the Go 1 benchmark suite run a few percent faster in Go 1.6
+than they did in Go 1.5.
+The garbage collector's pauses are even lower than in Go 1.5,
+especially for programs using
+a large amount of memory.
+</p>
+
+<p>
+There have been significant optimizations bringing more than 10% improvements
+to implementations of the
+<a href="/pkg/compress/bzip2/"><code>compress/bzip2</code></a>,
+<a href="/pkg/compress/gzip/"><code>compress/gzip</code></a>,
+<a href="/pkg/crypto/aes/"><code>crypto/aes</code></a>,
+<a href="/pkg/crypto/elliptic/"><code>crypto/elliptic</code></a>,
+<a href="/pkg/crypto/ecdsa/"><code>crypto/ecdsa</code></a>, and
+<a href="/pkg/sort/"><code>sort</code></a> packages.
+</p>
+
+<h2 id="library">Core library</h2>
+
+<h3 id="http2">HTTP/2</h3>
+
+<p>
+Go 1.6 adds transparent support in the
+<a href="/pkg/net/http/"><code>net/http</code></a> package
+for the new <a href="https://http2.github.io/">HTTP/2 protocol</a>.
+Go clients and servers will automatically use HTTP/2 as appropriate when using HTTPS.
+There is no exported API specific to details of the HTTP/2 protocol handling,
+just as there is no exported API specific to HTTP/1.1.
+</p>
+
+<p>
+Programs that must disable HTTP/2 can do so by setting
+<a href="/pkg/net/http/#Transport"><code>Transport.TLSNextProto</code></a> (for clients)
+or
+<a href="/pkg/net/http/#Server"><code>Server.TLSNextProto</code></a> (for servers)
+to a non-nil, empty map.
+</p>
+
+<p>
+Programs that must adjust HTTP/2 protocol-specific details can import and use
+<a href="https://golang.org/x/net/http2"><code>golang.org/x/net/http2</code></a>,
+in particular its
+<a href="https://godoc.org/golang.org/x/net/http2/#ConfigureServer">ConfigureServer</a>
+and
+<a href="https://godoc.org/golang.org/x/net/http2/#ConfigureTransport">ConfigureTransport</a>
+functions.
+</p>
+
+<h3 id="runtime">Runtime</h3>
+
+<p>
+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 the program
+under the
+<a href="https://blog.golang.org/race-detector">race detector</a>,
+which will more reliably identify the race
+and give more detail.
+</p>
+
+<p>
+For program-ending panics, the runtime now by default
+prints only the stack of the running goroutine,
+not all existing goroutines.
+Usually only the current goroutine is relevant to a panic,
+so omitting the others significantly reduces irrelevant output
+in a crash message.
+To see the stacks from all goroutines in crash messages, set the environment variable
+<code>GOTRACEBACK</code> to <code>all</code>
+or call
+<a href="/pkg/runtime/debug/#SetTraceback"><code>debug.SetTraceback</code></a>
+before the crash, and rerun the program.
+See the <a href="/pkg/runtime/#hdr-Environment_Variables">runtime documentation</a> for details.
+</p>
+
+<p>
+<em>Updating</em>:
+Uncaught panics intended to dump the state of the entire program,
+such as when a timeout is detected or when explicitly handling a received signal,
+should now call <code>debug.SetTraceback("all")</code> before panicking.
+Searching for uses of
+<a href="/pkg/os/signal/#Notify"><code>signal.Notify</code></a> may help identify such code.
+</p>
+
+<p>
+On Windows, Go programs in Go 1.5 and earlier forced
+the global Windows timer resolution to 1ms at startup
+by calling <code>timeBeginPeriod(1)</code>.
+Go no longer needs this for good scheduler performance,
+and changing the global timer resolution caused problems on some systems,
+so the call has been removed.
+</p>
+
+<p>
+When using <code>-buildmode=c-archive</code> or
+<code>-buildmode=c-shared</code> to build an archive or a shared
+library, the handling of signals has changed.
+In Go 1.5 the archive or shared library would install a signal handler
+for most signals.
+In Go 1.6 it will only install a signal handler for the
+synchronous signals needed to handle run-time panics in Go code:
+SIGBUS, SIGFPE, SIGSEGV.
+See the <a href="/pkg/os/signal">os/signal</a> package for more
+details.
+</p>
+
+<h3 id="reflect">Reflect</h3>
+
+<p>
+The
+<a href="/pkg/reflect/"><code>reflect</code></a> package has
+<a href="https://golang.org/issue/12367">resolved a long-standing incompatibility</a>
+between the gc and gccgo toolchains
+regarding embedded unexported struct types containing exported fields.
+Code that walks data structures using reflection, especially to implement
+serialization in the spirit
+of the
+<a href="/pkg/encoding/json/"><code>encoding/json</code></a> and
+<a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> packages,
+may need to be updated.
+</p>
+
+<p>
+The problem arises when using reflection to walk through
+an embedded unexported struct-typed field
+into an exported field of that struct.
+In this case, <code>reflect</code> had incorrectly reported
+the embedded field as exported, by returning an empty <code>Field.PkgPath</code>.
+Now it correctly reports the field as unexported
+but ignores that fact when evaluating access to exported fields
+contained within the struct.
+</p>
+
+<p>
+<em>Updating</em>:
+Typically, code that previously walked over structs and used
+</p>
+
+<pre>
+f.PkgPath != ""
+</pre>
+
+<p>
+to exclude inaccessible fields
+should now use
+</p>
+
+<pre>
+f.PkgPath != "" && !f.Anonymous
+</pre>
+
+<p>
+For example, see the changes to the implementations of
+<a href="https://go-review.googlesource.com/#/c/14011/2/src/encoding/json/encode.go"><code>encoding/json</code></a> and
+<a href="https://go-review.googlesource.com/#/c/14012/2/src/encoding/xml/typeinfo.go"><code>encoding/xml</code></a>.
+</p>
+
+<h3 id="sort">Sorting</h3>
+
+<p>
+In the
+<a href="/pkg/sort/"><code>sort</code></a>
+package,
+the implementation of
+<a href="/pkg/sort/#Sort"><code>Sort</code></a>
+has been rewritten to make about 10% fewer calls to the
+<a href="/pkg/sort/#Interface"><code>Interface</code></a>'s
+<code>Less</code> and <code>Swap</code>
+methods, with a corresponding overall time savings.
+The new algorithm does choose a different ordering than before
+for values that compare equal (those pairs for which <code>Less(i,</code> <code>j)</code> and <code>Less(j,</code> <code>i)</code> are false).
+</p>
+
+<p>
+<em>Updating</em>:
+The definition of <code>Sort</code> makes no guarantee about the final order of equal values,
+but the new behavior may still break programs that expect a specific order.
+Such programs should either refine their <code>Less</code> implementations
+to report the desired order
+or should switch to
+<a href="/pkg/sort/#Stable"><code>Stable</code></a>,
+which preserves the original input order
+of equal values.
+</p>
+
+<h3 id="template">Templates</h3>
+
+<p>
+In the
+<a href="/pkg/text/template/">text/template</a> package,
+there are two significant new features to make writing templates easier.
+</p>
+
+<p>
+First, it is now possible to <a href="/pkg/text/template/#hdr-Text_and_spaces">trim spaces around template actions</a>,
+which can make template definitions more readable.
+A minus sign at the beginning of an action says to trim space before the action,
+and a minus sign at the end of an action says to trim space after the action.
+For example, the template
+</p>
+
+<pre>
+{{"{{"}}23 -}}
+ <
+{{"{{"}}- 45}}
+</pre>
+
+<p>
+formats as <code>23<45</code>.
+</p>
+
+<p>
+Second, the new <a href="/pkg/text/template/#hdr-Actions"><code>{{"{{"}}block}}</code> action</a>,
+combined with allowing redefinition of named templates,
+provides a simple way to define pieces of a template that
+can be replaced in different instantiations.
+There is <a href="/pkg/text/template/#example_Template_block">an example</a>
+in the <code>text/template</code> package that demonstrates this new feature.
+</p>
+
+<h3 id="minor_library_changes">Minor changes to the library</h3>
+
+<ul>
+
+<li>
+The <a href="/pkg/archive/tar/"><code>archive/tar</code></a> package's
+implementation corrects many bugs in rare corner cases of the file format.
+One visible change is that the
+<a href="/pkg/archive/tar/#Reader"><code>Reader</code></a> type's
+<a href="/pkg/archive/tar/#Reader.Read"><code>Read</code></a> method
+now presents the content of special file types as being empty,
+returning <code>io.EOF</code> immediately.
+</li>
+
+<li>
+In the <a href="/pkg/archive/zip/"><code>archive/zip</code></a> package, the
+<a href="/pkg/archive/zip/#Reader"><code>Reader</code></a> type now has a
+<a href="/pkg/archive/zip/#Reader.RegisterDecompressor"><code>RegisterDecompressor</code></a> method,
+and the
+<a href="/pkg/archive/zip/#Writer"><code>Writer</code></a> type now has a
+<a href="/pkg/archive/zip/#Writer.RegisterCompressor"><code>RegisterCompressor</code></a> method,
+enabling control over compression options for individual zip files.
+These take precedence over the pre-existing global
+<a href="/pkg/archive/zip/#RegisterDecompressor"><code>RegisterDecompressor</code></a> and
+<a href="/pkg/archive/zip/#RegisterCompressor"><code>RegisterCompressor</code></a> functions.
+</li>
+
+<li>
+The <a href="/pkg/bufio/"><code>bufio</code></a> package's
+<a href="/pkg/bufio/#Scanner"><code>Scanner</code></a> type now has a
+<a href="/pkg/bufio/#Scanner.Buffer"><code>Buffer</code></a> method,
+to specify an initial buffer and maximum buffer size to use during scanning.
+This makes it possible, when needed, to scan tokens larger than
+<code>MaxScanTokenSize</code>.
+Also for the <code>Scanner</code>, the package now defines the
+<a href="/pkg/bufio/#ErrFinalToken"><code>ErrFinalToken</code></a> error value, for use by
+<a href="/pkg/bufio/#SplitFunc">split functions</a> to abort processing or to return a final empty token.
+</li>
+
+<li>
+The <a href="/pkg/compress/flate/"><code>compress/flate</code></a> package
+has deprecated its
+<a href="/pkg/compress/flate/#ReadError"><code>ReadError</code></a> and
+<a href="/pkg/compress/flate/#WriteError"><code>WriteError</code></a> error implementations.
+In Go 1.5 they were only rarely returned when an error was encountered;
+now they are never returned, although they remain defined for compatibility.
+</li>
+
+<li>
+The <a href="/pkg/compress/flate/"><code>compress/flate</code></a>,
+<a href="/pkg/compress/gzip/"><code>compress/gzip</code></a>, and
+<a href="/pkg/compress/zlib/"><code>compress/zlib</code></a> packages
+now report
+<a href="/pkg/io/#ErrUnexpectedEOF"><code>io.ErrUnexpectedEOF</code></a> for truncated input streams, instead of
+<a href="/pkg/io/#EOF"><code>io.EOF</code></a>.
+</li>
+
+<li>
+The <a href="/pkg/crypto/cipher/"><code>crypto/cipher</code></a> package now
+overwrites the destination buffer in the event of a GCM decryption failure.
+This is to allow the AESNI code to avoid using a temporary buffer.
+</li>
+
+<li>
+The <a href="/pkg/crypto/tls/"><code>crypto/tls</code></a> package
+has a variety of minor changes.
+It now allows
+<a href="/pkg/crypto/tls/#Listen"><code>Listen</code></a>
+to succeed when the
+<a href="/pkg/crypto/tls/#Config"><code>Config</code></a>
+has a nil <code>Certificates</code>, as long as the <code>GetCertificate</code> callback is set,
+it adds support for RSA with AES-GCM cipher suites,
+and
+it adds a
+<a href="/pkg/crypto/tls/#RecordHeaderError"><code>RecordHeaderError</code></a>
+to allow clients (in particular, the <a href="/pkg/net/http/"><code>net/http</code></a> package)
+to report a better error when attempting a TLS connection to a non-TLS server.
+</li>
+
+<li>
+The <a href="/pkg/crypto/x509/"><code>crypto/x509</code></a> package
+now permits certificates to contain negative serial numbers
+(technically an error, but unfortunately common in practice),
+and it defines a new
+<a href="/pkg/crypto/x509/#InsecureAlgorithmError"><code>InsecureAlgorithmError</code></a>
+to give a better error message when rejecting a certificate
+signed with an insecure algorithm like MD5.
+</li>
+
+<li>
+The <a href="/pkg/debug/dwarf"><code>debug/dwarf</code></a> and
+<a href="/pkg/debug/elf/"><code>debug/elf</code></a> packages
+together add support for compressed DWARF sections.
+User code needs no updating: the sections are decompressed automatically when read.
+</li>
+
+<li>
+The <a href="/pkg/debug/elf/"><code>debug/elf</code></a> package
+adds support for general compressed ELF sections.
+User code needs no updating: the sections are decompressed automatically when read.
+However, compressed
+<a href="/pkg/debug/elf/#Section"><code>Sections</code></a> do not support random access:
+they have a nil <code>ReaderAt</code> field.
+</li>
+
+<li>
+The <a href="/pkg/encoding/asn1/"><code>encoding/asn1</code></a> package
+now exports
+<a href="/pkg/encoding/asn1/#pkg-constants">tag and class constants</a>
+useful for advanced parsing of ASN.1 structures.
+</li>
+
+<li>
+Also in the <a href="/pkg/encoding/asn1/"><code>encoding/asn1</code></a> package,
+<a href="/pkg/encoding/asn1/#Unmarshal"><code>Unmarshal</code></a> now rejects various non-standard integer and length encodings.
+</li>
+
+<li>
+The <a href="/pkg/encoding/base64"><code>encoding/base64</code></a> package's
+<a href="/pkg/encoding/base64/#Decoder"><code>Decoder</code></a> has been fixed
+to process the final bytes of its input. Previously it processed as many four-byte tokens as
+possible but ignored the remainder, up to three bytes.
+The <code>Decoder</code> therefore now handles inputs in unpadded encodings (like
+<a href="/pkg/encoding/base64/#RawURLEncoding">RawURLEncoding</a>) correctly,
+but it also rejects inputs in padded encodings that are truncated or end with invalid bytes,
+such as trailing spaces.
+</li>
+
+<li>
+The <a href="/pkg/encoding/json/"><code>encoding/json</code></a> package
+now checks the syntax of a
+<a href="/pkg/encoding/json/#Number"><code>Number</code></a>
+before marshaling it, requiring that it conforms to the JSON specification for numeric values.
+As in previous releases, the zero <code>Number</code> (an empty string) is marshaled as a literal 0 (zero).
+</li>
+
+<li>
+The <a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> package's
+<a href="/pkg/encoding/xml/#Marshal"><code>Marshal</code></a>
+function now supports a <code>cdata</code> attribute, such as <code>chardata</code>
+but encoding its argument in one or more <code><![CDATA[ ... ]]></code> tags.
+</li>
+
+<li>
+Also in the <a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> package,
+<a href="/pkg/encoding/xml/#Decoder"><code>Decoder</code></a>'s
+<a href="/pkg/encoding/xml/#Decoder.Token"><code>Token</code></a> method
+now reports an error when encountering EOF before seeing all open tags closed,
+consistent with its general requirement that tags in the input be properly matched.
+To avoid that requirement, use
+<a href="/pkg/encoding/xml/#Decoder.RawToken"><code>RawToken</code></a>.
+</li>
+
+<li>
+The <a href="/pkg/fmt/"><code>fmt</code></a> package now allows
+any integer type as an argument to
+<a href="/pkg/fmt/#Printf"><code>Printf</code></a>'s <code>*</code> width and precision specification.
+In previous releases, the argument to <code>*</code> was required to have type <code>int</code>.
+</li>
+
+<li>
+Also in the <a href="/pkg/fmt/"><code>fmt</code></a> package,
+<a href="/pkg/fmt/#Scanf"><code>Scanf</code></a> can now scan hexadecimal strings using %X, as an alias for %x.
+Both formats accept any mix of upper- and lower-case hexadecimal.
+</li>
+
+<li>
+The <a href="/pkg/image/"><code>image</code></a>
+and
+<a href="/pkg/image/color/"><code>image/color</code></a> packages
+add
+<a href="/pkg/image/#NYCbCrA"><code>NYCbCrA</code></a>
+and
+<a href="/pkg/image/color/#NYCbCrA"><code>NYCbCrA</code></a>
+types, to support Y'CbCr images with non-premultiplied alpha.
+</li>
+
+<li>
+The <a href="/pkg/io/"><code>io</code></a> package's
+<a href="/pkg/io/#MultiWriter"><code>MultiWriter</code></a>
+implementation now implements a <code>WriteString</code> method,
+for use by
+<a href="/pkg/io/#WriteString"><code>WriteString</code></a>.
+</li>
+
+<li>
+In the <a href="/pkg/math/big/"><code>math/big</code></a> package,
+<a href="/pkg/math/big/#Int"><code>Int</code></a> adds
+<a href="/pkg/math/big/#Int.Append"><code>Append</code></a>
+and
+<a href="/pkg/math/big/#Int.Text"><code>Text</code></a>
+methods to give more control over printing.
+</li>
+
+<li>
+Also in the <a href="/pkg/math/big/"><code>math/big</code></a> package,
+<a href="/pkg/math/big/#Float"><code>Float</code></a> now implements
+<a href="/pkg/encoding/#TextMarshaler"><code>encoding.TextMarshaler</code></a> and
+<a href="/pkg/encoding/#TextUnmarshaler"><code>encoding.TextUnmarshaler</code></a>,
+allowing it to be serialized in a natural form by the
+<a href="/pkg/encoding/json/"><code>encoding/json</code></a> and
+<a href="/pkg/encoding/xml/"><code>encoding/xml</code></a> packages.
+</li>
+
+<li>
+Also in the <a href="/pkg/math/big/"><code>math/big</code></a> package,
+<a href="/pkg/math/big/#Float"><code>Float</code></a>'s
+<a href="/pkg/math/big/#Float.Append"><code>Append</code></a> method now supports the special precision argument -1.
+As in
+<a href="/pkg/strconv/#ParseFloat"><code>strconv.ParseFloat</code></a>,
+precision -1 means to use the smallest number of digits necessary such that
+<a href="/pkg/math/big/#Float.Parse"><code>Parse</code></a>
+reading the result into a <code>Float</code> of the same precision
+will yield the original value.
+</li>
+
+<li>
+The <a href="/pkg/math/rand/"><code>math/rand</code></a> package
+adds a
+<a href="/pkg/math/rand/#Read"><code>Read</code></a>
+function, and likewise
+<a href="/pkg/math/rand/#Rand"><code>Rand</code></a> adds a
+<a href="/pkg/math/rand/#Rand.Read"><code>Read</code></a> method.
+These make it easier to generate pseudorandom test data.
+Note that, like the rest of the package,
+these should not be used in cryptographic settings;
+for such purposes, use the <a href="/pkg/crypto/rand/"><code>crypto/rand</code></a> package instead.
+</li>
+
+<li>
+The <a href="/pkg/net/"><code>net</code></a> package's
+<a href="/pkg/net/#ParseMAC"><code>ParseMAC</code></a> function now accepts 20-byte IP-over-InfiniBand (IPoIB) link-layer addresses.
+</li>
+
+
+<li>
+Also in the <a href="/pkg/net/"><code>net</code></a> package,
+there have been a few changes to DNS lookups.
+First, the
+<a href="/pkg/net/#DNSError"><code>DNSError</code></a> error implementation now implements
+<a href="/pkg/net/#Error"><code>Error</code></a>,
+and in particular its new
+<a href="/pkg/net/#DNSError.IsTemporary"><code>IsTemporary</code></a>
+method returns true for DNS server errors.
+Second, DNS lookup functions such as
+<a href="/pkg/net/#LookupAddr"><code>LookupAddr</code></a>
+now return rooted domain names (with a trailing dot)
+on Plan 9 and Windows, to match the behavior of Go on Unix systems.
+</li>
+
+<li>
+The <a href="/pkg/net/http/"><code>net/http</code></a> package has
+a number of minor additions beyond the HTTP/2 support already discussed.
+First, the
+<a href="/pkg/net/http/#FileServer"><code>FileServer</code></a> now sorts its generated directory listings by file name.
+Second, the
+<a href="/pkg/net/http/#ServeFile"><code>ServeFile</code></a> function now refuses to serve a result
+if the request's URL path contains “..” (dot-dot) as a path element.
+Programs should typically use <code>FileServer</code> and
+<a href="/pkg/net/http/#Dir"><code>Dir</code></a>
+instead of calling <code>ServeFile</code> directly.
+Programs that need to serve file content in response to requests for URLs containing dot-dot can
+still call <a href="/pkg/net/http/#ServeContent"><code>ServeContent</code></a>.
+Third, the
+<a href="/pkg/net/http/#Client"><code>Client</code></a> now allows user code to set the
+<code>Expect:</code> <code>100-continue</code> header (see
+<a href="/pkg/net/http/#Transport"><code>Transport.ExpectContinueTimeout</code></a>).
+Fourth, there are
+<a href="/pkg/net/http/#pkg-constants">five new error codes</a>:
+<code>StatusPreconditionRequired</code> (428),
+<code>StatusTooManyRequests</code> (429),
+<code>StatusRequestHeaderFieldsTooLarge</code> (431), and
+<code>StatusNetworkAuthenticationRequired</code> (511) from RFC 6585,
+as well as the recently-approved
+<code>StatusUnavailableForLegalReasons</code> (451).
+Fifth, the implementation and documentation of
+<a href="/pkg/net/http/#CloseNotifier"><code>CloseNotifier</code></a>
+has been substantially changed.
+The <a href="/pkg/net/http/#Hijacker"><code>Hijacker</code></a>
+interface now works correctly on connections that have previously
+been used with <code>CloseNotifier</code>.
+The documentation now describes when <code>CloseNotifier</code>
+is expected to work.
+</li>
+
+<li>
+Also in the <a href="/pkg/net/http/"><code>net/http</code></a> package,
+there are a few changes related to the handling of a
+<a href="/pkg/net/http/#Request"><code>Request</code></a> data structure with its <code>Method</code> field set to the empty string.
+An empty <code>Method</code> field has always been documented as an alias for <code>"GET"</code>
+and it remains so.
+However, Go 1.6 fixes a few routines that did not treat an empty
+<code>Method</code> the same as an explicit <code>"GET"</code>.
+Most notably, in previous releases
+<a href="/pkg/net/http/#Client"><code>Client</code></a> followed redirects only with
+<code>Method</code> set explicitly to <code>"GET"</code>;
+in Go 1.6 <code>Client</code> also follows redirects for the empty <code>Method</code>.
+Finally,
+<a href="/pkg/net/http/#NewRequest"><code>NewRequest</code></a> accepts a <code>method</code> argument that has not been
+documented as allowed to be empty.
+In past releases, passing an empty <code>method</code> argument resulted
+in a <code>Request</code> with an empty <code>Method</code> field.
+In Go 1.6, the resulting <code>Request</code> always has an initialized
+<code>Method</code> field: if its argument is an empty string, <code>NewRequest</code>
+sets the <code>Method</code> field in the returned <code>Request</code> to <code>"GET"</code>.
+</li>
+
+<li>
+The <a href="/pkg/net/http/httptest/"><code>net/http/httptest</code></a> package's
+<a href="/pkg/net/http/httptest/#ResponseRecorder"><code>ResponseRecorder</code></a> now initializes a default Content-Type header
+using the same content-sniffing algorithm as in
+<a href="/pkg/net/http/#Server"><code>http.Server</code></a>.
+</li>
+
+<li>
+The <a href="/pkg/net/url/"><code>net/url</code></a> package's
+<a href="/pkg/net/url/#Parse"><code>Parse</code></a> is now stricter and more spec-compliant regarding the parsing
+of host names.
+For example, spaces in the host name are no longer accepted.
+</li>
+
+<li>
+Also in the <a href="/pkg/net/url/"><code>net/url</code></a> package,
+the <a href="/pkg/net/url/#Error"><code>Error</code></a> type now implements
+<a href="/pkg/net/#Error"><code>net.Error</code></a>.
+</li>
+
+<li>
+The <a href="/pkg/os/"><code>os</code></a> package's
+<a href="/pkg/os/#IsExist"><code>IsExist</code></a>,
+<a href="/pkg/os/#IsNotExist"><code>IsNotExist</code></a>,
+and
+<a href="/pkg/os/#IsPermission"><code>IsPermission</code></a>
+now return correct results when inquiring about an
+<a href="/pkg/os/#SyscallError"><code>SyscallError</code></a>.
+</li>
+
+<li>
+On Unix-like systems, when a write
+to <a href="/pkg/os/#pkg-variables"><code>os.Stdout</code>
+or <code>os.Stderr</code></a> (more precisely, an <code>os.File</code>
+opened for file descriptor 1 or 2) fails due to a broken pipe error,
+the program will raise a <code>SIGPIPE</code> signal.
+By default this will cause the program to exit; this may be changed by
+calling the
+<a href="/pkg/os/signal"><code>os/signal</code></a>
+<a href="/pkg/os/signal/#Notify"><code>Notify</code></a> function
+for <code>syscall.SIGPIPE</code>.
+A write to a broken pipe on a file descriptor other 1 or 2 will simply
+return <code>syscall.EPIPE</code> (possibly wrapped in
+<a href="/pkg/os#PathError"><code>os.PathError</code></a>
+and/or <a href="/pkg/os#SyscallError"><code>os.SyscallError</code></a>)
+to the caller.
+The old behavior of raising an uncatchable <code>SIGPIPE</code> signal
+after 10 consecutive writes to a broken pipe no longer occurs.
+</li>
+
+<li>
+In the <a href="/pkg/os/exec/"><code>os/exec</code></a> package,
+<a href="/pkg/os/exec/#Cmd"><code>Cmd</code></a>'s
+<a href="/pkg/os/exec/#Cmd.Output"><code>Output</code></a> method continues to return an
+<a href="/pkg/os/exec/#ExitError"><code>ExitError</code></a> when a command exits with an unsuccessful status.
+If standard error would otherwise have been discarded,
+the returned <code>ExitError</code> now holds a prefix and suffix
+(currently 32 kB) of the failed command's standard error output,
+for debugging or for inclusion in error messages.
+The <code>ExitError</code>'s
+<a href="/pkg/os/exec/#ExitError.String"><code>String</code></a>
+method does not show the captured standard error;
+programs must retrieve it from the data structure
+separately.
+</li>
+
+<li>
+On Windows, the <a href="/pkg/path/filepath/"><code>path/filepath</code></a> package's
+<a href="/pkg/path/filepath/#Join"><code>Join</code></a> function now correctly handles the case when the base is a relative drive path.
+For example, <code>Join(`c:`,</code> <code>`a`)</code> now
+returns <code>`c:a`</code> instead of <code>`c:\a`</code> as in past releases.
+This may affect code that expects the incorrect result.
+</li>
+
+<li>
+In the <a href="/pkg/regexp/"><code>regexp</code></a> package,
+the
+<a href="/pkg/regexp/#Regexp"><code>Regexp</code></a> type has always been safe for use by
+concurrent goroutines.
+It uses a <a href="/pkg/sync/#Mutex"><code>sync.Mutex</code></a> to protect
+a cache of scratch spaces used during regular expression searches.
+Some high-concurrency servers using the same <code>Regexp</code> from many goroutines
+have seen degraded performance due to contention on that mutex.
+To help such servers, <code>Regexp</code> now has a
+<a href="/pkg/regexp/#Regexp.Copy"><code>Copy</code></a> method,
+which makes a copy of a <code>Regexp</code> that shares most of the structure
+of the original but has its own scratch space cache.
+Two goroutines can use different copies of a <code>Regexp</code>
+without mutex contention.
+A copy does have additional space overhead, so <code>Copy</code>
+should only be used when contention has been observed.
+</li>
+
+<li>
+The <a href="/pkg/strconv/"><code>strconv</code></a> package adds
+<a href="/pkg/strconv/#IsGraphic"><code>IsGraphic</code></a>,
+similar to <a href="/pkg/strconv/#IsPrint"><code>IsPrint</code></a>.
+It also adds
+<a href="/pkg/strconv/#QuoteToGraphic"><code>QuoteToGraphic</code></a>,
+<a href="/pkg/strconv/#QuoteRuneToGraphic"><code>QuoteRuneToGraphic</code></a>,
+<a href="/pkg/strconv/#AppendQuoteToGraphic"><code>AppendQuoteToGraphic</code></a>,
+and
+<a href="/pkg/strconv/#AppendQuoteRuneToGraphic"><code>AppendQuoteRuneToGraphic</code></a>,
+analogous to
+<a href="/pkg/strconv/#QuoteToASCII"><code>QuoteToASCII</code></a>,
+<a href="/pkg/strconv/#QuoteRuneToASCII"><code>QuoteRuneToASCII</code></a>,
+and so on.
+The <code>ASCII</code> family escapes all space characters except ASCII space (U+0020).
+In contrast, the <code>Graphic</code> family does not escape any Unicode space characters (category Zs).
+</li>
+
+<li>
+In the <a href="/pkg/testing/"><code>testing</code></a> package,
+when a test calls
+<a href="/pkg/testing/#T.Parallel">t.Parallel</a>,
+that test is paused until all non-parallel tests complete, and then
+that test continues execution with all other parallel tests.
+Go 1.6 changes the time reported for such a test:
+previously the time counted only the parallel execution,
+but now it also counts the time from the start of testing
+until the call to <code>t.Parallel</code>.
+</li>
+
+<li>
+The <a href="/pkg/text/template/"><code>text/template</code></a> package
+contains two minor changes, in addition to the <a href="#template">major changes</a>
+described above.
+First, it adds a new
+<a href="/pkg/text/template/#ExecError"><code>ExecError</code></a> type
+returned for any error during
+<a href="/pkg/text/template/#Template.Execute"><code>Execute</code></a>
+that does not originate in a <code>Write</code> to the underlying writer.
+Callers can distinguish template usage errors from I/O errors by checking for
+<code>ExecError</code>.
+Second, the
+<a href="/pkg/text/template/#Template.Funcs"><code>Funcs</code></a> method
+now checks that the names used as keys in the
+<a href="/pkg/text/template/#FuncMap"><code>FuncMap</code></a>
+are identifiers that can appear in a template function invocation.
+If not, <code>Funcs</code> panics.
+</li>
+
+<li>
+The <a href="/pkg/time/"><code>time</code></a> package's
+<a href="/pkg/time/#Parse"><code>Parse</code></a> function has always rejected any day of month larger than 31,
+such as January 32.
+In Go 1.6, <code>Parse</code> now also rejects February 29 in non-leap years,
+February 30, February 31, April 31, June 31, September 31, and November 31.
+</li>
+
+</ul>
+
diff --git a/_content/doc/go1.7.html b/_content/doc/go1.7.html
new file mode 100644
index 0000000..2138871
--- /dev/null
+++ b/_content/doc/go1.7.html
@@ -0,0 +1,1280 @@
+<!--{
+ "Title": "Go 1.7 Release Notes",
+ "Template": true
+}-->
+
+<!--
+for acme:
+Edit .,s;^PKG:([a-z][A-Za-z0-9_/]+);<a href="/pkg/\1/"><code>\1</code></a>;g
+Edit .,s;^([a-z][A-Za-z0-9_/]+)\.([A-Z][A-Za-z0-9_]+\.)?([A-Z][A-Za-z0-9_]+)([ .',)]|$);<a href="/pkg/\1/#\2\3"><code>\3</code></a>\4;g
+Edit .,s;^FULL:([a-z][A-Za-z0-9_/]+)\.([A-Z][A-Za-z0-9_]+\.)?([A-Z][A-Za-z0-9_]+)([ .',)]|$);<a href="/pkg/\1/#\2\3"><code>\1.\2\3</code></a>\4;g
+Edit .,s;^DPKG:([a-z][A-Za-z0-9_/]+);<dl id="\1"><a href="/pkg/\1/">\1</a></dl>;g
+
+rsc last updated through 6729576
+-->
+
+<!--
+NOTE: In this document and others in this directory, the convention is to
+set fixed-width phrases with non-fixed-width spaces, as in
+<code>hello</code> <code>world</code>.
+Do not send CLs removing the interior tags from such phrases.
+-->
+
+<style>
+ main ul li { margin: 0.5em 0; }
+</style>
+
+<h2 id="introduction">Introduction to Go 1.7</h2>
+
+<p>
+The latest Go release, version 1.7, arrives six months after 1.6.
+Most of its changes are in the implementation of the toolchain, runtime, and libraries.
+There is one minor change to the language specification.
+As always, the release maintains the Go 1 <a href="/doc/go1compat.html">promise of compatibility</a>.
+We expect almost all Go programs to continue to compile and run as before.
+</p>
+
+<p>
+The release <a href="#ports">adds a port to IBM LinuxOne</a>;
+<a href="#compiler">updates the x86-64 compiler back end</a> to generate more efficient code;
+includes the <a href="#context">context package</a>, promoted from the
+<a href="https://golang.org/x/net/context">x/net subrepository</a>
+and now used in the standard library;
+and <a href="#testing">adds support in the testing package</a> for
+creating hierarchies of tests and benchmarks.
+The release also <a href="#cmd_go">finalizes the vendoring support</a>
+started in Go 1.5, making it a standard feature.
+</p>
+
+<h2 id="language">Changes to the language</h2>
+
+<p>
+There is one tiny language change in this release.
+The section on <a href="/ref/spec#Terminating_statements">terminating statements</a>
+clarifies that to determine whether a statement list ends in a terminating statement,
+the “final non-empty statement” is considered the end,
+matching the existing behavior of the gc and gccgo compiler toolchains.
+In earlier releases the definition referred only to the “final statement,”
+leaving the effect of trailing empty statements at the least unclear.
+The <a href="/pkg/go/types/"><code>go/types</code></a>
+package has been updated to match the gc and gccgo compiler toolchains
+in this respect.
+This change has no effect on the correctness of existing programs.
+</p>
+
+<h2 id="ports">Ports</h2>
+
+<p>
+Go 1.7 adds support for macOS 10.12 Sierra.
+Binaries built with versions of Go before 1.7 will not work
+correctly on Sierra.
+</p>
+
+<p>
+Go 1.7 adds an experimental port to <a href="https://en.wikipedia.org/wiki/Linux_on_z_Systems">Linux on z Systems</a> (<code>linux/s390x</code>)
+and the beginning of a port to Plan 9 on ARM (<code>plan9/arm</code>).
+</p>
+
+<p>
+The experimental ports to Linux on 64-bit MIPS (<code>linux/mips64</code> and <code>linux/mips64le</code>)
+added in Go 1.6 now have full support for cgo and external linking.
+</p>
+
+<p>
+The experimental port to Linux on little-endian 64-bit PowerPC (<code>linux/ppc64le</code>)
+now requires the POWER8 architecture or later.
+Big-endian 64-bit PowerPC (<code>linux/ppc64</code>) only requires the
+POWER5 architecture.
+</p>
+
+<p>
+The OpenBSD port now requires OpenBSD 5.6 or later, for access to the <a href="https://man.openbsd.org/getentropy.2"><i>getentropy</i>(2)</a> system call.
+</p>
+
+<h3 id="known_issues">Known Issues</h3>
+
+<p>
+There are some instabilities on FreeBSD that are known but not understood.
+These can lead to program crashes in rare cases.
+See <a href="https://golang.org/issue/16136">issue 16136</a>,
+<a href="https://golang.org/issue/15658">issue 15658</a>,
+and <a href="https://golang.org/issue/16396">issue 16396</a>.
+Any help in solving these FreeBSD-specific issues would be appreciated.
+</p>
+
+<h2 id="tools">Tools</h2>
+
+<h3 id="cmd_asm">Assembler</h3>
+
+<p>
+For 64-bit ARM systems, the vector register names have been
+corrected to <code>V0</code> through <code>V31</code>;
+previous releases incorrectly referred to them as <code>V32</code> through <code>V63</code>.
+</p>
+
+<p>
+For 64-bit x86 systems, the following instructions have been added:
+<code>PCMPESTRI</code>,
+<code>RORXL</code>,
+<code>RORXQ</code>,
+<code>VINSERTI128</code>,
+<code>VPADDD</code>,
+<code>VPADDQ</code>,
+<code>VPALIGNR</code>,
+<code>VPBLENDD</code>,
+<code>VPERM2F128</code>,
+<code>VPERM2I128</code>,
+<code>VPOR</code>,
+<code>VPSHUFB</code>,
+<code>VPSHUFD</code>,
+<code>VPSLLD</code>,
+<code>VPSLLDQ</code>,
+<code>VPSLLQ</code>,
+<code>VPSRLD</code>,
+<code>VPSRLDQ</code>,
+and
+<code>VPSRLQ</code>.
+</p>
+
+<h3 id="compiler">Compiler Toolchain</h3>
+
+<p>
+This release includes a new code generation back end for 64-bit x86 systems,
+following a <a href="https://golang.org/s/go17ssa">proposal from 2015</a>
+that has been under development since then.
+The new back end, based on
+<a href="https://en.wikipedia.org/wiki/Static_single_assignment_form">SSA</a>,
+generates more compact, more efficient code
+and provides a better platform for optimizations
+such as bounds check elimination.
+The new back end reduces the CPU time required by
+<a href="https://golang.org/test/bench/go1/">our benchmark programs</a> by 5-35%.
+</p>
+
+<p>
+For this release, the new back end can be disabled by passing
+<code>-ssa=0</code> to the compiler.
+If you find that your program compiles or runs successfully
+only with the new back end disabled, please
+<a href="https://golang.org/issue/new">file a bug report</a>.
+</p>
+
+<p>
+The format of exported metadata written by the compiler in package archives has changed:
+the old textual format has been replaced by a more compact binary format.
+This results in somewhat smaller package archives and fixes a few
+long-standing corner case bugs.
+</p>
+
+<p>
+For this release, the new export format can be disabled by passing
+<code>-newexport=0</code> to the compiler.
+If you find that your program compiles or runs successfully
+only with the new export format disabled, please
+<a href="https://golang.org/issue/new">file a bug report</a>.
+</p>
+
+<p>
+The linker's <code>-X</code> option no longer supports the unusual two-argument form
+<code>-X</code> <code>name</code> <code>value</code>,
+as <a href="/doc/go1.6#compiler">announced</a> in the Go 1.6 release
+and in warnings printed by the linker.
+Use <code>-X</code> <code>name=value</code> instead.
+</p>
+
+<p>
+The compiler and linker have been optimized and run significantly faster in this release than in Go 1.6,
+although they are still slower than we would like and will continue to be optimized in future releases.
+</p>
+
+<p>
+Due to changes across the compiler toolchain and standard library,
+binaries built with this release should typically be smaller than binaries
+built with Go 1.6,
+sometimes by as much as 20-30%.
+</p>
+
+<p>
+On x86-64 systems, Go programs now maintain stack frame pointers
+as expected by profiling tools like Linux's perf and Intel's VTune,
+making it easier to analyze and optimize Go programs using these tools.
+The frame pointer maintenance has a small run-time overhead that varies
+but averages around 2%. We hope to reduce this cost in future releases.
+To build a toolchain that does not use frame pointers, set
+<code>GOEXPERIMENT=noframepointer</code> when running
+<code>make.bash</code>, <code>make.bat</code>, or <code>make.rc</code>.
+</p>
+
+<h3 id="cmd_cgo">Cgo</h3>
+
+<p>
+Packages using <a href="/cmd/cgo/">cgo</a> may now include
+Fortran source files (in addition to C, C++, Objective C, and SWIG),
+although the Go bindings must still use C language APIs.
+</p>
+
+<p>
+Go bindings may now use a new helper function <code>C.CBytes</code>.
+In contrast to <code>C.CString</code>, which takes a Go <code>string</code>
+and returns a <code>*C.byte</code> (a C <code>char*</code>),
+<code>C.CBytes</code> takes a Go <code>[]byte</code>
+and returns an <code>unsafe.Pointer</code> (a C <code>void*</code>).
+</p>
+
+<p>
+Packages and binaries built using <code>cgo</code> have in past releases
+produced different output on each build,
+due to the embedding of temporary directory names.
+When using this release with
+new enough versions of GCC or Clang
+(those that support the <code>-fdebug-prefix-map</code> option),
+those builds should finally be deterministic.
+</p>
+
+<h3 id="gccgo">Gccgo</h3>
+
+<p>
+Due to the alignment of Go's semiannual release schedule with GCC's annual release schedule,
+GCC release 6 contains the Go 1.6.1 version of gccgo.
+The next release, GCC 7, will likely have the Go 1.8 version of gccgo.
+</p>
+
+<h3 id="cmd_go">Go command</h3>
+
+<p>
+The <a href="/cmd/go/"><code>go</code></a> command's basic operation
+is unchanged, but there are a number of changes worth noting.
+</p>
+
+<p>
+This release removes support for the <code>GO15VENDOREXPERIMENT</code> environment variable,
+as <a href="/doc/go1.6#go_command">announced</a> in the Go 1.6 release.
+<a href="https://golang.org/s/go15vendor">Vendoring support</a>
+is now a standard feature of the <code>go</code> command and toolchain.
+</p>
+
+<p>
+The <code>Package</code> data structure made available to
+“<code>go</code> <code>list</code>” now includes a
+<code>StaleReason</code> field explaining why a particular package
+is or is not considered stale (in need of rebuilding).
+This field is available to the <code>-f</code> or <code>-json</code>
+options and is useful for understanding why a target is being rebuilt.
+</p>
+
+<p>
+The “<code>go</code> <code>get</code>” command now supports
+import paths referring to <code>git.openstack.org</code>.
+</p>
+
+<p>
+This release adds experimental, minimal support for building programs using
+<a href="/pkg/go/build#hdr-Binary_Only_Packages">binary-only packages</a>,
+packages distributed in binary form
+without the corresponding source code.
+This feature is needed in some commercial settings
+but is not intended to be fully integrated into the rest of the toolchain.
+For example, tools that assume access to complete source code
+will not work with such packages, and there are no plans to support
+such packages in the “<code>go</code> <code>get</code>” command.
+</p>
+
+<h3 id="cmd_doc">Go doc</h3>
+
+<p>
+The “<code>go</code> <code>doc</code>” command
+now groups constructors with the type they construct,
+following <a href="/cmd/godoc/"><code>godoc</code></a>.
+</p>
+
+<h3 id="cmd_vet">Go vet</h3>
+
+<p>
+The “<code>go</code> <code>vet</code>” command
+has more accurate analysis in its <code>-copylock</code> and <code>-printf</code> checks,
+and a new <code>-tests</code> check that checks the name and signature of likely test functions.
+To avoid confusion with the new <code>-tests</code> check, the old, unadvertised
+<code>-test</code> option has been removed; it was equivalent to <code>-all</code> <code>-shadow</code>.
+</p>
+
+<p id="vet_lostcancel">
+The <code>vet</code> command also has a new check,
+<code>-lostcancel</code>, which detects failure to call the
+cancelation function returned by the <code>WithCancel</code>,
+<code>WithTimeout</code>, and <code>WithDeadline</code> functions in
+Go 1.7's new <code>context</code> package (see <a
+href='#context'>below</a>).
+Failure to call the function prevents the new <code>Context</code>
+from being reclaimed until its parent is cancelled.
+(The background context is never cancelled.)
+</p>
+
+<h3 id="cmd_dist">Go tool dist</h3>
+
+<p>
+The new subcommand “<code>go</code> <code>tool</code> <code>dist</code> <code>list</code>”
+prints all supported operating system/architecture pairs.
+</p>
+
+<h3 id="cmd_trace">Go tool trace</h3>
+
+<p>
+The “<code>go</code> <code>tool</code> <code>trace</code>” command,
+<a href="/doc/go1.5#trace_command">introduced in Go 1.5</a>,
+has been refined in various ways.
+</p>
+
+<p>
+First, collecting traces is significantly more efficient than in past releases.
+In this release, the typical execution-time overhead of collecting a trace is about 25%;
+in past releases it was at least 400%.
+Second, trace files now include file and line number information,
+making them more self-contained and making the
+original executable optional when running the trace tool.
+Third, the trace tool now breaks up large traces to avoid limits
+in the browser-based viewer.
+</p>
+
+<p>
+Although the trace file format has changed in this release,
+the Go 1.7 tools can still read traces from earlier releases.
+</p>
+
+<h2 id="performance">Performance</h2>
+
+<p>
+As always, the changes are so general and varied that precise statements
+about performance are difficult to make.
+Most programs should run a bit faster,
+due to speedups in the garbage collector and
+optimizations in the core library.
+On x86-64 systems, many programs will run significantly faster,
+due to improvements in generated code brought by the
+new compiler back end.
+As noted above, in our own benchmarks,
+the code generation changes alone typically reduce program CPU time by 5-35%.
+</p>
+
+<p>
+<!-- git log -''-grep '-[0-9][0-9]\.[0-9][0-9]%' go1.6.. -->
+There have been significant optimizations bringing more than 10% improvements
+to implementations in the
+<a href="/pkg/crypto/sha1/"><code>crypto/sha1</code></a>,
+<a href="/pkg/crypto/sha256/"><code>crypto/sha256</code></a>,
+<a href="/pkg/encoding/binary/"><code>encoding/binary</code></a>,
+<a href="/pkg/fmt/"><code>fmt</code></a>,
+<a href="/pkg/hash/adler32/"><code>hash/adler32</code></a>,
+<a href="/pkg/hash/crc32/"><code>hash/crc32</code></a>,
+<a href="/pkg/hash/crc64/"><code>hash/crc64</code></a>,
+<a href="/pkg/image/color/"><code>image/color</code></a>,
+<a href="/pkg/math/big/"><code>math/big</code></a>,
+<a href="/pkg/strconv/"><code>strconv</code></a>,
+<a href="/pkg/strings/"><code>strings</code></a>,
+<a href="/pkg/unicode/"><code>unicode</code></a>,
+and
+<a href="/pkg/unicode/utf16/"><code>unicode/utf16</code></a>
+packages.
+</p>
+
+<p>
+Garbage collection pauses should be significantly shorter than they
+were in Go 1.6 for programs with large numbers of idle goroutines,
+substantial stack size fluctuation, or large package-level variables.
+</p>
+
+<h2 id="library">Core library</h2>
+
+<h3 id="context">Context</h3>
+
+<p>
+Go 1.7 moves the <code>golang.org/x/net/context</code> package
+into the standard library as <a href="/pkg/context/"><code>context</code></a>.
+This allows the use of contexts for cancelation, timeouts, and passing
+request-scoped data in other standard library packages,
+including
+<a href="#net">net</a>,
+<a href="#net_http">net/http</a>,
+and
+<a href="#os_exec">os/exec</a>,
+as noted below.
+</p>
+
+<p>
+For more information about contexts, see the
+<a href="/pkg/context/">package documentation</a>
+and the Go blog post
+“<a href="https://blog.golang.org/context">Go Concurrent Patterns: Context</a>.”
+</p>
+
+<h3 id="httptrace">HTTP Tracing</h3>
+
+<p>
+Go 1.7 introduces <a href="/pkg/net/http/httptrace/"><code>net/http/httptrace</code></a>,
+a package that provides mechanisms for tracing events within HTTP requests.
+</p>
+
+<h3 id="testing">Testing</h3>
+
+<p>
+The <code>testing</code> package now supports the definition
+of tests with subtests and benchmarks with sub-benchmarks.
+This support makes it easy to write table-driven benchmarks
+and to create hierarchical tests.
+It also provides a way to share common setup and tear-down code.
+See the <a href="/pkg/testing/#hdr-Subtests_and_Sub_benchmarks">package documentation</a> for details.
+</p>
+
+<h3 id="runtime">Runtime</h3>
+
+<p>
+All panics started by the runtime now use panic values
+that implement both the
+builtin <a href="/ref/spec#Errors"><code>error</code></a>,
+and
+<a href="/pkg/runtime/#Error"><code>runtime.Error</code></a>,
+as
+<a href="/ref/spec#Run_time_panics">required by the language specification</a>.
+</p>
+
+<p>
+During panics, if a signal's name is known, it will be printed in the stack trace.
+Otherwise, the signal's number will be used, as it was before Go1.7.
+</p>
+
+<p>
+The new function
+<a href="/pkg/runtime/#KeepAlive"><code>KeepAlive</code></a>
+provides an explicit mechanism for declaring
+that an allocated object must be considered reachable
+at a particular point in a program,
+typically to delay the execution of an associated finalizer.
+</p>
+
+<p>
+The new function
+<a href="/pkg/runtime/#CallersFrames"><code>CallersFrames</code></a>
+translates a PC slice obtained from
+<a href="/pkg/runtime/#Callers"><code>Callers</code></a>
+into a sequence of frames corresponding to the call stack.
+This new API should be preferred instead of direct use of
+<a href="/pkg/runtime/#FuncForPC"><code>FuncForPC</code></a>,
+because the frame sequence can more accurately describe
+call stacks with inlined function calls.
+</p>
+
+<p>
+The new function
+<a href="/pkg/runtime/#SetCgoTraceback"><code>SetCgoTraceback</code></a>
+facilitates tighter integration between Go and C code executing
+in the same process called using cgo.
+</p>
+
+<p>
+On 32-bit systems, the runtime can now use memory allocated
+by the operating system anywhere in the address space,
+eliminating the
+“memory allocated by OS not in usable range” failure
+common in some environments.
+</p>
+
+<p>
+The runtime can now return unused memory to the operating system on
+all architectures.
+In Go 1.6 and earlier, the runtime could not
+release memory on ARM64, 64-bit PowerPC, or MIPS.
+</p>
+
+<p>
+On Windows, Go programs in Go 1.5 and earlier forced
+the global Windows timer resolution to 1ms at startup
+by calling <code>timeBeginPeriod(1)</code>.
+Changing the global timer resolution caused problems on some systems,
+and testing suggested that the call was not needed for good scheduler performance,
+so Go 1.6 removed the call.
+Go 1.7 brings the call back: under some workloads the call
+is still needed for good scheduler performance.
+</p>
+
+
+<h3 id="minor_library_changes">Minor changes to the library</h3>
+
+<p>
+As always, there are various minor changes and updates to the library,
+made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
+in mind.
+</p>
+
+<dl id="bufio"><dt><a href="/pkg/bufio/">bufio</a></dt>
+
+<dd>
+<p>
+In previous releases of Go, if
+<a href="/pkg/bufio/#Reader"><code>Reader</code></a>'s
+<a href="/pkg/bufio/#Reader.Peek"><code>Peek</code></a> method
+were asked for more bytes than fit in the underlying buffer,
+it would return an empty slice and the error <code>ErrBufferFull</code>.
+Now it returns the entire underlying buffer, still accompanied by the error <code>ErrBufferFull</code>.
+</p>
+</dd>
+</dl>
+
+<dl id="bytes"><dt><a href="/pkg/bytes/">bytes</a></dt>
+
+<dd>
+<p>
+The new functions
+<a href="/pkg/bytes/#ContainsAny"><code>ContainsAny</code></a> and
+<a href="/pkg/bytes/#ContainsRune"><code>ContainsRune</code></a>
+have been added for symmetry with
+the <a href="/pkg/strings/"><code>strings</code></a> package.
+</p>
+
+<p>
+In previous releases of Go, if
+<a href="/pkg/bytes/#Reader"><code>Reader</code></a>'s
+<a href="/pkg/bytes/#Reader.Read"><code>Read</code></a> method
+were asked for zero bytes with no data remaining, it would
+return a count of 0 and no error.
+Now it returns a count of 0 and the error
+<a href="/pkg/io/#EOF"><code>io.EOF</code></a>.
+</p>
+
+<p>
+The
+<a href="/pkg/bytes/#Reader"><code>Reader</code></a> type has a new method
+<a href="/pkg/bytes/#Reader.Reset"><code>Reset</code></a> to allow reuse of a <code>Reader</code>.
+</p>
+</dd>
+</dl>
+
+<dl id="compress_flate"><dt><a href="/pkg/compress/flate/">compress/flate</a></dt>
+
+<dd>
+<p>
+There are many performance optimizations throughout the package.
+Decompression speed is improved by about 10%,
+while compression for <code>DefaultCompression</code> is twice as fast.
+</p>
+
+<p>
+In addition to those general improvements,
+the
+<code>BestSpeed</code>
+compressor has been replaced entirely and uses an
+algorithm similar to <a href="https://github.com/google/snappy">Snappy</a>,
+resulting in about a 2.5X speed increase,
+although the output can be 5-10% larger than with the previous algorithm.
+</p>
+
+<p>
+There is also a new compression level
+<code>HuffmanOnly</code>
+that applies Huffman but not Lempel-Ziv encoding.
+<a href="https://blog.klauspost.com/constant-time-gzipzip-compression/">Forgoing Lempel-Ziv encoding</a> means that
+<code>HuffmanOnly</code> runs about 3X faster than the new <code>BestSpeed</code>
+but at the cost of producing compressed outputs that are 20-40% larger than those
+generated by the new <code>BestSpeed</code>.
+</p>
+
+<p>
+It is important to note that both
+<code>BestSpeed</code> and <code>HuffmanOnly</code> produce a compressed output that is
+<a href="https://tools.ietf.org/html/rfc1951">RFC 1951</a> compliant.
+In other words, any valid DEFLATE decompressor will continue to be able to decompress these outputs.
+</p>
+
+<p>
+Lastly, there is a minor change to the decompressor's implementation of
+<a href="/pkg/io/#Reader"><code>io.Reader</code></a>. In previous versions,
+the decompressor deferred reporting
+<a href="/pkg/io/#EOF"><code>io.EOF</code></a> until exactly no more bytes could be read.
+Now, it reports
+<a href="/pkg/io/#EOF"><code>io.EOF</code></a> more eagerly when reading the last set of bytes.
+</p>
+</dd>
+</dl>
+
+<dl id="crypto_tls"><dt><a href="/pkg/crypto/tls/">crypto/tls</a></dt>
+
+<dd>
+<p>
+The TLS implementation sends the first few data packets on each connection
+using small record sizes, gradually increasing to the TLS maximum record size.
+This heuristic reduces the amount of data that must be received before
+the first packet can be decrypted, improving communication latency over
+low-bandwidth networks.
+Setting
+<a href="/pkg/crypto/tls/#Config"><code>Config</code></a>'s
+<code>DynamicRecordSizingDisabled</code> field to true
+forces the behavior of Go 1.6 and earlier, where packets are
+as large as possible from the start of the connection.
+</p>
+
+<p>
+The TLS client now has optional, limited support for server-initiated renegotiation,
+enabled by setting the
+<a href="/pkg/crypto/tls/#Config"><code>Config</code></a>'s
+<code>Renegotiation</code> field.
+This is needed for connecting to many Microsoft Azure servers.
+</p>
+
+<p>
+The errors returned by the package now consistently begin with a
+<code>tls:</code> prefix.
+In past releases, some errors used a <code>crypto/tls:</code> prefix,
+some used a <code>tls:</code> prefix, and some had no prefix at all.
+</p>
+
+<p>
+When generating self-signed certificates, the package no longer sets the
+“Authority Key Identifier” field by default.
+</p>
+</dd>
+</dl>
+
+<dl id="crypto_x509"><dt><a href="/pkg/crypto/x509/">crypto/x509</a></dt>
+
+<dd>
+<p>
+The new function
+<a href="/pkg/crypto/x509/#SystemCertPool"><code>SystemCertPool</code></a>
+provides access to the entire system certificate pool if available.
+There is also a new associated error type
+<a href="/pkg/crypto/x509/#SystemRootsError"><code>SystemRootsError</code></a>.
+</p>
+</dd>
+</dl>
+
+<dl id="debug_dwarf"><dt><a href="/pkg/debug/dwarf/">debug/dwarf</a></dt>
+
+<dd>
+<p>
+The
+<a href="/pkg/debug/dwarf/#Reader"><code>Reader</code></a> type's new
+<a href="/pkg/debug/dwarf/#Reader.SeekPC"><code>SeekPC</code></a> method and the
+<a href="/pkg/debug/dwarf/#Data"><code>Data</code></a> type's new
+<a href="/pkg/debug/dwarf/#Ranges"><code>Ranges</code></a> method
+help to find the compilation unit to pass to a
+<a href="/pkg/debug/dwarf/#LineReader"><code>LineReader</code></a>
+and to identify the specific function for a given program counter.
+</p>
+</dd>
+</dl>
+
+<dl id="debug_elf"><dt><a href="/pkg/debug/elf/">debug/elf</a></dt>
+
+<dd>
+<p>
+The new
+<a href="/pkg/debug/elf/#R_390"><code>R_390</code></a> relocation type
+and its many predefined constants
+support the S390 port.
+</p>
+</dd>
+</dl>
+
+<dl id="encoding_asn1"><dt><a href="/pkg/encoding/asn1/">encoding/asn1</a></dt>
+
+<dd>
+<p>
+The ASN.1 decoder now rejects non-minimal integer encodings.
+This may cause the package to reject some invalid but formerly accepted ASN.1 data.
+</p>
+</dd>
+</dl>
+
+<dl id="encoding_json"><dt><a href="/pkg/encoding/json/">encoding/json</a></dt>
+
+<dd>
+<p>
+The
+<a href="/pkg/encoding/json/#Encoder"><code>Encoder</code></a>'s new
+<a href="/pkg/encoding/json/#Encoder.SetIndent"><code>SetIndent</code></a> method
+sets the indentation parameters for JSON encoding,
+like in the top-level
+<a href="/pkg/encoding/json/#Indent"><code>Indent</code></a> function.
+</p>
+
+<p>
+The
+<a href="/pkg/encoding/json/#Encoder"><code>Encoder</code></a>'s new
+<a href="/pkg/encoding/json/#Encoder.SetEscapeHTML"><code>SetEscapeHTML</code></a> method
+controls whether the
+<code>&</code>, <code><</code>, and <code>></code>
+characters in quoted strings should be escaped as
+<code>\u0026</code>, <code>\u003c</code>, and <code>\u003e</code>,
+respectively.
+As in previous releases, the encoder defaults to applying this escaping,
+to avoid certain problems that can arise when embedding JSON in HTML.
+</p>
+
+<p>
+In earlier versions of Go, this package only supported encoding and decoding
+maps using keys with string types.
+Go 1.7 adds support for maps using keys with integer types:
+the encoding uses a quoted decimal representation as the JSON key.
+Go 1.7 also adds support for encoding maps using non-string keys that implement
+the <code>MarshalText</code>
+(see
+<a href="/pkg/encoding/#TextMarshaler"><code>encoding.TextMarshaler</code></a>)
+method,
+as well as support for decoding maps using non-string keys that implement
+the <code>UnmarshalText</code>
+(see
+<a href="/pkg/encoding/#TextUnmarshaler"><code>encoding.TextUnmarshaler</code></a>)
+method.
+These methods are ignored for keys with string types in order to preserve
+the encoding and decoding used in earlier versions of Go.
+</p>
+
+<p>
+When encoding a slice of typed bytes,
+<a href="/pkg/encoding/json/#Marshal"><code>Marshal</code></a>
+now generates an array of elements encoded using
+that byte type's
+<code>MarshalJSON</code>
+or
+<code>MarshalText</code>
+method if present,
+only falling back to the default base64-encoded string data if neither method is available.
+Earlier versions of Go accept both the original base64-encoded string encoding
+and the array encoding (assuming the byte type also implements
+<code>UnmarshalJSON</code>
+or
+<code>UnmarshalText</code>
+as appropriate),
+so this change should be semantically backwards compatible with earlier versions of Go,
+even though it does change the chosen encoding.
+</p>
+</dd>
+</dl>
+
+<dl id="go_build"><dt><a href="/pkg/go/build/">go/build</a></dt>
+
+<dd>
+<p>
+To implement the go command's new support for binary-only packages
+and for Fortran code in cgo-based packages,
+the
+<a href="/pkg/go/build/#Package"><code>Package</code></a> type
+adds new fields <code>BinaryOnly</code>, <code>CgoFFLAGS</code>, and <code>FFiles</code>.
+</p>
+</dd>
+</dl>
+
+<dl id="go_doc"><dt><a href="/pkg/go/doc/">go/doc</a></dt>
+
+<dd>
+<p>
+To support the corresponding change in <code>go</code> <code>test</code> described above,
+<a href="/pkg/go/doc/#Example"><code>Example</code></a> struct adds a Unordered field
+indicating whether the example may generate its output lines in any order.
+</p>
+</dd>
+</dl>
+
+<dl id="io"><dt><a href="/pkg/io/">io</a></dt>
+
+<dd>
+<p>
+The package adds new constants
+<code>SeekStart</code>, <code>SeekCurrent</code>, and <code>SeekEnd</code>,
+for use with
+<a href="/pkg/io/#Seeker"><code>Seeker</code></a>
+implementations.
+These constants are preferred over <code>os.SEEK_SET</code>, <code>os.SEEK_CUR</code>, and <code>os.SEEK_END</code>,
+but the latter will be preserved for compatibility.
+</p>
+</dd>
+</dl>
+
+<dl id="math_big"><dt><a href="/pkg/math/big/">math/big</a></dt>
+
+<dd>
+<p>
+The
+<a href="/pkg/math/big/#Float"><code>Float</code></a> type adds
+<a href="/pkg/math/big/#Float.GobEncode"><code>GobEncode</code></a> and
+<a href="/pkg/math/big/#Float.GobDecode"><code>GobDecode</code></a> methods,
+so that values of type <code>Float</code> can now be encoded and decoded using the
+<a href="/pkg/encoding/gob/"><code>encoding/gob</code></a>
+package.
+</p>
+</dd>
+</dl>
+
+<dl id="math_rand"><dt><a href="/pkg/math/rand/">math/rand</a></dt>
+
+<dd>
+<p>
+The
+<a href="/pkg/math/rand/#Read"><code>Read</code></a> function and
+<a href="/pkg/math/rand/#Rand"><code>Rand</code></a>'s
+<a href="/pkg/math/rand/#Rand.Read"><code>Read</code></a> method
+now produce a pseudo-random stream of bytes that is consistent and not
+dependent on the size of the input buffer.
+</p>
+
+<p>
+The documentation clarifies that
+Rand's <a href="/pkg/math/rand/#Rand.Seed"><code>Seed</code></a>
+and <a href="/pkg/math/rand/#Rand.Read"><code>Read</code></a> methods
+are not safe to call concurrently, though the global
+functions <a href="/pkg/math/rand/#Seed"><code>Seed</code></a>
+and <a href="/pkg/math/rand/#Read"><code>Read</code></a> are (and have
+always been) safe.
+</p>
+</dd>
+</dl>
+
+<dl id="mime_multipart"><dt><a href="/pkg/mime/multipart/">mime/multipart</a></dt>
+
+<dd>
+<p>
+The
+<a href="/pkg/mime/multipart/#Writer"><code>Writer</code></a>
+implementation now emits each multipart section's header sorted by key.
+Previously, iteration over a map caused the section header to use a
+non-deterministic order.
+</p>
+</dd>
+</dl>
+
+<dl id="net"><dt><a href="/pkg/net/">net</a></dt>
+
+<dd>
+<p>
+As part of the introduction of <a href="#context">context</a>, the
+<a href="/pkg/net/#Dialer"><code>Dialer</code></a> type has a new method
+<a href="/pkg/net/#Dialer.DialContext"><code>DialContext</code></a>, like
+<a href="/pkg/net/#Dialer.Dial"><code>Dial</code></a> but adding the
+<a href="/pkg/context/#Context"><code>context.Context</code></a>
+for the dial operation.
+The context is intended to obsolete the <code>Dialer</code>'s
+<code>Cancel</code> and <code>Deadline</code> fields,
+but the implementation continues to respect them,
+for backwards compatibility.
+</p>
+
+<p>
+The
+<a href="/pkg/net/#IP"><code>IP</code></a> type's
+<a href="/pkg/net/#IP.String"><code>String</code></a> method has changed its result for invalid <code>IP</code> addresses.
+In past releases, if an <code>IP</code> byte slice had length other than 0, 4, or 16, <code>String</code>
+returned <code>"?"</code>.
+Go 1.7 adds the hexadecimal encoding of the bytes, as in <code>"?12ab"</code>.
+</p>
+
+<p>
+The pure Go <a href="/pkg/net/#hdr-Name_Resolution">name resolution</a>
+implementation now respects <code>nsswitch.conf</code>'s
+stated preference for the priority of DNS lookups compared to
+local file (that is, <code>/etc/hosts</code>) lookups.
+</p>
+</dd>
+</dl>
+
+<dl id="net_http"><dt><a href="/pkg/net/http/">net/http</a></dt>
+
+<dd>
+<p>
+<a href="/pkg/net/http/#ResponseWriter"><code>ResponseWriter</code></a>'s
+documentation now makes clear that beginning to write the response
+may prevent future reads on the request body.
+For maximal compatibility, implementations are encouraged to
+read the request body completely before writing any part of the response.
+</p>
+
+<p>
+As part of the introduction of <a href="#context">context</a>, the
+<a href="/pkg/net/http/#Request"><code>Request</code></a> has a new methods
+<a href="/pkg/net/http/#Request.Context"><code>Context</code></a>, to retrieve the associated context, and
+<a href="/pkg/net/http/#Request.WithContext"><code>WithContext</code></a>, to construct a copy of <code>Request</code>
+with a modified context.
+</p>
+
+<p>
+In the
+<a href="/pkg/net/http/#Server"><code>Server</code></a> implementation,
+<a href="/pkg/net/http/#Server.Serve"><code>Serve</code></a> records in the request context
+both the underlying <code>*Server</code> using the key <code>ServerContextKey</code>
+and the local address on which the request was received (a
+<a href="/pkg/net/#Addr"><code>Addr</code></a>) using the key <code>LocalAddrContextKey</code>.
+For example, the address on which a request received is
+<code>req.Context().Value(http.LocalAddrContextKey).(net.Addr)</code>.
+</p>
+
+<p>
+The server's <a href="/pkg/net/http/#Server.Serve"><code>Serve</code></a> method
+now only enables HTTP/2 support if the <code>Server.TLSConfig</code> field is <code>nil</code>
+or includes <code>"h2"</code> in its <code>TLSConfig.NextProtos</code>.
+</p>
+
+<p>
+The server implementation now
+pads response codes less than 100 to three digits
+as required by the protocol,
+so that <code>w.WriteHeader(5)</code> uses the HTTP response
+status <code>005</code>, not just <code>5</code>.
+</p>
+
+<p>
+The server implementation now correctly sends only one "Transfer-Encoding" header when "chunked"
+is set explicitly, following <a href="https://tools.ietf.org/html/rfc7230#section-3.3.1">RFC 7230</a>.
+</p>
+
+<p>
+The server implementation is now stricter about rejecting requests with invalid HTTP versions.
+Invalid requests claiming to be HTTP/0.x are now rejected (HTTP/0.9 was never fully supported),
+and plaintext HTTP/2 requests other than the "PRI * HTTP/2.0" upgrade request are now rejected as well.
+The server continues to handle encrypted HTTP/2 requests.
+</p>
+
+<p>
+In the server, a 200 status code is sent back by the timeout handler on an empty
+response body, instead of sending back 0 as the status code.
+</p>
+
+<p>
+In the client, the
+<a href="/pkg/net/http/#Transport"><code>Transport</code></a> implementation passes the request context
+to any dial operation connecting to the remote server.
+If a custom dialer is needed, the new <code>Transport</code> field
+<code>DialContext</code> is preferred over the existing <code>Dial</code> field,
+to allow the transport to supply a context.
+</p>
+
+<p>
+The
+<a href="/pkg/net/http/#Transport"><code>Transport</code></a> also adds fields
+<code>IdleConnTimeout</code>,
+<code>MaxIdleConns</code>,
+and
+<code>MaxResponseHeaderBytes</code>
+to help control client resources consumed
+by idle or chatty servers.
+</p>
+
+<p>
+A
+<a href="/pkg/net/http/#Client"><code>Client</code></a>'s configured <code>CheckRedirect</code> function can now
+return <code>ErrUseLastResponse</code> to indicate that the
+most recent redirect response should be returned as the
+result of the HTTP request.
+That response is now available to the <code>CheckRedirect</code> function
+as <code>req.Response</code>.
+</p>
+
+<p>
+Since Go 1, the default behavior of the HTTP client is
+to request server-side compression
+using the <code>Accept-Encoding</code> request header
+and then to decompress the response body transparently,
+and this behavior is adjustable using the
+<a href="/pkg/net/http/#Transport"><code>Transport</code></a>'s <code>DisableCompression</code> field.
+In Go 1.7, to aid the implementation of HTTP proxies, the
+<a href="/pkg/net/http/#Response"><code>Response</code></a>'s new
+<code>Uncompressed</code> field reports whether
+this transparent decompression took place.
+</p>
+
+<p>
+<a href="/pkg/net/http/#DetectContentType"><code>DetectContentType</code></a>
+adds support for a few new audio and video content types.
+</p>
+</dd>
+</dl>
+
+<dl id="net_http_cgi"><dt><a href="/pkg/net/http/cgi/">net/http/cgi</a></dt>
+
+<dd>
+<p>
+The
+<a href="/pkg/net/http/cgi/#Handler"><code>Handler</code></a>
+adds a new field
+<code>Stderr</code>
+that allows redirection of the child process's
+standard error away from the host process's
+standard error.
+</p>
+</dd>
+</dl>
+
+<dl id="net_http_httptest"><dt><a href="/pkg/net/http/httptest/">net/http/httptest</a></dt>
+
+<dd>
+<p>
+The new function
+<a href="/pkg/net/http/httptest/#NewRequest"><code>NewRequest</code></a>
+prepares a new
+<a href="/pkg/net/http/#Request"><code>http.Request</code></a>
+suitable for passing to an
+<a href="/pkg/net/http/#Handler"><code>http.Handler</code></a> during a test.
+</p>
+
+<p>
+The
+<a href="/pkg/net/http/httptest/#ResponseRecorder"><code>ResponseRecorder</code></a>'s new
+<a href="/pkg/net/http/httptest/#ResponseRecorder.Result"><code>Result</code></a> method
+returns the recorded
+<a href="/pkg/net/http/#Response"><code>http.Response</code></a>.
+Tests that need to check the response's headers or trailers
+should call <code>Result</code> and inspect the response fields
+instead of accessing
+<code>ResponseRecorder</code>'s <code>HeaderMap</code> directly.
+</p>
+</dd>
+</dl>
+
+<dl id="net_http_httputil"><dt><a href="/pkg/net/http/httputil/">net/http/httputil</a></dt>
+
+<dd>
+<p>
+The
+<a href="/pkg/net/http/httputil/#ReverseProxy"><code>ReverseProxy</code></a> implementation now responds with “502 Bad Gateway”
+when it cannot reach a back end; in earlier releases it responded with “500 Internal Server Error.”
+</p>
+
+<p>
+Both
+<a href="/pkg/net/http/httputil/#ClientConn"><code>ClientConn</code></a> and
+<a href="/pkg/net/http/httputil/#ServerConn"><code>ServerConn</code></a> have been documented as deprecated.
+They are low-level, old, and unused by Go's current HTTP stack
+and will no longer be updated.
+Programs should use
+<a href="/pkg/net/http/#Client"><code>http.Client</code></a>,
+<a href="/pkg/net/http/#Transport"><code>http.Transport</code></a>,
+and
+<a href="/pkg/net/http/#Server"><code>http.Server</code></a>
+instead.
+</p>
+</dd>
+</dl>
+
+<dl id="net_http_pprof"><dt><a href="/pkg/net/http/pprof/">net/http/pprof</a></dt>
+
+<dd>
+<p>
+The runtime trace HTTP handler, installed to handle the path <code>/debug/pprof/trace</code>,
+now accepts a fractional number in its <code>seconds</code> query parameter,
+allowing collection of traces for intervals smaller than one second.
+This is especially useful on busy servers.
+</p>
+</dd>
+</dl>
+
+<dl><dt><a href="/pkg/net/mail/">net/mail</a></dt>
+
+<dd>
+<p>
+The address parser now allows unescaped UTF-8 text in addresses
+following <a href="https://tools.ietf.org/html/rfc6532">RFC 6532</a>,
+but it does not apply any normalization to the result.
+For compatibility with older mail parsers,
+the address encoder, namely
+<a href="/pkg/net/mail/#Address"><code>Address</code></a>'s
+<a href="/pkg/net/mail/#Address.String"><code>String</code></a> method,
+continues to escape all UTF-8 text following <a href="https://tools.ietf.org/html/rfc5322">RFC 5322</a>.
+</p>
+
+<p>
+The <a href="/pkg/net/mail/#ParseAddress"><code>ParseAddress</code></a>
+function and
+the <a href="/pkg/net/mail/#AddressParser.Parse"><code>AddressParser.Parse</code></a>
+method are stricter.
+They used to ignore any characters following an e-mail address, but
+will now return an error for anything other than whitespace.
+</p>
+</dd>
+</dl>
+
+<dl id="net_url"><dt><a href="/pkg/net/url/">net/url</a></dt>
+
+<dd>
+<p>
+The
+<a href="/pkg/net/url/#URL"><code>URL</code></a>'s
+new <code>ForceQuery</code> field
+records whether the URL must have a query string,
+in order to distinguish URLs without query strings (like <code>/search</code>)
+from URLs with empty query strings (like <code>/search?</code>).
+</p>
+</dd>
+</dl>
+
+<dl id="os"><dt><a href="/pkg/os/">os</a></dt>
+
+<dd>
+<p>
+<a href="/pkg/os/#IsExist"><code>IsExist</code></a> now returns true for <code>syscall.ENOTEMPTY</code>,
+on systems where that error exists.
+</p>
+
+<p>
+On Windows,
+<a href="/pkg/os/#Remove"><code>Remove</code></a> now removes read-only files when possible,
+making the implementation behave as on
+non-Windows systems.
+</p>
+</dd>
+</dl>
+
+<dl id="os_exec"><dt><a href="/pkg/os/exec/">os/exec</a></dt>
+
+<dd>
+<p>
+As part of the introduction of <a href="#context">context</a>,
+the new constructor
+<a href="/pkg/os/exec/#CommandContext"><code>CommandContext</code></a>
+is like
+<a href="/pkg/os/exec/#Command"><code>Command</code></a> but includes a context that can be used to cancel the command execution.
+</p>
+</dd>
+</dl>
+
+<dl id="os_user"><dt><a href="/pkg/os/user/">os/user</a></dt>
+
+<dd>
+<p>
+The
+<a href="/pkg/os/user/#Current"><code>Current</code></a>
+function is now implemented even when cgo is not available.
+</p>
+
+<p>
+The new
+<a href="/pkg/os/user/#Group"><code>Group</code></a> type,
+along with the lookup functions
+<a href="/pkg/os/user/#LookupGroup"><code>LookupGroup</code></a> and
+<a href="/pkg/os/user/#LookupGroupId"><code>LookupGroupId</code></a>
+and the new field <code>GroupIds</code> in the <code>User</code> struct,
+provides access to system-specific user group information.
+</p>
+</dd>
+</dl>
+
+<dl id="reflect"><dt><a href="/pkg/reflect/">reflect</a></dt>
+
+<dd>
+<p>
+Although
+<a href="/pkg/reflect/#Value"><code>Value</code></a>'s
+<a href="/pkg/reflect/#Value.Field"><code>Field</code></a> method has always been documented to panic
+if the given field number <code>i</code> is out of range, it has instead
+silently returned a zero
+<a href="/pkg/reflect/#Value"><code>Value</code></a>.
+Go 1.7 changes the method to behave as documented.
+</p>
+
+<p>
+The new
+<a href="/pkg/reflect/#StructOf"><code>StructOf</code></a>
+function constructs a struct type at run time.
+It completes the set of type constructors, joining
+<a href="/pkg/reflect/#ArrayOf"><code>ArrayOf</code></a>,
+<a href="/pkg/reflect/#ChanOf"><code>ChanOf</code></a>,
+<a href="/pkg/reflect/#FuncOf"><code>FuncOf</code></a>,
+<a href="/pkg/reflect/#MapOf"><code>MapOf</code></a>,
+<a href="/pkg/reflect/#PtrTo"><code>PtrTo</code></a>,
+and
+<a href="/pkg/reflect/#SliceOf"><code>SliceOf</code></a>.
+</p>
+
+<p>
+<a href="/pkg/reflect/#StructTag"><code>StructTag</code></a>'s
+new method
+<a href="/pkg/reflect/#StructTag.Lookup"><code>Lookup</code></a>
+is like
+<a href="/pkg/reflect/#StructTag.Get"><code>Get</code></a>
+but distinguishes the tag not containing the given key
+from the tag associating an empty string with the given key.
+</p>
+
+<p>
+The
+<a href="/pkg/reflect/#Type.Method"><code>Method</code></a> and
+<a href="/pkg/reflect/#Type.NumMethod"><code>NumMethod</code></a>
+methods of
+<a href="/pkg/reflect/#Type"><code>Type</code></a> and
+<a href="/pkg/reflect/#Value"><code>Value</code></a>
+no longer return or count unexported methods.
+</p>
+</dd>
+</dl>
+
+<dl id="strings"><dt><a href="/pkg/strings/">strings</a></dt>
+
+<dd>
+<p>
+In previous releases of Go, if
+<a href="/pkg/strings/#Reader"><code>Reader</code></a>'s
+<a href="/pkg/strings/#Reader.Read"><code>Read</code></a> method
+were asked for zero bytes with no data remaining, it would
+return a count of 0 and no error.
+Now it returns a count of 0 and the error
+<a href="/pkg/io/#EOF"><code>io.EOF</code></a>.
+</p>
+
+<p>
+The
+<a href="/pkg/strings/#Reader"><code>Reader</code></a> type has a new method
+<a href="/pkg/strings/#Reader.Reset"><code>Reset</code></a> to allow reuse of a <code>Reader</code>.
+</p>
+</dd>
+</dl>
+
+<dl id="time"><dt><a href="/pkg/time/">time</a></dt>
+
+<dd>
+<p>
+<a href="/pkg/time/#Duration"><code>Duration</code></a>'s
+time.Duration.String method now reports the zero duration as <code>"0s"</code>, not <code>"0"</code>.
+<a href="/pkg/time/#ParseDuration"><code>ParseDuration</code></a> continues to accept both forms.
+</p>
+
+<p>
+The method call <code>time.Local.String()</code> now returns <code>"Local"</code> on all systems;
+in earlier releases, it returned an empty string on Windows.
+</p>
+
+<p>
+The time zone database in
+<code>$GOROOT/lib/time</code> has been updated
+to IANA release 2016d.
+This fallback database is only used when the system time zone database
+cannot be found, for example on Windows.
+The Windows time zone abbreviation list has also been updated.
+</p>
+</dd>
+</dl>
+
+<dl id="syscall"><dt><a href="/pkg/syscall/">syscall</a></dt>
+
+<dd>
+<p>
+On Linux, the
+<a href="/pkg/syscall/#SysProcAttr"><code>SysProcAttr</code></a> struct
+(as used in
+<a href="/pkg/os/exec/#Cmd"><code>os/exec.Cmd</code></a>'s <code>SysProcAttr</code> field)
+has a new <code>Unshareflags</code> field.
+If the field is nonzero, the child process created by
+<a href="/pkg/syscall/#ForkExec"><code>ForkExec</code></a>
+(as used in <code>exec.Cmd</code>'s <code>Run</code> method)
+will call the
+<a href="http://man7.org/linux/man-pages/man2/unshare.2.html"><i>unshare</i>(2)</a>
+system call before executing the new program.
+</p>
+</dd>
+</dl>
+
+
+<dl id="unicode"><dt><a href="/pkg/unicode/">unicode</a></dt>
+
+<dd>
+<p>
+The <a href="/pkg/unicode/"><code>unicode</code></a> package and associated
+support throughout the system has been upgraded from version 8.0 to
+<a href="http://www.unicode.org/versions/Unicode9.0.0/">Unicode 9.0</a>.
+</p>
+</dd>
+</dl>
diff --git a/_content/doc/go1.8.html b/_content/doc/go1.8.html
new file mode 100644
index 0000000..adb8991
--- /dev/null
+++ b/_content/doc/go1.8.html
@@ -0,0 +1,1665 @@
+<!--{
+ "Title": "Go 1.8 Release Notes",
+ "Template": true
+}-->
+
+<!--
+NOTE: In this document and others in this directory, the convention is to
+set fixed-width phrases with non-fixed-width spaces, as in
+<code>hello</code> <code>world</code>.
+Do not send CLs removing the interior tags from such phrases.
+-->
+
+<style>
+ main ul li { margin: 0.5em 0; }
+</style>
+
+<h2 id="introduction">Introduction to Go 1.8</h2>
+
+<p>
+The latest Go release, version 1.8, arrives six months after <a href="go1.7">Go 1.7</a>.
+Most of its changes are in the implementation of the toolchain, runtime, and libraries.
+There are <a href="#language">two minor changes</a> to the language specification.
+As always, the release maintains the Go 1 <a href="/doc/go1compat.html">promise of compatibility</a>.
+We expect almost all Go programs to continue to compile and run as before.
+</p>
+
+<p>
+The release <a href="#ports">adds support for 32-bit MIPS</a>,
+<a href="#compiler">updates the compiler back end</a> to generate more efficient code,
+<a href="#gc">reduces GC pauses</a> by eliminating stop-the-world stack rescanning,
+<a href="#h2push">adds HTTP/2 Push support</a>,
+<a href="#http_shutdown">adds HTTP graceful shutdown</a>,
+<a href="#more_context">adds more context support</a>,
+<a href="#mutex_prof">enables profiling mutexes</a>,
+and <a href="#sort_slice">simplifies sorting slices</a>.
+</p>
+
+<h2 id="language">Changes to the language</h2>
+
+<p>
+ When explicitly converting a value from one struct type to another,
+ as of Go 1.8 the tags are ignored. Thus two structs that differ
+ only in their tags may be converted from one to the other:
+</p>
+
+<pre>
+func example() {
+ type T1 struct {
+ X int `json:"foo"`
+ }
+ type T2 struct {
+ X int `json:"bar"`
+ }
+ var v1 T1
+ var v2 T2
+ v1 = T1(v2) // now legal
+}
+</pre>
+
+
+<p> <!-- CL 17711 -->
+ The language specification now only requires that implementations
+ support up to 16-bit exponents in floating-point constants. This does not affect
+ either the “<a href="/cmd/compile/"><code>gc</code></a>” or
+ <code>gccgo</code> compilers, both of
+ which still support 32-bit exponents.
+</p>
+
+<h2 id="ports">Ports</h2>
+
+<p>
+Go now supports 32-bit MIPS on Linux for both big-endian
+(<code>linux/mips</code>) and little-endian machines
+(<code>linux/mipsle</code>) that implement the MIPS32r1 instruction set with FPU
+or kernel FPU emulation. Note that many common MIPS-based routers lack an FPU and
+have firmware that doesn't enable kernel FPU emulation; Go won't run on such machines.
+</p>
+
+<p>
+On DragonFly BSD, Go now requires DragonFly 4.4.4 or later. <!-- CL 29491, CL 29971 -->
+</p>
+
+<p>
+On OpenBSD, Go now requires OpenBSD 5.9 or later. <!-- CL 34093 -->
+</p>
+
+<p>
+The Plan 9 port's networking support is now much more complete
+and matches the behavior of Unix and Windows with respect to deadlines
+and cancelation. For Plan 9 kernel requirements, see the
+<a href="https://golang.org/wiki/Plan9">Plan 9 wiki page</a>.
+</p>
+
+<p>
+ Go 1.8 now only supports OS X 10.8 or later. This is likely the last
+ Go release to support 10.8. Compiling Go or running
+ binaries on older OS X versions is untested.
+</p>
+
+<p>
+ Go 1.8 will be the last release to support Linux on ARMv5E and ARMv6 processors:
+ Go 1.9 will likely require the ARMv6K (as found in the Raspberry Pi 1) or later.
+ To identify whether a Linux system is ARMv6K or later, run
+ “<code>go</code> <code>tool</code> <code>dist</code> <code>-check-armv6k</code>”
+ (to facilitate testing, it is also possible to just copy the <code>dist</code> command to the
+ system without installing a full copy of Go 1.8)
+ and if the program terminates with output "ARMv6K supported." then the system
+ implements ARMv6K or later.
+ Go on non-Linux ARM systems already requires ARMv6K or later.
+</p>
+
+
+<h3 id="known_issues">Known Issues</h3>
+
+<p>
+There are some instabilities on FreeBSD and NetBSD that are known but not understood.
+These can lead to program crashes in rare cases.
+See
+<a href="https://golang.org/issue/15658">issue 15658</a> and
+<a href="https://golang.org/issue/16511">issue 16511</a>.
+Any help in solving these issues would be appreciated.
+</p>
+
+<h2 id="tools">Tools</h2>
+
+<h3 id="cmd_asm">Assembler</h3>
+
+<p>
+For 64-bit x86 systems, the following instructions have been added:
+<code>VBROADCASTSD</code>,
+<code>BROADCASTSS</code>,
+<code>MOVDDUP</code>,
+<code>MOVSHDUP</code>,
+<code>MOVSLDUP</code>,
+<code>VMOVDDUP</code>,
+<code>VMOVSHDUP</code>, and
+<code>VMOVSLDUP</code>.
+</p>
+
+<p>
+For 64-bit PPC systems, the common vector scalar instructions have been
+added:
+<code>LXS</code>,
+<code>LXSDX</code>,
+<code>LXSI</code>,
+<code>LXSIWAX</code>,
+<code>LXSIWZX</code>,
+<code>LXV</code>,
+<code>LXVD2X</code>,
+<code>LXVDSX</code>,
+<code>LXVW4X</code>,
+<code>MFVSR</code>,
+<code>MFVSRD</code>,
+<code>MFVSRWZ</code>,
+<code>MTVSR</code>,
+<code>MTVSRD</code>,
+<code>MTVSRWA</code>,
+<code>MTVSRWZ</code>,
+<code>STXS</code>,
+<code>STXSDX</code>,
+<code>STXSI</code>,
+<code>STXSIWX</code>,
+<code>STXV</code>,
+<code>STXVD2X</code>,
+<code>STXVW4X</code>,
+<code>XSCV</code>,
+<code>XSCVDPSP</code>,
+<code>XSCVDPSPN</code>,
+<code>XSCVDPSXDS</code>,
+<code>XSCVDPSXWS</code>,
+<code>XSCVDPUXDS</code>,
+<code>XSCVDPUXWS</code>,
+<code>XSCVSPDP</code>,
+<code>XSCVSPDPN</code>,
+<code>XSCVSXDDP</code>,
+<code>XSCVSXDSP</code>,
+<code>XSCVUXDDP</code>,
+<code>XSCVUXDSP</code>,
+<code>XSCVX</code>,
+<code>XSCVXP</code>,
+<code>XVCV</code>,
+<code>XVCVDPSP</code>,
+<code>XVCVDPSXDS</code>,
+<code>XVCVDPSXWS</code>,
+<code>XVCVDPUXDS</code>,
+<code>XVCVDPUXWS</code>,
+<code>XVCVSPDP</code>,
+<code>XVCVSPSXDS</code>,
+<code>XVCVSPSXWS</code>,
+<code>XVCVSPUXDS</code>,
+<code>XVCVSPUXWS</code>,
+<code>XVCVSXDDP</code>,
+<code>XVCVSXDSP</code>,
+<code>XVCVSXWDP</code>,
+<code>XVCVSXWSP</code>,
+<code>XVCVUXDDP</code>,
+<code>XVCVUXDSP</code>,
+<code>XVCVUXWDP</code>,
+<code>XVCVUXWSP</code>,
+<code>XVCVX</code>,
+<code>XVCVXP</code>,
+<code>XXLAND</code>,
+<code>XXLANDC</code>,
+<code>XXLANDQ</code>,
+<code>XXLEQV</code>,
+<code>XXLNAND</code>,
+<code>XXLNOR</code>,
+<code>XXLOR</code>,
+<code>XXLORC</code>,
+<code>XXLORQ</code>,
+<code>XXLXOR</code>,
+<code>XXMRG</code>,
+<code>XXMRGHW</code>,
+<code>XXMRGLW</code>,
+<code>XXPERM</code>,
+<code>XXPERMDI</code>,
+<code>XXSEL</code>,
+<code>XXSI</code>,
+<code>XXSLDWI</code>,
+<code>XXSPLT</code>, and
+<code>XXSPLTW</code>.
+</p>
+
+<h3 id="tool_yacc">Yacc</h3>
+
+<p> <!-- CL 27324, CL 27325 -->
+The <code>yacc</code> tool (previously available by running
+“<code>go</code> <code>tool</code> <code>yacc</code>”) has been removed.
+As of Go 1.7 it was no longer used by the Go compiler.
+It has moved to the “tools” repository and is now available at
+<code><a href="https://godoc.org/golang.org/x/tools/cmd/goyacc">golang.org/x/tools/cmd/goyacc</a></code>.
+</p>
+
+<h3 id="tool_fix">Fix</h3>
+
+<p> <!-- CL 28872 -->
+ The <code>fix</code> tool has a new “<code>context</code>”
+ fix to change imports from “<code>golang.org/x/net/context</code>”
+ to “<a href="/pkg/context/"><code>context</code></a>”.
+</p>
+
+<h3 id="tool_pprof">Pprof</h3>
+
+<p> <!-- CL 33157 -->
+ The <code>pprof</code> tool can now profile TLS servers
+ and skip certificate validation by using the “<code>https+insecure</code>”
+ URL scheme.
+</p>
+
+<p> <!-- CL 23781 -->
+ The callgrind output now has instruction-level granularity.
+</p>
+
+<h3 id="tool_trace">Trace</h3>
+
+<p> <!-- CL 23324 -->
+ The <code>trace</code> tool has a new <code>-pprof</code> flag for
+ producing pprof-compatible blocking and latency profiles from an
+ execution trace.
+</p>
+
+<p> <!-- CL 30017, CL 30702 -->
+ Garbage collection events are now shown more clearly in the
+ execution trace viewer. Garbage collection activity is shown on its
+ own row and GC helper goroutines are annotated with their roles.
+</p>
+
+<h3 id="tool_vet">Vet</h3>
+
+<p>Vet is stricter in some ways and looser where it
+ previously caused false positives.</p>
+
+<p>Vet now checks for copying an array of locks,
+ duplicate JSON and XML struct field tags,
+ non-space-separated struct tags,
+ deferred calls to HTTP <code>Response.Body.Close</code>
+ before checking errors, and
+ indexed arguments in <code>Printf</code>.
+ It also improves existing checks.</p>
+</p>
+
+<h3 id="compiler">Compiler Toolchain</h3>
+
+<p>
+Go 1.7 introduced a new compiler back end for 64-bit x86 systems.
+In Go 1.8, that back end has been developed further and is now used for
+all architectures.
+</p>
+
+<p>
+The new back end, based on
+<a href="https://en.wikipedia.org/wiki/Static_single_assignment_form">static single assignment form</a> (SSA),
+generates more compact, more efficient code
+and provides a better platform for optimizations
+such as bounds check elimination.
+The new back end reduces the CPU time required by
+<a href="https://golang.org/test/bench/go1/">our benchmark programs</a> by 20-30%
+on 32-bit ARM systems. For 64-bit x86 systems, which already used the SSA back end in
+Go 1.7, the gains are a more modest 0-10%. Other architectures will likely
+see improvements closer to the 32-bit ARM numbers.
+</p>
+
+<p>
+ The temporary <code>-ssa=0</code> compiler flag introduced in Go 1.7
+ to disable the new back end has been removed in Go 1.8.
+</p>
+
+<p>
+ In addition to enabling the new compiler back end for all systems,
+ Go 1.8 also introduces a new compiler front end. The new compiler
+ front end should not be noticeable to users but is the foundation for
+ future performance work.
+</p>
+
+<p>
+ The compiler and linker have been optimized and run faster in this
+ release than in Go 1.7, although they are still slower than we would
+ like and will continue to be optimized in future releases.
+ Compared to the previous release, Go 1.8 is
+ <a href="https://dave.cheney.net/2016/11/19/go-1-8-toolchain-improvements">about 15% faster</a>.
+</p>
+
+<h3 id="cmd_cgo">Cgo</h3>
+
+<p> <!-- CL 31141 -->
+The Go tool now remembers the value of the <code>CGO_ENABLED</code> environment
+variable set during <code>make.bash</code> and applies it to all future compilations
+by default to fix issue <a href="https://golang.org/issue/12808">#12808</a>.
+When doing native compilation, it is rarely necessary to explicitly set
+the <code>CGO_ENABLED</code> environment variable as <code>make.bash</code>
+will detect the correct setting automatically. The main reason to explicitly
+set the <code>CGO_ENABLED</code> environment variable is when your environment
+supports cgo, but you explicitly do not want cgo support, in which case, set
+<code>CGO_ENABLED=0</code> during <code>make.bash</code> or <code>all.bash</code>.
+</p>
+
+<p> <!-- CL 29991 -->
+The environment variable <code>PKG_CONFIG</code> may now be used to
+set the program to run to handle <code>#cgo</code> <code>pkg-config</code>
+directives. The default is <code>pkg-config</code>, the program
+always used by earlier releases. This is intended to make it easier
+to cross-compile
+<a href="/cmd/cgo/">cgo</a> code.
+</p>
+
+<p> <!-- CL 32354 -->
+The <a href="/cmd/cgo/">cgo</a> tool now supports a <code>-srcdir</code>
+option, which is used by the <a href="/cmd/go/">go</a> command.
+</p>
+
+<p> <!-- CL 31768, 31811 -->
+If <a href="/cmd/cgo/">cgo</a> code calls <code>C.malloc</code>, and
+<code>malloc</code> returns <code>NULL</code>, the program will now
+crash with an out of memory error.
+<code>C.malloc</code> will never return <code>nil</code>.
+Unlike most C functions, <code>C.malloc</code> may not be used in a
+two-result form returning an errno value.
+</p>
+
+<p> <!-- CL 33237 -->
+If <a href="/cmd/cgo/">cgo</a> is used to call a C function passing a
+pointer to a C union, and if the C union can contain any pointer
+values, and if <a href="/cmd/cgo/#hdr-Passing_pointers">cgo pointer
+checking</a> is enabled (as it is by default), the union value is now
+checked for Go pointers.
+</p>
+
+<h3 id="gccgo">Gccgo</h3>
+
+<p>
+Due to the alignment of Go's semiannual release schedule with GCC's
+annual release schedule,
+GCC release 6 contains the Go 1.6.1 version of gccgo.
+We expect that the next release, GCC 7, will contain the Go 1.8
+version of gccgo.
+</p>
+
+<h3 id="gopath">Default GOPATH</h3>
+
+<p>
+ The
+ <a href="/cmd/go/#hdr-GOPATH_environment_variable"><code>GOPATH</code>
+ environment variable</a> now has a default value if it
+ is unset. It defaults to
+ <code>$HOME/go</code> on Unix and
+ <code>%USERPROFILE%/go</code> on Windows.
+</p>
+
+<h3 id="go_get">Go get</h3>
+
+<p> <!-- CL 34818 -->
+ The “<code>go</code> <code>get</code>” command now always respects
+ HTTP proxy environment variables, regardless of whether
+ the <code style='white-space:nowrap'>-insecure</code> flag is used. In previous releases, the
+ <code style='white-space:nowrap'>-insecure</code> flag had the side effect of not using proxies.
+</p>
+
+<h3 id="go_bug">Go bug</h3>
+
+<p>
+ The new
+ “<a href="/cmd/go/#hdr-Print_information_for_bug_reports"><code>go</code> <code>bug</code></a>”
+ command starts a bug report on GitHub, prefilled
+ with information about the current system.
+</p>
+
+<h3 id="cmd_doc">Go doc</h3>
+
+<p> <!-- CL 25419 -->
+ The
+ “<a href="/cmd/go/#hdr-Show_documentation_for_package_or_symbol"><code>go</code> <code>doc</code></a>”
+ command now groups constants and variables with their type,
+ following the behavior of
+ <a href="/cmd/godoc/"><code>godoc</code></a>.
+</p>
+
+<p> <!-- CL 25420 -->
+ In order to improve the readability of <code>doc</code>'s
+ output, each summary of the first-level items is guaranteed to
+ occupy a single line.
+</p>
+
+<p> <!-- CL 31852 -->
+ Documentation for a specific method in an interface definition can
+ now be requested, as in
+ “<code>go</code> <code>doc</code> <code>net.Conn.SetDeadline</code>”.
+</p>
+
+<h3 id="plugin">Plugins</h3>
+
+<p>
+ Go now provides early support for plugins with a “<code>plugin</code>”
+ build mode for generating plugins written in Go, and a
+ new <a href="/pkg/plugin/"><code>plugin</code></a> package for
+ loading such plugins at run time. Plugin support is currently only
+ available on Linux. Please report any issues.
+</p>
+
+<h2 id="runtime">Runtime</h2>
+
+<h3 id="liveness">Argument Liveness</h3>
+
+<p>
+ <!-- Issue 15843 --> The garbage collector no longer considers
+ arguments live throughout the entirety of a function. For more
+ information, and for how to force a variable to remain live, see
+ the <a href="/pkg/runtime/#KeepAlive"><code>runtime.KeepAlive</code></a>
+ function added in Go 1.7.
+</p>
+
+<p>
+ <i>Updating:</i>
+ Code that sets a finalizer on an allocated object may need to add
+ calls to <code>runtime.KeepAlive</code> in functions or methods
+ using that object.
+ Read the
+ <a href="/pkg/runtime/#KeepAlive"><code>KeepAlive</code>
+ documentation</a> and its example for more details.
+</p>
+
+<h3 id="mapiter">Concurrent Map Misuse</h3>
+
+<p>
+In Go 1.6, the runtime
+<a href="/doc/go1.6#runtime">added lightweight,
+best-effort detection of concurrent misuse of maps</a>. This release
+improves that detector with support for detecting programs that
+concurrently write to and iterate over a map.
+</p>
+<p>
+As always, if one goroutine is writing to a map, no other goroutine should be
+reading (which includes iterating) 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 the program
+under the
+<a href="https://blog.golang.org/race-detector">race detector</a>,
+which will more reliably identify the race
+and give more detail.
+</p>
+
+<h3 id="memstats">MemStats Documentation</h3>
+
+<p> <!-- CL 28972 -->
+ The <a href="/pkg/runtime/#MemStats"><code>runtime.MemStats</code></a>
+ type has been more thoroughly documented.
+</p>
+
+<h2 id="performance">Performance</h2>
+
+<p>
+As always, the changes are so general and varied that precise statements
+about performance are difficult to make.
+Most programs should run a bit faster,
+due to speedups in the garbage collector and
+optimizations in the standard library.
+</p>
+
+<p>
+There have been optimizations to implementations in the
+<a href="/pkg/bytes/"><code>bytes</code></a>,
+<a href="/pkg/crypto/aes/"><code>crypto/aes</code></a>,
+<a href="/pkg/crypto/cipher/"><code>crypto/cipher</code></a>,
+<a href="/pkg/crypto/elliptic/"><code>crypto/elliptic</code></a>,
+<a href="/pkg/crypto/sha256/"><code>crypto/sha256</code></a>,
+<a href="/pkg/crypto/sha512/"><code>crypto/sha512</code></a>,
+<a href="/pkg/encoding/asn1/"><code>encoding/asn1</code></a>,
+<a href="/pkg/encoding/csv/"><code>encoding/csv</code></a>,
+<a href="/pkg/encoding/hex/"><code>encoding/hex</code></a>,
+<a href="/pkg/encoding/json/"><code>encoding/json</code></a>,
+<a href="/pkg/hash/crc32/"><code>hash/crc32</code></a>,
+<a href="/pkg/image/color/"><code>image/color</code></a>,
+<a href="/pkg/image/draw/"><code>image/draw</code></a>,
+<a href="/pkg/math/"><code>math</code></a>,
+<a href="/pkg/math/big/"><code>math/big</code></a>,
+<a href="/pkg/reflect/"><code>reflect</code></a>,
+<a href="/pkg/regexp/"><code>regexp</code></a>,
+<a href="/pkg/runtime/"><code>runtime</code></a>,
+<a href="/pkg/strconv/"><code>strconv</code></a>,
+<a href="/pkg/strings/"><code>strings</code></a>,
+<a href="/pkg/syscall/"><code>syscall</code></a>,
+<a href="/pkg/text/template/"><code>text/template</code></a>, and
+<a href="/pkg/unicode/utf8/"><code>unicode/utf8</code></a>
+packages.
+</p>
+
+<h3 id="gc">Garbage Collector</h3>
+
+<p>
+ Garbage collection pauses should be significantly shorter than they
+ were in Go 1.7, usually under 100 microseconds and often as low as
+ 10 microseconds.
+ See the
+ <a href="https://github.com/golang/proposal/blob/master/design/17503-eliminate-rescan.md"
+ >document on eliminating stop-the-world stack re-scanning</a>
+ for details. More work remains for Go 1.9.
+</p>
+
+<h3 id="defer">Defer</h3>
+
+<!-- CL 29656, CL 29656 -->
+<p>
+ The overhead of <a href="/ref/spec/#Defer_statements">deferred
+ function calls</a> has been reduced by about half.
+</p>
+
+<h3 id="cgoperf">Cgo</h3>
+
+<p>The overhead of calls from Go into C has been reduced by about half.</p>
+
+<h2 id="library">Standard library</h2>
+
+<h3 id="examples">Examples</h3>
+
+<p>
+Examples have been added to the documentation across many packages.
+</p>
+
+<h3 id="sort_slice">Sort</h3>
+
+<p>
+The <a href="/pkg/sort/">sort</a> package
+now includes a convenience function
+<a href="/pkg/sort/#Slice"><code>Slice</code></a> to sort a
+slice given a <em>less</em> function.
+
+In many cases this means that writing a new sorter type is not
+necessary.
+</p>
+
+<p>
+Also new are
+<a href="/pkg/sort/#SliceStable"><code>SliceStable</code></a> and
+<a href="/pkg/sort/#SliceIsSorted"><code>SliceIsSorted</code></a>.
+</p>
+
+<h3 id="h2push">HTTP/2 Push</h3>
+
+<p>
+The <a href="/pkg/net/http/">net/http</a> package now includes a
+mechanism to
+send HTTP/2 server pushes from a
+<a href="/pkg/net/http/#Handler"><code>Handler</code></a>.
+Similar to the existing <code>Flusher</code> and <code>Hijacker</code>
+interfaces, an HTTP/2
+<a href="/pkg/net/http/#ResponseWriter"><code>ResponseWriter</code></a>
+now implements the new
+<a href="/pkg/net/http/#Pusher"><code>Pusher</code></a> interface.
+</p>
+
+<h3 id="http_shutdown">HTTP Server Graceful Shutdown</h3>
+
+<p> <!-- CL 32329 -->
+ The HTTP Server now has support for graceful shutdown using the new
+ <a href="/pkg/net/http/#Server.Shutdown"><code>Server.Shutdown</code></a>
+ method and abrupt shutdown using the new
+ <a href="/pkg/net/http/#Server.Close"><code>Server.Close</code></a>
+ method.
+</p>
+
+<h3 id="more_context">More Context Support</h3>
+
+<p>
+ Continuing <a href="/doc/go1.7#context">Go 1.7's adoption</a>
+ of <a href="/pkg/context/#Context"><code>context.Context</code></a>
+ into the standard library, Go 1.8 adds more context support
+ to existing packages:
+</p>
+
+<ul>
+ <li>The new <a href="/pkg/net/http/#Server.Shutdown"><code>Server.Shutdown</code></a>
+ takes a context argument.</li>
+ <li>There have been <a href="#database_sql">significant additions</a> to the
+ <a href="/pkg/database/sql/">database/sql</a> package with context support.</li>
+ <li>All nine of the new <code>Lookup</code> methods on the new
+ <a href="/pkg/net/#Resolver"><code>net.Resolver</code></a> now
+ take a context.</li>
+ </ul>
+
+<h3 id="mutex_prof">Mutex Contention Profiling</h3>
+
+<p>
+ The runtime and tools now support profiling contended mutexes.
+</p>
+
+<p>
+ Most users will want to use the new <code>-mutexprofile</code>
+ flag with “<a href="/cmd/go/#hdr-Description_of_testing_flags"><code>go</code> <code>test</code></a>”,
+ and then use <a href="/cmd/pprof/">pprof</a> on the resultant file.
+</p>
+
+<p>
+ Lower-level support is also available via the new
+ <a href="/pkg/runtime/#MutexProfile"><code>MutexProfile</code></a>
+ and
+ <a href="/pkg/runtime/#SetMutexProfileFraction"><code>SetMutexProfileFraction</code></a>.
+</p>
+
+<p>
+ A known limitation for Go 1.8 is that the profile only reports contention for
+ <a href="/pkg/sync/#Mutex"><code>sync.Mutex</code></a>,
+ not
+ <a href="/pkg/sync/#RWMutex"><code>sync.RWMutex</code></a>.
+</p>
+
+<h3 id="minor_library_changes">Minor changes to the library</h3>
+
+<p>
+As always, there are various minor changes and updates to the library,
+made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
+in mind. The following sections list the user visible changes and additions.
+Optimizations and minor bug fixes are not listed.
+</p>
+
+<dl id="archive_tar"><dt><a href="/pkg/archive/tar/">archive/tar</a></dt>
+ <dd>
+
+ <p> <!-- CL 28471, CL 31440, CL 31441, CL 31444, CL 28418, CL 31439 -->
+ The tar implementation corrects many bugs in corner cases of the file format.
+ The <a href="/pkg/archive/tar/#Reader"><code>Reader</code></a>
+ is now able to process tar files in the PAX format with entries larger than 8GB.
+ The <a href="/pkg/archive/tar/#Writer"><code>Writer</code></a>
+ no longer produces invalid tar files in some situations involving long pathnames.
+ </p>
+
+ </dd>
+</dl>
+
+<dl id="compress_flate"><dt><a href="/pkg/compress/flate/">compress/flate</a></dt>
+ <dd>
+
+ <p> <!-- CL 31640, CL 31174, CL 32149 -->
+ There have been some minor fixes to the encoder to improve the
+ compression ratio in certain situations. As a result, the exact
+ encoded output of <code>DEFLATE</code> may be different from Go 1.7. Since
+ <code>DEFLATE</code> is the underlying compression of gzip, png, zlib, and zip,
+ those formats may have changed outputs.
+ </p>
+
+ <p> <!-- CL 31174 -->
+ The encoder, when operating in
+ <a href="/pkg/compress/flate/#NoCompression"><code>NoCompression</code></a>
+ mode, now produces a consistent output that is not dependent on
+ the size of the slices passed to the
+ <a href="/pkg/compress/flate/#Writer.Write"><code>Write</code></a>
+ method.
+ </p>
+
+ <p> <!-- CL 28216 -->
+ The decoder, upon encountering an error, now returns any
+ buffered data it had uncompressed along with the error.
+ </p>
+
+ </dd>
+</dl>
+
+
+<dl id="compress_gzip"><dt><a href="/pkg/compress/gzip/">compress/gzip</a></dt>
+ <dd>
+
+ <p>
+ The <a href="/pkg/compress/gzip/#Writer"><code>Writer</code></a>
+ now encodes a zero <code>MTIME</code> field when
+ the <a href="/pkg/compress/gzip/#Header"><code>Header.ModTime</code></a>
+ field is the zero value.
+
+ In previous releases of Go, the <code>Writer</code> would encode
+ a nonsensical value.
+
+ Similarly,
+ the <a href="/pkg/compress/gzip/#Reader"><code>Reader</code></a>
+ now reports a zero encoded <code>MTIME</code> field as a zero
+ <code>Header.ModTime</code>.
+ </p>
+
+ </dd>
+</dl>
+
+<dl id="context"><dt><a href="/pkg/context/">context</a></dt>
+ <dd>
+ <p> <!-- CL 30370 -->
+ The <a href="/pkg/context#DeadlineExceeded"><code>DeadlineExceeded</code></a>
+ error now implements
+ <a href="/pkg/net/#Error"><code>net.Error</code></a>
+ and reports true for both the <code>Timeout</code> and
+ <code>Temporary</code> methods.
+ </p>
+ </dd>
+</dl>
+
+<dl id="crypto_tls"><dt><a href="/pkg/crypto/tls/">crypto/tls</a></dt>
+ <dd>
+ <p> <!-- CL 25159, CL 31318 -->
+ The new method
+ <a href="/pkg/crypto/tls/#Conn.CloseWrite"><code>Conn.CloseWrite</code></a>
+ allows TLS connections to be half closed.
+ </p>
+
+ <p> <!-- CL 28075 -->
+ The new method
+ <a href="/pkg/crypto/tls/#Config.Clone"><code>Config.Clone</code></a>
+ clones a TLS configuration.
+ </p>
+
+ <p>
+ <!-- CL 30790 -->
+ The new <a href="/pkg/crypto/tls/#Config.GetConfigForClient"><code>Config.GetConfigForClient</code></a>
+ callback allows selecting a configuration for a client dynamically, based
+ on the client's
+ <a href="/pkg/crypto/tls/#ClientHelloInfo"><code>ClientHelloInfo</code></a>.
+
+ <!-- CL 31391, CL 32119 -->
+ The <a href="/pkg/crypto/tls/#ClientHelloInfo"><code>ClientHelloInfo</code></a>
+ struct now has new
+ fields <code>Conn</code>, <code>SignatureSchemes</code> (using
+ the new
+ type <a href="/kg/crypto/tls/#SignatureScheme"><code>SignatureScheme</code></a>),
+ <code>SupportedProtos</code>, and <code>SupportedVersions</code>.
+ </p>
+
+ <p> <!-- CL 32115 -->
+ The new <a href="/pkg/crypto/tls/#Config.GetClientCertificate"><code>Config.GetClientCertificate</code></a>
+ callback allows selecting a client certificate based on the server's
+ TLS <code>CertificateRequest</code> message, represented by the new
+ <a href="/pkg/crypto/tls/#CertificateRequestInfo"><code>CertificateRequestInfo</code></a>.
+ </p>
+
+ <p> <!-- CL 27434 -->
+ The new
+ <a href="/pkg/crypto/tls/#Config.KeyLogWriter"><code>Config.KeyLogWriter</code></a>
+ allows debugging TLS connections
+ in <a href="https://www.wireshark.org/">WireShark</a> and
+ similar tools.
+ </p>
+
+ <p> <!-- CL 32115 -->
+ The new
+ <a href="/pkg/crypto/tls/#Config.VerifyPeerCertificate"><code>Config.VerifyPeerCertificate</code></a>
+ callback allows additional validation of a peer's presented certificate.
+ </p>
+
+ <p> <!-- CL 18130 -->
+ The <code>crypto/tls</code> package now implements basic
+ countermeasures against CBC padding oracles. There should be
+ no explicit secret-dependent timings, but it does not attempt to
+ normalize memory accesses to prevent cache timing leaks.
+ </p>
+
+ <p>
+ The <code>crypto/tls</code> package now supports
+ X25519 and <!-- CL 30824, CL 30825 -->
+ ChaCha20-Poly1305. <!-- CL 30957, CL 30958 -->
+ ChaCha20-Poly1305 is now prioritized unless <!-- CL 32871 -->
+ hardware support for AES-GCM is present.
+ </p>
+
+ <p> <!-- CL 27315, CL 35290 -->
+ AES-128-CBC cipher suites with SHA-256 are also
+ now supported, but disabled by default.
+ </p>
+
+ </dd>
+</dl>
+
+<dl id="crypto_x509"><dt><a href="/pkg/crypto/x509/">crypto/x509</a></dt>
+ <dd>
+ <p> <!-- CL 24743 -->
+ PSS signatures are now supported.
+ </p>
+
+ <p> <!-- CL 32644 -->
+ <a href="/pkg/crypto/x509/#UnknownAuthorityError"><code>UnknownAuthorityError</code></a>
+ now has a <code>Cert</code> field, reporting the untrusted
+ certificate.
+ </p>
+
+ <p>
+ Certificate validation is more permissive in a few cases and
+ stricter in a few other cases.
+ <!--
+crypto/x509: allow a leaf certificate to be specified directly as root (CL 27393)
+crypto/x509: check that the issuer name matches the issuer's subject name (CL 23571)
+crypto/x509: don't accept a root that already appears in a chain. (CL 32121)
+crypto/x509: fix name constraints handling (CL 30155)
+crypto/x509: parse all names in an RDN (CL 30810)
+crypto/x509: recognise ISO OID for RSA+SHA1 (CL 27394)
+crypto/x509: require a NULL parameters for RSA public keys (CL 16166, CL 27312)
+crypto/x509: return error for missing SerialNumber (CL 27238)
+-->
+ </p>
+
+ <p><!-- CL 30375 -->
+ Root certificates will now also be looked for
+ at <code>/etc/pki/ca-trust/extracted/pem/tls-ca-bundle.pem</code>
+ on Linux, to support RHEL and CentOS.
+ </p>
+
+ </dd>
+</dl>
+
+<dl id="database_sql"><dt><a href="/pkg/database/sql/">database/sql</a></dt>
+ <dd>
+ <p>
+ The package now supports <code>context.Context</code>. There are new methods
+ ending in <code>Context</code> such as
+ <a href="/pkg/database/sql/#DB.QueryContext"><code>DB.QueryContext</code></a> and
+ <a href="/pkg/database/sql/#DB.PrepareContext"><code>DB.PrepareContext</code></a>
+ that take context arguments. Using the new <code>Context</code> methods ensures that
+ connections are closed and returned to the connection pool when the
+ request is done; enables canceling in-progress queries
+ should the driver support that; and allows the database
+ pool to cancel waiting for the next available connection.
+ </p>
+ <p>
+ The <a href="/pkg/database/sql#IsolationLevel"><code>IsolationLevel</code></a>
+ can now be set when starting a transaction by setting the isolation level
+ on <a href="/pkg/database/sql#TxOptions.Isolation"><code>TxOptions.Isolation</code></a> and passing
+ it to <a href="/pkg/database/sql#DB.BeginTx"><code>DB.BeginTx</code></a>.
+ An error will be returned if an isolation level is selected that the driver
+ does not support. A read-only attribute may also be set on the transaction
+ by setting <a href="/pkg/database/sql/#TxOptions.ReadOnly"><code>TxOptions.ReadOnly</code></a>
+ to true.
+ </p>
+ <p>
+ Queries now expose the SQL column type information for drivers that support it.
+ Rows can return <a href="/pkg/database/sql#Rows.ColumnTypes"><code>ColumnTypes</code></a>
+ which can include SQL type information, column type lengths, and the Go type.
+ </p>
+ <p>
+ A <a href="/pkg/database/sql/#Rows"><code>Rows</code></a>
+ can now represent multiple result sets. After
+ <a href="/pkg/database/sql/#Rows.Next"><code>Rows.Next</code></a> returns false,
+ <a href="/pkg/database/sql/#Rows.NextResultSet"><code>Rows.NextResultSet</code></a>
+ may be called to advance to the next result set. The existing <code>Rows</code>
+ should continue to be used after it advances to the next result set.
+ </p>
+ <p>
+ <a href="/pkg/database/sql/#NamedArg"><code>NamedArg</code></a> may be used
+ as query arguments. The new function <a href="/pkg/database/sql/#Named"><code>Named</code></a>
+ helps create a <a href="/pkg/database/sql/#NamedArg"><code>NamedArg</code></a>
+ more succinctly.
+ <p>
+ If a driver supports the new
+ <a href="/pkg/database/sql/driver/#Pinger"><code>Pinger</code></a>
+ interface, the
+ <a href="/pkg/database/sql/#DB.Ping"><code>DB.Ping</code></a>
+ and
+ <a href="/pkg/database/sql/#DB.PingContext"><code>DB.PingContext</code></a>
+ methods will use that interface to check whether a
+ database connection is still valid.
+ </p>
+ <p>
+ The new <code>Context</code> query methods work for all drivers, but
+ <code>Context</code> cancelation is not responsive unless the driver has been
+ updated to use them. The other features require driver support in
+ <a href="/pkg/database/sql/driver"><code>database/sql/driver</code></a>.
+ Driver authors should review the new interfaces. Users of existing
+ driver should review the driver documentation to see what
+ it supports and any system specific documentation on each feature.
+ </p>
+ </dd>
+</dl>
+
+<dl id="debug_pe"><dt><a href="/pkg/debug/pe/">debug/pe</a></dt>
+ <dd>
+ <p> <!-- CL 22720, CL 27212, CL 22181, CL 22332, CL 22336, Issue 15345 -->
+ The package has been extended and is now used by
+ <a href="/cmd/link/">the Go linker</a> to read <code>gcc</code>-generated object files.
+ The new
+ <a href="/pkg/debug/pe/#File.StringTable"><code>File.StringTable</code></a>
+ and
+ <a href="/pkg/debug/pe/#Section.Relocs"><code>Section.Relocs</code></a>
+ fields provide access to the COFF string table and COFF relocations.
+ The new
+ <a href="/pkg/debug/pe/#File.COFFSymbols"><code>File.COFFSymbols</code></a>
+ allows low-level access to the COFF symbol table.
+ </p>
+ </dd>
+</dl>
+
+<dl id="encoding_base64"><dt><a href="/pkg/encoding/base64/">encoding/base64</a></dt>
+ <dd>
+ <p> <!-- CL 24964 -->
+ The new
+ <a href="/pkg/encoding/base64/#Encoding.Strict"><code>Encoding.Strict</code></a>
+ method returns an <code>Encoding</code> that causes the decoder
+ to return an error when the trailing padding bits are not zero.
+ </p>
+ </dd>
+</dl>
+
+<dl id="encoding_binary"><dt><a href="/pkg/encoding/binary/">encoding/binary</a></dt>
+ <dd>
+ <p> <!-- CL 28514 -->
+ <a href="/pkg/encoding/binary/#Read"><code>Read</code></a>
+ and
+ <a href="/pkg/encoding/binary/#Write"><code>Write</code></a>
+ now support booleans.
+ </p>
+ </dd>
+</dl>
+
+<dl id="encoding_json"><dt><a href="/pkg/encoding/json/">encoding/json</a></dt>
+ <dd>
+
+ <p> <!-- CL 18692 -->
+ <a href="/pkg/encoding/json/#UnmarshalTypeError"><code>UnmarshalTypeError</code></a>
+ now includes the struct and field name.
+ </p>
+
+ <p> <!-- CL 31932 -->
+ A nil <a href="/pkg/encoding/json/#Marshaler"><code>Marshaler</code></a>
+ now marshals as a JSON <code>null</code> value.
+ </p>
+
+ <p> <!-- CL 21811 -->
+ A <a href="/pkg/encoding/json/#RawMessage"><code>RawMessage</code></a> value now
+ marshals the same as its pointer type.
+ </p>
+
+ <p> <!-- CL 30371 -->
+ <a href="/pkg/encoding/json/#Marshal"><code>Marshal</code></a>
+ encodes floating-point numbers using the same format as in ES6,
+ preferring decimal (not exponential) notation for a wider range of values.
+ In particular, all floating-point integers up to 2<sup>64</sup> format the
+ same as the equivalent <code>int64</code> representation.
+ </p>
+
+ <p> <!-- CL 30944 -->
+ In previous versions of Go, unmarshaling a JSON <code>null</code> into an
+ <a href="/pkg/encoding/json/#Unmarshaler"><code>Unmarshaler</code></a>
+ was considered a no-op; now the <code>Unmarshaler</code>'s
+ <code>UnmarshalJSON</code> method is called with the JSON literal
+ <code>null</code> and can define the semantics of that case.
+ </p>
+
+ </dd>
+</dl>
+
+<dl id="encoding_pem"><dt><a href="/pkg/encoding/pem/">encoding/pem</a></dt>
+ <dd>
+ <p> <!-- CL 27391 -->
+ <a href="/pkg/encoding/pem/#Decode"><code>Decode</code></a>
+ is now strict about the format of the ending line.
+ </p>
+ </dd>
+</dl>
+
+<dl id="encoding_xml"><dt><a href="/pkg/encoding/xml/">encoding/xml</a></dt>
+ <dd>
+ <p> <!-- CL 30946 -->
+ <a href="/pkg/encoding/xml/#Unmarshal"><code>Unmarshal</code></a>
+ now has wildcard support for collecting all attributes using
+ the new <code>",any,attr"</code> struct tag.
+ </p>
+ </dd>
+</dl>
+
+<dl id="expvar"><dt><a href="/pkg/expvar/">expvar</a></dt>
+ <dd>
+ <p> <!-- CL 30917 -->
+ The new methods
+ <a href="/pkg/expvar/#Int.Value"><code>Int.Value</code></a>,
+ <a href="/pkg/expvar/#String.Value"><code>String.Value</code></a>,
+ <a href="/pkg/expvar/#Float.Value"><code>Float.Value</code></a>, and
+ <a href="/pkg/expvar/#Func.Value"><code>Func.Value</code></a>
+ report the current value of an exported variable.
+ </p>
+
+ <p> <!-- CL 24722 -->
+ The new
+ function <a href="/pkg/expvar/#Handler"><code>Handler</code></a>
+ returns the package's HTTP handler, to enable installing it in
+ non-standard locations.
+ </p>
+ </dd>
+</dl>
+
+<dl id="fmt"><dt><a href="/pkg/fmt/">fmt</a></dt>
+ <dd>
+ <p><!-- CL 30611 -->
+ <a href="/pkg/fmt/#Scanf"><code>Scanf</code></a>,
+ <a href="/pkg/fmt/#Fscanf"><code>Fscanf</code></a>, and
+ <a href="/pkg/fmt/#Sscanf"><code>Sscanf</code></a> now
+ handle spaces differently and more consistently than
+ previous releases. See the
+ <a href="/pkg/fmt/#hdr-Scanning">scanning documentation</a>
+ for details.
+ </p>
+ </dd>
+</dl>
+
+<dl id="go_doc"><dt><a href="/pkg/go/doc/">go/doc</a></dt>
+ <dd>
+ <p><!-- CL 29870 -->
+ The new <a href="/pkg/go/doc/#IsPredeclared"><code>IsPredeclared</code></a>
+ function reports whether a string is a predeclared identifier.
+ </p>
+ </dd>
+</dl>
+
+<dl id="go_types"><dt><a href="/pkg/go/types/">go/types</a></dt>
+ <dd>
+ <p><!-- CL 30715 -->
+ The new function
+ <a href="/pkg/go/types/#Default"><code>Default</code></a>
+ returns the default "typed" type for an "untyped" type.
+ </p>
+
+ <p><!-- CL 31939 -->
+ The alignment of <code>complex64</code> now matches
+ the <a href="/cmd/compile/">Go compiler</a>.
+ </p>
+ </dd>
+</dl>
+
+<dl id="html_template"><dt><a href="/pkg/html/template/">html/template</a></dt>
+ <dd>
+ <p><!-- CL 14336 -->
+ The package now validates
+ the <code>"type"</code> attribute on
+ a <code><script></code> tag.
+ </p>
+ </dd>
+</dl>
+
+<dl id="image_png"><dt><a href="/pkg/image/png/">image/png</a></dt>
+ <dd>
+ <p> <!-- CL 32143, CL 32140 -->
+ <a href="/pkg/image/png/#Decode"><code>Decode</code></a>
+ (and <code>DecodeConfig</code>)
+ now supports True Color and grayscale transparency.
+ </p>
+ <p> <!-- CL 29872 -->
+ <a href="/pkg/image/png/#Encoder"><code>Encoder</code></a>
+ is now faster and creates smaller output
+ when encoding paletted images.
+ </p>
+ </dd>
+</dl>
+
+<dl id="math_big"><dt><a href="/pkg/math/big/">math/big</a></dt>
+ <dd>
+ <p><!-- CL 30706 -->
+ The new method
+ <a href="/pkg/math/big/#Int.Sqrt"><code>Int.Sqrt</code></a>
+ calculates ⌊√x⌋.
+ </p>
+
+ <p>
+ The new method
+ <a href="/pkg/math/big/#Float.Scan"><code>Float.Scan</code></a>
+ is a support routine for
+ <a href="/pkg/fmt/#Scanner"><code>fmt.Scanner</code></a>.
+ </p>
+
+ <p>
+ <a href="/pkg/math/big/#Int.ModInverse"><code>Int.ModInverse</code></a>
+ now supports negative numbers.
+ </p>
+
+ </dd>
+</dl>
+
+<dl id="math_rand"><dt><a href="/pkg/math/rand/">math/rand</a></dt>
+ <dd>
+
+ <p><!-- CL 27253, CL 33456 -->
+ The new <a href="/pkg/math/rand/#Rand.Uint64"><code>Rand.Uint64</code></a>
+ method returns <code>uint64</code> values. The
+ new <a href="/pkg/math/rand/#Source64"><code>Source64</code></a>
+ interface describes sources capable of generating such values
+ directly; otherwise the <code>Rand.Uint64</code> method
+ constructs a <code>uint64</code> from two calls
+ to <a href="/pkg/math/rand/#Source"><code>Source</code></a>'s
+ <code>Int63</code> method.
+ </p>
+
+ </dd>
+</dl>
+
+<dl id="mime"><dt><a href="/pkg/mime/">mime</a></dt>
+ <dd>
+ <p> <!-- CL 32175 -->
+ <a href="/pkg/mime/#ParseMediaType"><code>ParseMediaType</code></a>
+ now preserves unnecessary backslash escapes as literals,
+ in order to support MSIE.
+ When MSIE sends a full file path (in “intranet mode”), it does not
+ escape backslashes: “<code>C:\dev\go\foo.txt</code>”, not
+ “<code>C:\\dev\\go\\foo.txt</code>”.
+ If we see an unnecessary backslash escape, we now assume it is from MSIE
+ and intended as a literal backslash.
+ No known MIME generators emit unnecessary backslash escapes
+ for simple token characters like numbers and letters.
+ </p>
+ </dd>
+</dl>
+
+<dl id="mime_quotedprintable"><dt><a href="/pkg/mime/quotedprintable/">mime/quotedprintable</a></dt>
+ <dd>
+
+ <p>
+ The
+ <a href="/pkg/mime/quotedprintable/#Reader"><code>Reader</code></a>'s
+ parsing has been relaxed in two ways to accept
+ more input seen in the wild.
+
+ <!-- CL 32174 -->
+ First, it accepts an equals sign (<code>=</code>) not followed
+ by two hex digits as a literal equal sign.
+
+ <!-- CL 27530 -->
+ Second, it silently ignores a trailing equals sign at the end of
+ an encoded input.
+ </p>
+
+ </dd>
+</dl>
+
+<dl id="net"><dt><a href="/pkg/net/">net</a></dt>
+ <dd>
+
+ <p><!-- CL 30164, CL 33473 -->
+ The <a href="/pkg/net/#Conn"><code>Conn</code></a> documentation
+ has been updated to clarify expectations of an interface
+ implementation. Updates in the <code>net/http</code> packages
+ depend on implementations obeying the documentation.
+ </p>
+ <p><i>Updating:</i> implementations of the <code>Conn</code> interface should verify
+ they implement the documented semantics. The
+ <a href="https://godoc.org/golang.org/x/net/nettest">golang.org/x/net/nettest</a>
+ package will exercise a <code>Conn</code> and validate it behaves properly.
+ </p>
+
+ <p><!-- CL 32099 -->
+ The new method
+ <a href="/pkg/net/#UnixListener.SetUnlinkOnClose"><code>UnixListener.SetUnlinkOnClose</code></a>
+ sets whether the underlying socket file should be removed from the file system when
+ the listener is closed.
+ </p>
+
+ <p><!-- CL 29951 -->
+ The new <a href="/pkg/net/#Buffers"><code>Buffers</code></a> type permits
+ writing to the network more efficiently from multiple discontiguous buffers
+ in memory. On certain machines, for certain types of connections,
+ this is optimized into an OS-specific batch write operation (such as <code>writev</code>).
+ </p>
+
+ <p><!-- CL 29440 -->
+ The new <a href="/pkg/net/#Resolver"><code>Resolver</code></a> looks up names and numbers
+ and supports <a href="/pkg/context/#Context"><code>context.Context</code></a>.
+ The <a href="/pkg/net/#Dialer"><code>Dialer</code></a> now has an optional
+ <a href="/pkg/net/#Dialer.Resolver"><code>Resolver</code> field</a>.
+ </p>
+
+ <p><!-- CL 29892 -->
+ <a href="/pkg/net/#Interfaces"><code>Interfaces</code></a> is now supported on Solaris.
+ </p>
+
+ <p><!-- CL 29233, CL 24901 -->
+ The Go DNS resolver now supports <code>resolv.conf</code>'s “<code>rotate</code>”
+ and “<code>option</code> <code>ndots:0</code>” options. The “<code>ndots</code>” option is
+ now respected in the same way as <code>libresolve</code>.
+ </p>
+
+ </dd>
+</dl>
+
+<dl id="net_http"><dt><a href="/pkg/net/http/">net/http</a></dt>
+ <dd>
+
+ <p>Server changes:</p>
+ <ul>
+ <li>The server now supports graceful shutdown support, <a href="#http_shutdown">mentioned above</a>.</li>
+
+ <li> <!-- CL 32024 -->
+ The <a href="/pkg/net/http/#Server"><code>Server</code></a>
+ adds configuration options
+ <code>ReadHeaderTimeout</code> and <code>IdleTimeout</code>
+ and documents <code>WriteTimeout</code>.
+ </li>
+
+ <li> <!-- CL 32014 -->
+ <a href="/pkg/net/http/#FileServer"><code>FileServer</code></a>
+ and
+ <a href="/pkg/net/http/#ServeContent"><code>ServeContent</code></a>
+ now support HTTP <code>If-Match</code> conditional requests,
+ in addition to the previous <code>If-None-Match</code>
+ support for ETags properly formatted according to RFC 7232, section 2.3.
+ </li>
+ </ul>
+
+ <p>
+ There are several additions to what a server's <code>Handler</code> can do:
+ </p>
+
+ <ul>
+ <li><!-- CL 31173 -->
+ The <a href="/pkg/context/#Context"><code>Context</code></a>
+ returned
+ by <a href="/pkg/net/http/#Request.Context"><code>Request.Context</code></a>
+ is canceled if the underlying <code>net.Conn</code>
+ closes. For instance, if the user closes their browser in the
+ middle of a slow request, the <code>Handler</code> can now
+ detect that the user is gone. This complements the
+ existing <a href="/pkg/net/http/#CloseNotifier"><code>CloseNotifier</code></a>
+ support. This functionality requires that the underlying
+ <a href="/pkg/net/#Conn"><code>net.Conn</code></a> implements
+ <a href="#net">recently clarified interface documentation</a>.
+ </li>
+
+ <li><!-- CL 32479 -->
+ To serve trailers produced after the header has already been written,
+ see the new
+ <a href="/pkg/net/http/#TrailerPrefix"><code>TrailerPrefix</code></a>
+ mechanism.
+ </li>
+
+ <li><!-- CL 33099 -->
+ A <code>Handler</code> can now abort a response by panicking
+ with the error
+ <a href="/pkg/net/http/#ErrAbortHandler"><code>ErrAbortHandler</code></a>.
+ </li>
+
+ <li><!-- CL 30812 -->
+ A <code>Write</code> of zero bytes to a
+ <a href="/pkg/net/http/#ResponseWriter"><code>ResponseWriter</code></a>
+ is now defined as a
+ way to test whether a <code>ResponseWriter</code> has been hijacked:
+ if so, the <code>Write</code> returns
+ <a href="/pkg/net/http/#ErrHijacked"><code>ErrHijacked</code></a>
+ without printing an error
+ to the server's error log.
+ </li>
+
+ </ul>
+
+ <p>Client & Transport changes:</p>
+ <ul>
+ <li><!-- CL 28930, CL 31435 -->
+ The <a href="/pkg/net/http/#Client"><code>Client</code></a>
+ now copies most request headers on redirect. See
+ <a href="/pkg/net/http/#Client">the documentation</a>
+ on the <code>Client</code> type for details.
+ </li>
+
+ <li><!-- CL 29072 -->
+ The <a href="/pkg/net/http/#Transport"><code>Transport</code></a>
+ now supports international domain names. Consequently, so do
+ <a href="/pkg/net/http/#Get">Get</a> and other helpers.
+ </li>
+
+ <li><!-- CL 31733, CL 29852 -->
+ The <code>Client</code> now supports 301, 307, and 308 redirects.
+
+ For example, <code>Client.Post</code> now follows 301
+ redirects, converting them to <code>GET</code> requests
+ without bodies, like it did for 302 and 303 redirect responses
+ previously.
+
+ The <code>Client</code> now also follows 307 and 308
+ redirects, preserving the original request method and body, if
+ any. If the redirect requires resending the request body, the
+ request must have the new
+ <a href="/pkg/net/http/#Request"><code>Request.GetBody</code></a>
+ field defined.
+ <a href="/pkg/net/http/#NewRequest"><code>NewRequest</code></a>
+ sets <code>Request.GetBody</code> automatically for common
+ body types.
+ </li>
+
+ <li><!-- CL 32482 -->
+ The <code>Transport</code> now rejects requests for URLs with
+ ports containing non-digit characters.
+ </li>
+
+ <li><!-- CL 27117 -->
+ The <code>Transport</code> will now retry non-idempotent
+ requests if no bytes were written before a network failure
+ and the request has no body.
+ </li>
+
+ <li><!-- CL 32481 -->
+ The
+ new <a href="/pkg/net/http/#Transport"><code>Transport.ProxyConnectHeader</code></a>
+ allows configuration of header values to send to a proxy
+ during a <code>CONNECT</code> request.
+ </li>
+
+ <li> <!-- CL 28077 -->
+ The <a href="/pkg/net/http/#DefaultTransport"><code>DefaultTransport.Dialer</code></a>
+ now enables <code>DualStack</code> ("<a href="https://tools.ietf.org/html/rfc6555">Happy Eyeballs</a>") support,
+ allowing the use of IPv4 as a backup if it looks like IPv6 might be
+ failing.
+ </li>
+
+ <li> <!-- CL 31726 -->
+ The <a href="/pkg/net/http/#Transport"><code>Transport</code></a>
+ no longer reads a byte of a non-nil
+ <a href="/pkg/net/http/#Request.Body"><code>Request.Body</code></a>
+ when the
+ <a href="/pkg/net/http/#Request.ContentLength"><code>Request.ContentLength</code></a>
+ is zero to determine whether the <code>ContentLength</code>
+ is actually zero or just undefined.
+ To explicitly signal that a body has zero length,
+ either set it to <code>nil</code>, or set it to the new value
+ <a href="/pkg/net/http/#NoBody"><code>NoBody</code></a>.
+ The new <code>NoBody</code> value is intended for use by <code>Request</code>
+ constructor functions; it is used by
+ <a href="/pkg/net/http/#NewRequest"><code>NewRequest</code></a>.
+ </li>
+ </ul>
+
+ </dd>
+</dl>
+
+<dl id="net_http_httptrace"><dt><a href="/pkg/net/http/httptrace/">net/http/httptrace</a></dt>
+ <dd>
+ <p> <!-- CL 30359 -->
+ There is now support for tracing a client request's TLS handshakes with
+ the new
+ <a href="/pkg/net/http/httptrace/#ClientTrace.TLSHandshakeStart"><code>ClientTrace.TLSHandshakeStart</code></a>
+ and
+ <a href="/pkg/net/http/httptrace/#ClientTrace.TLSHandshakeDone"><code>ClientTrace.TLSHandshakeDone</code></a>.
+ </p>
+ </dd>
+</dl>
+
+<dl id="net_http_httputil"><dt><a href="/pkg/net/http/httputil/">net/http/httputil</a></dt>
+ <dd>
+ <p> <!-- CL 32356 -->
+ The <a href="/pkg/net/http/httputil/#ReverseProxy"><code>ReverseProxy</code></a>
+ has a new optional hook,
+ <a href="/pkg/net/http/httputil/#ReverseProxy.ModifyResponse"><code>ModifyResponse</code></a>,
+ for modifying the response from the back end before proxying it to the client.
+ </p>
+
+ </dd>
+</dl>
+
+<dl id="net_mail"><dt><a href="/pkg/net/mail/">net/mail</a></dt>
+ <dd>
+
+ <p> <!-- CL 32176 -->
+ Empty quoted strings are once again allowed in the name part of
+ an address. That is, Go 1.4 and earlier accepted
+ <code>""</code> <code><gopher@example.com></code>,
+ but Go 1.5 introduced a bug that rejected this address.
+ The address is recognized again.
+ </p>
+
+ <p> <!-- CL 31581 -->
+ The
+ <a href="/pkg/net/mail/#Header.Date"><code>Header.Date</code></a>
+ method has always provided a way to parse
+ the <code>Date:</code> header.
+ A new function
+ <a href="/pkg/net/mail/#ParseDate"><code>ParseDate</code></a>
+ allows parsing dates found in other
+ header lines, such as the <code>Resent-Date:</code> header.
+ </p>
+
+ </dd>
+</dl>
+
+<dl id="net_smtp"><dt><a href="/pkg/net/smtp/">net/smtp</a></dt>
+ <dd>
+
+ <p> <!-- CL 33143 -->
+ If an implementation of the
+ <a href="/pkg/net/smtp/#Auth"><code>Auth.Start</code></a>
+ method returns an empty <code>toServer</code> value,
+ the package no longer sends
+ trailing whitespace in the SMTP <code>AUTH</code> command,
+ which some servers rejected.
+ </p>
+
+ </dd>
+</dl>
+
+<dl id="net_url"><dt><a href="/pkg/net/url/">net/url</a></dt>
+ <dd>
+
+ <p> <!-- CL 31322 -->
+ The new functions
+ <a href="/pkg/net/url/#PathEscape"><code>PathEscape</code></a>
+ and
+ <a href="/pkg/net/url/#PathUnescape"><code>PathUnescape</code></a>
+ are similar to the query escaping and unescaping functions but
+ for path elements.
+ </p>
+
+ <p> <!-- CL 28933 -->
+ The new methods
+ <a href="/pkg/net/url/#URL.Hostname"><code>URL.Hostname</code></a>
+ and
+ <a href="/pkg/net/url/#URL.Port"><code>URL.Port</code></a>
+ return the hostname and port fields of a URL,
+ correctly handling the case where the port may not be present.
+ </p>
+
+ <p> <!-- CL 28343 -->
+ The existing method
+ <a href="/pkg/net/url/#URL.ResolveReference"><code>URL.ResolveReference</code></a>
+ now properly handles paths with escaped bytes without losing
+ the escaping.
+ </p>
+
+ <p> <!-- CL 31467 -->
+ The <code>URL</code> type now implements
+ <a href="/pkg/encoding/#BinaryMarshaler"><code>encoding.BinaryMarshaler</code></a> and
+ <a href="/pkg/encoding/#BinaryUnmarshaler"><code>encoding.BinaryUnmarshaler</code></a>,
+ making it possible to process URLs in <a href="/pkg/encoding/gob/">gob data</a>.
+ </p>
+
+ <p> <!-- CL 29610, CL 31582 -->
+ Following RFC 3986,
+ <a href="/pkg/net/url/#Parse"><code>Parse</code></a>
+ now rejects URLs like <code>this_that:other/thing</code> instead of
+ interpreting them as relative paths (<code>this_that</code> is not a valid scheme).
+ To force interpretation as a relative path,
+ such URLs should be prefixed with “<code>./</code>”.
+ The <code>URL.String</code> method now inserts this prefix as needed.
+ </p>
+
+ </dd>
+</dl>
+
+<dl id="os"><dt><a href="/pkg/os/">os</a></dt>
+ <dd>
+ <p> <!-- CL 16551 -->
+ The new function
+ <a href="/pkg/os/#Executable"><code>Executable</code></a> returns
+ the path name of the running executable.
+ </p>
+
+ <p> <!-- CL 30614 -->
+ An attempt to call a method on
+ an <a href="/pkg/os/#File"><code>os.File</code></a> that has
+ already been closed will now return the new error
+ value <a href="/pkg/os/#ErrClosed"><code>os.ErrClosed</code></a>.
+ Previously it returned a system-specific error such
+ as <code>syscall.EBADF</code>.
+ </p>
+
+ <p> <!-- CL 31358 -->
+ On Unix systems, <a href="/pkg/os/#Rename"><code>os.Rename</code></a>
+ will now return an error when used to rename a directory to an
+ existing empty directory.
+ Previously it would fail when renaming to a non-empty directory
+ but succeed when renaming to an empty directory.
+ This makes the behavior on Unix correspond to that of other systems.
+ </p>
+
+ <p> <!-- CL 32451 -->
+ On Windows, long absolute paths are now transparently converted to
+ extended-length paths (paths that start with “<code>\\?\</code>”).
+ This permits the package to work with files whose path names are
+ longer than 260 characters.
+ </p>
+
+ <p> <!-- CL 29753 -->
+ On Windows, <a href="/pkg/os/#IsExist"><code>os.IsExist</code></a>
+ will now return <code>true</code> for the system
+ error <code>ERROR_DIR_NOT_EMPTY</code>.
+ This roughly corresponds to the existing handling of the Unix
+ error <code>ENOTEMPTY</code>.
+ </p>
+
+ <p> <!-- CL 32152 -->
+ On Plan 9, files that are not served by <code>#M</code> will now
+ have <a href="/pkg/os/#ModeDevice"><code>ModeDevice</code></a> set in
+ the value returned
+ by <a href="/pkg/os/#FileInfo"><code>FileInfo.Mode</code></a>.
+ </p>
+ </dd>
+</dl>
+
+<dl id="path_filepath"><dt><a href="/pkg/path/filepath/">path/filepath</a></dt>
+ <dd>
+ <p>
+ A number of bugs and corner cases on Windows were fixed:
+ <a href="/pkg/path/filepath/#Abs"><code>Abs</code></a> now calls <code>Clean</code> as documented,
+ <a href="/pkg/path/filepath/#Glob"><code>Glob</code></a> now matches
+ “<code>\\?\c:\*</code>”,
+ <a href="/pkg/path/filepath/#EvalSymlinks"><code>EvalSymlinks</code></a> now
+ correctly handles “<code>C:.</code>”, and
+ <a href="/pkg/path/filepath/#Clean"><code>Clean</code></a> now properly
+ handles a leading “<code>..</code>” in the path.
+ </p>
+ </dd>
+</dl>
+
+<dl id="reflect"><dt><a href="/pkg/reflect/">reflect</a></dt>
+ <dd>
+ <p> <!-- CL 30088 -->
+ The new function
+ <a href="/pkg/reflect/#Swapper"><code>Swapper</code></a> was
+ added to support <a href="#sortslice"><code>sort.Slice</code></a>.
+ </p>
+ </dd>
+</dl>
+
+<dl id="strconv"><dt><a href="/pkg/strconv/">strconv</a></dt>
+ <dd>
+ <p> <!-- CL 31210 -->
+ The <a href="/pkg/strconv/#Unquote"><code>Unquote</code></a>
+ function now strips carriage returns (<code>\r</code>) in
+ backquoted raw strings, following the
+ <a href="/ref/spec#String_literals">Go language semantics</a>.
+ </p>
+ </dd>
+</dl>
+
+<dl id="syscall"><dt><a href="/pkg/syscall/">syscall</a></dt>
+ <dd>
+ <p> <!-- CL 25050, CL 25022 -->
+ The <a href="/pkg/syscall/#Getpagesize"><code>Getpagesize</code></a>
+ now returns the system's size, rather than a constant value.
+ Previously it always returned 4KB.
+ </p>
+
+ <p> <!-- CL 31446 -->
+ The signature
+ of <a href="/pkg/syscall/#Utimes"><code>Utimes</code></a> has
+ changed on Solaris to match all the other Unix systems'
+ signature. Portable code should continue to use
+ <a href="/pkg/os/#Chtimes"><code>os.Chtimes</code></a> instead.
+ </p>
+
+ <p> <!-- CL 32319 -->
+ The <code>X__cmsg_data</code> field has been removed from
+ <a href="/pkg/syscall/#Cmsghdr"><code>Cmsghdr</code></a>.
+ </p>
+ </dd>
+</dl>
+
+<dl id="text_template"><dt><a href="/pkg/text/template/">text/template</a></dt>
+ <dd>
+ <p> <!-- CL 31462 -->
+ <a href="/pkg/text/template/#Template.Execute"><code>Template.Execute</code></a>
+ can now take a
+ <a href="/pkg/reflect/#Value"><code>reflect.Value</code></a> as its data
+ argument, and
+ <a href="/pkg/text/template/#FuncMap"><code>FuncMap</code></a>
+ functions can also accept and return <code>reflect.Value</code>.
+ </p>
+
+ </dd>
+</dl>
+
+<dl id="time"><dt><a href="/pkg/time/">time</a></dt>
+ <dd>
+
+ <p> <!-- CL 20118 --> The new function
+ <a href="/pkg/time/#Until"><code>Until</code></a> complements
+ the analogous <code>Since</code> function.
+ </p>
+
+ <p> <!-- CL 29338 -->
+ <a href="/pkg/time/#ParseDuration"><code>ParseDuration</code></a>
+ now accepts long fractional parts.
+ </p>
+
+ <p> <!-- CL 33429 -->
+ <a href="/pkg/time/#Parse"><code>Parse</code></a>
+ now rejects dates before the start of a month, such as June 0;
+ it already rejected dates beyond the end of the month, such as
+ June 31 and July 32.
+ </p>
+
+ <p> <!-- CL 33029 --> <!-- CL 34816 -->
+ The <code>tzdata</code> database has been updated to version
+ 2016j for systems that don't already have a local time zone
+ database.
+ </p>
+
+ <p>
+ </dd>
+</dl>
+
+<dl id="testing"><dt><a href="/pkg/testing/">testing</a></dt>
+ <dd>
+ <p><!-- CL 29970 -->
+ The new method
+ <a href="/pkg/testing/#T.Name"><code>T.Name</code></a>
+ (and <code>B.Name</code>) returns the name of the current
+ test or benchmark.
+ </p>
+
+ <p><!-- CL 32483 -->
+ The new function
+ <a href="/pkg/testing/#CoverMode"><code>CoverMode</code></a>
+ reports the test coverage mode.
+ </p>
+
+ <p><!-- CL 32615 -->
+ Tests and benchmarks are now marked as failed if the race
+ detector is enabled and a data race occurs during execution.
+ Previously, individual test cases would appear to pass,
+ and only the overall execution of the test binary would fail.
+ </p>
+
+ <p><!-- CL 32455 -->
+ The signature of the
+ <a href="/pkg/testing/#MainStart"><code>MainStart</code></a>
+ function has changed, as allowed by the documentation. It is an
+ internal detail and not part of the Go 1 compatibility promise.
+ If you're not calling <code>MainStart</code> directly but see
+ errors, that likely means you set the
+ normally-empty <code>GOROOT</code> environment variable and it
+ doesn't match the version of your <code>go</code> command's binary.
+ </p>
+
+ </dd>
+</dl>
+
+<dl id="unicode"><dt><a href="/pkg/unicode/">unicode</a></dt>
+ <dd>
+ <p><!-- CL 30935 -->
+ <a href="/pkg/unicode/#SimpleFold"><code>SimpleFold</code></a>
+ now returns its argument unchanged if the provided input was an invalid rune.
+ Previously, the implementation failed with an index bounds check panic.
+ </p>
+ </dd>
+</dl>
diff --git a/_content/doc/go1.9.html b/_content/doc/go1.9.html
new file mode 100644
index 0000000..ddd310f
--- /dev/null
+++ b/_content/doc/go1.9.html
@@ -0,0 +1,1023 @@
+<!--{
+ "Title": "Go 1.9 Release Notes",
+ "Template": true
+}-->
+
+<!--
+NOTE: In this document and others in this directory, the convention is to
+set fixed-width phrases with non-fixed-width spaces, as in
+<code>hello</code> <code>world</code>.
+Do not send CLs removing the interior tags from such phrases.
+-->
+
+<style>
+ main ul li { margin: 0.5em 0; }
+</style>
+
+<h2 id="introduction">Introduction to Go 1.9</h2>
+
+<p>
+ The latest Go release, version 1.9, arrives six months
+ after <a href="go1.8">Go 1.8</a> and is the tenth release in
+ the <a href="https://golang.org/doc/devel/release.html">Go 1.x
+ series</a>.
+ There are two <a href="#language">changes to the language</a>:
+ adding support for type aliases and defining when implementations
+ may fuse floating point operations.
+ Most of the changes are in the implementation of the toolchain,
+ runtime, and libraries.
+ As always, the release maintains the Go 1
+ <a href="/doc/go1compat.html">promise of compatibility</a>.
+ We expect almost all Go programs to continue to compile and run as
+ before.
+</p>
+
+<p>
+ The release
+ adds <a href="#monotonic-time">transparent monotonic time support</a>,
+ <a href="#parallel-compile">parallelizes compilation of functions</a> within a package,
+ better supports <a href="#test-helper">test helper functions</a>,
+ includes a new <a href="#math-bits">bit manipulation package</a>,
+ and has a new <a href="#sync-map">concurrent map type</a>.
+</p>
+
+<h2 id="language">Changes to the language</h2>
+
+<p>
+ There are two changes to the language.
+</p>
+<p>
+ Go now supports type aliases to support gradual code repair while
+ moving a type between packages.
+ The <a href="https://golang.org/design/18130-type-alias">type alias
+ design document</a>
+ and <a href="https://talks.golang.org/2016/refactor.article">an
+ article on refactoring</a> cover the problem in detail.
+ In short, a type alias declaration has the form:
+</p>
+
+<pre>
+type T1 = T2
+</pre>
+
+<p>
+ This declaration introduces an alias name <code>T1</code>—an
+ alternate spelling—for the type denoted by <code>T2</code>; that is,
+ both <code>T1</code> and <code>T2</code> denote the same type.
+</p>
+
+<p> <!-- CL 40391 -->
+ A smaller language change is that the
+ <a href="/ref/spec#Floating_point_operators">language specification
+ now states</a> when implementations are allowed to fuse floating
+ point operations together, such as by using an architecture's "fused
+ multiply and add" (FMA) instruction to compute <code>x*y</code> <code>+</code> <code>z</code>
+ without rounding the intermediate result <code>x*y</code>.
+ To force the intermediate rounding, write <code>float64(x*y)</code> <code>+</code> <code>z</code>.
+</p>
+
+<h2 id="ports">Ports</h2>
+
+<p>
+ There are no new supported operating systems or processor
+ architectures in this release.
+</p>
+
+<h3 id="power8">ppc64x requires POWER8</h3>
+
+<p> <!-- CL 36725, CL 36832 -->
+ Both <code>GOARCH=ppc64</code> and <code>GOARCH=ppc64le</code> now
+ require at least POWER8 support. In previous releases,
+ only <code>GOARCH=ppc64le</code> required POWER8 and the big
+ endian <code>ppc64</code> architecture supported older
+ hardware.
+<p>
+
+<h3 id="freebsd">FreeBSD</h3>
+
+<p>
+ Go 1.9 is the last release that will run on FreeBSD 9.3,
+ which is already
+ <a href="https://www.freebsd.org/security/unsupported.html">unsupported by FreeBSD</a>.
+ Go 1.10 will require FreeBSD 10.3+.
+</p>
+
+<h3 id="openbsd">OpenBSD 6.0</h3>
+
+<p> <!-- CL 40331 -->
+ Go 1.9 now enables PT_TLS generation for cgo binaries and thus
+ requires OpenBSD 6.0 or newer. Go 1.9 no longer supports
+ OpenBSD 5.9.
+<p>
+
+<h3 id="known_issues">Known Issues</h3>
+
+<p>
+ There are some instabilities on FreeBSD that are known but not understood.
+ These can lead to program crashes in rare cases.
+ See <a href="https://golang.org/issue/15658">issue 15658</a>.
+ Any help in solving this FreeBSD-specific issue would be appreciated.
+</p>
+
+<p>
+ Go stopped running NetBSD builders during the Go 1.9 development
+ cycle due to NetBSD kernel crashes, up to and including NetBSD 7.1.
+ As Go 1.9 is being released, NetBSD 7.1.1 is being released with a fix.
+ However, at this time we have no NetBSD builders passing our test suite.
+ Any help investigating the
+ <a href="https://github.com/golang/go/labels/OS-NetBSD">various NetBSD issues</a>
+ would be appreciated.
+</p>
+
+<h2 id="tools">Tools</h2>
+
+<h3 id="parallel-compile">Parallel Compilation</h3>
+
+<p>
+ The Go compiler now supports compiling a package's functions in parallel, taking
+ advantage of multiple cores. This is in addition to the <code>go</code> command's
+ existing support for parallel compilation of separate packages.
+ Parallel compilation is on by default, but it can be disabled by setting the
+ environment variable <code>GO19CONCURRENTCOMPILATION</code> to <code>0</code>.
+</p>
+
+<h3 id="vendor-dotdotdot">Vendor matching with ./...</h3>
+
+<p><!-- CL 38745 -->
+ By popular request, <code>./...</code> no longer matches packages
+ in <code>vendor</code> directories in tools accepting package names,
+ such as <code>go</code> <code>test</code>. To match vendor
+ directories, write <code>./vendor/...</code>.
+</p>
+
+<h3 id="goroot">Moved GOROOT</h3>
+
+<p><!-- CL 42533 -->
+ The <a href="/cmd/go/">go tool</a> will now use the path from which it
+ was invoked to attempt to locate the root of the Go install tree.
+ This means that if the entire Go installation is moved to a new
+ location, the go tool should continue to work as usual.
+ This may be overridden by setting <code>GOROOT</code> in the environment,
+ which should only be done in unusual circumstances.
+ Note that this does not affect the result of
+ the <a href="/pkg/runtime/#GOROOT">runtime.GOROOT</a> function, which
+ will continue to report the original installation location;
+ this may be fixed in later releases.
+</p>
+
+<h3 id="compiler">Compiler Toolchain</h3>
+
+<p><!-- CL 37441 -->
+ Complex division is now C99-compatible. This has always been the
+ case in gccgo and is now fixed in the gc toolchain.
+</p>
+
+<p> <!-- CL 36983 -->
+ The linker will now generate DWARF information for cgo executables on Windows.
+</p>
+
+<p> <!-- CL 44210, CL 40095 -->
+ The compiler now includes lexical scopes in the generated DWARF if the
+ <code>-N -l</code> flags are provided, allowing
+ debuggers to hide variables that are not in scope. The <code>.debug_info</code>
+ section is now DWARF version 4.
+</p>
+
+<p> <!-- CL 43855 -->
+ The values of <code>GOARM</code> and <code>GO386</code> now affect a
+ compiled package's build ID, as used by the <code>go</code> tool's
+ dependency caching.
+</p>
+
+<h3 id="asm">Assembler</h3>
+
+<p> <!-- CL 42028 -->
+ The four-operand ARM <code>MULA</code> instruction is now assembled correctly,
+ with the addend register as the third argument and the result
+ register as the fourth and final argument.
+ In previous releases, the two meanings were reversed.
+ The three-operand form, in which the fourth argument is implicitly
+ the same as the third, is unaffected.
+ Code using four-operand <code>MULA</code> instructions
+ will need to be updated, but we believe this form is very rarely used.
+ <code>MULAWT</code> and <code>MULAWB</code> were already
+ using the correct order in all forms and are unchanged.
+</p>
+
+<p> <!-- CL 42990 -->
+ The assembler now supports <code>ADDSUBPS/PD</code>, completing the
+ two missing x86 SSE3 instructions.
+</p>
+
+<h3 id="go-doc">Doc</h3>
+
+<p><!-- CL 36031 -->
+ Long lists of arguments are now truncated. This improves the readability
+ of <code>go</code> <code>doc</code> on some generated code.
+</p>
+
+<p><!-- CL 38438 -->
+ Viewing documentation on struct fields is now supported.
+ For example, <code>go</code> <code>doc</code> <code>http.Client.Jar</code>.
+</p>
+
+<h3 id="go-env-json">Env</h3>
+
+<p> <!-- CL 38757 -->
+ The new <code>go</code> <code>env</code> <code>-json</code> flag
+ enables JSON output, instead of the default OS-specific output
+ format.
+</p>
+
+<h3 id="go-test-list">Test</h3>
+
+<p> <!-- CL 41195 -->
+ The <a href="/cmd/go/#hdr-Description_of_testing_flags"><code>go</code> <code>test</code></a>
+ command accepts a new <code>-list</code> flag, which takes a regular
+ expression as an argument and prints to stdout the name of any
+ tests, benchmarks, or examples that match it, without running them.
+</p>
+
+
+<h3 id="go-tool-pprof">Pprof</h3>
+
+<p> <!-- CL 34192 -->
+ Profiles produced by the <code>runtime/pprof</code> package now
+ include symbol information, so they can be viewed
+ in <code>go</code> <code>tool</code> <code>pprof</code>
+ without the binary that produced the profile.
+</p>
+
+<p> <!-- CL 38343 -->
+ The <code>go</code> <code>tool</code> <code>pprof</code> command now
+ uses the HTTP proxy information defined in the environment, using
+ <a href="/pkg/net/http/#ProxyFromEnvironment"><code>http.ProxyFromEnvironment</code></a>.
+</p>
+
+<h3 id="vet">Vet</h3>
+
+<!-- CL 40112 -->
+<p>
+ The <a href="/cmd/vet/"><code>vet</code> command</a>
+ has been better integrated into the
+ <a href="/cmd/go/"><code>go</code> tool</a>,
+ so <code>go</code> <code>vet</code> now supports all standard build
+ flags while <code>vet</code>'s own flags are now available
+ from <code>go</code> <code>vet</code> as well as
+ from <code>go</code> <code>tool</code> <code>vet</code>.
+</p>
+
+<h3 id="gccgo">Gccgo</h3>
+
+<p>
+Due to the alignment of Go's semiannual release schedule with GCC's
+annual release schedule,
+GCC release 7 contains the Go 1.8.3 version of gccgo.
+We expect that the next release, GCC 8, will contain the Go 1.10
+version of gccgo.
+</p>
+
+<h2 id="runtime">Runtime</h2>
+
+<h3 id="callersframes">Call stacks with inlined frames</h3>
+
+<p>
+ Users of
+ <a href="/pkg/runtime#Callers"><code>runtime.Callers</code></a>
+ should avoid directly inspecting the resulting PC slice and instead use
+ <a href="/pkg/runtime#CallersFrames"><code>runtime.CallersFrames</code></a>
+ to get a complete view of the call stack, or
+ <a href="/pkg/runtime#Caller"><code>runtime.Caller</code></a>
+ to get information about a single caller.
+ This is because an individual element of the PC slice cannot account
+ for inlined frames or other nuances of the call stack.
+</p>
+
+<p>
+ Specifically, code that directly iterates over the PC slice and uses
+ functions such as
+ <a href="/pkg/runtime#FuncForPC"><code>runtime.FuncForPC</code></a>
+ to resolve each PC individually will miss inlined frames.
+ To get a complete view of the stack, such code should instead use
+ <code>CallersFrames</code>.
+ Likewise, code should not assume that the length returned by
+ <code>Callers</code> is any indication of the call depth.
+ It should instead count the number of frames returned by
+ <code>CallersFrames</code>.
+</p>
+
+<p>
+ Code that queries a single caller at a specific depth should use
+ <code>Caller</code> rather than passing a slice of length 1 to
+ <code>Callers</code>.
+</p>
+
+<p>
+ <a href="/pkg/runtime#CallersFrames"><code>runtime.CallersFrames</code></a>
+ has been available since Go 1.7, so code can be updated prior to
+ upgrading to Go 1.9.
+</p>
+
+<h2 id="performance">Performance</h2>
+
+<p>
+ As always, the changes are so general and varied that precise
+ statements about performance are difficult to make. Most programs
+ should run a bit faster, due to speedups in the garbage collector,
+ better generated code, and optimizations in the core library.
+</p>
+
+<h3 id="gc">Garbage Collector</h3>
+
+<p> <!-- CL 37520 -->
+ Library functions that used to trigger stop-the-world garbage
+ collection now trigger concurrent garbage collection.
+
+ Specifically, <a href="/pkg/runtime/#GC"><code>runtime.GC</code></a>,
+ <a href="/pkg/runtime/debug/#SetGCPercent"><code>debug.SetGCPercent</code></a>,
+ and
+ <a href="/pkg/runtime/debug/#FreeOSMemory"><code>debug.FreeOSMemory</code></a>,
+ now trigger concurrent garbage collection, blocking only the calling
+ goroutine until the garbage collection is done.
+</p>
+
+<p> <!-- CL 34103, CL 39835 -->
+ The
+ <a href="/pkg/runtime/debug/#SetGCPercent"><code>debug.SetGCPercent</code></a>
+ function only triggers a garbage collection if one is immediately
+ necessary because of the new GOGC value.
+ This makes it possible to adjust GOGC on-the-fly.
+</p>
+
+<p> <!-- CL 38732 -->
+ Large object allocation performance is significantly improved in
+ applications using large (>50GB) heaps containing many large
+ objects.
+</p>
+
+<p> <!-- CL 34937 -->
+ The <a href="/pkg/runtime/#ReadMemStats"><code>runtime.ReadMemStats</code></a>
+ function now takes less than 100µs even for very large heaps.
+</p>
+
+<h2 id="library">Core library</h2>
+
+<h3 id="monotonic-time">Transparent Monotonic Time support</h3>
+
+<p> <!-- CL 36255 -->
+ The <a href="/pkg/time/"><code>time</code></a> package now transparently
+ tracks monotonic time in each <a href="/pkg/time/#Time"><code>Time</code></a>
+ value, making computing durations between two <code>Time</code> values
+ a safe operation in the presence of wall clock adjustments.
+ See the <a href="/pkg/time/#hdr-Monotonic_Clocks">package docs</a> and
+ <a href="https://golang.org/design/12914-monotonic">design document</a>
+ for details.
+</p>
+
+<h3 id="math-bits">New bit manipulation package</h3>
+
+<p> <!-- CL 36315 -->
+ Go 1.9 includes a new package,
+ <a href="/pkg/math/bits/"><code>math/bits</code></a>, with optimized
+ implementations for manipulating bits. On most architectures,
+ functions in this package are additionally recognized by the
+ compiler and treated as intrinsics for additional performance.
+</p>
+
+<h3 id="test-helper">Test Helper Functions</h3>
+
+<p> <!-- CL 38796 -->
+ The
+ new <a href="/pkg/testing/#T.Helper"><code>(*T).Helper</code></a>
+ and <a href="/pkg/testing/#B.Helper"><code>(*B).Helper</code></a>
+ methods mark the calling function as a test helper function. When
+ printing file and line information, that function will be skipped.
+ This permits writing test helper functions while still having useful
+ line numbers for users.
+</p>
+
+<h3 id="sync-map">Concurrent Map</h3>
+
+<p> <!-- CL 36617 -->
+ The new <a href="/pkg/sync/#Map"><code>Map</code></a> type
+ in the <a href="/pkg/sync/"><code>sync</code></a> package
+ is a concurrent map with amortized-constant-time loads, stores, and
+ deletes. It is safe for multiple goroutines to call a <code>Map</code>'s methods
+ concurrently.
+</p>
+
+<h3 id="pprof-labels">Profiler Labels</h3>
+
+<p><!-- CL 34198 -->
+ The <a href="/pkg/runtime/pprof"><code>runtime/pprof</code> package</a>
+ now supports adding labels to <code>pprof</code> profiler records.
+ Labels form a key-value map that is used to distinguish calls of the
+ same function in different contexts when looking at profiles
+ with the <a href="/cmd/pprof/"><code>pprof</code> command</a>.
+ The <code>pprof</code> package's
+ new <a href="/pkg/runtime/pprof/#Do"><code>Do</code> function</a>
+ runs code associated with some provided labels. Other new functions
+ in the package help work with labels.
+</p>
+
+</dl><!-- runtime/pprof -->
+
+
+<h3 id="minor_library_changes">Minor changes to the library</h3>
+
+<p>
+ As always, there are various minor changes and updates to the library,
+ made with the Go 1 <a href="/doc/go1compat">promise of compatibility</a>
+ in mind.
+</p>
+
+<dl id="archive/zip"><dt><a href="/pkg/archive/zip/">archive/zip</a></dt>
+ <dd>
+ <p><!-- CL 39570 -->
+ The
+ ZIP <a href="/pkg/archive/zip/#Writer"><code>Writer</code></a>
+ now sets the UTF-8 bit in
+ the <a href="/pkg/archive/zip/#FileHeader.Flags"><code>FileHeader.Flags</code></a>
+ when appropriate.
+ </p>
+
+</dl><!-- archive/zip -->
+
+<dl id="crypto/rand"><dt><a href="/pkg/crypto/rand/">crypto/rand</a></dt>
+ <dd>
+ <p><!-- CL 43852 -->
+ On Linux, Go now calls the <code>getrandom</code> system call
+ without the <code>GRND_NONBLOCK</code> flag; it will now block
+ until the kernel has sufficient randomness. On kernels predating
+ the <code>getrandom</code> system call, Go continues to read
+ from <code>/dev/urandom</code>.
+ </p>
+
+</dl><!-- crypto/rand -->
+
+<dl id="crypto/x509"><dt><a href="/pkg/crypto/x509/">crypto/x509</a></dt>
+ <dd>
+ <p><!-- CL 36093 -->
+
+ On Unix systems the environment
+ variables <code>SSL_CERT_FILE</code>
+ and <code>SSL_CERT_DIR</code> can now be used to override the
+ system default locations for the SSL certificate file and SSL
+ certificate files directory, respectively.
+ </p>
+
+ <p>The FreeBSD file <code>/usr/local/etc/ssl/cert.pem</code> is
+ now included in the certificate search path.
+ </p>
+
+ <p><!-- CL 36900 -->
+
+ The package now supports excluded domains in name constraints.
+ In addition to enforcing such constraints,
+ <a href="/pkg/crypto/x509/#CreateCertificate"><code>CreateCertificate</code></a>
+ will create certificates with excluded name constraints
+ if the provided template certificate has the new
+ field
+ <a href="/pkg/crypto/x509/#Certificate.ExcludedDNSDomains"><code>ExcludedDNSDomains</code></a>
+ populated.
+ </p>
+
+ <p><!-- CL 36696 -->
+
+ If any SAN extension, including with no DNS names, is present
+ in the certificate, then the Common Name from
+ <a href="/pkg/crypto/x509/#Certificate.Subject"><code>Subject</code></a> is ignored.
+ In previous releases, the code tested only whether DNS-name SANs were
+ present in a certificate.
+ </p>
+
+</dl><!-- crypto/x509 -->
+
+<dl id="database/sql"><dt><a href="/pkg/database/sql/">database/sql</a></dt>
+ <dd>
+ <p><!-- CL 35476 -->
+ The package will now use a cached <a href="/pkg/database/sql/#Stmt"><code>Stmt</code></a> if
+ available in <a href="/pkg/database/sql/#Tx.Stmt"><code>Tx.Stmt</code></a>.
+ This prevents statements from being re-prepared each time
+ <a href="/pkg/database/sql/#Tx.Stmt"><code>Tx.Stmt</code></a> is called.
+ </p>
+
+ <p><!-- CL 38533 -->
+ The package now allows drivers to implement their own argument checkers by implementing
+ <a href="/pkg/database/sql/driver/#NamedValueChecker"><code>driver.NamedValueChecker</code></a>.
+ This also allows drivers to support <code>OUTPUT</code> and <code>INOUT</code> parameter types.
+ <a href="/pkg/database/sql/#Out"><code>Out</code></a> should be used to return output parameters
+ when supported by the driver.
+ </p>
+
+ <p><!-- CL 39031 -->
+ <a href="/pkg/database/sql/#Rows.Scan"><code>Rows.Scan</code></a> can now scan user-defined string types.
+ Previously the package supported scanning into numeric types like <code>type</code> <code>Int</code> <code>int64</code>. It now also supports
+ scanning into string types like <code>type</code> <code>String</code> <code>string</code>.
+ </p>
+
+ <p><!-- CL 40694 -->
+ The new <a href="/pkg/database/sql/#DB.Conn"><code>DB.Conn</code></a> method returns the new
+ <a href="/pkg/database/sql/#Conn"><code>Conn</code></a> type representing an
+ exclusive connection to the database from the connection pool. All queries run on
+ a <a href="/pkg/database/sql/#Conn"><code>Conn</code></a> will use the same underlying
+ connection until <a href="/pkg/database/sql/#Conn.Close"><code>Conn.Close</code></a> is called
+ to return the connection to the connection pool.
+ </p>
+
+</dl><!-- database/sql -->
+
+<dl id="encoding/asn1"><dt><a href="/pkg/encoding/asn1/">encoding/asn1</a></dt>
+ <dd>
+ <p><!-- CL 38660 -->
+ The new
+ <a href="/pkg/encoding/asn1/#NullBytes"><code>NullBytes</code></a>
+ and
+ <a href="/pkg/encoding/asn1/#NullRawValue"><code>NullRawValue</code></a>
+ represent the ASN.1 NULL type.
+ </p>
+
+</dl><!-- encoding/asn1 -->
+
+<dl id="encoding/base32"><dt><a href="/pkg/encoding/base32/">encoding/base32</a></dt>
+ <dd>
+ <p><!-- CL 38634 -->
+ The new <a href="/pkg/encoding/base32/#Encoding.WithPadding">Encoding.WithPadding</a>
+ method adds support for custom padding characters and disabling padding.
+ </p>
+
+</dl><!-- encoding/base32 -->
+
+<dl id="encoding/csv"><dt><a href="/pkg/encoding/csv/">encoding/csv</a></dt>
+ <dd>
+ <p><!-- CL 41730 -->
+ The new field
+ <a href="/pkg/encoding/csv/#Reader.ReuseRecord"><code>Reader.ReuseRecord</code></a>
+ controls whether calls to
+ <a href="/pkg/encoding/csv/#Reader.Read"><code>Read</code></a>
+ may return a slice sharing the backing array of the previous
+ call's returned slice for improved performance.
+ </p>
+
+</dl><!-- encoding/csv -->
+
+<dl id="fmt"><dt><a href="/pkg/fmt/">fmt</a></dt>
+ <dd>
+ <p><!-- CL 37051 -->
+ The sharp flag ('<code>#</code>') is now supported when printing
+ floating point and complex numbers. It will always print a
+ decimal point
+ for <code>%e</code>, <code>%E</code>, <code>%f</code>, <code>%F</code>, <code>%g</code>
+ and <code>%G</code>; it will not remove trailing zeros
+ for <code>%g</code> and <code>%G</code>.
+ </p>
+
+</dl><!-- fmt -->
+
+<dl id="hash/fnv"><dt><a href="/pkg/hash/fnv/">hash/fnv</a></dt>
+ <dd>
+ <p><!-- CL 38356 -->
+ The package now includes 128-bit FNV-1 and FNV-1a hash support with
+ <a href="/pkg/hash/fnv/#New128"><code>New128</code></a> and
+ <a href="/pkg/hash/fnv/#New128a"><code>New128a</code></a>, respectively.
+ </p>
+
+</dl><!-- hash/fnv -->
+
+<dl id="html/template"><dt><a href="/pkg/html/template/">html/template</a></dt>
+ <dd>
+ <p><!-- CL 37880, CL 40936 -->
+ The package now reports an error if a predefined escaper (one of
+ "html", "urlquery" and "js") is found in a pipeline and does not match
+ what the auto-escaper would have decided on its own.
+ This avoids certain security or correctness issues.
+ Now use of one of these escapers is always either a no-op or an error.
+ (The no-op case eases migration from <a href="/pkg/text/template/">text/template</a>.)
+ </p>
+
+</dl><!-- html/template -->
+
+<dl id="image"><dt><a href="/pkg/image/">image</a></dt>
+ <dd>
+ <p><!-- CL 36734 -->
+ The <a href="/pkg/image/#Rectangle.Intersect"><code>Rectangle.Intersect</code></a>
+ method now returns a zero <code>Rectangle</code> when called on
+ adjacent but non-overlapping rectangles, as documented. In
+ earlier releases it would incorrectly return an empty but
+ non-zero <code>Rectangle</code>.
+ </p>
+
+</dl><!-- image -->
+
+<dl id="image/color"><dt><a href="/pkg/image/color/">image/color</a></dt>
+ <dd>
+ <p><!-- CL 36732 -->
+ The YCbCr to RGBA conversion formula has been tweaked to ensure
+ that rounding adjustments span the complete [0, 0xffff] RGBA
+ range.
+ </p>
+
+</dl><!-- image/color -->
+
+<dl id="image/png"><dt><a href="/pkg/image/png/">image/png</a></dt>
+ <dd>
+ <p><!-- CL 34150 -->
+ The new <a href="/pkg/image/png/#Encoder.BufferPool"><code>Encoder.BufferPool</code></a>
+ field allows specifying an <a href="/pkg/image/png/#EncoderBufferPool"><code>EncoderBufferPool</code></a>,
+ that will be used by the encoder to get temporary <code>EncoderBuffer</code>
+ buffers when encoding a PNG image.
+
+ The use of a <code>BufferPool</code> reduces the number of
+ memory allocations performed while encoding multiple images.
+ </p>
+
+ <p><!-- CL 38271 -->
+ The package now supports the decoding of transparent 8-bit
+ grayscale ("Gray8") images.
+ </p>
+
+</dl><!-- image/png -->
+
+<dl id="math/big"><dt><a href="/pkg/math/big/">math/big</a></dt>
+ <dd>
+ <p><!-- CL 36487 -->
+ The new
+ <a href="/pkg/math/big/#Int.IsInt64"><code>IsInt64</code></a>
+ and
+ <a href="/pkg/math/big/#Int.IsUint64"><code>IsUint64</code></a>
+ methods report whether an <code>Int</code>
+ may be represented as an <code>int64</code> or <code>uint64</code>
+ value.
+ </p>
+
+</dl><!-- math/big -->
+
+<dl id="mime/multipart"><dt><a href="/pkg/mime/multipart/">mime/multipart</a></dt>
+ <dd>
+ <p><!-- CL 39223 -->
+ The new
+ <a href="/pkg/mime/multipart/#FileHeader.Size"><code>FileHeader.Size</code></a>
+ field describes the size of a file in a multipart message.
+ </p>
+
+</dl><!-- mime/multipart -->
+
+<dl id="net"><dt><a href="/pkg/net/">net</a></dt>
+ <dd>
+ <p><!-- CL 32572 -->
+ The new
+ <a href="/pkg/net/#Resolver.StrictErrors"><code>Resolver.StrictErrors</code></a>
+ provides control over how Go's built-in DNS resolver handles
+ temporary errors during queries composed of multiple sub-queries,
+ such as an A+AAAA address lookup.
+ </p>
+
+ <p><!-- CL 37260 -->
+ The new
+ <a href="/pkg/net/#Resolver.Dial"><code>Resolver.Dial</code></a>
+ allows a <code>Resolver</code> to use a custom dial function.
+ </p>
+
+ <p><!-- CL 40510 -->
+ <a href="/pkg/net/#JoinHostPort"><code>JoinHostPort</code></a> now only places an address in square brackets if the host contains a colon.
+ In previous releases it would also wrap addresses in square brackets if they contained a percent ('<code>%</code>') sign.
+ </p>
+
+ <p><!-- CL 37913 -->
+ The new methods
+ <a href="/pkg/net/#TCPConn.SyscallConn"><code>TCPConn.SyscallConn</code></a>,
+ <a href="/pkg/net/#IPConn.SyscallConn"><code>IPConn.SyscallConn</code></a>,
+ <a href="/pkg/net/#UDPConn.SyscallConn"><code>UDPConn.SyscallConn</code></a>,
+ and
+ <a href="/pkg/net/#UnixConn.SyscallConn"><code>UnixConn.SyscallConn</code></a>
+ provide access to the connections' underlying file descriptors.
+ </p>
+
+ <p><!-- 45088 -->
+ It is now safe to call <a href="/pkg/net/#Dial"><code>Dial</code></a> with the address obtained from
+ <code>(*TCPListener).String()</code> after creating the listener with
+ <code><a href="/pkg/net/#Listen">Listen</a>("tcp", ":0")</code>.
+ Previously it failed on some machines with half-configured IPv6 stacks.
+ </p>
+
+</dl><!-- net -->
+
+<dl id="net/http"><dt><a href="/pkg/net/http/">net/http</a></dt>
+ <dd>
+
+ <p><!-- CL 37328 -->
+ The <a href="/pkg/net/http/#Cookie.String"><code>Cookie.String</code></a> method, used for
+ <code>Cookie</code> and <code>Set-Cookie</code> headers, now encloses values in double quotes
+ if the value contains either a space or a comma.
+ </p>
+
+ <p>Server changes:</p>
+ <ul>
+ <li><!-- CL 38194 -->
+ <a href="/pkg/net/http/#ServeMux"><code>ServeMux</code></a> now ignores ports in the host
+ header when matching handlers. The host is matched unmodified for <code>CONNECT</code> requests.
+ </li>
+
+ <li><!-- CL 44074 -->
+ The new <a href="/pkg/net/http/#Server.ServeTLS"><code>Server.ServeTLS</code></a> method wraps
+ <a href="/pkg/net/http/#Server.Serve"><code>Server.Serve</code></a> with added TLS support.
+ </li>
+
+ <li><!-- CL 34727 -->
+ <a href="/pkg/net/http/#Server.WriteTimeout"><code>Server.WriteTimeout</code></a>
+ now applies to HTTP/2 connections and is enforced per-stream.
+ </li>
+
+ <li><!-- CL 43231 -->
+ HTTP/2 now uses the priority write scheduler by default.
+ Frames are scheduled by following HTTP/2 priorities as described in
+ <a href="https://tools.ietf.org/html/rfc7540#section-5.3">RFC 7540 Section 5.3</a>.
+ </li>
+
+ <li><!-- CL 36483 -->
+ The HTTP handler returned by <a href="/pkg/net/http/#StripPrefix"><code>StripPrefix</code></a>
+ now calls its provided handler with a modified clone of the original <code>*http.Request</code>.
+ Any code storing per-request state in maps keyed by <code>*http.Request</code> should
+ use
+ <a href="/pkg/net/http/#Request.Context"><code>Request.Context</code></a>,
+ <a href="/pkg/net/http/#Request.WithContext"><code>Request.WithContext</code></a>,
+ and
+ <a href="/pkg/context/#WithValue"><code>context.WithValue</code></a> instead.
+ </li>
+
+ <li><!-- CL 35490 -->
+ <a href="/pkg/net/http/#LocalAddrContextKey"><code>LocalAddrContextKey</code></a> now contains
+ the connection's actual network address instead of the interface address used by the listener.
+ </li>
+ </ul>
+
+ <p>Client & Transport changes:</p>
+ <ul>
+ <li><!-- CL 35488 -->
+ The <a href="/pkg/net/http/#Transport"><code>Transport</code></a>
+ now supports making requests via SOCKS5 proxy when the URL returned by
+ <a href="/pkg/net/http/#Transport.Proxy"><code>Transport.Proxy</code></a>
+ has the scheme <code>socks5</code>.
+ </li>
+ </ul>
+
+</dl><!-- net/http -->
+
+<dl id="net/http/fcgi"><dt><a href="/pkg/net/http/fcgi/">net/http/fcgi</a></dt>
+ <dd>
+ <p><!-- CL 40012 -->
+ The new
+ <a href="/pkg/net/http/fcgi/#ProcessEnv"><code>ProcessEnv</code></a>
+ function returns FastCGI environment variables associated with an HTTP request
+ for which there are no appropriate
+ <a href="/pkg/net/http/#Request"><code>http.Request</code></a>
+ fields, such as <code>REMOTE_USER</code>.
+ </p>
+
+</dl><!-- net/http/fcgi -->
+
+<dl id="net/http/httptest"><dt><a href="/pkg/net/http/httptest/">net/http/httptest</a></dt>
+ <dd>
+ <p><!-- CL 34639 -->
+ The new
+ <a href="/pkg/net/http/httptest/#Server.Client"><code>Server.Client</code></a>
+ method returns an HTTP client configured for making requests to the test server.
+ </p>
+
+ <p>
+ The new
+ <a href="/pkg/net/http/httptest/#Server.Certificate"><code>Server.Certificate</code></a>
+ method returns the test server's TLS certificate, if any.
+ </p>
+
+</dl><!-- net/http/httptest -->
+
+<dl id="net/http/httputil"><dt><a href="/pkg/net/http/httputil/">net/http/httputil</a></dt>
+ <dd>
+ <p><!-- CL 43712 -->
+ The <a href="/pkg/net/http/httputil/#ReverseProxy"><code>ReverseProxy</code></a>
+ now proxies all HTTP/2 response trailers, even those not declared in the initial response
+ header. Such undeclared trailers are used by the gRPC protocol.
+ </p>
+
+</dl><!-- net/http/httputil -->
+
+<dl id="os"><dt><a href="/pkg/os/">os</a></dt>
+ <dd>
+ <p><!-- CL 36800 -->
+ The <code>os</code> package now uses the internal runtime poller
+ for file I/O.
+ This reduces the number of threads required for read/write
+ operations on pipes, and it eliminates races when one goroutine
+ closes a file while another is using the file for I/O.
+ </p>
+
+ <dd>
+ <p><!-- CL 37915 -->
+ On Windows,
+ <a href="/pkg/os/#Args"><code>Args</code></a>
+ is now populated without <code>shell32.dll</code>, improving process start-up time by 1-7 ms.
+ </p>
+
+</dl><!-- os -->
+
+<dl id="os/exec"><dt><a href="/pkg/os/exec/">os/exec</a></dt>
+ <dd>
+ <p><!-- CL 37586 -->
+ The <code>os/exec</code> package now prevents child processes from being created with
+ any duplicate environment variables.
+ If <a href="/pkg/os/exec/#Cmd.Env"><code>Cmd.Env</code></a>
+ contains duplicate environment keys, only the last
+ value in the slice for each duplicate key is used.
+ </p>
+
+</dl><!-- os/exec -->
+
+<dl id="os/user"><dt><a href="/pkg/os/user/">os/user</a></dt>
+ <dd>
+ <p><!-- CL 37664 -->
+ <a href="/pkg/os/user/#Lookup"><code>Lookup</code></a> and
+ <a href="/pkg/os/user/#LookupId"><code>LookupId</code></a> now
+ work on Unix systems when <code>CGO_ENABLED=0</code> by reading
+ the <code>/etc/passwd</code> file.
+ </p>
+
+ <p><!-- CL 33713 -->
+ <a href="/pkg/os/user/#LookupGroup"><code>LookupGroup</code></a> and
+ <a href="/pkg/os/user/#LookupGroupId"><code>LookupGroupId</code></a> now
+ work on Unix systems when <code>CGO_ENABLED=0</code> by reading
+ the <code>/etc/group</code> file.
+ </p>
+
+</dl><!-- os/user -->
+
+<dl id="reflect"><dt><a href="/pkg/reflect/">reflect</a></dt>
+ <dd>
+ <p><!-- CL 38335 -->
+ The new
+ <a href="/pkg/reflect/#MakeMapWithSize"><code>MakeMapWithSize</code></a>
+ function creates a map with a capacity hint.
+ </p>
+
+</dl><!-- reflect -->
+
+<dl id="pkg-runtime"><dt><a href="/pkg/runtime/">runtime</a></dt>
+ <dd>
+ <p><!-- CL 37233, CL 37726 -->
+ Tracebacks generated by the runtime and recorded in profiles are
+ now accurate in the presence of inlining.
+ To retrieve tracebacks programmatically, applications should use
+ <a href="/pkg/runtime/#CallersFrames"><code>runtime.CallersFrames</code></a>
+ rather than directly iterating over the results of
+ <a href="/pkg/runtime/#Callers"><code>runtime.Callers</code></a>.
+ </p>
+
+ <p><!-- CL 38403 -->
+ On Windows, Go no longer forces the system timer to run at high
+ resolution when the program is idle.
+ This should reduce the impact of Go programs on battery life.
+ </p>
+
+ <p><!-- CL 29341 -->
+ On FreeBSD, <code>GOMAXPROCS</code> and
+ <a href="/pkg/runtime/#NumCPU"><code>runtime.NumCPU</code></a>
+ are now based on the process' CPU mask, rather than the total
+ number of CPUs.
+ </p>
+
+ <p><!-- CL 43641 -->
+ The runtime has preliminary support for Android O.
+ </p>
+
+</dl><!-- runtime -->
+
+<dl id="runtime/debug"><dt><a href="/pkg/runtime/debug/">runtime/debug</a></dt>
+ <dd>
+ <p><!-- CL 34013 -->
+ Calling
+ <a href="/pkg/runtime/debug/#SetGCPercent"><code>SetGCPercent</code></a>
+ with a negative value no longer runs an immediate garbage collection.
+ </p>
+
+</dl><!-- runtime/debug -->
+
+<dl id="runtime/trace"><dt><a href="/pkg/runtime/trace/">runtime/trace</a></dt>
+ <dd>
+ <p><!-- CL 36015 -->
+ The execution trace now displays mark assist events, which
+ indicate when an application goroutine is forced to assist
+ garbage collection because it is allocating too quickly.
+ </p>
+
+ <p><!-- CL 40810 -->
+ "Sweep" events now encompass the entire process of finding free
+ space for an allocation, rather than recording each individual
+ span that is swept.
+ This reduces allocation latency when tracing allocation-heavy
+ programs.
+ The sweep event shows how many bytes were swept and how many
+ were reclaimed.
+ </p>
+
+</dl><!-- runtime/trace -->
+
+<dl id="sync"><dt><a href="/pkg/sync/">sync</a></dt>
+ <dd>
+ <p><!-- CL 34310 -->
+ <a href="/pkg/sync/#Mutex"><code>Mutex</code></a> is now more fair.
+ </p>
+
+</dl><!-- sync -->
+
+<dl id="syscall"><dt><a href="/pkg/syscall/">syscall</a></dt>
+ <dd>
+ <p><!-- CL 36697 -->
+ The new field
+ <a href="/pkg/syscall/#Credential.NoSetGroups"><code>Credential.NoSetGroups</code></a>
+ controls whether Unix systems make a <code>setgroups</code> system call
+ to set supplementary groups when starting a new process.
+ </p>
+
+ <p><!-- CL 43512 -->
+ The new field
+ <a href="/pkg/syscall/#SysProcAttr.AmbientCaps"><code>SysProcAttr.AmbientCaps</code></a>
+ allows setting ambient capabilities on Linux 4.3+ when creating
+ a new process.
+ </p>
+
+ <p><!-- CL 37439 -->
+ On 64-bit x86 Linux, process creation latency has been optimized with
+ use of <code>CLONE_VFORK</code> and <code>CLONE_VM</code>.
+ </p>
+
+ <p><!-- CL 37913 -->
+ The new
+ <a href="/pkg/syscall/#Conn"><code>Conn</code></a>
+ interface describes some types in the
+ <a href="/pkg/net/"><code>net</code></a>
+ package that can provide access to their underlying file descriptor
+ using the new
+ <a href="/pkg/syscall/#RawConn"><code>RawConn</code></a>
+ interface.
+ </p>
+
+</dl><!-- syscall -->
+
+
+<dl id="testing/quick"><dt><a href="/pkg/testing/quick/">testing/quick</a></dt>
+ <dd>
+ <p><!-- CL 39152 -->
+ The package now chooses values in the full range when
+ generating <code>int64</code> and <code>uint64</code> random
+ numbers; in earlier releases generated values were always
+ limited to the [-2<sup>62</sup>, 2<sup>62</sup>) range.
+ </p>
+
+ <p>
+ In previous releases, using a nil
+ <a href="/pkg/testing/quick/#Config.Rand"><code>Config.Rand</code></a>
+ value caused a fixed deterministic random number generator to be used.
+ It now uses a random number generator seeded with the current time.
+ For the old behavior, set <code>Config.Rand</code> to <code>rand.New(rand.NewSource(0))</code>.
+ </p>
+
+</dl><!-- testing/quick -->
+
+<dl id="text/template"><dt><a href="/pkg/text/template/">text/template</a></dt>
+ <dd>
+ <p><!-- CL 38420 -->
+ The handling of empty blocks, which was broken by a Go 1.8
+ change that made the result dependent on the order of templates,
+ has been fixed, restoring the old Go 1.7 behavior.
+ </p>
+
+</dl><!-- text/template -->
+
+<dl id="time"><dt><a href="/pkg/time/">time</a></dt>
+ <dd>
+ <p><!-- CL 36615 -->
+ The new methods
+ <a href="/pkg/time/#Duration.Round"><code>Duration.Round</code></a>
+ and
+ <a href="/pkg/time/#Duration.Truncate"><code>Duration.Truncate</code></a>
+ handle rounding and truncating durations to multiples of a given duration.
+ </p>
+
+ <p><!-- CL 35710 -->
+ Retrieving the time and sleeping now work correctly under Wine.
+ </p>
+
+ <p>
+ If a <code>Time</code> value has a monotonic clock reading, its
+ string representation (as returned by <code>String</code>) now includes a
+ final field <code>"m=±value"</code>, where <code>value</code> is the
+ monotonic clock reading formatted as a decimal number of seconds.
+ </p>
+
+ <p><!-- CL 44832 -->
+ The included <code>tzdata</code> timezone database has been
+ updated to version 2017b. As always, it is only used if the
+ system does not already have the database available.
+ </p>
+
+</dl><!-- time -->
diff --git a/_content/doc/go1.html b/_content/doc/go1.html
new file mode 100644
index 0000000..fa84062
--- /dev/null
+++ b/_content/doc/go1.html
@@ -0,0 +1,2037 @@
+<!--{
+ "Title": "Go 1 Release Notes",
+ "Template": true
+}-->
+
+<h2 id="introduction">Introduction to Go 1</h2>
+
+<p>
+Go version 1, Go 1 for short, defines a language and a set of core libraries
+that provide a stable foundation for creating reliable products, projects, and
+publications.
+</p>
+
+<p>
+The driving motivation for Go 1 is stability for its users. People should be able to
+write Go programs and expect that they will continue to compile and run without
+change, on a time scale of years, including in production environments such as
+Google App Engine. Similarly, people should be able to write books about Go, be
+able to say which version of Go the book is describing, and have that version
+number still be meaningful much later.
+</p>
+
+<p>
+Code that compiles in Go 1 should, with few exceptions, continue to compile and
+run throughout the lifetime of that version, even as we issue updates and bug
+fixes such as Go version 1.1, 1.2, and so on. Other than critical fixes, changes
+made to the language and library for subsequent releases of Go 1 may
+add functionality but will not break existing Go 1 programs.
+<a href="go1compat.html">The Go 1 compatibility document</a>
+explains the compatibility guidelines in more detail.
+</p>
+
+<p>
+Go 1 is a representation of Go as it used today, not a wholesale rethinking of
+the language. We avoided designing new features and instead focused on cleaning
+up problems and inconsistencies and improving portability. There are a number
+changes to the Go language and packages that we had considered for some time and
+prototyped but not released primarily because they are significant and
+backwards-incompatible. Go 1 was an opportunity to get them out, which is
+helpful for the long term, but also means that Go 1 introduces incompatibilities
+for old programs. Fortunately, the <code>go</code> <code>fix</code> tool can
+automate much of the work needed to bring programs up to the Go 1 standard.
+</p>
+
+<p>
+This document outlines the major changes in Go 1 that will affect programmers
+updating existing code; its reference point is the prior release, r60 (tagged as
+r60.3). It also explains how to update code from r60 to run under Go 1.
+</p>
+
+<h2 id="language">Changes to the language</h2>
+
+<h3 id="append">Append</h3>
+
+<p>
+The <code>append</code> predeclared variadic function makes it easy to grow a slice
+by adding elements to the end.
+A common use is to add bytes to the end of a byte slice when generating output.
+However, <code>append</code> did not provide a way to append a string to a <code>[]byte</code>,
+which is another common case.
+</p>
+
+{{code "/doc/progs/go1.go" `/greeting := ..byte/` `/append.*hello/`}}
+
+<p>
+By analogy with the similar property of <code>copy</code>, Go 1
+permits a string to be appended (byte-wise) directly to a byte
+slice, reducing the friction between strings and byte slices.
+The conversion is no longer necessary:
+</p>
+
+{{code "/doc/progs/go1.go" `/append.*world/`}}
+
+<p>
+<em>Updating</em>:
+This is a new feature, so existing code needs no changes.
+</p>
+
+<h3 id="close">Close</h3>
+
+<p>
+The <code>close</code> predeclared function provides a mechanism
+for a sender to signal that no more values will be sent.
+It is important to the implementation of <code>for</code> <code>range</code>
+loops over channels and is helpful in other situations.
+Partly by design and partly because of race conditions that can occur otherwise,
+it is intended for use only by the goroutine sending on the channel,
+not by the goroutine receiving data.
+However, before Go 1 there was no compile-time checking that <code>close</code>
+was being used correctly.
+</p>
+
+<p>
+To close this gap, at least in part, Go 1 disallows <code>close</code> on receive-only channels.
+Attempting to close such a channel is a compile-time error.
+</p>
+
+<pre>
+ var c chan int
+ var csend chan<- int = c
+ var crecv <-chan int = c
+ close(c) // legal
+ close(csend) // legal
+ close(crecv) // illegal
+</pre>
+
+<p>
+<em>Updating</em>:
+Existing code that attempts to close a receive-only channel was
+erroneous even before Go 1 and should be fixed. The compiler will
+now reject such code.
+</p>
+
+<h3 id="literals">Composite literals</h3>
+
+<p>
+In Go 1, a composite literal of array, slice, or map type can elide the
+type specification for the elements' initializers if they are of pointer type.
+All four of the initializations in this example are legal; the last one was illegal before Go 1.
+</p>
+
+{{code "/doc/progs/go1.go" `/type Date struct/` `/STOP/`}}
+
+<p>
+<em>Updating</em>:
+This change has no effect on existing code, but the command
+<code>gofmt</code> <code>-s</code> applied to existing source
+will, among other things, elide explicit element types wherever permitted.
+</p>
+
+
+<h3 id="init">Goroutines during init</h3>
+
+<p>
+The old language defined that <code>go</code> statements executed during initialization created goroutines but that they did not begin to run until initialization of the entire program was complete.
+This introduced clumsiness in many places and, in effect, limited the utility
+of the <code>init</code> construct:
+if it was possible for another package to use the library during initialization, the library
+was forced to avoid goroutines.
+This design was done for reasons of simplicity and safety but,
+as our confidence in the language grew, it seemed unnecessary.
+Running goroutines during initialization is no more complex or unsafe than running them during normal execution.
+</p>
+
+<p>
+In Go 1, code that uses goroutines can be called from
+<code>init</code> routines and global initialization expressions
+without introducing a deadlock.
+</p>
+
+{{code "/doc/progs/go1.go" `/PackageGlobal/` `/^}/`}}
+
+<p>
+<em>Updating</em>:
+This is a new feature, so existing code needs no changes,
+although it's possible that code that depends on goroutines not starting before <code>main</code> will break.
+There was no such code in the standard repository.
+</p>
+
+<h3 id="rune">The rune type</h3>
+
+<p>
+The language spec allows the <code>int</code> type to be 32 or 64 bits wide, but current implementations set <code>int</code> to 32 bits even on 64-bit platforms.
+It would be preferable to have <code>int</code> be 64 bits on 64-bit platforms.
+(There are important consequences for indexing large slices.)
+However, this change would waste space when processing Unicode characters with
+the old language because the <code>int</code> type was also used to hold Unicode code points: each code point would waste an extra 32 bits of storage if <code>int</code> grew from 32 bits to 64.
+</p>
+
+<p>
+To make changing to 64-bit <code>int</code> feasible,
+Go 1 introduces a new basic type, <code>rune</code>, to represent
+individual Unicode code points.
+It is an alias for <code>int32</code>, analogous to <code>byte</code>
+as an alias for <code>uint8</code>.
+</p>
+
+<p>
+Character literals such as <code>'a'</code>, <code>'語'</code>, and <code>'\u0345'</code>
+now have default type <code>rune</code>,
+analogous to <code>1.0</code> having default type <code>float64</code>.
+A variable initialized to a character constant will therefore
+have type <code>rune</code> unless otherwise specified.
+</p>
+
+<p>
+Libraries have been updated to use <code>rune</code> rather than <code>int</code>
+when appropriate. For instance, the functions <code>unicode.ToLower</code> and
+relatives now take and return a <code>rune</code>.
+</p>
+
+{{code "/doc/progs/go1.go" `/STARTRUNE/` `/ENDRUNE/`}}
+
+<p>
+<em>Updating</em>:
+Most source code will be unaffected by this because the type inference from
+<code>:=</code> initializers introduces the new type silently, and it propagates
+from there.
+Some code may get type errors that a trivial conversion will resolve.
+</p>
+
+<h3 id="error">The error type</h3>
+
+<p>
+Go 1 introduces a new built-in type, <code>error</code>, which has the following definition:
+</p>
+
+<pre>
+ type error interface {
+ Error() string
+ }
+</pre>
+
+<p>
+Since the consequences of this type are all in the package library,
+it is discussed <a href="#errors">below</a>.
+</p>
+
+<h3 id="delete">Deleting from maps</h3>
+
+<p>
+In the old language, to delete the entry with key <code>k</code> from map <code>m</code>, one wrote the statement,
+</p>
+
+<pre>
+ m[k] = value, false
+</pre>
+
+<p>
+This syntax was a peculiar special case, the only two-to-one assignment.
+It required passing a value (usually ignored) that is evaluated but discarded,
+plus a boolean that was nearly always the constant <code>false</code>.
+It did the job but was odd and a point of contention.
+</p>
+
+<p>
+In Go 1, that syntax has gone; instead there is a new built-in
+function, <code>delete</code>. The call
+</p>
+
+{{code "/doc/progs/go1.go" `/delete\(m, k\)/`}}
+
+<p>
+will delete the map entry retrieved by the expression <code>m[k]</code>.
+There is no return value. Deleting a non-existent entry is a no-op.
+</p>
+
+<p>
+<em>Updating</em>:
+Running <code>go</code> <code>fix</code> will convert expressions of the form <code>m[k] = value,
+false</code> into <code>delete(m, k)</code> when it is clear that
+the ignored value can be safely discarded from the program and
+<code>false</code> refers to the predefined boolean constant.
+The fix tool
+will flag other uses of the syntax for inspection by the programmer.
+</p>
+
+<h3 id="iteration">Iterating in maps</h3>
+
+<p>
+The old language specification did not define the order of iteration for maps,
+and in practice it differed across hardware platforms.
+This caused tests that iterated over maps to be fragile and non-portable, with the
+unpleasant property that a test might always pass on one machine but break on another.
+</p>
+
+<p>
+In Go 1, the order in which elements are visited when iterating
+over a map using a <code>for</code> <code>range</code> statement
+is defined to be unpredictable, even if the same loop is run multiple
+times with the same map.
+Code should not assume that the elements are visited in any particular order.
+</p>
+
+<p>
+This change means that code that depends on iteration order is very likely to break early and be fixed long before it becomes a problem.
+Just as important, it allows the map implementation to ensure better map balancing even when programs are using range loops to select an element from a map.
+</p>
+
+{{code "/doc/progs/go1.go" `/Sunday/` `/^ }/`}}
+
+<p>
+<em>Updating</em>:
+This is one change where tools cannot help. Most existing code
+will be unaffected, but some programs may break or misbehave; we
+recommend manual checking of all range statements over maps to
+verify they do not depend on iteration order. There were a few such
+examples in the standard repository; they have been fixed.
+Note that it was already incorrect to depend on the iteration order, which
+was unspecified. This change codifies the unpredictability.
+</p>
+
+<h3 id="multiple_assignment">Multiple assignment</h3>
+
+<p>
+The language specification has long guaranteed that in assignments
+the right-hand-side expressions are all evaluated before any left-hand-side expressions are assigned.
+To guarantee predictable behavior,
+Go 1 refines the specification further.
+</p>
+
+<p>
+If the left-hand side of the assignment
+statement contains expressions that require evaluation, such as
+function calls or array indexing operations, these will all be done
+using the usual left-to-right rule before any variables are assigned
+their value. Once everything is evaluated, the actual assignments
+proceed in left-to-right order.
+</p>
+
+<p>
+These examples illustrate the behavior.
+</p>
+
+{{code "/doc/progs/go1.go" `/sa :=/` `/then sc.0. = 2/`}}
+
+<p>
+<em>Updating</em>:
+This is one change where tools cannot help, but breakage is unlikely.
+No code in the standard repository was broken by this change, and code
+that depended on the previous unspecified behavior was already incorrect.
+</p>
+
+<h3 id="shadowing">Returns and shadowed variables</h3>
+
+<p>
+A common mistake is to use <code>return</code> (without arguments) after an assignment to a variable that has the same name as a result variable but is not the same variable.
+This situation is called <em>shadowing</em>: the result variable has been shadowed by another variable with the same name declared in an inner scope.
+</p>
+
+<p>
+In functions with named return values,
+the Go 1 compilers disallow return statements without arguments if any of the named return values is shadowed at the point of the return statement.
+(It isn't part of the specification, because this is one area we are still exploring;
+the situation is analogous to the compilers rejecting functions that do not end with an explicit return statement.)
+</p>
+
+<p>
+This function implicitly returns a shadowed return value and will be rejected by the compiler:
+</p>
+
+<pre>
+ func Bug() (i, j, k int) {
+ for i = 0; i < 5; i++ {
+ for j := 0; j < 5; j++ { // Redeclares j.
+ k += i*j
+ if k > 100 {
+ return // Rejected: j is shadowed here.
+ }
+ }
+ }
+ return // OK: j is not shadowed here.
+ }
+</pre>
+
+<p>
+<em>Updating</em>:
+Code that shadows return values in this way will be rejected by the compiler and will need to be fixed by hand.
+The few cases that arose in the standard repository were mostly bugs.
+</p>
+
+<h3 id="unexported">Copying structs with unexported fields</h3>
+
+<p>
+The old language did not allow a package to make a copy of a struct value containing unexported fields belonging to a different package.
+There was, however, a required exception for a method receiver;
+also, the implementations of <code>copy</code> and <code>append</code> have never honored the restriction.
+</p>
+
+<p>
+Go 1 will allow packages to copy struct values containing unexported fields from other packages.
+Besides resolving the inconsistency,
+this change admits a new kind of API: a package can return an opaque value without resorting to a pointer or interface.
+The new implementations of <code>time.Time</code> and
+<code>reflect.Value</code> are examples of types taking advantage of this new property.
+</p>
+
+<p>
+As an example, if package <code>p</code> includes the definitions,
+</p>
+
+<pre>
+ type Struct struct {
+ Public int
+ secret int
+ }
+ func NewStruct(a int) Struct { // Note: not a pointer.
+ return Struct{a, f(a)}
+ }
+ func (s Struct) String() string {
+ return fmt.Sprintf("{%d (secret %d)}", s.Public, s.secret)
+ }
+</pre>
+
+<p>
+a package that imports <code>p</code> can assign and copy values of type
+<code>p.Struct</code> at will.
+Behind the scenes the unexported fields will be assigned and copied just
+as if they were exported,
+but the client code will never be aware of them. The code
+</p>
+
+<pre>
+ import "p"
+
+ myStruct := p.NewStruct(23)
+ copyOfMyStruct := myStruct
+ fmt.Println(myStruct, copyOfMyStruct)
+</pre>
+
+<p>
+will show that the secret field of the struct has been copied to the new value.
+</p>
+
+<p>
+<em>Updating</em>:
+This is a new feature, so existing code needs no changes.
+</p>
+
+<h3 id="equality">Equality</h3>
+
+<p>
+Before Go 1, the language did not define equality on struct and array values.
+This meant,
+among other things, that structs and arrays could not be used as map keys.
+On the other hand, Go did define equality on function and map values.
+Function equality was problematic in the presence of closures
+(when are two closures equal?)
+while map equality compared pointers, not the maps' content, which was usually
+not what the user would want.
+</p>
+
+<p>
+Go 1 addressed these issues.
+First, structs and arrays can be compared for equality and inequality
+(<code>==</code> and <code>!=</code>),
+and therefore be used as map keys,
+provided they are composed from elements for which equality is also defined,
+using element-wise comparison.
+</p>
+
+{{code "/doc/progs/go1.go" `/type Day struct/` `/Printf/`}}
+
+<p>
+Second, Go 1 removes the definition of equality for function values,
+except for comparison with <code>nil</code>.
+Finally, map equality is gone too, also except for comparison with <code>nil</code>.
+</p>
+
+<p>
+Note that equality is still undefined for slices, for which the
+calculation is in general infeasible. Also note that the ordered
+comparison operators (<code><</code> <code><=</code>
+<code>></code> <code>>=</code>) are still undefined for
+structs and arrays.
+
+<p>
+<em>Updating</em>:
+Struct and array equality is a new feature, so existing code needs no changes.
+Existing code that depends on function or map equality will be
+rejected by the compiler and will need to be fixed by hand.
+Few programs will be affected, but the fix may require some
+redesign.
+</p>
+
+<h2 id="packages">The package hierarchy</h2>
+
+<p>
+Go 1 addresses many deficiencies in the old standard library and
+cleans up a number of packages, making them more internally consistent
+and portable.
+</p>
+
+<p>
+This section describes how the packages have been rearranged in Go 1.
+Some have moved, some have been renamed, some have been deleted.
+New packages are described in later sections.
+</p>
+
+<h3 id="hierarchy">The package hierarchy</h3>
+
+<p>
+Go 1 has a rearranged package hierarchy that groups related items
+into subdirectories. For instance, <code>utf8</code> and
+<code>utf16</code> now occupy subdirectories of <code>unicode</code>.
+Also, <a href="#subrepo">some packages</a> have moved into
+subrepositories of
+<a href="//code.google.com/p/go"><code>code.google.com/p/go</code></a>
+while <a href="#deleted">others</a> have been deleted outright.
+</p>
+
+<table class="codetable" frame="border" summary="Moved packages">
+<colgroup align="left" width="60%"></colgroup>
+<colgroup align="left" width="40%"></colgroup>
+<tr>
+<th align="left">Old path</th>
+<th align="left">New path</th>
+</tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>asn1</td> <td>encoding/asn1</td></tr>
+<tr><td>csv</td> <td>encoding/csv</td></tr>
+<tr><td>gob</td> <td>encoding/gob</td></tr>
+<tr><td>json</td> <td>encoding/json</td></tr>
+<tr><td>xml</td> <td>encoding/xml</td></tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>exp/template/html</td> <td>html/template</td></tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>big</td> <td>math/big</td></tr>
+<tr><td>cmath</td> <td>math/cmplx</td></tr>
+<tr><td>rand</td> <td>math/rand</td></tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>http</td> <td>net/http</td></tr>
+<tr><td>http/cgi</td> <td>net/http/cgi</td></tr>
+<tr><td>http/fcgi</td> <td>net/http/fcgi</td></tr>
+<tr><td>http/httptest</td> <td>net/http/httptest</td></tr>
+<tr><td>http/pprof</td> <td>net/http/pprof</td></tr>
+<tr><td>mail</td> <td>net/mail</td></tr>
+<tr><td>rpc</td> <td>net/rpc</td></tr>
+<tr><td>rpc/jsonrpc</td> <td>net/rpc/jsonrpc</td></tr>
+<tr><td>smtp</td> <td>net/smtp</td></tr>
+<tr><td>url</td> <td>net/url</td></tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>exec</td> <td>os/exec</td></tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>scanner</td> <td>text/scanner</td></tr>
+<tr><td>tabwriter</td> <td>text/tabwriter</td></tr>
+<tr><td>template</td> <td>text/template</td></tr>
+<tr><td>template/parse</td> <td>text/template/parse</td></tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>utf8</td> <td>unicode/utf8</td></tr>
+<tr><td>utf16</td> <td>unicode/utf16</td></tr>
+</table>
+
+<p>
+Note that the package names for the old <code>cmath</code> and
+<code>exp/template/html</code> packages have changed to <code>cmplx</code>
+and <code>template</code>.
+</p>
+
+<p>
+<em>Updating</em>:
+Running <code>go</code> <code>fix</code> will update all imports and package renames for packages that
+remain inside the standard repository. Programs that import packages
+that are no longer in the standard repository will need to be edited
+by hand.
+</p>
+
+<h3 id="exp">The package tree exp</h3>
+
+<p>
+Because they are not standardized, the packages under the <code>exp</code> directory will not be available in the
+standard Go 1 release distributions, although they will be available in source code form
+in <a href="//code.google.com/p/go/">the repository</a> for
+developers who wish to use them.
+</p>
+
+<p>
+Several packages have moved under <code>exp</code> at the time of Go 1's release:
+</p>
+
+<ul>
+<li><code>ebnf</code></li>
+<li><code>html</code><sup>†</sup></li>
+<li><code>go/types</code></li>
+</ul>
+
+<p>
+(<sup>†</sup>The <code>EscapeString</code> and <code>UnescapeString</code> types remain
+in package <code>html</code>.)
+</p>
+
+<p>
+All these packages are available under the same names, with the prefix <code>exp/</code>: <code>exp/ebnf</code> etc.
+</p>
+
+<p>
+Also, the <code>utf8.String</code> type has been moved to its own package, <code>exp/utf8string</code>.
+</p>
+
+<p>
+Finally, the <code>gotype</code> command now resides in <code>exp/gotype</code>, while
+<code>ebnflint</code> is now in <code>exp/ebnflint</code>.
+If they are installed, they now reside in <code>$GOROOT/bin/tool</code>.
+</p>
+
+<p>
+<em>Updating</em>:
+Code that uses packages in <code>exp</code> will need to be updated by hand,
+or else compiled from an installation that has <code>exp</code> available.
+The <code>go</code> <code>fix</code> tool or the compiler will complain about such uses.
+</p>
+
+<h3 id="old">The package tree old</h3>
+
+<p>
+Because they are deprecated, the packages under the <code>old</code> directory will not be available in the
+standard Go 1 release distributions, although they will be available in source code form for
+developers who wish to use them.
+</p>
+
+<p>
+The packages in their new locations are:
+</p>
+
+<ul>
+<li><code>old/netchan</code></li>
+</ul>
+
+<p>
+<em>Updating</em>:
+Code that uses packages now in <code>old</code> will need to be updated by hand,
+or else compiled from an installation that has <code>old</code> available.
+The <code>go</code> <code>fix</code> tool will warn about such uses.
+</p>
+
+<h3 id="deleted">Deleted packages</h3>
+
+<p>
+Go 1 deletes several packages outright:
+</p>
+
+<ul>
+<li><code>container/vector</code></li>
+<li><code>exp/datafmt</code></li>
+<li><code>go/typechecker</code></li>
+<li><code>old/regexp</code></li>
+<li><code>old/template</code></li>
+<li><code>try</code></li>
+</ul>
+
+<p>
+and also the command <code>gotry</code>.
+</p>
+
+<p>
+<em>Updating</em>:
+Code that uses <code>container/vector</code> should be updated to use
+slices directly. See
+<a href="//code.google.com/p/go-wiki/wiki/SliceTricks">the Go
+Language Community Wiki</a> for some suggestions.
+Code that uses the other packages (there should be almost zero) will need to be rethought.
+</p>
+
+<h3 id="subrepo">Packages moving to subrepositories</h3>
+
+<p>
+Go 1 has moved a number of packages into other repositories, usually sub-repositories of
+<a href="//code.google.com/p/go/">the main Go repository</a>.
+This table lists the old and new import paths:
+
+<table class="codetable" frame="border" summary="Sub-repositories">
+<colgroup align="left" width="40%"></colgroup>
+<colgroup align="left" width="60%"></colgroup>
+<tr>
+<th align="left">Old</th>
+<th align="left">New</th>
+</tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>crypto/bcrypt</td> <td>code.google.com/p/go.crypto/bcrypt</tr>
+<tr><td>crypto/blowfish</td> <td>code.google.com/p/go.crypto/blowfish</tr>
+<tr><td>crypto/cast5</td> <td>code.google.com/p/go.crypto/cast5</tr>
+<tr><td>crypto/md4</td> <td>code.google.com/p/go.crypto/md4</tr>
+<tr><td>crypto/ocsp</td> <td>code.google.com/p/go.crypto/ocsp</tr>
+<tr><td>crypto/openpgp</td> <td>code.google.com/p/go.crypto/openpgp</tr>
+<tr><td>crypto/openpgp/armor</td> <td>code.google.com/p/go.crypto/openpgp/armor</tr>
+<tr><td>crypto/openpgp/elgamal</td> <td>code.google.com/p/go.crypto/openpgp/elgamal</tr>
+<tr><td>crypto/openpgp/errors</td> <td>code.google.com/p/go.crypto/openpgp/errors</tr>
+<tr><td>crypto/openpgp/packet</td> <td>code.google.com/p/go.crypto/openpgp/packet</tr>
+<tr><td>crypto/openpgp/s2k</td> <td>code.google.com/p/go.crypto/openpgp/s2k</tr>
+<tr><td>crypto/ripemd160</td> <td>code.google.com/p/go.crypto/ripemd160</tr>
+<tr><td>crypto/twofish</td> <td>code.google.com/p/go.crypto/twofish</tr>
+<tr><td>crypto/xtea</td> <td>code.google.com/p/go.crypto/xtea</tr>
+<tr><td>exp/ssh</td> <td>code.google.com/p/go.crypto/ssh</tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>image/bmp</td> <td>code.google.com/p/go.image/bmp</tr>
+<tr><td>image/tiff</td> <td>code.google.com/p/go.image/tiff</tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>net/dict</td> <td>code.google.com/p/go.net/dict</tr>
+<tr><td>net/websocket</td> <td>code.google.com/p/go.net/websocket</tr>
+<tr><td>exp/spdy</td> <td>code.google.com/p/go.net/spdy</tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>encoding/git85</td> <td>code.google.com/p/go.codereview/git85</tr>
+<tr><td>patch</td> <td>code.google.com/p/go.codereview/patch</tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>exp/wingui</td> <td>code.google.com/p/gowingui</tr>
+</table>
+
+<p>
+<em>Updating</em>:
+Running <code>go</code> <code>fix</code> will update imports of these packages to use the new import paths.
+Installations that depend on these packages will need to install them using
+a <code>go get</code> command.
+</p>
+
+<h2 id="major">Major changes to the library</h2>
+
+<p>
+This section describes significant changes to the core libraries, the ones that
+affect the most programs.
+</p>
+
+<h3 id="errors">The error type and errors package</h3>
+
+<p>
+The placement of <code>os.Error</code> in package <code>os</code> is mostly historical: errors first came up when implementing package <code>os</code>, and they seemed system-related at the time.
+Since then it has become clear that errors are more fundamental than the operating system. For example, it would be nice to use <code>Errors</code> in packages that <code>os</code> depends on, like <code>syscall</code>.
+Also, having <code>Error</code> in <code>os</code> introduces many dependencies on <code>os</code> that would otherwise not exist.
+</p>
+
+<p>
+Go 1 solves these problems by introducing a built-in <code>error</code> interface type and a separate <code>errors</code> package (analogous to <code>bytes</code> and <code>strings</code>) that contains utility functions.
+It replaces <code>os.NewError</code> with
+<a href="/pkg/errors/#New"><code>errors.New</code></a>,
+giving errors a more central place in the environment.
+</p>
+
+<p>
+So the widely-used <code>String</code> method does not cause accidental satisfaction
+of the <code>error</code> interface, the <code>error</code> interface uses instead
+the name <code>Error</code> for that method:
+</p>
+
+<pre>
+ type error interface {
+ Error() string
+ }
+</pre>
+
+<p>
+The <code>fmt</code> library automatically invokes <code>Error</code>, as it already
+does for <code>String</code>, for easy printing of error values.
+</p>
+
+{{code "/doc/progs/go1.go" `/START ERROR EXAMPLE/` `/END ERROR EXAMPLE/`}}
+
+<p>
+All standard packages have been updated to use the new interface; the old <code>os.Error</code> is gone.
+</p>
+
+<p>
+A new package, <a href="/pkg/errors/"><code>errors</code></a>, contains the function
+</p>
+
+<pre>
+func New(text string) error
+</pre>
+
+<p>
+to turn a string into an error. It replaces the old <code>os.NewError</code>.
+</p>
+
+{{code "/doc/progs/go1.go" `/ErrSyntax/`}}
+
+<p>
+<em>Updating</em>:
+Running <code>go</code> <code>fix</code> will update almost all code affected by the change.
+Code that defines error types with a <code>String</code> method will need to be updated
+by hand to rename the methods to <code>Error</code>.
+</p>
+
+<h3 id="errno">System call errors</h3>
+
+<p>
+The old <code>syscall</code> package, which predated <code>os.Error</code>
+(and just about everything else),
+returned errors as <code>int</code> values.
+In turn, the <code>os</code> package forwarded many of these errors, such
+as <code>EINVAL</code>, but using a different set of errors on each platform.
+This behavior was unpleasant and unportable.
+</p>
+
+<p>
+In Go 1, the
+<a href="/pkg/syscall/"><code>syscall</code></a>
+package instead returns an <code>error</code> for system call errors.
+On Unix, the implementation is done by a
+<a href="/pkg/syscall/#Errno"><code>syscall.Errno</code></a> type
+that satisfies <code>error</code> and replaces the old <code>os.Errno</code>.
+</p>
+
+<p>
+The changes affecting <code>os.EINVAL</code> and relatives are
+described <a href="#os">elsewhere</a>.
+
+<p>
+<em>Updating</em>:
+Running <code>go</code> <code>fix</code> will update almost all code affected by the change.
+Regardless, most code should use the <code>os</code> package
+rather than <code>syscall</code> and so will be unaffected.
+</p>
+
+<h3 id="time">Time</h3>
+
+<p>
+Time is always a challenge to support well in a programming language.
+The old Go <code>time</code> package had <code>int64</code> units, no
+real type safety,
+and no distinction between absolute times and durations.
+</p>
+
+<p>
+One of the most sweeping changes in the Go 1 library is therefore a
+complete redesign of the
+<a href="/pkg/time/"><code>time</code></a> package.
+Instead of an integer number of nanoseconds as an <code>int64</code>,
+and a separate <code>*time.Time</code> type to deal with human
+units such as hours and years,
+there are now two fundamental types:
+<a href="/pkg/time/#Time"><code>time.Time</code></a>
+(a value, so the <code>*</code> is gone), which represents a moment in time;
+and <a href="/pkg/time/#Duration"><code>time.Duration</code></a>,
+which represents an interval.
+Both have nanosecond resolution.
+A <code>Time</code> can represent any time into the ancient
+past and remote future, while a <code>Duration</code> can
+span plus or minus only about 290 years.
+There are methods on these types, plus a number of helpful
+predefined constant durations such as <code>time.Second</code>.
+</p>
+
+<p>
+Among the new methods are things like
+<a href="/pkg/time/#Time.Add"><code>Time.Add</code></a>,
+which adds a <code>Duration</code> to a <code>Time</code>, and
+<a href="/pkg/time/#Time.Sub"><code>Time.Sub</code></a>,
+which subtracts two <code>Times</code> to yield a <code>Duration</code>.
+</p>
+
+<p>
+The most important semantic change is that the Unix epoch (Jan 1, 1970) is now
+relevant only for those functions and methods that mention Unix:
+<a href="/pkg/time/#Unix"><code>time.Unix</code></a>
+and the <a href="/pkg/time/#Time.Unix"><code>Unix</code></a>
+and <a href="/pkg/time/#Time.UnixNano"><code>UnixNano</code></a> methods
+of the <code>Time</code> type.
+In particular,
+<a href="/pkg/time/#Now"><code>time.Now</code></a>
+returns a <code>time.Time</code> value rather than, in the old
+API, an integer nanosecond count since the Unix epoch.
+</p>
+
+{{code "/doc/progs/go1.go" `/sleepUntil/` `/^}/`}}
+
+<p>
+The new types, methods, and constants have been propagated through
+all the standard packages that use time, such as <code>os</code> and
+its representation of file time stamps.
+</p>
+
+<p>
+<em>Updating</em>:
+The <code>go</code> <code>fix</code> tool will update many uses of the old <code>time</code> package to use the new
+types and methods, although it does not replace values such as <code>1e9</code>
+representing nanoseconds per second.
+Also, because of type changes in some of the values that arise,
+some of the expressions rewritten by the fix tool may require
+further hand editing; in such cases the rewrite will include
+the correct function or method for the old functionality, but
+may have the wrong type or require further analysis.
+</p>
+
+<h2 id="minor">Minor changes to the library</h2>
+
+<p>
+This section describes smaller changes, such as those to less commonly
+used packages or that affect
+few programs beyond the need to run <code>go</code> <code>fix</code>.
+This category includes packages that are new in Go 1.
+Collectively they improve portability, regularize behavior, and
+make the interfaces more modern and Go-like.
+</p>
+
+<h3 id="archive_zip">The archive/zip package</h3>
+
+<p>
+In Go 1, <a href="/pkg/archive/zip/#Writer"><code>*zip.Writer</code></a> no
+longer has a <code>Write</code> method. Its presence was a mistake.
+</p>
+
+<p>
+<em>Updating</em>:
+What little code is affected will be caught by the compiler and must be updated by hand.
+</p>
+
+<h3 id="bufio">The bufio package</h3>
+
+<p>
+In Go 1, <a href="/pkg/bufio/#NewReaderSize"><code>bufio.NewReaderSize</code></a>
+and
+<a href="/pkg/bufio/#NewWriterSize"><code>bufio.NewWriterSize</code></a>
+functions no longer return an error for invalid sizes.
+If the argument size is too small or invalid, it is adjusted.
+</p>
+
+<p>
+<em>Updating</em>:
+Running <code>go</code> <code>fix</code> will update calls that assign the error to _.
+Calls that aren't fixed will be caught by the compiler and must be updated by hand.
+</p>
+
+<h3 id="compress">The compress/flate, compress/gzip and compress/zlib packages</h3>
+
+<p>
+In Go 1, the <code>NewWriterXxx</code> functions in
+<a href="/pkg/compress/flate"><code>compress/flate</code></a>,
+<a href="/pkg/compress/gzip"><code>compress/gzip</code></a> and
+<a href="/pkg/compress/zlib"><code>compress/zlib</code></a>
+all return <code>(*Writer, error)</code> if they take a compression level,
+and <code>*Writer</code> otherwise. Package <code>gzip</code>'s
+<code>Compressor</code> and <code>Decompressor</code> types have been renamed
+to <code>Writer</code> and <code>Reader</code>. Package <code>flate</code>'s
+<code>WrongValueError</code> type has been removed.
+</p>
+
+<p>
+<em>Updating</em>
+Running <code>go</code> <code>fix</code> will update old names and calls that assign the error to _.
+Calls that aren't fixed will be caught by the compiler and must be updated by hand.
+</p>
+
+<h3 id="crypto_aes_des">The crypto/aes and crypto/des packages</h3>
+
+<p>
+In Go 1, the <code>Reset</code> method has been removed. Go does not guarantee
+that memory is not copied and therefore this method was misleading.
+</p>
+
+<p>
+The cipher-specific types <code>*aes.Cipher</code>, <code>*des.Cipher</code>,
+and <code>*des.TripleDESCipher</code> have been removed in favor of
+<code>cipher.Block</code>.
+</p>
+
+<p>
+<em>Updating</em>:
+Remove the calls to Reset. Replace uses of the specific cipher types with
+cipher.Block.
+</p>
+
+<h3 id="crypto_elliptic">The crypto/elliptic package</h3>
+
+<p>
+In Go 1, <a href="/pkg/crypto/elliptic/#Curve"><code>elliptic.Curve</code></a>
+has been made an interface to permit alternative implementations. The curve
+parameters have been moved to the
+<a href="/pkg/crypto/elliptic/#CurveParams"><code>elliptic.CurveParams</code></a>
+structure.
+</p>
+
+<p>
+<em>Updating</em>:
+Existing users of <code>*elliptic.Curve</code> will need to change to
+simply <code>elliptic.Curve</code>. Calls to <code>Marshal</code>,
+<code>Unmarshal</code> and <code>GenerateKey</code> are now functions
+in <code>crypto/elliptic</code> that take an <code>elliptic.Curve</code>
+as their first argument.
+</p>
+
+<h3 id="crypto_hmac">The crypto/hmac package</h3>
+
+<p>
+In Go 1, the hash-specific functions, such as <code>hmac.NewMD5</code>, have
+been removed from <code>crypto/hmac</code>. Instead, <code>hmac.New</code> takes
+a function that returns a <code>hash.Hash</code>, such as <code>md5.New</code>.
+</p>
+
+<p>
+<em>Updating</em>:
+Running <code>go</code> <code>fix</code> will perform the needed changes.
+</p>
+
+<h3 id="crypto_x509">The crypto/x509 package</h3>
+
+<p>
+In Go 1, the
+<a href="/pkg/crypto/x509/#CreateCertificate"><code>CreateCertificate</code></a>
+function and
+<a href="/pkg/crypto/x509/#Certificate.CreateCRL"><code>CreateCRL</code></a>
+method in <code>crypto/x509</code> have been altered to take an
+<code>interface{}</code> where they previously took a <code>*rsa.PublicKey</code>
+or <code>*rsa.PrivateKey</code>. This will allow other public key algorithms
+to be implemented in the future.
+</p>
+
+<p>
+<em>Updating</em>:
+No changes will be needed.
+</p>
+
+<h3 id="encoding_binary">The encoding/binary package</h3>
+
+<p>
+In Go 1, the <code>binary.TotalSize</code> function has been replaced by
+<a href="/pkg/encoding/binary/#Size"><code>Size</code></a>,
+which takes an <code>interface{}</code> argument rather than
+a <code>reflect.Value</code>.
+</p>
+
+<p>
+<em>Updating</em>:
+What little code is affected will be caught by the compiler and must be updated by hand.
+</p>
+
+<h3 id="encoding_xml">The encoding/xml package</h3>
+
+<p>
+In Go 1, the <a href="/pkg/encoding/xml/"><code>xml</code></a> package
+has been brought closer in design to the other marshaling packages such
+as <a href="/pkg/encoding/gob/"><code>encoding/gob</code></a>.
+</p>
+
+<p>
+The old <code>Parser</code> type is renamed
+<a href="/pkg/encoding/xml/#Decoder"><code>Decoder</code></a> and has a new
+<a href="/pkg/encoding/xml/#Decoder.Decode"><code>Decode</code></a> method. An
+<a href="/pkg/encoding/xml/#Encoder"><code>Encoder</code></a> type was also introduced.
+</p>
+
+<p>
+The functions <a href="/pkg/encoding/xml/#Marshal"><code>Marshal</code></a>
+and <a href="/pkg/encoding/xml/#Unmarshal"><code>Unmarshal</code></a>
+work with <code>[]byte</code> values now. To work with streams,
+use the new <a href="/pkg/encoding/xml/#Encoder"><code>Encoder</code></a>
+and <a href="/pkg/encoding/xml/#Decoder"><code>Decoder</code></a> types.
+</p>
+
+<p>
+When marshaling or unmarshaling values, the format of supported flags in
+field tags has changed to be closer to the
+<a href="/pkg/encoding/json"><code>json</code></a> package
+(<code>`xml:"name,flag"`</code>). The matching done between field tags, field
+names, and the XML attribute and element names is now case-sensitive.
+The <code>XMLName</code> field tag, if present, must also match the name
+of the XML element being marshaled.
+</p>
+
+<p>
+<em>Updating</em>:
+Running <code>go</code> <code>fix</code> will update most uses of the package except for some calls to
+<code>Unmarshal</code>. Special care must be taken with field tags,
+since the fix tool will not update them and if not fixed by hand they will
+misbehave silently in some cases. For example, the old
+<code>"attr"</code> is now written <code>",attr"</code> while plain
+<code>"attr"</code> remains valid but with a different meaning.
+</p>
+
+<h3 id="expvar">The expvar package</h3>
+
+<p>
+In Go 1, the <code>RemoveAll</code> function has been removed.
+The <code>Iter</code> function and Iter method on <code>*Map</code> have
+been replaced by
+<a href="/pkg/expvar/#Do"><code>Do</code></a>
+and
+<a href="/pkg/expvar/#Map.Do"><code>(*Map).Do</code></a>.
+</p>
+
+<p>
+<em>Updating</em>:
+Most code using <code>expvar</code> will not need changing. The rare code that used
+<code>Iter</code> can be updated to pass a closure to <code>Do</code> to achieve the same effect.
+</p>
+
+<h3 id="flag">The flag package</h3>
+
+<p>
+In Go 1, the interface <a href="/pkg/flag/#Value"><code>flag.Value</code></a> has changed slightly.
+The <code>Set</code> method now returns an <code>error</code> instead of
+a <code>bool</code> to indicate success or failure.
+</p>
+
+<p>
+There is also a new kind of flag, <code>Duration</code>, to support argument
+values specifying time intervals.
+Values for such flags must be given units, just as <code>time.Duration</code>
+formats them: <code>10s</code>, <code>1h30m</code>, etc.
+</p>
+
+{{code "/doc/progs/go1.go" `/timeout/`}}
+
+<p>
+<em>Updating</em>:
+Programs that implement their own flags will need minor manual fixes to update their
+<code>Set</code> methods.
+The <code>Duration</code> flag is new and affects no existing code.
+</p>
+
+
+<h3 id="go">The go/* packages</h3>
+
+<p>
+Several packages under <code>go</code> have slightly revised APIs.
+</p>
+
+<p>
+A concrete <code>Mode</code> type was introduced for configuration mode flags
+in the packages
+<a href="/pkg/go/scanner/"><code>go/scanner</code></a>,
+<a href="/pkg/go/parser/"><code>go/parser</code></a>,
+<a href="/pkg/go/printer/"><code>go/printer</code></a>, and
+<a href="/pkg/go/doc/"><code>go/doc</code></a>.
+</p>
+
+<p>
+The modes <code>AllowIllegalChars</code> and <code>InsertSemis</code> have been removed
+from the <a href="/pkg/go/scanner/"><code>go/scanner</code></a> package. They were mostly
+useful for scanning text other then Go source files. Instead, the
+<a href="/pkg/text/scanner/"><code>text/scanner</code></a> package should be used
+for that purpose.
+</p>
+
+<p>
+The <a href="/pkg/go/scanner/#ErrorHandler"><code>ErrorHandler</code></a> provided
+to the scanner's <a href="/pkg/go/scanner/#Scanner.Init"><code>Init</code></a> method is
+now simply a function rather than an interface. The <code>ErrorVector</code> type has
+been removed in favor of the (existing) <a href="/pkg/go/scanner/#ErrorList"><code>ErrorList</code></a>
+type, and the <code>ErrorVector</code> methods have been migrated. Instead of embedding
+an <code>ErrorVector</code> in a client of the scanner, now a client should maintain
+an <code>ErrorList</code>.
+</p>
+
+<p>
+The set of parse functions provided by the <a href="/pkg/go/parser/"><code>go/parser</code></a>
+package has been reduced to the primary parse function
+<a href="/pkg/go/parser/#ParseFile"><code>ParseFile</code></a>, and a couple of
+convenience functions <a href="/pkg/go/parser/#ParseDir"><code>ParseDir</code></a>
+and <a href="/pkg/go/parser/#ParseExpr"><code>ParseExpr</code></a>.
+</p>
+
+<p>
+The <a href="/pkg/go/printer/"><code>go/printer</code></a> package supports an additional
+configuration mode <a href="/pkg/go/printer/#Mode"><code>SourcePos</code></a>;
+if set, the printer will emit <code>//line</code> comments such that the generated
+output contains the original source code position information. The new type
+<a href="/pkg/go/printer/#CommentedNode"><code>CommentedNode</code></a> can be
+used to provide comments associated with an arbitrary
+<a href="/pkg/go/ast/#Node"><code>ast.Node</code></a> (until now only
+<a href="/pkg/go/ast/#File"><code>ast.File</code></a> carried comment information).
+</p>
+
+<p>
+The type names of the <a href="/pkg/go/doc/"><code>go/doc</code></a> package have been
+streamlined by removing the <code>Doc</code> suffix: <code>PackageDoc</code>
+is now <code>Package</code>, <code>ValueDoc</code> is <code>Value</code>, etc.
+Also, all types now consistently have a <code>Name</code> field (or <code>Names</code>,
+in the case of type <code>Value</code>) and <code>Type.Factories</code> has become
+<code>Type.Funcs</code>.
+Instead of calling <code>doc.NewPackageDoc(pkg, importpath)</code>,
+documentation for a package is created with:
+</p>
+
+<pre>
+ doc.New(pkg, importpath, mode)
+</pre>
+
+<p>
+where the new <code>mode</code> parameter specifies the operation mode:
+if set to <a href="/pkg/go/doc/#AllDecls"><code>AllDecls</code></a>, all declarations
+(not just exported ones) are considered.
+The function <code>NewFileDoc</code> was removed, and the function
+<code>CommentText</code> has become the method
+<a href="/pkg/go/ast/#CommentGroup.Text"><code>Text</code></a> of
+<a href="/pkg/go/ast/#CommentGroup"><code>ast.CommentGroup</code></a>.
+</p>
+
+<p>
+In package <a href="/pkg/go/token/"><code>go/token</code></a>, the
+<a href="/pkg/go/token/#FileSet"><code>token.FileSet</code></a> method <code>Files</code>
+(which originally returned a channel of <code>*token.File</code>s) has been replaced
+with the iterator <a href="/pkg/go/token/#FileSet.Iterate"><code>Iterate</code></a> that
+accepts a function argument instead.
+</p>
+
+<p>
+In package <a href="/pkg/go/build/"><code>go/build</code></a>, the API
+has been nearly completely replaced.
+The package still computes Go package information
+but it does not run the build: the <code>Cmd</code> and <code>Script</code>
+types are gone.
+(To build code, use the new
+<a href="/cmd/go/"><code>go</code></a> command instead.)
+The <code>DirInfo</code> type is now named
+<a href="/pkg/go/build/#Package"><code>Package</code></a>.
+<code>FindTree</code> and <code>ScanDir</code> are replaced by
+<a href="/pkg/go/build/#Import"><code>Import</code></a>
+and
+<a href="/pkg/go/build/#ImportDir"><code>ImportDir</code></a>.
+</p>
+
+<p>
+<em>Updating</em>:
+Code that uses packages in <code>go</code> will have to be updated by hand; the
+compiler will reject incorrect uses. Templates used in conjunction with any of the
+<code>go/doc</code> types may need manual fixes; the renamed fields will lead
+to run-time errors.
+</p>
+
+<h3 id="hash">The hash package</h3>
+
+<p>
+In Go 1, the definition of <a href="/pkg/hash/#Hash"><code>hash.Hash</code></a> includes
+a new method, <code>BlockSize</code>. This new method is used primarily in the
+cryptographic libraries.
+</p>
+
+<p>
+The <code>Sum</code> method of the
+<a href="/pkg/hash/#Hash"><code>hash.Hash</code></a> interface now takes a
+<code>[]byte</code> argument, to which the hash value will be appended.
+The previous behavior can be recreated by adding a <code>nil</code> argument to the call.
+</p>
+
+<p>
+<em>Updating</em>:
+Existing implementations of <code>hash.Hash</code> will need to add a
+<code>BlockSize</code> method. Hashes that process the input one byte at
+a time can implement <code>BlockSize</code> to return 1.
+Running <code>go</code> <code>fix</code> will update calls to the <code>Sum</code> methods of the various
+implementations of <code>hash.Hash</code>.
+</p>
+
+<p>
+<em>Updating</em>:
+Since the package's functionality is new, no updating is necessary.
+</p>
+
+<h3 id="http">The http package</h3>
+
+<p>
+In Go 1 the <a href="/pkg/net/http/"><code>http</code></a> package is refactored,
+putting some of the utilities into a
+<a href="/pkg/net/http/httputil/"><code>httputil</code></a> subdirectory.
+These pieces are only rarely needed by HTTP clients.
+The affected items are:
+</p>
+
+<ul>
+<li>ClientConn</li>
+<li>DumpRequest</li>
+<li>DumpRequestOut</li>
+<li>DumpResponse</li>
+<li>NewChunkedReader</li>
+<li>NewChunkedWriter</li>
+<li>NewClientConn</li>
+<li>NewProxyClientConn</li>
+<li>NewServerConn</li>
+<li>NewSingleHostReverseProxy</li>
+<li>ReverseProxy</li>
+<li>ServerConn</li>
+</ul>
+
+<p>
+The <code>Request.RawURL</code> field has been removed; it was a
+historical artifact.
+</p>
+
+<p>
+The <code>Handle</code> and <code>HandleFunc</code>
+functions, and the similarly-named methods of <code>ServeMux</code>,
+now panic if an attempt is made to register the same pattern twice.
+</p>
+
+<p>
+<em>Updating</em>:
+Running <code>go</code> <code>fix</code> will update the few programs that are affected except for
+uses of <code>RawURL</code>, which must be fixed by hand.
+</p>
+
+<h3 id="image">The image package</h3>
+
+<p>
+The <a href="/pkg/image/"><code>image</code></a> package has had a number of
+minor changes, rearrangements and renamings.
+</p>
+
+<p>
+Most of the color handling code has been moved into its own package,
+<a href="/pkg/image/color/"><code>image/color</code></a>.
+For the elements that moved, a symmetry arises; for instance,
+each pixel of an
+<a href="/pkg/image/#RGBA"><code>image.RGBA</code></a>
+is a
+<a href="/pkg/image/color/#RGBA"><code>color.RGBA</code></a>.
+</p>
+
+<p>
+The old <code>image/ycbcr</code> package has been folded, with some
+renamings, into the
+<a href="/pkg/image/"><code>image</code></a>
+and
+<a href="/pkg/image/color/"><code>image/color</code></a>
+packages.
+</p>
+
+<p>
+The old <code>image.ColorImage</code> type is still in the <code>image</code>
+package but has been renamed
+<a href="/pkg/image/#Uniform"><code>image.Uniform</code></a>,
+while <code>image.Tiled</code> has been removed.
+</p>
+
+<p>
+This table lists the renamings.
+</p>
+
+<table class="codetable" frame="border" summary="image renames">
+<colgroup align="left" width="50%"></colgroup>
+<colgroup align="left" width="50%"></colgroup>
+<tr>
+<th align="left">Old</th>
+<th align="left">New</th>
+</tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>image.Color</td> <td>color.Color</td></tr>
+<tr><td>image.ColorModel</td> <td>color.Model</td></tr>
+<tr><td>image.ColorModelFunc</td> <td>color.ModelFunc</td></tr>
+<tr><td>image.PalettedColorModel</td> <td>color.Palette</td></tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>image.RGBAColor</td> <td>color.RGBA</td></tr>
+<tr><td>image.RGBA64Color</td> <td>color.RGBA64</td></tr>
+<tr><td>image.NRGBAColor</td> <td>color.NRGBA</td></tr>
+<tr><td>image.NRGBA64Color</td> <td>color.NRGBA64</td></tr>
+<tr><td>image.AlphaColor</td> <td>color.Alpha</td></tr>
+<tr><td>image.Alpha16Color</td> <td>color.Alpha16</td></tr>
+<tr><td>image.GrayColor</td> <td>color.Gray</td></tr>
+<tr><td>image.Gray16Color</td> <td>color.Gray16</td></tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>image.RGBAColorModel</td> <td>color.RGBAModel</td></tr>
+<tr><td>image.RGBA64ColorModel</td> <td>color.RGBA64Model</td></tr>
+<tr><td>image.NRGBAColorModel</td> <td>color.NRGBAModel</td></tr>
+<tr><td>image.NRGBA64ColorModel</td> <td>color.NRGBA64Model</td></tr>
+<tr><td>image.AlphaColorModel</td> <td>color.AlphaModel</td></tr>
+<tr><td>image.Alpha16ColorModel</td> <td>color.Alpha16Model</td></tr>
+<tr><td>image.GrayColorModel</td> <td>color.GrayModel</td></tr>
+<tr><td>image.Gray16ColorModel</td> <td>color.Gray16Model</td></tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>ycbcr.RGBToYCbCr</td> <td>color.RGBToYCbCr</td></tr>
+<tr><td>ycbcr.YCbCrToRGB</td> <td>color.YCbCrToRGB</td></tr>
+<tr><td>ycbcr.YCbCrColorModel</td> <td>color.YCbCrModel</td></tr>
+<tr><td>ycbcr.YCbCrColor</td> <td>color.YCbCr</td></tr>
+<tr><td>ycbcr.YCbCr</td> <td>image.YCbCr</td></tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>ycbcr.SubsampleRatio444</td> <td>image.YCbCrSubsampleRatio444</td></tr>
+<tr><td>ycbcr.SubsampleRatio422</td> <td>image.YCbCrSubsampleRatio422</td></tr>
+<tr><td>ycbcr.SubsampleRatio420</td> <td>image.YCbCrSubsampleRatio420</td></tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>image.ColorImage</td> <td>image.Uniform</td></tr>
+</table>
+
+<p>
+The image package's <code>New</code> functions
+(<a href="/pkg/image/#NewRGBA"><code>NewRGBA</code></a>,
+<a href="/pkg/image/#NewRGBA64"><code>NewRGBA64</code></a>, etc.)
+take an <a href="/pkg/image/#Rectangle"><code>image.Rectangle</code></a> as an argument
+instead of four integers.
+</p>
+
+<p>
+Finally, there are new predefined <code>color.Color</code> variables
+<a href="/pkg/image/color/#Black"><code>color.Black</code></a>,
+<a href="/pkg/image/color/#White"><code>color.White</code></a>,
+<a href="/pkg/image/color/#Opaque"><code>color.Opaque</code></a>
+and
+<a href="/pkg/image/color/#Transparent"><code>color.Transparent</code></a>.
+</p>
+
+<p>
+<em>Updating</em>:
+Running <code>go</code> <code>fix</code> will update almost all code affected by the change.
+</p>
+
+<h3 id="log_syslog">The log/syslog package</h3>
+
+<p>
+In Go 1, the <a href="/pkg/log/syslog/#NewLogger"><code>syslog.NewLogger</code></a>
+function returns an error as well as a <code>log.Logger</code>.
+</p>
+
+<p>
+<em>Updating</em>:
+What little code is affected will be caught by the compiler and must be updated by hand.
+</p>
+
+<h3 id="mime">The mime package</h3>
+
+<p>
+In Go 1, the <a href="/pkg/mime/#FormatMediaType"><code>FormatMediaType</code></a> function
+of the <code>mime</code> package has been simplified to make it
+consistent with
+<a href="/pkg/mime/#ParseMediaType"><code>ParseMediaType</code></a>.
+It now takes <code>"text/html"</code> rather than <code>"text"</code> and <code>"html"</code>.
+</p>
+
+<p>
+<em>Updating</em>:
+What little code is affected will be caught by the compiler and must be updated by hand.
+</p>
+
+<h3 id="net">The net package</h3>
+
+<p>
+In Go 1, the various <code>SetTimeout</code>,
+<code>SetReadTimeout</code>, and <code>SetWriteTimeout</code> methods
+have been replaced with
+<a href="/pkg/net/#IPConn.SetDeadline"><code>SetDeadline</code></a>,
+<a href="/pkg/net/#IPConn.SetReadDeadline"><code>SetReadDeadline</code></a>, and
+<a href="/pkg/net/#IPConn.SetWriteDeadline"><code>SetWriteDeadline</code></a>,
+respectively. Rather than taking a timeout value in nanoseconds that
+apply to any activity on the connection, the new methods set an
+absolute deadline (as a <code>time.Time</code> value) after which
+reads and writes will time out and no longer block.
+</p>
+
+<p>
+There are also new functions
+<a href="/pkg/net/#DialTimeout"><code>net.DialTimeout</code></a>
+to simplify timing out dialing a network address and
+<a href="/pkg/net/#ListenMulticastUDP"><code>net.ListenMulticastUDP</code></a>
+to allow multicast UDP to listen concurrently across multiple listeners.
+The <code>net.ListenMulticastUDP</code> function replaces the old
+<code>JoinGroup</code> and <code>LeaveGroup</code> methods.
+</p>
+
+<p>
+<em>Updating</em>:
+Code that uses the old methods will fail to compile and must be updated by hand.
+The semantic change makes it difficult for the fix tool to update automatically.
+</p>
+
+<h3 id="os">The os package</h3>
+
+<p>
+The <code>Time</code> function has been removed; callers should use
+the <a href="/pkg/time/#Time"><code>Time</code></a> type from the
+<code>time</code> package.
+</p>
+
+<p>
+The <code>Exec</code> function has been removed; callers should use
+<code>Exec</code> from the <code>syscall</code> package, where available.
+</p>
+
+<p>
+The <code>ShellExpand</code> function has been renamed to <a
+href="/pkg/os/#ExpandEnv"><code>ExpandEnv</code></a>.
+</p>
+
+<p>
+The <a href="/pkg/os/#NewFile"><code>NewFile</code></a> function
+now takes a <code>uintptr</code> fd, instead of an <code>int</code>.
+The <a href="/pkg/os/#File.Fd"><code>Fd</code></a> method on files now
+also returns a <code>uintptr</code>.
+</p>
+
+<p>
+There are no longer error constants such as <code>EINVAL</code>
+in the <code>os</code> package, since the set of values varied with
+the underlying operating system. There are new portable functions like
+<a href="/pkg/os/#IsPermission"><code>IsPermission</code></a>
+to test common error properties, plus a few new error values
+with more Go-like names, such as
+<a href="/pkg/os/#ErrPermission"><code>ErrPermission</code></a>
+and
+<a href="/pkg/os/#ErrNotExist"><code>ErrNotExist</code></a>.
+</p>
+
+<p>
+The <code>Getenverror</code> function has been removed. To distinguish
+between a non-existent environment variable and an empty string,
+use <a href="/pkg/os/#Environ"><code>os.Environ</code></a> or
+<a href="/pkg/syscall/#Getenv"><code>syscall.Getenv</code></a>.
+</p>
+
+
+<p>
+The <a href="/pkg/os/#Process.Wait"><code>Process.Wait</code></a> method has
+dropped its option argument and the associated constants are gone
+from the package.
+Also, the function <code>Wait</code> is gone; only the method of
+the <code>Process</code> type persists.
+</p>
+
+<p>
+The <code>Waitmsg</code> type returned by
+<a href="/pkg/os/#Process.Wait"><code>Process.Wait</code></a>
+has been replaced with a more portable
+<a href="/pkg/os/#ProcessState"><code>ProcessState</code></a>
+type with accessor methods to recover information about the
+process.
+Because of changes to <code>Wait</code>, the <code>ProcessState</code>
+value always describes an exited process.
+Portability concerns simplified the interface in other ways, but the values returned by the
+<a href="/pkg/os/#ProcessState.Sys"><code>ProcessState.Sys</code></a> and
+<a href="/pkg/os/#ProcessState.SysUsage"><code>ProcessState.SysUsage</code></a>
+methods can be type-asserted to underlying system-specific data structures such as
+<a href="/pkg/syscall/#WaitStatus"><code>syscall.WaitStatus</code></a> and
+<a href="/pkg/syscall/#Rusage"><code>syscall.Rusage</code></a> on Unix.
+</p>
+
+<p>
+<em>Updating</em>:
+Running <code>go</code> <code>fix</code> will drop a zero argument to <code>Process.Wait</code>.
+All other changes will be caught by the compiler and must be updated by hand.
+</p>
+
+<h4 id="os_fileinfo">The os.FileInfo type</h4>
+
+<p>
+Go 1 redefines the <a href="/pkg/os/#FileInfo"><code>os.FileInfo</code></a> type,
+changing it from a struct to an interface:
+</p>
+
+<pre>
+ type FileInfo interface {
+ Name() string // base name of the file
+ Size() int64 // length in bytes
+ Mode() FileMode // file mode bits
+ ModTime() time.Time // modification time
+ IsDir() bool // abbreviation for Mode().IsDir()
+ Sys() interface{} // underlying data source (can return nil)
+ }
+</pre>
+
+<p>
+The file mode information has been moved into a subtype called
+<a href="/pkg/os/#FileMode"><code>os.FileMode</code></a>,
+a simple integer type with <code>IsDir</code>, <code>Perm</code>, and <code>String</code>
+methods.
+</p>
+
+<p>
+The system-specific details of file modes and properties such as (on Unix)
+i-number have been removed from <code>FileInfo</code> altogether.
+Instead, each operating system's <code>os</code> package provides an
+implementation of the <code>FileInfo</code> interface, which
+has a <code>Sys</code> method that returns the
+system-specific representation of file metadata.
+For instance, to discover the i-number of a file on a Unix system, unpack
+the <code>FileInfo</code> like this:
+</p>
+
+<pre>
+ fi, err := os.Stat("hello.go")
+ if err != nil {
+ log.Fatal(err)
+ }
+ // Check that it's a Unix file.
+ unixStat, ok := fi.Sys().(*syscall.Stat_t)
+ if !ok {
+ log.Fatal("hello.go: not a Unix file")
+ }
+ fmt.Printf("file i-number: %d\n", unixStat.Ino)
+</pre>
+
+<p>
+Assuming (which is unwise) that <code>"hello.go"</code> is a Unix file,
+the i-number expression could be contracted to
+</p>
+
+<pre>
+ fi.Sys().(*syscall.Stat_t).Ino
+</pre>
+
+<p>
+The vast majority of uses of <code>FileInfo</code> need only the methods
+of the standard interface.
+</p>
+
+<p>
+The <code>os</code> package no longer contains wrappers for the POSIX errors
+such as <code>ENOENT</code>.
+For the few programs that need to verify particular error conditions, there are
+now the boolean functions
+<a href="/pkg/os/#IsExist"><code>IsExist</code></a>,
+<a href="/pkg/os/#IsNotExist"><code>IsNotExist</code></a>
+and
+<a href="/pkg/os/#IsPermission"><code>IsPermission</code></a>.
+</p>
+
+{{code "/doc/progs/go1.go" `/os\.Open/` `/}/`}}
+
+<p>
+<em>Updating</em>:
+Running <code>go</code> <code>fix</code> will update code that uses the old equivalent of the current <code>os.FileInfo</code>
+and <code>os.FileMode</code> API.
+Code that needs system-specific file details will need to be updated by hand.
+Code that uses the old POSIX error values from the <code>os</code> package
+will fail to compile and will also need to be updated by hand.
+</p>
+
+<h3 id="os_signal">The os/signal package</h3>
+
+<p>
+The <code>os/signal</code> package in Go 1 replaces the
+<code>Incoming</code> function, which returned a channel
+that received all incoming signals,
+with the selective <code>Notify</code> function, which asks
+for delivery of specific signals on an existing channel.
+</p>
+
+<p>
+<em>Updating</em>:
+Code must be updated by hand.
+A literal translation of
+</p>
+<pre>
+c := signal.Incoming()
+</pre>
+<p>
+is
+</p>
+<pre>
+c := make(chan os.Signal, 1)
+signal.Notify(c) // ask for all signals
+</pre>
+<p>
+but most code should list the specific signals it wants to handle instead:
+</p>
+<pre>
+c := make(chan os.Signal, 1)
+signal.Notify(c, syscall.SIGHUP, syscall.SIGQUIT)
+</pre>
+
+<h3 id="path_filepath">The path/filepath package</h3>
+
+<p>
+In Go 1, the <a href="/pkg/path/filepath/#Walk"><code>Walk</code></a> function of the
+<code>path/filepath</code> package
+has been changed to take a function value of type
+<a href="/pkg/path/filepath/#WalkFunc"><code>WalkFunc</code></a>
+instead of a <code>Visitor</code> interface value.
+<code>WalkFunc</code> unifies the handling of both files and directories.
+</p>
+
+<pre>
+ type WalkFunc func(path string, info os.FileInfo, err error) error
+</pre>
+
+<p>
+The <code>WalkFunc</code> function will be called even for files or directories that could not be opened;
+in such cases the error argument will describe the failure.
+If a directory's contents are to be skipped,
+the function should return the value <a href="/pkg/path/filepath/#pkg-variables"><code>filepath.SkipDir</code></a>
+</p>
+
+{{code "/doc/progs/go1.go" `/STARTWALK/` `/ENDWALK/`}}
+
+<p>
+<em>Updating</em>:
+The change simplifies most code but has subtle consequences, so affected programs
+will need to be updated by hand.
+The compiler will catch code using the old interface.
+</p>
+
+<h3 id="regexp">The regexp package</h3>
+
+<p>
+The <a href="/pkg/regexp/"><code>regexp</code></a> package has been rewritten.
+It has the same interface but the specification of the regular expressions
+it supports has changed from the old "egrep" form to that of
+<a href="//code.google.com/p/re2/">RE2</a>.
+</p>
+
+<p>
+<em>Updating</em>:
+Code that uses the package should have its regular expressions checked by hand.
+</p>
+
+<h3 id="runtime">The runtime package</h3>
+
+<p>
+In Go 1, much of the API exported by package
+<code>runtime</code> has been removed in favor of
+functionality provided by other packages.
+Code using the <code>runtime.Type</code> interface
+or its specific concrete type implementations should
+now use package <a href="/pkg/reflect/"><code>reflect</code></a>.
+Code using <code>runtime.Semacquire</code> or <code>runtime.Semrelease</code>
+should use channels or the abstractions in package <a href="/pkg/sync/"><code>sync</code></a>.
+The <code>runtime.Alloc</code>, <code>runtime.Free</code>,
+and <code>runtime.Lookup</code> functions, an unsafe API created for
+debugging the memory allocator, have no replacement.
+</p>
+
+<p>
+Before, <code>runtime.MemStats</code> was a global variable holding
+statistics about memory allocation, and calls to <code>runtime.UpdateMemStats</code>
+ensured that it was up to date.
+In Go 1, <code>runtime.MemStats</code> is a struct type, and code should use
+<a href="/pkg/runtime/#ReadMemStats"><code>runtime.ReadMemStats</code></a>
+to obtain the current statistics.
+</p>
+
+<p>
+The package adds a new function,
+<a href="/pkg/runtime/#NumCPU"><code>runtime.NumCPU</code></a>, that returns the number of CPUs available
+for parallel execution, as reported by the operating system kernel.
+Its value can inform the setting of <code>GOMAXPROCS</code>.
+The <code>runtime.Cgocalls</code> and <code>runtime.Goroutines</code> functions
+have been renamed to <code>runtime.NumCgoCall</code> and <code>runtime.NumGoroutine</code>.
+</p>
+
+<p>
+<em>Updating</em>:
+Running <code>go</code> <code>fix</code> will update code for the function renamings.
+Other code will need to be updated by hand.
+</p>
+
+<h3 id="strconv">The strconv package</h3>
+
+<p>
+In Go 1, the
+<a href="/pkg/strconv/"><code>strconv</code></a>
+package has been significantly reworked to make it more Go-like and less C-like,
+although <code>Atoi</code> lives on (it's similar to
+<code>int(ParseInt(x, 10, 0))</code>, as does
+<code>Itoa(x)</code> (<code>FormatInt(int64(x), 10)</code>).
+There are also new variants of some of the functions that append to byte slices rather than
+return strings, to allow control over allocation.
+</p>
+
+<p>
+This table summarizes the renamings; see the
+<a href="/pkg/strconv/">package documentation</a>
+for full details.
+</p>
+
+<table class="codetable" frame="border" summary="strconv renames">
+<colgroup align="left" width="50%"></colgroup>
+<colgroup align="left" width="50%"></colgroup>
+<tr>
+<th align="left">Old call</th>
+<th align="left">New call</th>
+</tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>Atob(x)</td> <td>ParseBool(x)</td></tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>Atof32(x)</td> <td>ParseFloat(x, 32)§</td></tr>
+<tr><td>Atof64(x)</td> <td>ParseFloat(x, 64)</td></tr>
+<tr><td>AtofN(x, n)</td> <td>ParseFloat(x, n)</td></tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>Atoi(x)</td> <td>Atoi(x)</td></tr>
+<tr><td>Atoi(x)</td> <td>ParseInt(x, 10, 0)§</td></tr>
+<tr><td>Atoi64(x)</td> <td>ParseInt(x, 10, 64)</td></tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>Atoui(x)</td> <td>ParseUint(x, 10, 0)§</td></tr>
+<tr><td>Atoui64(x)</td> <td>ParseUint(x, 10, 64)</td></tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>Btoi64(x, b)</td> <td>ParseInt(x, b, 64)</td></tr>
+<tr><td>Btoui64(x, b)</td> <td>ParseUint(x, b, 64)</td></tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>Btoa(x)</td> <td>FormatBool(x)</td></tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>Ftoa32(x, f, p)</td> <td>FormatFloat(float64(x), f, p, 32)</td></tr>
+<tr><td>Ftoa64(x, f, p)</td> <td>FormatFloat(x, f, p, 64)</td></tr>
+<tr><td>FtoaN(x, f, p, n)</td> <td>FormatFloat(x, f, p, n)</td></tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>Itoa(x)</td> <td>Itoa(x)</td></tr>
+<tr><td>Itoa(x)</td> <td>FormatInt(int64(x), 10)</td></tr>
+<tr><td>Itoa64(x)</td> <td>FormatInt(x, 10)</td></tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>Itob(x, b)</td> <td>FormatInt(int64(x), b)</td></tr>
+<tr><td>Itob64(x, b)</td> <td>FormatInt(x, b)</td></tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>Uitoa(x)</td> <td>FormatUint(uint64(x), 10)</td></tr>
+<tr><td>Uitoa64(x)</td> <td>FormatUint(x, 10)</td></tr>
+<tr>
+<td colspan="2"><hr></td>
+</tr>
+<tr><td>Uitob(x, b)</td> <td>FormatUint(uint64(x), b)</td></tr>
+<tr><td>Uitob64(x, b)</td> <td>FormatUint(x, b)</td></tr>
+</table>
+
+<p>
+<em>Updating</em>:
+Running <code>go</code> <code>fix</code> will update almost all code affected by the change.
+<br>
+§ <code>Atoi</code> persists but <code>Atoui</code> and <code>Atof32</code> do not, so
+they may require
+a cast that must be added by hand; the <code>go</code> <code>fix</code> tool will warn about it.
+</p>
+
+
+<h3 id="templates">The template packages</h3>
+
+<p>
+The <code>template</code> and <code>exp/template/html</code> packages have moved to
+<a href="/pkg/text/template/"><code>text/template</code></a> and
+<a href="/pkg/html/template/"><code>html/template</code></a>.
+More significant, the interface to these packages has been simplified.
+The template language is the same, but the concept of "template set" is gone
+and the functions and methods of the packages have changed accordingly,
+often by elimination.
+</p>
+
+<p>
+Instead of sets, a <code>Template</code> object
+may contain multiple named template definitions,
+in effect constructing
+name spaces for template invocation.
+A template can invoke any other template associated with it, but only those
+templates associated with it.
+The simplest way to associate templates is to parse them together, something
+made easier with the new structure of the packages.
+</p>
+
+<p>
+<em>Updating</em>:
+The imports will be updated by fix tool.
+Single-template uses will be otherwise be largely unaffected.
+Code that uses multiple templates in concert will need to be updated by hand.
+The <a href="/pkg/text/template/#pkg-examples">examples</a> in
+the documentation for <code>text/template</code> can provide guidance.
+</p>
+
+<h3 id="testing">The testing package</h3>
+
+<p>
+The testing package has a type, <code>B</code>, passed as an argument to benchmark functions.
+In Go 1, <code>B</code> has new methods, analogous to those of <code>T</code>, enabling
+logging and failure reporting.
+</p>
+
+{{code "/doc/progs/go1.go" `/func.*Benchmark/` `/^}/`}}
+
+<p>
+<em>Updating</em>:
+Existing code is unaffected, although benchmarks that use <code>println</code>
+or <code>panic</code> should be updated to use the new methods.
+</p>
+
+<h3 id="testing_script">The testing/script package</h3>
+
+<p>
+The testing/script package has been deleted. It was a dreg.
+</p>
+
+<p>
+<em>Updating</em>:
+No code is likely to be affected.
+</p>
+
+<h3 id="unsafe">The unsafe package</h3>
+
+<p>
+In Go 1, the functions
+<code>unsafe.Typeof</code>, <code>unsafe.Reflect</code>,
+<code>unsafe.Unreflect</code>, <code>unsafe.New</code>, and
+<code>unsafe.NewArray</code> have been removed;
+they duplicated safer functionality provided by
+package <a href="/pkg/reflect/"><code>reflect</code></a>.
+</p>
+
+<p>
+<em>Updating</em>:
+Code using these functions must be rewritten to use
+package <a href="/pkg/reflect/"><code>reflect</code></a>.
+The changes to <a href="//golang.org/change/2646dc956207">encoding/gob</a> and the <a href="//code.google.com/p/goprotobuf/source/detail?r=5340ad310031">protocol buffer library</a>
+may be helpful as examples.
+</p>
+
+<h3 id="url">The url package</h3>
+
+<p>
+In Go 1 several fields from the <a href="/pkg/net/url/#URL"><code>url.URL</code></a> type
+were removed or replaced.
+</p>
+
+<p>
+The <a href="/pkg/net/url/#URL.String"><code>String</code></a> method now
+predictably rebuilds an encoded URL string using all of <code>URL</code>'s
+fields as necessary. The resulting string will also no longer have
+passwords escaped.
+</p>
+
+<p>
+The <code>Raw</code> field has been removed. In most cases the <code>String</code>
+method may be used in its place.
+</p>
+
+<p>
+The old <code>RawUserinfo</code> field is replaced by the <code>User</code>
+field, of type <a href="/pkg/net/url/#Userinfo"><code>*net.Userinfo</code></a>.
+Values of this type may be created using the new <a href="/pkg/net/url/#User"><code>net.User</code></a>
+and <a href="/pkg/net/url/#UserPassword"><code>net.UserPassword</code></a>
+functions. The <code>EscapeUserinfo</code> and <code>UnescapeUserinfo</code>
+functions are also gone.
+</p>
+
+<p>
+The <code>RawAuthority</code> field has been removed. The same information is
+available in the <code>Host</code> and <code>User</code> fields.
+</p>
+
+<p>
+The <code>RawPath</code> field and the <code>EncodedPath</code> method have
+been removed. The path information in rooted URLs (with a slash following the
+schema) is now available only in decoded form in the <code>Path</code> field.
+Occasionally, the encoded data may be required to obtain information that
+was lost in the decoding process. These cases must be handled by accessing
+the data the URL was built from.
+</p>
+
+<p>
+URLs with non-rooted paths, such as <code>"mailto:dev@golang.org?subject=Hi"</code>,
+are also handled differently. The <code>OpaquePath</code> boolean field has been
+removed and a new <code>Opaque</code> string field introduced to hold the encoded
+path for such URLs. In Go 1, the cited URL parses as:
+</p>
+
+<pre>
+ URL{
+ Scheme: "mailto",
+ Opaque: "dev@golang.org",
+ RawQuery: "subject=Hi",
+ }
+</pre>
+
+<p>
+A new <a href="/pkg/net/url/#URL.RequestURI"><code>RequestURI</code></a> method was
+added to <code>URL</code>.
+</p>
+
+<p>
+The <code>ParseWithReference</code> function has been renamed to <code>ParseWithFragment</code>.
+</p>
+
+<p>
+<em>Updating</em>:
+Code that uses the old fields will fail to compile and must be updated by hand.
+The semantic changes make it difficult for the fix tool to update automatically.
+</p>
+
+<h2 id="cmd_go">The go command</h2>
+
+<p>
+Go 1 introduces the <a href="/cmd/go/">go command</a>, a tool for fetching,
+building, and installing Go packages and commands. The <code>go</code> command
+does away with makefiles, instead using Go source code to find dependencies and
+determine build conditions. Most existing Go programs will no longer require
+makefiles to be built.
+</p>
+
+<p>
+See <a href="/doc/code.html">How to Write Go Code</a> for a primer on the
+<code>go</code> command and the <a href="/cmd/go/">go command documentation</a>
+for the full details.
+</p>
+
+<p>
+<em>Updating</em>:
+Projects that depend on the Go project's old makefile-based build
+infrastructure (<code>Make.pkg</code>, <code>Make.cmd</code>, and so on) should
+switch to using the <code>go</code> command for building Go code and, if
+necessary, rewrite their makefiles to perform any auxiliary build tasks.
+</p>
+
+<h2 id="cmd_cgo">The cgo command</h2>
+
+<p>
+In Go 1, the <a href="/cmd/cgo">cgo command</a>
+uses a different <code>_cgo_export.h</code>
+file, which is generated for packages containing <code>//export</code> lines.
+The <code>_cgo_export.h</code> file now begins with the C preamble comment,
+so that exported function definitions can use types defined there.
+This has the effect of compiling the preamble multiple times, so a
+package using <code>//export</code> must not put function definitions
+or variable initializations in the C preamble.
+</p>
+
+<h2 id="releases">Packaged releases</h2>
+
+<p>
+One of the most significant changes associated with Go 1 is the availability
+of prepackaged, downloadable distributions.
+They are available for many combinations of architecture and operating system
+(including Windows) and the list will grow.
+Installation details are described on the
+<a href="/doc/install">Getting Started</a> page, while
+the distributions themselves are listed on the
+<a href="/dl/">downloads page</a>.
diff --git a/_content/doc/go1compat.html b/_content/doc/go1compat.html
new file mode 100644
index 0000000..b4303a3
--- /dev/null
+++ b/_content/doc/go1compat.html
@@ -0,0 +1,201 @@
+<!--{
+ "Title": "Go 1 and the Future of Go Programs"
+}-->
+
+<h2 id="introduction">Introduction</h2>
+<p>
+The release of Go version 1, Go 1 for short, is a major milestone
+in the development of the language. Go 1 is a stable platform for
+the growth of programs and projects written in Go.
+</p>
+
+<p>
+Go 1 defines two things: first, the specification of the language;
+and second, the specification of a set of core APIs, the "standard
+packages" of the Go library. The Go 1 release includes their
+implementation in the form of two compiler suites (gc and gccgo),
+and the core libraries themselves.
+</p>
+
+<p>
+It is intended that programs written to the Go 1 specification will
+continue to compile and run correctly, unchanged, over the lifetime
+of that specification. At some indefinite point, a Go 2 specification
+may arise, but until that time, Go programs that work today should
+continue to work even as future "point" releases of Go 1 arise (Go
+1.1, Go 1.2, etc.).
+</p>
+
+<p>
+Compatibility is at the source level. Binary compatibility for
+compiled packages is not guaranteed between releases. After a point
+release, Go source will need to be recompiled to link against the
+new release.
+</p>
+
+<p>
+The APIs may grow, acquiring new packages and features, but not in
+a way that breaks existing Go 1 code.
+</p>
+
+<h2 id="expectations">Expectations</h2>
+
+<p>
+Although we expect that the vast majority of programs will maintain
+this compatibility over time, it is impossible to guarantee that
+no future change will break any program. This document is an attempt
+to set expectations for the compatibility of Go 1 software in the
+future. There are a number of ways in which a program that compiles
+and runs today may fail to do so after a future point release. They
+are all unlikely but worth recording.
+</p>
+
+<ul>
+<li>
+Security. A security issue in the specification or implementation
+may come to light whose resolution requires breaking compatibility.
+We reserve the right to address such security issues.
+</li>
+
+<li>
+Unspecified behavior. The Go specification tries to be explicit
+about most properties of the language, but there are some aspects
+that are undefined. Programs that depend on such unspecified behavior
+may break in future releases.
+</li>
+
+<li>
+Specification errors. If it becomes necessary to address an
+inconsistency or incompleteness in the specification, resolving the
+issue could affect the meaning or legality of existing programs.
+We reserve the right to address such issues, including updating the
+implementations. Except for security issues, no incompatible changes
+to the specification would be made.
+</li>
+
+<li>
+Bugs. If a compiler or library has a bug that violates the
+specification, a program that depends on the buggy behavior may
+break if the bug is fixed. We reserve the right to fix such bugs.
+</li>
+
+<li>
+Struct literals. For the addition of features in later point
+releases, it may be necessary to add fields to exported structs in
+the API. Code that uses unkeyed struct literals (such as pkg.T{3,
+"x"}) to create values of these types would fail to compile after
+such a change. However, code that uses keyed literals (pkg.T{A:
+3, B: "x"}) will continue to compile after such a change. We will
+update such data structures in a way that allows keyed struct
+literals to remain compatible, although unkeyed literals may fail
+to compile. (There are also more intricate cases involving nested
+data structures or interfaces, but they have the same resolution.)
+We therefore recommend that composite literals whose type is defined
+in a separate package should use the keyed notation.
+</li>
+
+<li>
+Methods. As with struct fields, it may be necessary to add methods
+to types.
+Under some circumstances, such as when the type is embedded in
+a struct along with another type,
+the addition of the new method may break
+the struct by creating a conflict with an existing method of the other
+embedded type.
+We cannot protect against this rare case and do not guarantee compatibility
+should it arise.
+</li>
+
+<li>
+Dot imports. If a program imports a standard package
+using <code>import . "path"</code>, additional names defined in the
+imported package in future releases may conflict with other names
+defined in the program. We do not recommend the use of <code>import .</code>
+outside of tests, and using it may cause a program to fail
+to compile in future releases.
+</li>
+
+<li>
+Use of package <code>unsafe</code>. Packages that import
+<a href="/pkg/unsafe/"><code>unsafe</code></a>
+may depend on internal properties of the Go implementation.
+We reserve the right to make changes to the implementation
+that may break such programs.
+</li>
+
+</ul>
+
+<p>
+Of course, for all of these possibilities, should they arise, we
+would endeavor whenever feasible to update the specification,
+compilers, or libraries without affecting existing code.
+</p>
+
+<p>
+These same considerations apply to successive point releases. For
+instance, code that runs under Go 1.2 should be compatible with Go
+1.2.1, Go 1.3, Go 1.4, etc., although not necessarily with Go 1.1
+since it may use features added only in Go 1.2
+</p>
+
+<p>
+Features added between releases, available in the source repository
+but not part of the numbered binary releases, are under active
+development. No promise of compatibility is made for software using
+such features until they have been released.
+</p>
+
+<p>
+Finally, although it is not a correctness issue, it is possible
+that the performance of a program may be affected by
+changes in the implementation of the compilers or libraries upon
+which it depends.
+No guarantee can be made about the performance of a
+given program between releases.
+</p>
+
+<p>
+Although these expectations apply to Go 1 itself, we hope similar
+considerations would be made for the development of externally
+developed software based on Go 1.
+</p>
+
+<h2 id="subrepos">Sub-repositories</h2>
+
+<p>
+Code in sub-repositories of the main go tree, such as
+<a href="//golang.org/x/net">golang.org/x/net</a>,
+may be developed under
+looser compatibility requirements. However, the sub-repositories
+will be tagged as appropriate to identify versions that are compatible
+with the Go 1 point releases.
+</p>
+
+<h2 id="operating_systems">Operating systems</h2>
+
+<p>
+It is impossible to guarantee long-term compatibility with operating
+system interfaces, which are changed by outside parties.
+The <a href="/pkg/syscall/"><code>syscall</code></a> package
+is therefore outside the purview of the guarantees made here.
+As of Go version 1.4, the <code>syscall</code> package is frozen.
+Any evolution of the system call interface must be supported elsewhere,
+such as in the
+<a href="//golang.org/x/sys">go.sys</a> subrepository.
+For details and background, see
+<a href="//golang.org/s/go1.4-syscall">this document</a>.
+</p>
+
+<h2 id="tools">Tools</h2>
+
+<p>
+Finally, the Go toolchain (compilers, linkers, build tools, and so
+on) is under active development and may change behavior. This
+means, for instance, that scripts that depend on the location and
+properties of the tools may be broken by a point release.
+</p>
+
+<p>
+These caveats aside, we believe that Go 1 will be a firm foundation
+for the development of Go and its ecosystem.
+</p>
diff --git a/_content/doc/go_faq.html b/_content/doc/go_faq.html
new file mode 100644
index 0000000..45b6110
--- /dev/null
+++ b/_content/doc/go_faq.html
@@ -0,0 +1,2483 @@
+<!--{
+ "Title": "Frequently Asked Questions (FAQ)",
+ "Path": "/doc/faq"
+}-->
+
+<h2 id="Origins">Origins</h2>
+
+<h3 id="What_is_the_purpose_of_the_project">
+What is the purpose of the project?</h3>
+
+<p>
+At the time of Go's inception, only a decade ago, the programming world was different from today.
+Production software was usually written in C++ or Java,
+GitHub did not exist, most computers were not yet multiprocessors,
+and other than Visual Studio and Eclipse there were few IDEs or other high-level tools available
+at all, let alone for free on the Internet.
+</p>
+
+<p>
+Meanwhile, we had become frustrated by the undue complexity required to use
+the languages we worked with to develop server software.
+Computers had become enormously quicker since languages such as
+C, C++ and Java were first developed but the act of programming had not
+itself advanced nearly as much.
+Also, it was clear that multiprocessors were becoming universal but
+most languages offered little help to program them efficiently
+and safely.
+</p>
+
+<p>
+We decided to take a step back and think about what major issues were
+going to dominate software engineering in the years ahead as technology
+developed, and how a new language might help address them.
+For instance, the rise of multicore CPUs argued that a language should
+provide first-class support for some sort of concurrency or parallelism.
+And to make resource management tractable in a large concurrent program,
+garbage collection, or at least some sort of safe automatic memory management was required.
+</p>
+
+<p>
+These considerations led to
+<a href="https://commandcenter.blogspot.com/2017/09/go-ten-years-and-climbing.html">a
+series of discussions</a> from which Go arose, first as a set of ideas and
+desiderata, then as a language.
+An overarching goal was that Go do more to help the working programmer
+by enabling tooling, automating mundane tasks such as code formatting,
+and removing obstacles to working on large code bases.
+</p>
+
+<p>
+A much more expansive description of the goals of Go and how
+they are met, or at least approached, is available in the article,
+<a href="//talks.golang.org/2012/splash.article">Go at Google:
+Language Design in the Service of Software Engineering</a>.
+</p>
+
+<h3 id="history">
+What is the history of the project?</h3>
+<p>
+Robert Griesemer, Rob Pike and Ken Thompson started sketching the
+goals for a new language on the white board on September 21, 2007.
+Within a few days the goals had settled into a plan to do something
+and a fair idea of what it would be. Design continued part-time in
+parallel with unrelated work. By January 2008, Ken had started work
+on a compiler with which to explore ideas; it generated C code as its
+output. By mid-year the language had become a full-time project and
+had settled enough to attempt a production compiler. In May 2008,
+Ian Taylor independently started on a GCC front end for Go using the
+draft specification. Russ Cox joined in late 2008 and helped move the language
+and libraries from prototype to reality.
+</p>
+
+<p>
+Go became a public open source project on November 10, 2009.
+Countless people from the community have contributed ideas, discussions, and code.
+</p>
+
+<p>
+There are now millions of Go programmers—gophers—around the world,
+and there are more every day.
+Go's success has far exceeded our expectations.
+</p>
+
+<h3 id="gopher">
+What's the origin of the gopher mascot?</h3>
+
+<p>
+The mascot and logo were designed by
+<a href="https://reneefrench.blogspot.com">Renée French</a>, who also designed
+<a href="https://9p.io/plan9/glenda.html">Glenda</a>,
+the Plan 9 bunny.
+A <a href="https://blog.golang.org/gopher">blog post</a>
+about the gopher explains how it was
+derived from one she used for a <a href="https://wfmu.org/">WFMU</a>
+T-shirt design some years ago.
+The logo and mascot are covered by the
+<a href="https://creativecommons.org/licenses/by/3.0/">Creative Commons Attribution 3.0</a>
+license.
+</p>
+
+<p>
+The gopher has a
+<a href="/doc/gopher/modelsheet.jpg">model sheet</a>
+illustrating his characteristics and how to represent them correctly.
+The model sheet was first shown in a
+<a href="https://www.youtube.com/watch?v=4rw_B4yY69k">talk</a>
+by Renée at Gophercon in 2016.
+He has unique features; he's the <em>Go gopher</em>, not just any old gopher.
+</p>
+
+<h3 id="go_or_golang">
+Is the language called Go or Golang?</h3>
+
+<p>
+The language is called Go.
+The "golang" moniker arose because the web site is
+<a href="https://golang.org">golang.org</a>, not
+go.org, which was not available to us.
+Many use the golang name, though, and it is handy as
+a label.
+For instance, the Twitter tag for the language is "#golang".
+The language's name is just plain Go, regardless.
+</p>
+
+<p>
+A side note: Although the
+<a href="https://blog.golang.org/go-brand">official logo</a>
+has two capital letters, the language name is written Go, not GO.
+</p>
+
+<h3 id="creating_a_new_language">
+Why did you create a new language?</h3>
+
+<p>
+Go was born out of frustration with existing languages and
+environments for the work we were doing at Google.
+Programming had become too
+difficult and the choice of languages was partly to blame. One had to
+choose either efficient compilation, efficient execution, or ease of
+programming; all three were not available in the same mainstream
+language. Programmers who could were choosing ease over
+safety and efficiency by moving to dynamically typed languages such as
+Python and JavaScript rather than C++ or, to a lesser extent, Java.
+</p>
+
+<p>
+We were not alone in our concerns.
+After many years with a pretty quiet landscape for programming languages,
+Go was among the first of several new languages—Rust,
+Elixir, Swift, and more—that have made programming language development
+an active, almost mainstream field again.
+</p>
+
+<p>
+Go addressed these issues by attempting to combine the ease of programming of an interpreted,
+dynamically typed
+language with the efficiency and safety of a statically typed, compiled language.
+It also aimed to be modern, with support for networked and multicore
+computing. Finally, working with Go is intended to be <i>fast</i>: it should take
+at most a few seconds to build a large executable on a single computer.
+To meet these goals required addressing a number of
+linguistic issues: an expressive but lightweight type system;
+concurrency and garbage collection; rigid dependency specification;
+and so on. These cannot be addressed well by libraries or tools; a new
+language was called for.
+</p>
+
+<p>
+The article <a href="//talks.golang.org/2012/splash.article">Go at Google</a>
+discusses the background and motivation behind the design of the Go language,
+as well as providing more detail about many of the answers presented in this FAQ.
+</p>
+
+
+<h3 id="ancestors">
+What are Go's ancestors?</h3>
+<p>
+Go is mostly in the C family (basic syntax),
+with significant input from the Pascal/Modula/Oberon
+family (declarations, packages),
+plus some ideas from languages
+inspired by Tony Hoare's CSP,
+such as Newsqueak and Limbo (concurrency).
+However, it is a new language across the board.
+In every respect the language was designed by thinking
+about what programmers do and how to make programming, at least the
+kind of programming we do, more effective, which means more fun.
+</p>
+
+<h3 id="principles">
+What are the guiding principles in the design?</h3>
+
+<p>
+When Go was designed, Java and C++ were the most commonly
+used languages for writing servers, at least at Google.
+We felt that these languages required
+too much bookkeeping and repetition.
+Some programmers reacted by moving towards more dynamic,
+fluid languages like Python, at the cost of efficiency and
+type safety.
+We felt it should be possible to have the efficiency,
+the safety, and the fluidity in a single language.
+</p>
+
+<p>
+Go attempts to reduce the amount of typing in both senses of the word.
+Throughout its design, we have tried to reduce clutter and
+complexity. There are no forward declarations and no header files;
+everything is declared exactly once. Initialization is expressive,
+automatic, and easy to use. Syntax is clean and light on keywords.
+Repetition (<code>foo.Foo* myFoo = new(foo.Foo)</code>) is reduced by
+simple type derivation using the <code>:=</code>
+declare-and-initialize construct. And perhaps most radically, there
+is no type hierarchy: types just <i>are</i>, they don't have to
+announce their relationships. These simplifications allow Go to be
+expressive yet comprehensible without sacrificing, well, sophistication.
+</p>
+<p>
+Another important principle is to keep the concepts orthogonal.
+Methods can be implemented for any type; structures represent data while
+interfaces represent abstraction; and so on. Orthogonality makes it
+easier to understand what happens when things combine.
+</p>
+
+<h2 id="Usage">Usage</h2>
+
+<h3 id="internal_usage">
+Is Google using Go internally?</h3>
+
+<p>
+Yes. Go is used widely in production inside Google.
+One easy example is the server behind
+<a href="//golang.org">golang.org</a>.
+It's just the <a href="/cmd/godoc"><code>godoc</code></a>
+document server running in a production configuration on
+<a href="https://developers.google.com/appengine/">Google App Engine</a>.
+</p>
+
+<p>
+A more significant instance is Google's download server, <code>dl.google.com</code>,
+which delivers Chrome binaries and other large installables such as <code>apt-get</code>
+packages.
+</p>
+
+<p>
+Go is not the only language used at Google, far from it, but it is a key language
+for a number of areas including
+<a href="https://talks.golang.org/2013/go-sreops.slide">site reliability
+engineering (SRE)</a>
+and large-scale data processing.
+</p>
+
+<h3 id="external_usage">
+What other companies use Go?</h3>
+
+<p>
+Go usage is growing worldwide, especially but by no means exclusively
+in the cloud computing space.
+A couple of major cloud infrastructure projects written in Go are
+Docker and Kubernetes,
+but there are many more.
+</p>
+
+<p>
+It's not just cloud, though.
+The Go Wiki includes a
+<a href="https://github.com/golang/go/wiki/GoUsers">page</a>,
+updated regularly, that lists some of the many companies using Go.
+</p>
+
+<p>
+The Wiki also has a page with links to
+<a href="https://github.com/golang/go/wiki/SuccessStories">success stories</a>
+about companies and projects that are using the language.
+</p>
+
+<h3 id="Do_Go_programs_link_with_Cpp_programs">
+Do Go programs link with C/C++ programs?</h3>
+
+<p>
+It is possible to use C and Go together in the same address space,
+but it is not a natural fit and can require special interface software.
+Also, linking C with Go code gives up the memory
+safety and stack management properties that Go provides.
+Sometimes it's absolutely necessary to use C libraries to solve a problem,
+but doing so always introduces an element of risk not present with
+pure Go code, so do so with care.
+</p>
+
+<p>
+If you do need to use C with Go, how to proceed depends on the Go
+compiler implementation.
+There are three Go compiler implementations supported by the
+Go team.
+These are <code>gc</code>, the default compiler,
+<code>gccgo</code>, which uses the GCC back end,
+and a somewhat less mature <code>gollvm</code>, which uses the LLVM infrastructure.
+</p>
+
+<p>
+<code>Gc</code> uses a different calling convention and linker from C and
+therefore cannot be called directly from C programs, or vice versa.
+The <a href="/cmd/cgo/"><code>cgo</code></a> program provides the mechanism for a
+“foreign function interface” to allow safe calling of
+C libraries from Go code.
+SWIG extends this capability to C++ libraries.
+</p>
+
+<p>
+You can also use <code>cgo</code> and SWIG with <code>Gccgo</code> and <code>gollvm</code>.
+Since they use a traditional API, it's also possible, with great care,
+to link code from these compilers directly with GCC/LLVM-compiled C or C++ programs.
+However, doing so safely requires an understanding of the calling conventions for
+all languages concerned, as well as concern for stack limits when calling C or C++
+from Go.
+</p>
+
+<h3 id="ide">
+What IDEs does Go support?</h3>
+
+<p>
+The Go project does not include a custom IDE, but the language and
+libraries have been designed to make it easy to analyze source code.
+As a consequence, most well-known editors and IDEs support Go well,
+either directly or through a plugin.
+</p>
+
+<p>
+The list of well-known IDEs and editors that have good Go support
+available includes Emacs, Vim, VSCode, Atom, Eclipse, Sublime, IntelliJ
+(through a custom variant called Goland), and many more.
+Chances are your favorite environment is a productive one for
+programming in Go.
+</p>
+
+<h3 id="protocol_buffers">
+Does Go support Google's protocol buffers?</h3>
+
+<p>
+A separate open source project provides the necessary compiler plugin and library.
+It is available at
+<a href="//github.com/golang/protobuf">github.com/golang/protobuf/</a>.
+</p>
+
+
+<h3 id="Can_I_translate_the_Go_home_page">
+Can I translate the Go home page into another language?</h3>
+
+<p>
+Absolutely. We encourage developers to make Go Language sites in their own languages.
+However, if you choose to add the Google logo or branding to your site
+(it does not appear on <a href="//golang.org/">golang.org</a>),
+you will need to abide by the guidelines at
+<a href="//www.google.com/permissions/guidelines.html">www.google.com/permissions/guidelines.html</a>
+</p>
+
+<h2 id="Design">Design</h2>
+
+<h3 id="runtime">
+Does Go have a runtime?</h3>
+
+<p>
+Go does have an extensive library, called the <em>runtime</em>,
+that is part of every Go program.
+The runtime library implements garbage collection, concurrency,
+stack management, and other critical features of the Go language.
+Although it is more central to the language, Go's runtime is analogous
+to <code>libc</code>, the C library.
+</p>
+
+<p>
+It is important to understand, however, that Go's runtime does not
+include a virtual machine, such as is provided by the Java runtime.
+Go programs are compiled ahead of time to native machine code
+(or JavaScript or WebAssembly, for some variant implementations).
+Thus, although the term is often used to describe the virtual
+environment in which a program runs, in Go the word “runtime”
+is just the name given to the library providing critical language services.
+</p>
+
+<h3 id="unicode_identifiers">
+What's up with Unicode identifiers?</h3>
+
+<p>
+When designing Go, we wanted to make sure that it was not
+overly ASCII-centric,
+which meant extending the space of identifiers from the
+confines of 7-bit ASCII.
+Go's rule—identifier characters must be
+letters or digits as defined by Unicode—is simple to understand
+and to implement but has restrictions.
+Combining characters are
+excluded by design, for instance,
+and that excludes some languages such as Devanagari.
+</p>
+
+<p>
+This rule has one other unfortunate consequence.
+Since an exported identifier must begin with an
+upper-case letter, identifiers created from characters
+in some languages can, by definition, not be exported.
+For now the
+only solution is to use something like <code>X日本語</code>, which
+is clearly unsatisfactory.
+</p>
+
+<p>
+Since the earliest version of the language, there has been considerable
+thought into how best to expand the identifier space to accommodate
+programmers using other native languages.
+Exactly what to do remains an active topic of discussion, and a future
+version of the language may be more liberal in its definition
+of an identifier.
+For instance, it might adopt some of the ideas from the Unicode
+organization's <a href="http://unicode.org/reports/tr31/">recommendations</a>
+for identifiers.
+Whatever happens, it must be done compatibly while preserving
+(or perhaps expanding) the way letter case determines visibility of
+identifiers, which remains one of our favorite features of Go.
+</p>
+
+<p>
+For the time being, we have a simple rule that can be expanded later
+without breaking programs, one that avoids bugs that would surely arise
+from a rule that admits ambiguous identifiers.
+</p>
+
+<h3 id="Why_doesnt_Go_have_feature_X">Why does Go not have feature X?</h3>
+
+<p>
+Every language contains novel features and omits someone's favorite
+feature. Go was designed with an eye on felicity of programming, speed of
+compilation, orthogonality of concepts, and the need to support features
+such as concurrency and garbage collection. Your favorite feature may be
+missing because it doesn't fit, because it affects compilation speed or
+clarity of design, or because it would make the fundamental system model
+too difficult.
+</p>
+
+<p>
+If it bothers you that Go is missing feature <var>X</var>,
+please forgive us and investigate the features that Go does have. You might find that
+they compensate in interesting ways for the lack of <var>X</var>.
+</p>
+
+<h3 id="generics">
+Why does Go not have generic types?</h3>
+<p>
+A <a href="https://golang.org/issue/43651">language proposal
+implementing a form of generic types</a> has been accepted for
+inclusion in the language.
+If all goes well it will be available in the Go 1.18 release.
+</p>
+
+<p>
+Go was intended as a language for writing server programs that would be
+easy to maintain over time.
+(See <a href="https://talks.golang.org/2012/splash.article">this
+article</a> for more background.)
+The design concentrated on things like scalability, readability, and
+concurrency.
+Polymorphic programming did not seem essential to the language's
+goals at the time, and so was left out for simplicity.
+</p>
+
+<p>
+The language is more mature now, and there is scope to consider
+some form of generic programming.
+However, there remain some caveats.
+</p>
+
+<p>
+Generics are convenient but they come at a cost in
+complexity in the type system and run-time. We haven't yet found a
+design that gives value proportionate to the complexity, although we
+continue to think about it. Meanwhile, Go's built-in maps and slices,
+plus the ability to use the empty interface to construct containers
+(with explicit unboxing) mean in many cases it is possible to write
+code that does what generics would enable, if less smoothly.
+</p>
+
+<p>
+The topic remains open.
+For a look at several previous unsuccessful attempts to
+design a good generics solution for Go, see
+<a href="https://golang.org/issue/15292">this proposal</a>.
+</p>
+
+<h3 id="exceptions">
+Why does Go not have exceptions?</h3>
+<p>
+We believe that coupling exceptions to a control
+structure, as in the <code>try-catch-finally</code> idiom, results in
+convoluted code. It also tends to encourage programmers to label
+too many ordinary errors, such as failing to open a file, as
+exceptional.
+</p>
+
+<p>
+Go takes a different approach. For plain error handling, Go's multi-value
+returns make it easy to report an error without overloading the return value.
+<a href="/doc/articles/error_handling.html">A canonical error type, coupled
+with Go's other features</a>, makes error handling pleasant but quite different
+from that in other languages.
+</p>
+
+<p>
+Go also has a couple
+of built-in functions to signal and recover from truly exceptional
+conditions. The recovery mechanism is executed only as part of a
+function's state being torn down after an error, which is sufficient
+to handle catastrophe but requires no extra control structures and,
+when used well, can result in clean error-handling code.
+</p>
+
+<p>
+See the <a href="/doc/articles/defer_panic_recover.html">Defer, Panic, and Recover</a> article for details.
+Also, the <a href="https://blog.golang.org/errors-are-values">Errors are values</a> blog post
+describes one approach to handling errors cleanly in Go by demonstrating that,
+since errors are just values, the full power of Go can be deployed in error handling.
+</p>
+
+<h3 id="assertions">
+Why does Go not have assertions?</h3>
+
+<p>
+Go doesn't provide assertions. They are undeniably convenient, but our
+experience has been that programmers use them as a crutch to avoid thinking
+about proper error handling and reporting. Proper error handling means that
+servers continue to operate instead of crashing after a non-fatal error.
+Proper error reporting means that errors are direct and to the point,
+saving the programmer from interpreting a large crash trace. Precise
+errors are particularly important when the programmer seeing the errors is
+not familiar with the code.
+</p>
+
+<p>
+We understand that this is a point of contention. There are many things in
+the Go language and libraries that differ from modern practices, simply
+because we feel it's sometimes worth trying a different approach.
+</p>
+
+<h3 id="csp">
+Why build concurrency on the ideas of CSP?</h3>
+<p>
+Concurrency and multi-threaded programming have over time
+developed a reputation for difficulty. We believe this is due partly to complex
+designs such as
+<a href="https://en.wikipedia.org/wiki/POSIX_Threads">pthreads</a>
+and partly to overemphasis on low-level details
+such as mutexes, condition variables, and memory barriers.
+Higher-level interfaces enable much simpler code, even if there are still
+mutexes and such under the covers.
+</p>
+
+<p>
+One of the most successful models for providing high-level linguistic support
+for concurrency comes from Hoare's Communicating Sequential Processes, or CSP.
+Occam and Erlang are two well known languages that stem from CSP.
+Go's concurrency primitives derive from a different part of the family tree
+whose main contribution is the powerful notion of channels as first class objects.
+Experience with several earlier languages has shown that the CSP model
+fits well into a procedural language framework.
+</p>
+
+<h3 id="goroutines">
+Why goroutines instead of threads?</h3>
+<p>
+Goroutines are part of making concurrency easy to use. The idea, which has
+been around for a while, is to multiplex independently executing
+functions—coroutines—onto a set of threads.
+When a coroutine blocks, such as by calling a blocking system call,
+the run-time automatically moves other coroutines on the same operating
+system thread to a different, runnable thread so they won't be blocked.
+The programmer sees none of this, which is the point.
+The result, which we call goroutines, can be very cheap: they have little
+overhead beyond the memory for the stack, which is just a few kilobytes.
+</p>
+
+<p>
+To make the stacks small, Go's run-time uses resizable, bounded stacks. A newly
+minted goroutine is given a few kilobytes, which is almost always enough.
+When it isn't, the run-time grows (and shrinks) the memory for storing
+the stack automatically, allowing many goroutines to live in a modest
+amount of memory.
+The CPU overhead averages about three cheap instructions per function call.
+It is practical to create hundreds of thousands of goroutines in the same
+address space.
+If goroutines were just threads, system resources would
+run out at a much smaller number.
+</p>
+
+<h3 id="atomic_maps">
+Why are map operations not defined to be atomic?</h3>
+
+<p>
+After long discussion it was decided that the typical use of maps did not require
+safe access from multiple goroutines, and in those cases where it did, the map was
+probably part of some larger data structure or computation that was already
+synchronized. Therefore requiring that all map operations grab a mutex would slow
+down most programs and add safety to few. This was not an easy decision,
+however, since it means uncontrolled map access can crash the program.
+</p>
+
+<p>
+The language does not preclude atomic map updates. When required, such
+as when hosting an untrusted program, the implementation could interlock
+map access.
+</p>
+
+<p>
+Map access is unsafe only when updates are occurring.
+As long as all goroutines are only reading—looking up elements in the map,
+including iterating through it using a
+<code>for</code> <code>range</code> loop—and not changing the map
+by assigning to elements or doing deletions,
+it is safe for them to access the map concurrently without synchronization.
+</p>
+
+<p>
+As an aid to correct map use, some implementations of the language
+contain a special check that automatically reports at run time when a map is modified
+unsafely by concurrent execution.
+</p>
+
+<h3 id="language_changes">
+Will you accept my language change?</h3>
+
+<p>
+People often suggest improvements to the language—the
+<a href="//groups.google.com/group/golang-nuts">mailing list</a>
+contains a rich history of such discussions—but very few of these changes have
+been accepted.
+</p>
+
+<p>
+Although Go is an open source project, the language and libraries are protected
+by a <a href="/doc/go1compat.html">compatibility promise</a> that prevents
+changes that break existing programs, at least at the source code level
+(programs may need to be recompiled occasionally to stay current).
+If your proposal violates the Go 1 specification we cannot even entertain the
+idea, regardless of its merit.
+A future major release of Go may be incompatible with Go 1, but discussions
+on that topic have only just begun and one thing is certain:
+there will be very few such incompatibilities introduced in the process.
+Moreover, the compatibility promise encourages us to provide an automatic path
+forward for old programs to adapt should that situation arise.
+</p>
+
+<p>
+Even if your proposal is compatible with the Go 1 spec, it might
+not be in the spirit of Go's design goals.
+The article <i><a href="//talks.golang.org/2012/splash.article">Go
+at Google: Language Design in the Service of Software Engineering</a></i>
+explains Go's origins and the motivation behind its design.
+</p>
+
+<h2 id="types">Types</h2>
+
+<h3 id="Is_Go_an_object-oriented_language">
+Is Go an object-oriented language?</h3>
+
+<p>
+Yes and no. Although Go has types and methods and allows an
+object-oriented style of programming, there is no type hierarchy.
+The concept of “interface” in Go provides a different approach that
+we believe is easy to use and in some ways more general. There are
+also ways to embed types in other types to provide something
+analogous—but not identical—to subclassing.
+Moreover, methods in Go are more general than in C++ or Java:
+they can be defined for any sort of data, even built-in types such
+as plain, “unboxed” integers.
+They are not restricted to structs (classes).
+</p>
+
+<p>
+Also, the lack of a type hierarchy makes “objects” in Go feel much more
+lightweight than in languages such as C++ or Java.
+</p>
+
+<h3 id="How_do_I_get_dynamic_dispatch_of_methods">
+How do I get dynamic dispatch of methods?</h3>
+
+<p>
+The only way to have dynamically dispatched methods is through an
+interface. Methods on a struct or any other concrete type are always resolved statically.
+</p>
+
+<h3 id="inheritance">
+Why is there no type inheritance?</h3>
+<p>
+Object-oriented programming, at least in the best-known languages,
+involves too much discussion of the relationships between types,
+relationships that often could be derived automatically. Go takes a
+different approach.
+</p>
+
+<p>
+Rather than requiring the programmer to declare ahead of time that two
+types are related, in Go a type automatically satisfies any interface
+that specifies a subset of its methods. Besides reducing the
+bookkeeping, this approach has real advantages. Types can satisfy
+many interfaces at once, without the complexities of traditional
+multiple inheritance.
+Interfaces can be very lightweight—an interface with
+one or even zero methods can express a useful concept.
+Interfaces can be added after the fact if a new idea comes along
+or for testing—without annotating the original types.
+Because there are no explicit relationships between types
+and interfaces, there is no type hierarchy to manage or discuss.
+</p>
+
+<p>
+It's possible to use these ideas to construct something analogous to
+type-safe Unix pipes. For instance, see how <code>fmt.Fprintf</code>
+enables formatted printing to any output, not just a file, or how the
+<code>bufio</code> package can be completely separate from file I/O,
+or how the <code>image</code> packages generate compressed
+image files. All these ideas stem from a single interface
+(<code>io.Writer</code>) representing a single method
+(<code>Write</code>). And that's only scratching the surface.
+Go's interfaces have a profound influence on how programs are structured.
+</p>
+
+<p>
+It takes some getting used to but this implicit style of type
+dependency is one of the most productive things about Go.
+</p>
+
+<h3 id="methods_on_basics">
+Why is <code>len</code> a function and not a method?</h3>
+<p>
+We debated this issue but decided
+implementing <code>len</code> and friends as functions was fine in practice and
+didn't complicate questions about the interface (in the Go type sense)
+of basic types.
+</p>
+
+<h3 id="overloading">
+Why does Go not support overloading of methods and operators?</h3>
+<p>
+Method dispatch is simplified if it doesn't need to do type matching as well.
+Experience with other languages told us that having a variety of
+methods with the same name but different signatures was occasionally useful
+but that it could also be confusing and fragile in practice. Matching only by name
+and requiring consistency in the types was a major simplifying decision
+in Go's type system.
+</p>
+
+<p>
+Regarding operator overloading, it seems more a convenience than an absolute
+requirement. Again, things are simpler without it.
+</p>
+
+<h3 id="implements_interface">
+Why doesn't Go have "implements" declarations?</h3>
+
+<p>
+A Go type satisfies an interface by implementing the methods of that interface,
+nothing more. This property allows interfaces to be defined and used without
+needing to modify existing code. It enables a kind of
+<a href="https://en.wikipedia.org/wiki/Structural_type_system">structural typing</a> that
+promotes separation of concerns and improves code re-use, and makes it easier
+to build on patterns that emerge as the code develops.
+The semantics of interfaces is one of the main reasons for Go's nimble,
+lightweight feel.
+</p>
+
+<p>
+See the <a href="#inheritance">question on type inheritance</a> for more detail.
+</p>
+
+<h3 id="guarantee_satisfies_interface">
+How can I guarantee my type satisfies an interface?</h3>
+
+<p>
+You can ask the compiler to check that the type <code>T</code> implements the
+interface <code>I</code> by attempting an assignment using the zero value for
+<code>T</code> or pointer to <code>T</code>, as appropriate:
+</p>
+
+<pre>
+type T struct{}
+var _ I = T{} // Verify that T implements I.
+var _ I = (*T)(nil) // Verify that *T implements I.
+</pre>
+
+<p>
+If <code>T</code> (or <code>*T</code>, accordingly) doesn't implement
+<code>I</code>, the mistake will be caught at compile time.
+</p>
+
+<p>
+If you wish the users of an interface to explicitly declare that they implement
+it, you can add a method with a descriptive name to the interface's method set.
+For example:
+</p>
+
+<pre>
+type Fooer interface {
+ Foo()
+ ImplementsFooer()
+}
+</pre>
+
+<p>
+A type must then implement the <code>ImplementsFooer</code> method to be a
+<code>Fooer</code>, clearly documenting the fact and announcing it in
+<a href="/cmd/go/#hdr-Show_documentation_for_package_or_symbol">go doc</a>'s output.
+</p>
+
+<pre>
+type Bar struct{}
+func (b Bar) ImplementsFooer() {}
+func (b Bar) Foo() {}
+</pre>
+
+<p>
+Most code doesn't make use of such constraints, since they limit the utility of
+the interface idea. Sometimes, though, they're necessary to resolve ambiguities
+among similar interfaces.
+</p>
+
+<h3 id="t_and_equal_interface">
+Why doesn't type T satisfy the Equal interface?</h3>
+
+<p>
+Consider this simple interface to represent an object that can compare
+itself with another value:
+</p>
+
+<pre>
+type Equaler interface {
+ Equal(Equaler) bool
+}
+</pre>
+
+<p>
+and this type, <code>T</code>:
+</p>
+
+<pre>
+type T int
+func (t T) Equal(u T) bool { return t == u } // does not satisfy Equaler
+</pre>
+
+<p>
+Unlike the analogous situation in some polymorphic type systems,
+<code>T</code> does not implement <code>Equaler</code>.
+The argument type of <code>T.Equal</code> is <code>T</code>,
+not literally the required type <code>Equaler</code>.
+</p>
+
+<p>
+In Go, the type system does not promote the argument of
+<code>Equal</code>; that is the programmer's responsibility, as
+illustrated by the type <code>T2</code>, which does implement
+<code>Equaler</code>:
+</p>
+
+<pre>
+type T2 int
+func (t T2) Equal(u Equaler) bool { return t == u.(T2) } // satisfies Equaler
+</pre>
+
+<p>
+Even this isn't like other type systems, though, because in Go <em>any</em>
+type that satisfies <code>Equaler</code> could be passed as the
+argument to <code>T2.Equal</code>, and at run time we must
+check that the argument is of type <code>T2</code>.
+Some languages arrange to make that guarantee at compile time.
+</p>
+
+<p>
+A related example goes the other way:
+</p>
+
+<pre>
+type Opener interface {
+ Open() Reader
+}
+
+func (t T3) Open() *os.File
+</pre>
+
+<p>
+In Go, <code>T3</code> does not satisfy <code>Opener</code>,
+although it might in another language.
+</p>
+
+<p>
+While it is true that Go's type system does less for the programmer
+in such cases, the lack of subtyping makes the rules about
+interface satisfaction very easy to state: are the function's names
+and signatures exactly those of the interface?
+Go's rule is also easy to implement efficiently.
+We feel these benefits offset the lack of
+automatic type promotion. Should Go one day adopt some form of polymorphic
+typing, we expect there would be a way to express the idea of these
+examples and also have them be statically checked.
+</p>
+
+<h3 id="convert_slice_of_interface">
+Can I convert a []T to an []interface{}?</h3>
+
+<p>
+Not directly.
+It is disallowed by the language specification because the two types
+do not have the same representation in memory.
+It is necessary to copy the elements individually to the destination
+slice. This example converts a slice of <code>int</code> to a slice of
+<code>interface{}</code>:
+</p>
+
+<pre>
+t := []int{1, 2, 3, 4}
+s := make([]interface{}, len(t))
+for i, v := range t {
+ s[i] = v
+}
+</pre>
+
+<h3 id="convert_slice_with_same_underlying_type">
+Can I convert []T1 to []T2 if T1 and T2 have the same underlying type?</h3>
+
+This last line of this code sample does not compile.
+
+<pre>
+type T1 int
+type T2 int
+var t1 T1
+var x = T2(t1) // OK
+var st1 []T1
+var sx = ([]T2)(st1) // NOT OK
+</pre>
+
+<p>
+In Go, types are closely tied to methods, in that every named type has
+a (possibly empty) method set.
+The general rule is that you can change the name of the type being
+converted (and thus possibly change its method set) but you can't
+change the name (and method set) of elements of a composite type.
+Go requires you to be explicit about type conversions.
+</p>
+
+<h3 id="nil_error">
+Why is my nil error value not equal to nil?
+</h3>
+
+<p>
+Under the covers, interfaces are implemented as two elements, a type <code>T</code>
+and a value <code>V</code>.
+<code>V</code> is a concrete value such as an <code>int</code>,
+<code>struct</code> or pointer, never an interface itself, and has
+type <code>T</code>.
+For instance, if we store the <code>int</code> value 3 in an interface,
+the resulting interface value has, schematically,
+(<code>T=int</code>, <code>V=3</code>).
+The value <code>V</code> is also known as the interface's
+<em>dynamic</em> value,
+since a given interface variable might hold different values <code>V</code>
+(and corresponding types <code>T</code>)
+during the execution of the program.
+</p>
+
+<p>
+An interface value is <code>nil</code> only if the <code>V</code> and <code>T</code>
+are both unset, (<code>T=nil</code>, <code>V</code> is not set),
+In particular, a <code>nil</code> interface will always hold a <code>nil</code> type.
+If we store a <code>nil</code> pointer of type <code>*int</code> inside
+an interface value, the inner type will be <code>*int</code> regardless of the value of the pointer:
+(<code>T=*int</code>, <code>V=nil</code>).
+Such an interface value will therefore be non-<code>nil</code>
+<em>even when the pointer value <code>V</code> inside is</em> <code>nil</code>.
+</p>
+
+<p>
+This situation can be confusing, and arises when a <code>nil</code> value is
+stored inside an interface value such as an <code>error</code> return:
+</p>
+
+<pre>
+func returnsError() error {
+ var p *MyError = nil
+ if bad() {
+ p = ErrBad
+ }
+ return p // Will always return a non-nil error.
+}
+</pre>
+
+<p>
+If all goes well, the function returns a <code>nil</code> <code>p</code>,
+so the return value is an <code>error</code> interface
+value holding (<code>T=*MyError</code>, <code>V=nil</code>).
+This means that if the caller compares the returned error to <code>nil</code>,
+it will always look as if there was an error even if nothing bad happened.
+To return a proper <code>nil</code> <code>error</code> to the caller,
+the function must return an explicit <code>nil</code>:
+</p>
+
+
+<pre>
+func returnsError() error {
+ if bad() {
+ return ErrBad
+ }
+ return nil
+}
+</pre>
+
+<p>
+It's a good idea for functions
+that return errors always to use the <code>error</code> type in
+their signature (as we did above) rather than a concrete type such
+as <code>*MyError</code>, to help guarantee the error is
+created correctly. As an example,
+<a href="/pkg/os/#Open"><code>os.Open</code></a>
+returns an <code>error</code> even though, if not <code>nil</code>,
+it's always of concrete type
+<a href="/pkg/os/#PathError"><code>*os.PathError</code></a>.
+</p>
+
+<p>
+Similar situations to those described here can arise whenever interfaces are used.
+Just keep in mind that if any concrete value
+has been stored in the interface, the interface will not be <code>nil</code>.
+For more information, see
+<a href="/doc/articles/laws_of_reflection.html">The Laws of Reflection</a>.
+</p>
+
+
+<h3 id="unions">
+Why are there no untagged unions, as in C?</h3>
+
+<p>
+Untagged unions would violate Go's memory safety
+guarantees.
+</p>
+
+<h3 id="variant_types">
+Why does Go not have variant types?</h3>
+
+<p>
+Variant types, also known as algebraic types, provide a way to specify
+that a value might take one of a set of other types, but only those
+types. A common example in systems programming would specify that an
+error is, say, a network error, a security error or an application
+error and allow the caller to discriminate the source of the problem
+by examining the type of the error. Another example is a syntax tree
+in which each node can be a different type: declaration, statement,
+assignment and so on.
+</p>
+
+<p>
+We considered adding variant types to Go, but after discussion
+decided to leave them out because they overlap in confusing ways
+with interfaces. What would happen if the elements of a variant type
+were themselves interfaces?
+</p>
+
+<p>
+Also, some of what variant types address is already covered by the
+language. The error example is easy to express using an interface
+value to hold the error and a type switch to discriminate cases. The
+syntax tree example is also doable, although not as elegantly.
+</p>
+
+<h3 id="covariant_types">
+Why does Go not have covariant result types?</h3>
+
+<p>
+Covariant result types would mean that an interface like
+</p>
+
+<pre>
+type Copyable interface {
+ Copy() interface{}
+}
+</pre>
+
+<p>
+would be satisfied by the method
+</p>
+
+<pre>
+func (v Value) Copy() Value
+</pre>
+
+<p>because <code>Value</code> implements the empty interface.
+In Go method types must match exactly, so <code>Value</code> does not
+implement <code>Copyable</code>.
+Go separates the notion of what a
+type does—its methods—from the type's implementation.
+If two methods return different types, they are not doing the same thing.
+Programmers who want covariant result types are often trying to
+express a type hierarchy through interfaces.
+In Go it's more natural to have a clean separation between interface
+and implementation.
+</p>
+
+<h2 id="values">Values</h2>
+
+<h3 id="conversions">
+Why does Go not provide implicit numeric conversions?</h3>
+
+<p>
+The convenience of automatic conversion between numeric types in C is
+outweighed by the confusion it causes. When is an expression unsigned?
+How big is the value? Does it overflow? Is the result portable, independent
+of the machine on which it executes?
+It also complicates the compiler; “the usual arithmetic conversions”
+are not easy to implement and inconsistent across architectures.
+For reasons of portability, we decided to make things clear and straightforward
+at the cost of some explicit conversions in the code.
+The definition of constants in Go—arbitrary precision values free
+of signedness and size annotations—ameliorates matters considerably,
+though.
+</p>
+
+<p>
+A related detail is that, unlike in C, <code>int</code> and <code>int64</code>
+are distinct types even if <code>int</code> is a 64-bit type. The <code>int</code>
+type is generic; if you care about how many bits an integer holds, Go
+encourages you to be explicit.
+</p>
+
+<h3 id="constants">
+How do constants work in Go?</h3>
+
+<p>
+Although Go is strict about conversion between variables of different
+numeric types, constants in the language are much more flexible.
+Literal constants such as <code>23</code>, <code>3.14159</code>
+and <a href="/pkg/math/#pkg-constants"><code>math.Pi</code></a>
+occupy a sort of ideal number space, with arbitrary precision and
+no overflow or underflow.
+For instance, the value of <code>math.Pi</code> is specified to 63 places
+in the source code, and constant expressions involving the value keep
+precision beyond what a <code>float64</code> could hold.
+Only when the constant or constant expression is assigned to a
+variable—a memory location in the program—does
+it become a "computer" number with
+the usual floating-point properties and precision.
+</p>
+
+<p>
+Also,
+because they are just numbers, not typed values, constants in Go can be
+used more freely than variables, thereby softening some of the awkwardness
+around the strict conversion rules.
+One can write expressions such as
+</p>
+
+<pre>
+sqrt2 := math.Sqrt(2)
+</pre>
+
+<p>
+without complaint from the compiler because the ideal number <code>2</code>
+can be converted safely and accurately
+to a <code>float64</code> for the call to <code>math.Sqrt</code>.
+</p>
+
+<p>
+A blog post titled <a href="https://blog.golang.org/constants">Constants</a>
+explores this topic in more detail.
+</p>
+
+<h3 id="builtin_maps">
+Why are maps built in?</h3>
+<p>
+The same reason strings are: they are such a powerful and important data
+structure that providing one excellent implementation with syntactic support
+makes programming more pleasant. We believe that Go's implementation of maps
+is strong enough that it will serve for the vast majority of uses.
+If a specific application can benefit from a custom implementation, it's possible
+to write one but it will not be as convenient syntactically; this seems a reasonable tradeoff.
+</p>
+
+<h3 id="map_keys">
+Why don't maps allow slices as keys?</h3>
+<p>
+Map lookup requires an equality operator, which slices do not implement.
+They don't implement equality because equality is not well defined on such types;
+there are multiple considerations involving shallow vs. deep comparison, pointer vs.
+value comparison, how to deal with recursive types, and so on.
+We may revisit this issue—and implementing equality for slices
+will not invalidate any existing programs—but without a clear idea of what
+equality of slices should mean, it was simpler to leave it out for now.
+</p>
+
+<p>
+In Go 1, unlike prior releases, equality is defined for structs and arrays, so such
+types can be used as map keys. Slices still do not have a definition of equality, though.
+</p>
+
+<h3 id="references">
+Why are maps, slices, and channels references while arrays are values?</h3>
+<p>
+There's a lot of history on that topic. Early on, maps and channels
+were syntactically pointers and it was impossible to declare or use a
+non-pointer instance. Also, we struggled with how arrays should work.
+Eventually we decided that the strict separation of pointers and
+values made the language harder to use. Changing these
+types to act as references to the associated, shared data structures resolved
+these issues. This change added some regrettable complexity to the
+language but had a large effect on usability: Go became a more
+productive, comfortable language when it was introduced.
+</p>
+
+<h2 id="Writing_Code">Writing Code</h2>
+
+<h3 id="How_are_libraries_documented">
+How are libraries documented?</h3>
+
+<p>
+There is a program, <code>godoc</code>, written in Go, that extracts
+package documentation from the source code and serves it as a web
+page with links to declarations, files, and so on.
+An instance is running at
+<a href="/pkg/">golang.org/pkg/</a>.
+In fact, <code>godoc</code> implements the full site at
+<a href="/">golang.org/</a>.
+</p>
+
+<p>
+A <code>godoc</code> instance may be configured to provide rich,
+interactive static analyses of symbols in the programs it displays; details are
+listed <a href="https://golang.org/lib/godoc/analysis/help.html">here</a>.
+</p>
+
+<p>
+For access to documentation from the command line, the
+<a href="https://golang.org/pkg/cmd/go/">go</a> tool has a
+<a href="https://golang.org/pkg/cmd/go/#hdr-Show_documentation_for_package_or_symbol">doc</a>
+subcommand that provides a textual interface to the same information.
+</p>
+
+<h3 id="Is_there_a_Go_programming_style_guide">
+Is there a Go programming style guide?</h3>
+
+<p>
+There is no explicit style guide, although there is certainly
+a recognizable "Go style".
+</p>
+
+<p>
+Go has established conventions to guide decisions around
+naming, layout, and file organization.
+The document <a href="effective_go.html">Effective Go</a>
+contains some advice on these topics.
+More directly, the program <code>gofmt</code> is a pretty-printer
+whose purpose is to enforce layout rules; it replaces the usual
+compendium of do's and don'ts that allows interpretation.
+All the Go code in the repository, and the vast majority in the
+open source world, has been run through <code>gofmt</code>.
+</p>
+
+<p>
+The document titled
+<a href="//golang.org/s/comments">Go Code Review Comments</a>
+is a collection of very short essays about details of Go idiom that are often
+missed by programmers.
+It is a handy reference for people doing code reviews for Go projects.
+</p>
+
+<h3 id="How_do_I_submit_patches_to_the_Go_libraries">
+How do I submit patches to the Go libraries?</h3>
+
+<p>
+The library sources are in the <code>src</code> directory of the repository.
+If you want to make a significant change, please discuss on the mailing list before embarking.
+</p>
+
+<p>
+See the document
+<a href="contribute.html">Contributing to the Go project</a>
+for more information about how to proceed.
+</p>
+
+<h3 id="git_https">
+Why does "go get" use HTTPS when cloning a repository?</h3>
+
+<p>
+Companies often permit outgoing traffic only on the standard TCP ports 80 (HTTP)
+and 443 (HTTPS), blocking outgoing traffic on other ports, including TCP port 9418
+(git) and TCP port 22 (SSH).
+When using HTTPS instead of HTTP, <code>git</code> enforces certificate validation by
+default, providing protection against man-in-the-middle, eavesdropping and tampering attacks.
+The <code>go get</code> command therefore uses HTTPS for safety.
+</p>
+
+<p>
+<code>Git</code> can be configured to authenticate over HTTPS or to use SSH in place of HTTPS.
+To authenticate over HTTPS, you can add a line
+to the <code>$HOME/.netrc</code> file that git consults:
+</p>
+<pre>
+machine github.com login <i>USERNAME</i> password <i>APIKEY</i>
+</pre>
+<p>
+For GitHub accounts, the password can be a
+<a href="https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line/">personal access token</a>.
+</p>
+
+<p>
+<code>Git</code> can also be configured to use SSH in place of HTTPS for URLs matching a given prefix.
+For example, to use SSH for all GitHub access,
+add these lines to your <code>~/.gitconfig</code>:
+</p>
+<pre>
+[url "ssh://git@github.com/"]
+ insteadOf = https://github.com/
+</pre>
+
+<h3 id="get_version">
+How should I manage package versions using "go get"?</h3>
+
+<p>
+The Go toolchain has a built-in system for managing versioned sets of related packages, known as <dfn>modules</dfn>.
+Modules were introduced in <a href="/doc/go1.11#modules">Go 1.11</a> and have been ready for production use since <a href="/doc/go1.14#introduction">1.14</a>.
+</p>
+
+<p>
+To create a project using modules, run <a href="/ref/mod#go-mod-init"><code>go mod init</code></a>.
+This command creates a <code>go.mod</code> file that tracks dependency versions.
+</p>
+
+<pre>
+go mod init example.com/project
+</pre>
+
+<p>
+To add, upgrade, or downgrade a dependency, run <a href="/ref/mod#go-get"><code>go get</code></a>:
+</p>
+
+<pre>
+go get golang.org/x/text@v0.3.5
+</pre>
+
+<p>
+See <a href="/doc/tutorial/create-module.html">Tutorial: Create a module</a> for more information on getting started.
+</p>
+
+<p>
+See <a href="/doc/#developing-modules">Developing modules</a> for guides on managing dependencies with modules.
+</p>
+
+<p>
+Packages within modules should maintain backward compatibility as they evolve, following the <a href="https://research.swtch.com/vgo-import">import compatibility rule</a>:
+</p>
+
+<blockquote>
+If an old package and a new package have the same import path,<br>
+the new package must be backwards compatible with the old package.
+</blockquote>
+
+<p>
+The <a href="/doc/go1compat.html">Go 1 compatibility guidelines</a> are a good reference here:
+don't remove exported names, encourage tagged composite literals, and so on.
+If different functionality is required, add a new name instead of changing an old one.
+</p>
+
+<p>
+Modules codify this with <a href="https://semver.org/">semantic versioning</a> and semantic import versioning.
+If a break in compatibility is required, release a module at a new major version.
+Modules at major version 2 and higher require a <a href="/ref/mod#major-version-suffixes">major version suffix</a> as part of their path (like <code>/v2</code>).
+This preserves the import compatibility rule: packages in different major versions of a module have distinct paths.
+</p>
+
+<h2 id="Pointers">Pointers and Allocation</h2>
+
+<h3 id="pass_by_value">
+When are function parameters passed by value?</h3>
+
+<p>
+As in all languages in the C family, everything in Go is passed by value.
+That is, a function always gets a copy of the
+thing being passed, as if there were an assignment statement assigning the
+value to the parameter. For instance, passing an <code>int</code> value
+to a function makes a copy of the <code>int</code>, and passing a pointer
+value makes a copy of the pointer, but not the data it points to.
+(See a <a href="/doc/faq#methods_on_values_or_pointers">later
+section</a> for a discussion of how this affects method receivers.)
+</p>
+
+<p>
+Map and slice values behave like pointers: they are descriptors that
+contain pointers to the underlying map or slice data. Copying a map or
+slice value doesn't copy the data it points to. Copying an interface value
+makes a copy of the thing stored in the interface value. If the interface
+value holds a struct, copying the interface value makes a copy of the
+struct. If the interface value holds a pointer, copying the interface value
+makes a copy of the pointer, but again not the data it points to.
+</p>
+
+<p>
+Note that this discussion is about the semantics of the operations.
+Actual implementations may apply optimizations to avoid copying
+as long as the optimizations do not change the semantics.
+</p>
+
+<h3 id="pointer_to_interface">
+When should I use a pointer to an interface?</h3>
+
+<p>
+Almost never. Pointers to interface values arise only in rare, tricky situations involving
+disguising an interface value's type for delayed evaluation.
+</p>
+
+<p>
+It is a common mistake to pass a pointer to an interface value
+to a function expecting an interface. The compiler will complain about this
+error but the situation can still be confusing, because sometimes a
+<a href="#different_method_sets">pointer
+is necessary to satisfy an interface</a>.
+The insight is that although a pointer to a concrete type can satisfy
+an interface, with one exception <em>a pointer to an interface can never satisfy an interface</em>.
+</p>
+
+<p>
+Consider the variable declaration,
+</p>
+
+<pre>
+var w io.Writer
+</pre>
+
+<p>
+The printing function <code>fmt.Fprintf</code> takes as its first argument
+a value that satisfies <code>io.Writer</code>—something that implements
+the canonical <code>Write</code> method. Thus we can write
+</p>
+
+<pre>
+fmt.Fprintf(w, "hello, world\n")
+</pre>
+
+<p>
+If however we pass the address of <code>w</code>, the program will not compile.
+</p>
+
+<pre>
+fmt.Fprintf(&w, "hello, world\n") // Compile-time error.
+</pre>
+
+<p>
+The one exception is that any value, even a pointer to an interface, can be assigned to
+a variable of empty interface type (<code>interface{}</code>).
+Even so, it's almost certainly a mistake if the value is a pointer to an interface;
+the result can be confusing.
+</p>
+
+<h3 id="methods_on_values_or_pointers">
+Should I define methods on values or pointers?</h3>
+
+<pre>
+func (s *MyStruct) pointerMethod() { } // method on pointer
+func (s MyStruct) valueMethod() { } // method on value
+</pre>
+
+<p>
+For programmers unaccustomed to pointers, the distinction between these
+two examples can be confusing, but the situation is actually very simple.
+When defining a method on a type, the receiver (<code>s</code> in the above
+examples) behaves exactly as if it were an argument to the method.
+Whether to define the receiver as a value or as a pointer is the same
+question, then, as whether a function argument should be a value or
+a pointer.
+There are several considerations.
+</p>
+
+<p>
+First, and most important, does the method need to modify the
+receiver?
+If it does, the receiver <em>must</em> be a pointer.
+(Slices and maps act as references, so their story is a little
+more subtle, but for instance to change the length of a slice
+in a method the receiver must still be a pointer.)
+In the examples above, if <code>pointerMethod</code> modifies
+the fields of <code>s</code>,
+the caller will see those changes, but <code>valueMethod</code>
+is called with a copy of the caller's argument (that's the definition
+of passing a value), so changes it makes will be invisible to the caller.
+</p>
+
+<p>
+By the way, in Java method receivers are always pointers,
+although their pointer nature is somewhat disguised
+(and there is a proposal to add value receivers to the language).
+It is the value receivers in Go that are unusual.
+</p>
+
+<p>
+Second is the consideration of efficiency. If the receiver is large,
+a big <code>struct</code> for instance, it will be much cheaper to
+use a pointer receiver.
+</p>
+
+<p>
+Next is consistency. If some of the methods of the type must have
+pointer receivers, the rest should too, so the method set is
+consistent regardless of how the type is used.
+See the section on <a href="#different_method_sets">method sets</a>
+for details.
+</p>
+
+<p>
+For types such as basic types, slices, and small <code>structs</code>,
+a value receiver is very cheap so unless the semantics of the method
+requires a pointer, a value receiver is efficient and clear.
+</p>
+
+
+<h3 id="new_and_make">
+What's the difference between new and make?</h3>
+
+<p>
+In short: <code>new</code> allocates memory, while <code>make</code> initializes
+the slice, map, and channel types.
+</p>
+
+<p>
+See the <a href="/doc/effective_go.html#allocation_new">relevant section
+of Effective Go</a> for more details.
+</p>
+
+<h3 id="q_int_sizes">
+What is the size of an <code>int</code> on a 64 bit machine?</h3>
+
+<p>
+The sizes of <code>int</code> and <code>uint</code> are implementation-specific
+but the same as each other on a given platform.
+For portability, code that relies on a particular
+size of value should use an explicitly sized type, like <code>int64</code>.
+On 32-bit machines the compilers use 32-bit integers by default,
+while on 64-bit machines integers have 64 bits.
+(Historically, this was not always true.)
+</p>
+
+<p>
+On the other hand, floating-point scalars and complex
+types are always sized (there are no <code>float</code> or <code>complex</code> basic types),
+because programmers should be aware of precision when using floating-point numbers.
+The default type used for an (untyped) floating-point constant is <code>float64</code>.
+Thus <code>foo</code> <code>:=</code> <code>3.0</code> declares a variable <code>foo</code>
+of type <code>float64</code>.
+For a <code>float32</code> variable initialized by an (untyped) constant, the variable type
+must be specified explicitly in the variable declaration:
+</p>
+
+<pre>
+var foo float32 = 3.0
+</pre>
+
+<p>
+Alternatively, the constant must be given a type with a conversion as in
+<code>foo := float32(3.0)</code>.
+</p>
+
+<h3 id="stack_or_heap">
+How do I know whether a variable is allocated on the heap or the stack?</h3>
+
+<p>
+From a correctness standpoint, you don't need to know.
+Each variable in Go exists as long as there are references to it.
+The storage location chosen by the implementation is irrelevant to the
+semantics of the language.
+</p>
+
+<p>
+The storage location does have an effect on writing efficient programs.
+When possible, the Go compilers will allocate variables that are
+local to a function in that function's stack frame. However, if the
+compiler cannot prove that the variable is not referenced after the
+function returns, then the compiler must allocate the variable on the
+garbage-collected heap to avoid dangling pointer errors.
+Also, if a local variable is very large, it might make more sense
+to store it on the heap rather than the stack.
+</p>
+
+<p>
+In the current compilers, if a variable has its address taken, that variable
+is a candidate for allocation on the heap. However, a basic <em>escape
+analysis</em> recognizes some cases when such variables will not
+live past the return from the function and can reside on the stack.
+</p>
+
+<h3 id="Why_does_my_Go_process_use_so_much_virtual_memory">
+Why does my Go process use so much virtual memory?</h3>
+
+<p>
+The Go memory allocator reserves a large region of virtual memory as an arena
+for allocations. This virtual memory is local to the specific Go process; the
+reservation does not deprive other processes of memory.
+</p>
+
+<p>
+To find the amount of actual memory allocated to a Go process, use the Unix
+<code>top</code> command and consult the <code>RES</code> (Linux) or
+<code>RSIZE</code> (macOS) columns.
+<!-- TODO(adg): find out how this works on Windows -->
+</p>
+
+<h2 id="Concurrency">Concurrency</h2>
+
+<h3 id="What_operations_are_atomic_What_about_mutexes">
+What operations are atomic? What about mutexes?</h3>
+
+<p>
+A description of the atomicity of operations in Go can be found in
+the <a href="/ref/mem">Go Memory Model</a> document.
+</p>
+
+<p>
+Low-level synchronization and atomic primitives are available in the
+<a href="/pkg/sync">sync</a> and
+<a href="/pkg/sync/atomic">sync/atomic</a>
+packages.
+These packages are good for simple tasks such as incrementing
+reference counts or guaranteeing small-scale mutual exclusion.
+</p>
+
+<p>
+For higher-level operations, such as coordination among
+concurrent servers, higher-level techniques can lead
+to nicer programs, and Go supports this approach through
+its goroutines and channels.
+For instance, you can structure your program so that only one
+goroutine at a time is ever responsible for a particular piece of data.
+That approach is summarized by the original
+<a href="https://www.youtube.com/watch?v=PAAkCSZUG1c">Go proverb</a>,
+</p>
+
+<p>
+Do not communicate by sharing memory. Instead, share memory by communicating.
+</p>
+
+<p>
+See the <a href="/doc/codewalk/sharemem/">Share Memory By Communicating</a> code walk
+and its <a href="https://blog.golang.org/2010/07/share-memory-by-communicating.html">
+associated article</a> for a detailed discussion of this concept.
+</p>
+
+<p>
+Large concurrent programs are likely to borrow from both these toolkits.
+</p>
+
+<h3 id="parallel_slow">
+Why doesn't my program run faster with more CPUs?</h3>
+
+<p>
+Whether a program runs faster with more CPUs depends on the problem
+it is solving.
+The Go language provides concurrency primitives, such as goroutines
+and channels, but concurrency only enables parallelism
+when the underlying problem is intrinsically parallel.
+Problems that are intrinsically sequential cannot be sped up by adding
+more CPUs, while those that can be broken into pieces that can
+execute in parallel can be sped up, sometimes dramatically.
+</p>
+
+<p>
+Sometimes adding more CPUs can slow a program down.
+In practical terms, programs that spend more time
+synchronizing or communicating than doing useful computation
+may experience performance degradation when using
+multiple OS threads.
+This is because passing data between threads involves switching
+contexts, which has significant cost, and that cost can increase
+with more CPUs.
+For instance, the <a href="/ref/spec#An_example_package">prime sieve example</a>
+from the Go specification has no significant parallelism although it launches many
+goroutines; increasing the number of threads (CPUs) is more likely to slow it down than
+to speed it up.
+</p>
+
+<p>
+For more detail on this topic see the talk entitled
+<a href="//blog.golang.org/2013/01/concurrency-is-not-parallelism.html">Concurrency
+is not Parallelism</a>.
+
+<h3 id="number_cpus">
+How can I control the number of CPUs?</h3>
+
+<p>
+The number of CPUs available simultaneously to executing goroutines is
+controlled by the <code>GOMAXPROCS</code> shell environment variable,
+whose default value is the number of CPU cores available.
+Programs with the potential for parallel execution should therefore
+achieve it by default on a multiple-CPU machine.
+To change the number of parallel CPUs to use,
+set the environment variable or use the similarly-named
+<a href="/pkg/runtime/#GOMAXPROCS">function</a>
+of the runtime package to configure the
+run-time support to utilize a different number of threads.
+Setting it to 1 eliminates the possibility of true parallelism,
+forcing independent goroutines to take turns executing.
+</p>
+
+<p>
+The runtime can allocate more threads than the value
+of <code>GOMAXPROCS</code> to service multiple outstanding
+I/O requests.
+<code>GOMAXPROCS</code> only affects how many goroutines
+can actually execute at once; arbitrarily more may be blocked
+in system calls.
+</p>
+
+<p>
+Go's goroutine scheduler is not as good as it needs to be, although it
+has improved over time.
+In the future, it may better optimize its use of OS threads.
+For now, if there are performance issues,
+setting <code>GOMAXPROCS</code> on a per-application basis may help.
+</p>
+
+
+<h3 id="no_goroutine_id">
+Why is there no goroutine ID?</h3>
+
+<p>
+Goroutines do not have names; they are just anonymous workers.
+They expose no unique identifier, name, or data structure to the programmer.
+Some people are surprised by this, expecting the <code>go</code>
+statement to return some item that can be used to access and control
+the goroutine later.
+</p>
+
+<p>
+The fundamental reason goroutines are anonymous is so that
+the full Go language is available when programming concurrent code.
+By contrast, the usage patterns that develop when threads and goroutines are
+named can restrict what a library using them can do.
+</p>
+
+<p>
+Here is an illustration of the difficulties.
+Once one names a goroutine and constructs a model around
+it, it becomes special, and one is tempted to associate all computation
+with that goroutine, ignoring the possibility
+of using multiple, possibly shared goroutines for the processing.
+If the <code>net/http</code> package associated per-request
+state with a goroutine,
+clients would be unable to use more goroutines
+when serving a request.
+</p>
+
+<p>
+Moreover, experience with libraries such as those for graphics systems
+that require all processing to occur on the "main thread"
+has shown how awkward and limiting the approach can be when
+deployed in a concurrent language.
+The very existence of a special thread or goroutine forces
+the programmer to distort the program to avoid crashes
+and other problems caused by inadvertently operating
+on the wrong thread.
+</p>
+
+<p>
+For those cases where a particular goroutine is truly special,
+the language provides features such as channels that can be
+used in flexible ways to interact with it.
+</p>
+
+<h2 id="Functions_methods">Functions and Methods</h2>
+
+<h3 id="different_method_sets">
+Why do T and *T have different method sets?</h3>
+
+<p>
+As the <a href="/ref/spec#Types">Go specification</a> says,
+the method set of a type <code>T</code> consists of all methods
+with receiver type <code>T</code>,
+while that of the corresponding pointer
+type <code>*T</code> consists of all methods with receiver <code>*T</code> or
+<code>T</code>.
+That means the method set of <code>*T</code>
+includes that of <code>T</code>,
+but not the reverse.
+</p>
+
+<p>
+This distinction arises because
+if an interface value contains a pointer <code>*T</code>,
+a method call can obtain a value by dereferencing the pointer,
+but if an interface value contains a value <code>T</code>,
+there is no safe way for a method call to obtain a pointer.
+(Doing so would allow a method to modify the contents of
+the value inside the interface, which is not permitted by
+the language specification.)
+</p>
+
+<p>
+Even in cases where the compiler could take the address of a value
+to pass to the method, if the method modifies the value the changes
+will be lost in the caller.
+As an example, if the <code>Write</code> method of
+<a href="/pkg/bytes/#Buffer"><code>bytes.Buffer</code></a>
+used a value receiver rather than a pointer,
+this code:
+</p>
+
+<pre>
+var buf bytes.Buffer
+io.Copy(buf, os.Stdin)
+</pre>
+
+<p>
+would copy standard input into a <i>copy</i> of <code>buf</code>,
+not into <code>buf</code> itself.
+This is almost never the desired behavior.
+</p>
+
+<h3 id="closures_and_goroutines">
+What happens with closures running as goroutines?</h3>
+
+<p>
+Some confusion may arise when using closures with concurrency.
+Consider the following program:
+</p>
+
+<pre>
+func main() {
+ done := make(chan bool)
+
+ values := []string{"a", "b", "c"}
+ for _, v := range values {
+ go func() {
+ fmt.Println(v)
+ done <- true
+ }()
+ }
+
+ // wait for all goroutines to complete before exiting
+ for _ = range values {
+ <-done
+ }
+}
+</pre>
+
+<p>
+One might mistakenly expect to see <code>a, b, c</code> as the output.
+What you'll probably see instead is <code>c, c, c</code>. This is because
+each iteration of the loop uses the same instance of the variable <code>v</code>, so
+each closure shares that single variable. When the closure runs, it prints the
+value of <code>v</code> at the time <code>fmt.Println</code> is executed,
+but <code>v</code> may have been modified since the goroutine was launched.
+To help detect this and other problems before they happen, run
+<a href="/cmd/go/#hdr-Run_go_tool_vet_on_packages"><code>go vet</code></a>.
+</p>
+
+<p>
+To bind the current value of <code>v</code> to each closure as it is launched, one
+must modify the inner loop to create a new variable each iteration.
+One way is to pass the variable as an argument to the closure:
+</p>
+
+<pre>
+ for _, v := range values {
+ go func(<b>u</b> string) {
+ fmt.Println(<b>u</b>)
+ done <- true
+ }(<b>v</b>)
+ }
+</pre>
+
+<p>
+In this example, the value of <code>v</code> is passed as an argument to the
+anonymous function. That value is then accessible inside the function as
+the variable <code>u</code>.
+</p>
+
+<p>
+Even easier is just to create a new variable, using a declaration style that may
+seem odd but works fine in Go:
+</p>
+
+<pre>
+ for _, v := range values {
+ <b>v := v</b> // create a new 'v'.
+ go func() {
+ fmt.Println(<b>v</b>)
+ done <- true
+ }()
+ }
+</pre>
+
+<p>
+This behavior of the language, not defining a new variable for
+each iteration, may have been a mistake in retrospect.
+It may be addressed in a later version but, for compatibility,
+cannot change in Go version 1.
+</p>
+
+<h2 id="Control_flow">Control flow</h2>
+
+<h3 id="Does_Go_have_a_ternary_form">
+Why does Go not have the <code>?:</code> operator?</h3>
+
+<p>
+There is no ternary testing operation in Go.
+You may use the following to achieve the same
+result:
+</p>
+
+<pre>
+if expr {
+ n = trueVal
+} else {
+ n = falseVal
+}
+</pre>
+
+<p>
+The reason <code>?:</code> is absent from Go is that the language's designers
+had seen the operation used too often to create impenetrably complex expressions.
+The <code>if-else</code> form, although longer,
+is unquestionably clearer.
+A language needs only one conditional control flow construct.
+</p>
+
+<h2 id="Packages_Testing">Packages and Testing</h2>
+
+<h3 id="How_do_I_create_a_multifile_package">
+How do I create a multifile package?</h3>
+
+<p>
+Put all the source files for the package in a directory by themselves.
+Source files can refer to items from different files at will; there is
+no need for forward declarations or a header file.
+</p>
+
+<p>
+Other than being split into multiple files, the package will compile and test
+just like a single-file package.
+</p>
+
+<h3 id="How_do_I_write_a_unit_test">
+How do I write a unit test?</h3>
+
+<p>
+Create a new file ending in <code>_test.go</code> in the same directory
+as your package sources. Inside that file, <code>import "testing"</code>
+and write functions of the form
+</p>
+
+<pre>
+func TestFoo(t *testing.T) {
+ ...
+}
+</pre>
+
+<p>
+Run <code>go test</code> in that directory.
+That script finds the <code>Test</code> functions,
+builds a test binary, and runs it.
+</p>
+
+<p>See the <a href="/doc/code.html">How to Write Go Code</a> document,
+the <a href="/pkg/testing/"><code>testing</code></a> package
+and the <a href="/cmd/go/#hdr-Test_packages"><code>go test</code></a> subcommand for more details.
+</p>
+
+<h3 id="testing_framework">
+Where is my favorite helper function for testing?</h3>
+
+<p>
+Go's standard <a href="/pkg/testing/"><code>testing</code></a> package makes it easy to write unit tests, but it lacks
+features provided in other language's testing frameworks such as assertion functions.
+An <a href="#assertions">earlier section</a> of this document explained why Go
+doesn't have assertions, and
+the same arguments apply to the use of <code>assert</code> in tests.
+Proper error handling means letting other tests run after one has failed, so
+that the person debugging the failure gets a complete picture of what is
+wrong. It is more useful for a test to report that
+<code>isPrime</code> gives the wrong answer for 2, 3, 5, and 7 (or for
+2, 4, 8, and 16) than to report that <code>isPrime</code> gives the wrong
+answer for 2 and therefore no more tests were run. The programmer who
+triggers the test failure may not be familiar with the code that fails.
+Time invested writing a good error message now pays off later when the
+test breaks.
+</p>
+
+<p>
+A related point is that testing frameworks tend to develop into mini-languages
+of their own, with conditionals and controls and printing mechanisms,
+but Go already has all those capabilities; why recreate them?
+We'd rather write tests in Go; it's one fewer language to learn and the
+approach keeps the tests straightforward and easy to understand.
+</p>
+
+<p>
+If the amount of extra code required to write
+good errors seems repetitive and overwhelming, the test might work better if
+table-driven, iterating over a list of inputs and outputs defined
+in a data structure (Go has excellent support for data structure literals).
+The work to write a good test and good error messages will then be amortized over many
+test cases. The standard Go library is full of illustrative examples, such as in
+<a href="/src/fmt/fmt_test.go">the formatting tests for the <code>fmt</code> package</a>.
+</p>
+
+<h3 id="x_in_std">
+Why isn't <i>X</i> in the standard library?</h3>
+
+<p>
+The standard library's purpose is to support the runtime, connect to
+the operating system, and provide key functionality that many Go
+programs require, such as formatted I/O and networking.
+It also contains elements important for web programming, including
+cryptography and support for standards like HTTP, JSON, and XML.
+</p>
+
+<p>
+There is no clear criterion that defines what is included because for
+a long time, this was the <i>only</i> Go library.
+There are criteria that define what gets added today, however.
+</p>
+
+<p>
+New additions to the standard library are rare and the bar for
+inclusion is high.
+Code included in the standard library bears a large ongoing maintenance cost
+(often borne by those other than the original author),
+is subject to the <a href="/doc/go1compat.html">Go 1 compatibility promise</a>
+(blocking fixes to any flaws in the API),
+and is subject to the Go
+<a href="https://golang.org/s/releasesched">release schedule</a>,
+preventing bug fixes from being available to users quickly.
+</p>
+
+<p>
+Most new code should live outside of the standard library and be accessible
+via the <a href="/cmd/go/"><code>go</code> tool</a>'s
+<code>go get</code> command.
+Such code can have its own maintainers, release cycle,
+and compatibility guarantees.
+Users can find packages and read their documentation at
+<a href="https://godoc.org/">godoc.org</a>.
+</p>
+
+<p>
+Although there are pieces in the standard library that don't really belong,
+such as <code>log/syslog</code>, we continue to maintain everything in the
+library because of the Go 1 compatibility promise.
+But we encourage most new code to live elsewhere.
+</p>
+
+<h2 id="Implementation">Implementation</h2>
+
+<h3 id="What_compiler_technology_is_used_to_build_the_compilers">
+What compiler technology is used to build the compilers?</h3>
+
+<p>
+There are several production compilers for Go, and a number of others
+in development for various platforms.
+</p>
+
+<p>
+The default compiler, <code>gc</code>, is included with the
+Go distribution as part of the support for the <code>go</code>
+command.
+<code>Gc</code> was originally written in C
+because of the difficulties of bootstrapping—you'd need a Go compiler to
+set up a Go environment.
+But things have advanced and since the Go 1.5 release the compiler has been
+a Go program.
+The compiler was converted from C to Go using automatic translation tools, as
+described in this <a href="/s/go13compiler">design document</a>
+and <a href="https://talks.golang.org/2015/gogo.slide#1">talk</a>.
+Thus the compiler is now "self-hosting", which means we needed to face
+the bootstrapping problem.
+The solution is to have a working Go installation already in place,
+just as one normally has with a working C installation.
+The story of how to bring up a new Go environment from source
+is described <a href="/s/go15bootstrap">here</a> and
+<a href="/doc/install/source">here</a>.
+</p>
+
+<p>
+<code>Gc</code> is written in Go with a recursive descent parser
+and uses a custom loader, also written in Go but
+based on the Plan 9 loader, to generate ELF/Mach-O/PE binaries.
+</p>
+
+<p>
+At the beginning of the project we considered using LLVM for
+<code>gc</code> but decided it was too large and slow to meet
+our performance goals.
+More important in retrospect, starting with LLVM would have made it
+harder to introduce some of the ABI and related changes, such as
+stack management, that Go requires but are not part of the standard
+C setup.
+A new <a href="https://go.googlesource.com/gollvm/">LLVM implementation</a>
+is starting to come together now, however.
+</p>
+
+<p>
+The <code>Gccgo</code> compiler is a front end written in C++
+with a recursive descent parser coupled to the
+standard GCC back end.
+</p>
+
+<p>
+Go turned out to be a fine language in which to implement a Go compiler,
+although that was not its original goal.
+Not being self-hosting from the beginning allowed Go's design to
+concentrate on its original use case, which was networked servers.
+Had we decided Go should compile itself early on, we might have
+ended up with a language targeted more for compiler construction,
+which is a worthy goal but not the one we had initially.
+</p>
+
+<p>
+Although <code>gc</code> does not use them (yet?), a native lexer and
+parser are available in the <a href="/pkg/go/"><code>go</code></a> package
+and there is also a native <a href="/pkg/go/types">type checker</a>.
+</p>
+
+<h3 id="How_is_the_run_time_support_implemented">
+How is the run-time support implemented?</h3>
+
+<p>
+Again due to bootstrapping issues, the run-time code was originally written mostly in C (with a
+tiny bit of assembler) but it has since been translated to Go
+(except for some assembler bits).
+<code>Gccgo</code>'s run-time support uses <code>glibc</code>.
+The <code>gccgo</code> compiler implements goroutines using
+a technique called segmented stacks,
+supported by recent modifications to the gold linker.
+<code>Gollvm</code> similarly is built on the corresponding
+LLVM infrastructure.
+</p>
+
+<h3 id="Why_is_my_trivial_program_such_a_large_binary">
+Why is my trivial program such a large binary?</h3>
+
+<p>
+The linker in the <code>gc</code> toolchain
+creates statically-linked binaries by default.
+All Go binaries therefore include the Go
+runtime, along with the run-time type information necessary to support dynamic
+type checks, reflection, and even panic-time stack traces.
+</p>
+
+<p>
+A simple C "hello, world" program compiled and linked statically using
+gcc on Linux is around 750 kB, including an implementation of
+<code>printf</code>.
+An equivalent Go program using
+<code>fmt.Printf</code> weighs a couple of megabytes, but that includes
+more powerful run-time support and type and debugging information.
+</p>
+
+<p>
+A Go program compiled with <code>gc</code> can be linked with
+the <code>-ldflags=-w</code> flag to disable DWARF generation,
+removing debugging information from the binary but with no
+other loss of functionality.
+This can reduce the binary size substantially.
+</p>
+
+<h3 id="unused_variables_and_imports">
+Can I stop these complaints about my unused variable/import?</h3>
+
+<p>
+The presence of an unused variable may indicate a bug, while
+unused imports just slow down compilation,
+an effect that can become substantial as a program accumulates
+code and programmers over time.
+For these reasons, Go refuses to compile programs with unused
+variables or imports,
+trading short-term convenience for long-term build speed and
+program clarity.
+</p>
+
+<p>
+Still, when developing code, it's common to create these situations
+temporarily and it can be annoying to have to edit them out before the
+program will compile.
+</p>
+
+<p>
+Some have asked for a compiler option to turn those checks off
+or at least reduce them to warnings.
+Such an option has not been added, though,
+because compiler options should not affect the semantics of the
+language and because the Go compiler does not report warnings, only
+errors that prevent compilation.
+</p>
+
+<p>
+There are two reasons for having no warnings. First, if it's worth
+complaining about, it's worth fixing in the code. (And if it's not
+worth fixing, it's not worth mentioning.) Second, having the compiler
+generate warnings encourages the implementation to warn about weak
+cases that can make compilation noisy, masking real errors that
+<em>should</em> be fixed.
+</p>
+
+<p>
+It's easy to address the situation, though. Use the blank identifier
+to let unused things persist while you're developing.
+</p>
+
+<pre>
+import "unused"
+
+// This declaration marks the import as used by referencing an
+// item from the package.
+var _ = unused.Item // TODO: Delete before committing!
+
+func main() {
+ debugData := debug.Profile()
+ _ = debugData // Used only during debugging.
+ ....
+}
+</pre>
+
+<p>
+Nowadays, most Go programmers use a tool,
+<a href="https://godoc.org/golang.org/x/tools/cmd/goimports">goimports</a>,
+which automatically rewrites a Go source file to have the correct imports,
+eliminating the unused imports issue in practice.
+This program is easily connected to most editors to run automatically when a Go source file is written.
+</p>
+
+<h3 id="virus">
+Why does my virus-scanning software think my Go distribution or compiled binary is infected?</h3>
+
+<p>
+This is a common occurrence, especially on Windows machines, and is almost always a false positive.
+Commercial virus scanning programs are often confused by the structure of Go binaries, which
+they don't see as often as those compiled from other languages.
+</p>
+
+<p>
+If you've just installed the Go distribution and the system reports it is infected, that's certainly a mistake.
+To be really thorough, you can verify the download by comparing the checksum with those on the
+<a href="https://golang.org/dl/">downloads page</a>.
+</p>
+
+<p>
+In any case, if you believe the report is in error, please report a bug to the supplier of your virus scanner.
+Maybe in time virus scanners can learn to understand Go programs.
+</p>
+
+<h2 id="Performance">Performance</h2>
+
+<h3 id="Why_does_Go_perform_badly_on_benchmark_x">
+Why does Go perform badly on benchmark X?</h3>
+
+<p>
+One of Go's design goals is to approach the performance of C for comparable
+programs, yet on some benchmarks it does quite poorly, including several
+in <a href="https://go.googlesource.com/exp/+/master/shootout/">golang.org/x/exp/shootout</a>.
+The slowest depend on libraries for which versions of comparable performance
+are not available in Go.
+For instance, <a href="https://go.googlesource.com/exp/+/master/shootout/pidigits.go">pidigits.go</a>
+depends on a multi-precision math package, and the C
+versions, unlike Go's, use <a href="https://gmplib.org/">GMP</a> (which is
+written in optimized assembler).
+Benchmarks that depend on regular expressions
+(<a href="https://go.googlesource.com/exp/+/master/shootout/regex-dna.go">regex-dna.go</a>,
+for instance) are essentially comparing Go's native <a href="/pkg/regexp">regexp package</a> to
+mature, highly optimized regular expression libraries like PCRE.
+</p>
+
+<p>
+Benchmark games are won by extensive tuning and the Go versions of most
+of the benchmarks need attention. If you measure comparable C
+and Go programs
+(<a href="https://go.googlesource.com/exp/+/master/shootout/reverse-complement.go">reverse-complement.go</a>
+is one example), you'll see the two languages are much closer in raw performance
+than this suite would indicate.
+</p>
+
+<p>
+Still, there is room for improvement. The compilers are good but could be
+better, many libraries need major performance work, and the garbage collector
+isn't fast enough yet. (Even if it were, taking care not to generate unnecessary
+garbage can have a huge effect.)
+</p>
+
+<p>
+In any case, Go can often be very competitive.
+There has been significant improvement in the performance of many programs
+as the language and tools have developed.
+See the blog post about
+<a href="//blog.golang.org/2011/06/profiling-go-programs.html">profiling
+Go programs</a> for an informative example.
+
+<h2 id="change_from_c">Changes from C</h2>
+
+<h3 id="different_syntax">
+Why is the syntax so different from C?</h3>
+<p>
+Other than declaration syntax, the differences are not major and stem
+from two desires. First, the syntax should feel light, without too
+many mandatory keywords, repetition, or arcana. Second, the language
+has been designed to be easy to analyze
+and can be parsed without a symbol table. This makes it much easier
+to build tools such as debuggers, dependency analyzers, automated
+documentation extractors, IDE plug-ins, and so on. C and its
+descendants are notoriously difficult in this regard.
+</p>
+
+<h3 id="declarations_backwards">
+Why are declarations backwards?</h3>
+<p>
+They're only backwards if you're used to C. In C, the notion is that a
+variable is declared like an expression denoting its type, which is a
+nice idea, but the type and expression grammars don't mix very well and
+the results can be confusing; consider function pointers. Go mostly
+separates expression and type syntax and that simplifies things (using
+prefix <code>*</code> for pointers is an exception that proves the rule). In C,
+the declaration
+</p>
+<pre>
+ int* a, b;
+</pre>
+<p>
+declares <code>a</code> to be a pointer but not <code>b</code>; in Go
+</p>
+<pre>
+ var a, b *int
+</pre>
+<p>
+declares both to be pointers. This is clearer and more regular.
+Also, the <code>:=</code> short declaration form argues that a full variable
+declaration should present the same order as <code>:=</code> so
+</p>
+<pre>
+ var a uint64 = 1
+</pre>
+<p>
+has the same effect as
+</p>
+<pre>
+ a := uint64(1)
+</pre>
+<p>
+Parsing is also simplified by having a distinct grammar for types that
+is not just the expression grammar; keywords such as <code>func</code>
+and <code>chan</code> keep things clear.
+</p>
+
+<p>
+See the article about
+<a href="/doc/articles/gos_declaration_syntax.html">Go's Declaration Syntax</a>
+for more details.
+</p>
+
+<h3 id="no_pointer_arithmetic">
+Why is there no pointer arithmetic?</h3>
+<p>
+Safety. Without pointer arithmetic it's possible to create a
+language that can never derive an illegal address that succeeds
+incorrectly. Compiler and hardware technology have advanced to the
+point where a loop using array indices can be as efficient as a loop
+using pointer arithmetic. Also, the lack of pointer arithmetic can
+simplify the implementation of the garbage collector.
+</p>
+
+<h3 id="inc_dec">
+Why are <code>++</code> and <code>--</code> statements and not expressions? And why postfix, not prefix?</h3>
+<p>
+Without pointer arithmetic, the convenience value of pre- and postfix
+increment operators drops. By removing them from the expression
+hierarchy altogether, expression syntax is simplified and the messy
+issues around order of evaluation of <code>++</code> and <code>--</code>
+(consider <code>f(i++)</code> and <code>p[i] = q[++i]</code>)
+are eliminated as well. The simplification is
+significant. As for postfix vs. prefix, either would work fine but
+the postfix version is more traditional; insistence on prefix arose
+with the STL, a library for a language whose name contains, ironically, a
+postfix increment.
+</p>
+
+<h3 id="semicolons">
+Why are there braces but no semicolons? And why can't I put the opening
+brace on the next line?</h3>
+<p>
+Go uses brace brackets for statement grouping, a syntax familiar to
+programmers who have worked with any language in the C family.
+Semicolons, however, are for parsers, not for people, and we wanted to
+eliminate them as much as possible. To achieve this goal, Go borrows
+a trick from BCPL: the semicolons that separate statements are in the
+formal grammar but are injected automatically, without lookahead, by
+the lexer at the end of any line that could be the end of a statement.
+This works very well in practice but has the effect that it forces a
+brace style. For instance, the opening brace of a function cannot
+appear on a line by itself.
+</p>
+
+<p>
+Some have argued that the lexer should do lookahead to permit the
+brace to live on the next line. We disagree. Since Go code is meant
+to be formatted automatically by
+<a href="/cmd/gofmt/"><code>gofmt</code></a>,
+<i>some</i> style must be chosen. That style may differ from what
+you've used in C or Java, but Go is a different language and
+<code>gofmt</code>'s style is as good as any other. More
+important—much more important—the advantages of a single,
+programmatically mandated format for all Go programs greatly outweigh
+any perceived disadvantages of the particular style.
+Note too that Go's style means that an interactive implementation of
+Go can use the standard syntax one line at a time without special rules.
+</p>
+
+<h3 id="garbage_collection">
+Why do garbage collection? Won't it be too expensive?</h3>
+<p>
+One of the biggest sources of bookkeeping in systems programs is
+managing the lifetimes of allocated objects.
+In languages such as C in which it is done manually,
+it can consume a significant amount of programmer time and is
+often the cause of pernicious bugs.
+Even in languages like C++ or Rust that provide mechanisms
+to assist, those mechanisms can have a significant effect on the
+design of the software, often adding programming overhead
+of its own.
+We felt it was critical to eliminate such
+programmer overheads, and advances in garbage collection
+technology in the last few years gave us confidence that it
+could be implemented cheaply enough, and with low enough
+latency, that it could be a viable approach for networked
+systems.
+</p>
+
+<p>
+Much of the difficulty of concurrent programming
+has its roots in the object lifetime problem:
+as objects get passed among threads it becomes cumbersome
+to guarantee they become freed safely.
+Automatic garbage collection makes concurrent code far easier to write.
+Of course, implementing garbage collection in a concurrent environment is
+itself a challenge, but meeting it once rather than in every
+program helps everyone.
+</p>
+
+<p>
+Finally, concurrency aside, garbage collection makes interfaces
+simpler because they don't need to specify how memory is managed across them.
+</p>
+
+<p>
+This is not to say that the recent work in languages
+like Rust that bring new ideas to the problem of managing
+resources is misguided; we encourage this work and are excited to see
+how it evolves.
+But Go takes a more traditional approach by addressing
+object lifetimes through
+garbage collection, and garbage collection alone.
+</p>
+
+<p>
+The current implementation is a mark-and-sweep collector.
+If the machine is a multiprocessor, the collector runs on a separate CPU
+core in parallel with the main program.
+Major work on the collector in recent years has reduced pause times
+often to the sub-millisecond range, even for large heaps,
+all but eliminating one of the major objections to garbage collection
+in networked servers.
+Work continues to refine the algorithm, reduce overhead and
+latency further, and to explore new approaches.
+The 2018
+<a href="https://blog.golang.org/ismmkeynote">ISMM keynote</a>
+by Rick Hudson of the Go team
+describes the progress so far and suggests some future approaches.
+</p>
+
+<p>
+On the topic of performance, keep in mind that Go gives the programmer
+considerable control over memory layout and allocation, much more than
+is typical in garbage-collected languages. A careful programmer can reduce
+the garbage collection overhead dramatically by using the language well;
+see the article about
+<a href="//blog.golang.org/2011/06/profiling-go-programs.html">profiling
+Go programs</a> for a worked example, including a demonstration of Go's
+profiling tools.
+</p>
diff --git a/_content/doc/gopath_code.html b/_content/doc/gopath_code.html
new file mode 100644
index 0000000..5495e47
--- /dev/null
+++ b/_content/doc/gopath_code.html
@@ -0,0 +1,648 @@
+<!--{
+ "Title": "How to Write Go Code (with GOPATH)"
+}-->
+
+<h2 id="Introduction">Introduction</h2>
+
+<p><b>
+If you are new to Go, please see the more recent
+<a href="code.html">How to Write Go Code</a>.
+</b></p>
+
+<p>
+This document demonstrates the development of a simple Go package and
+introduces the <a href="/cmd/go/">go tool</a>, the standard way to fetch,
+build, and install Go packages and commands.
+</p>
+
+<p>
+The <code>go</code> tool requires you to organize your code in a specific
+way. Please read this document carefully.
+It explains the simplest way to get up and running with your Go installation.
+</p>
+
+<p>
+A similar explanation is available as a
+<a href="//www.youtube.com/watch?v=XCsL89YtqCs">screencast</a>.
+</p>
+
+
+<h2 id="Organization">Code organization</h2>
+
+<h3 id="Overview">Overview</h3>
+
+<ul>
+ <li>Go programmers typically keep all their Go code in a single <i>workspace</i>.</li>
+ <li>A workspace contains many version control <i>repositories</i>
+ (managed by Git, for example).</li>
+ <li>Each repository contains one or more <i>packages</i>.</li>
+ <li>Each package consists of one or more Go source files in a single directory.</li>
+ <li>The path to a package's directory determines its <i>import path</i>.</li>
+</ul>
+
+<p>
+Note that this differs from other programming environments in which every
+project has a separate workspace and workspaces are closely tied to version
+control repositories.
+</p>
+
+<h3 id="Workspaces">Workspaces</h3>
+
+<p>
+A workspace is a directory hierarchy with two directories at its root:
+</p>
+
+<ul>
+<li><code>src</code> contains Go source files, and
+<li><code>bin</code> contains executable commands.
+</ul>
+
+<p>
+The <code>go</code> tool builds and installs binaries to the <code>bin</code> directory.
+</p>
+
+<p>
+The <code>src</code> subdirectory typically contains multiple version control
+repositories (such as for Git or Mercurial) that track the development of one
+or more source packages.
+</p>
+
+<p>
+To give you an idea of how a workspace looks in practice, here's an example:
+</p>
+
+<pre>
+bin/
+ hello # command executable
+ outyet # command executable
+src/
+ <a href="https://github.com/golang/example/">github.com/golang/example/</a>
+ .git/ # Git repository metadata
+ hello/
+ hello.go # command source
+ outyet/
+ main.go # command source
+ main_test.go # test source
+ stringutil/
+ reverse.go # package source
+ reverse_test.go # test source
+ <a href="https://golang.org/x/image/">golang.org/x/image/</a>
+ .git/ # Git repository metadata
+ bmp/
+ reader.go # package source
+ writer.go # package source
+ ... (many more repositories and packages omitted) ...
+</pre>
+
+<p>
+The tree above shows a workspace containing two repositories
+(<code>example</code> and <code>image</code>).
+The <code>example</code> repository contains two commands (<code>hello</code>
+and <code>outyet</code>) and one library (<code>stringutil</code>).
+The <code>image</code> repository contains the <code>bmp</code> package
+and <a href="https://pkg.go.dev/golang.org/x/image">several others</a>.
+</p>
+
+<p>
+A typical workspace contains many source repositories containing many
+packages and commands. Most Go programmers keep <i>all</i> their Go source code
+and dependencies in a single workspace.
+</p>
+
+<p>
+Note that symbolic links should <b>not</b> be used to link files or directories into your workspace.
+</p>
+
+<p>
+Commands and libraries are built from different kinds of source packages.
+We will discuss the distinction <a href="#PackageNames">later</a>.
+</p>
+
+
+<h3 id="GOPATH">The <code>GOPATH</code> environment variable</h3>
+
+<p>
+The <code>GOPATH</code> environment variable specifies the location of your
+workspace. It defaults to a directory named <code>go</code> inside your home directory,
+so <code>$HOME/go</code> on Unix,
+<code>$home/go</code> on Plan 9,
+and <code>%USERPROFILE%\go</code> (usually <code>C:\Users\YourName\go</code>) on Windows.
+</p>
+
+<p>
+If you would like to work in a different location, you will need to
+<a href="https://golang.org/wiki/SettingGOPATH">set <code>GOPATH</code></a>
+to the path to that directory.
+(Another common setup is to set <code>GOPATH=$HOME</code>.)
+Note that <code>GOPATH</code> must <b>not</b> be the
+same path as your Go installation.
+</p>
+
+<p>
+The command <code>go</code> <code>env</code> <code>GOPATH</code>
+prints the effective current <code>GOPATH</code>;
+it prints the default location if the environment variable is unset.
+</p>
+
+<p>
+For convenience, add the workspace's <code>bin</code> subdirectory
+to your <code>PATH</code>:
+</p>
+
+<pre>
+$ <b>export PATH=$PATH:$(go env GOPATH)/bin</b>
+</pre>
+
+<p>
+The scripts in the rest of this document use <code>$GOPATH</code>
+instead of <code>$(go env GOPATH)</code> for brevity.
+To make the scripts run as written
+if you have not set GOPATH,
+you can substitute $HOME/go in those commands
+or else run:
+</p>
+
+<pre>
+$ <b>export GOPATH=$(go env GOPATH)</b>
+</pre>
+
+<p>
+To learn more about the <code>GOPATH</code> environment variable, see
+<a href="/cmd/go/#hdr-GOPATH_environment_variable"><code>'go help gopath'</code></a>.
+</p>
+
+<h3 id="ImportPaths">Import paths</h3>
+
+<p>
+An <i>import path</i> is a string that uniquely identifies a package.
+A package's import path corresponds to its location inside a workspace
+or in a remote repository (explained below).
+</p>
+
+<p>
+The packages from the standard library are given short import paths such as
+<code>"fmt"</code> and <code>"net/http"</code>.
+For your own packages, you must choose a base path that is unlikely to
+collide with future additions to the standard library or other external
+libraries.
+</p>
+
+<p>
+If you keep your code in a source repository somewhere, then you should use the
+root of that source repository as your base path.
+For instance, if you have a <a href="https://github.com/">GitHub</a> account at
+<code>github.com/user</code>, that should be your base path.
+</p>
+
+<p>
+Note that you don't need to publish your code to a remote repository before you
+can build it. It's just a good habit to organize your code as if you will
+publish it someday. In practice you can choose any arbitrary path name,
+as long as it is unique to the standard library and greater Go ecosystem.
+</p>
+
+<p>
+We'll use <code>github.com/user</code> as our base path. Create a directory
+inside your workspace in which to keep source code:
+</p>
+
+<pre>
+$ <b>mkdir -p $GOPATH/src/github.com/user</b>
+</pre>
+
+
+<h3 id="Command">Your first program</h3>
+
+<p>
+To compile and run a simple program, first choose a package path (we'll use
+<code>github.com/user/hello</code>) and create a corresponding package directory
+inside your workspace:
+</p>
+
+<pre>
+$ <b>mkdir $GOPATH/src/github.com/user/hello</b>
+</pre>
+
+<p>
+Next, create a file named <code>hello.go</code> inside that directory,
+containing the following Go code.
+</p>
+
+<pre>
+package main
+
+import "fmt"
+
+func main() {
+ fmt.Println("Hello, world.")
+}
+</pre>
+
+<p>
+Now you can build and install that program with the <code>go</code> tool:
+</p>
+
+<pre>
+$ <b>go install github.com/user/hello</b>
+</pre>
+
+<p>
+Note that you can run this command from anywhere on your system. The
+<code>go</code> tool finds the source code by looking for the
+<code>github.com/user/hello</code> package inside the workspace specified by
+<code>GOPATH</code>.
+</p>
+
+<p>
+You can also omit the package path if you run <code>go install</code> from the
+package directory:
+</p>
+
+<pre>
+$ <b>cd $GOPATH/src/github.com/user/hello</b>
+$ <b>go install</b>
+</pre>
+
+<p>
+This command builds the <code>hello</code> command, producing an executable
+binary. It then installs that binary to the workspace's <code>bin</code>
+directory as <code>hello</code> (or, under Windows, <code>hello.exe</code>).
+In our example, that will be <code>$GOPATH/bin/hello</code>, which is
+<code>$HOME/go/bin/hello</code>.
+</p>
+
+<p>
+The <code>go</code> tool will only print output when an error occurs, so if
+these commands produce no output they have executed successfully.
+</p>
+
+<p>
+You can now run the program by typing its full path at the command line:
+</p>
+
+<pre>
+$ <b>$GOPATH/bin/hello</b>
+Hello, world.
+</pre>
+
+<p>
+Or, as you have added <code>$GOPATH/bin</code> to your <code>PATH</code>,
+just type the binary name:
+</p>
+
+<pre>
+$ <b>hello</b>
+Hello, world.
+</pre>
+
+<p>
+If you're using a source control system, now would be a good time to initialize
+a repository, add the files, and commit your first change. Again, this step is
+optional: you do not need to use source control to write Go code.
+</p>
+
+<pre>
+$ <b>cd $GOPATH/src/github.com/user/hello</b>
+$ <b>git init</b>
+Initialized empty Git repository in /home/user/go/src/github.com/user/hello/.git/
+$ <b>git add hello.go</b>
+$ <b>git commit -m "initial commit"</b>
+[master (root-commit) 0b4507d] initial commit
+ 1 file changed, 7 insertion(+)
+ create mode 100644 hello.go
+</pre>
+
+<p>
+Pushing the code to a remote repository is left as an exercise for the reader.
+</p>
+
+
+<h3 id="Library">Your first library</h3>
+
+<p>
+Let's write a library and use it from the <code>hello</code> program.
+</p>
+
+<p>
+Again, the first step is to choose a package path (we'll use
+<code>github.com/user/stringutil</code>) and create the package directory:
+</p>
+
+<pre>
+$ <b>mkdir $GOPATH/src/github.com/user/stringutil</b>
+</pre>
+
+<p>
+Next, create a file named <code>reverse.go</code> in that directory with the
+following contents.
+</p>
+
+<pre>
+// Package stringutil contains utility functions for working with strings.
+package stringutil
+
+// Reverse returns its argument string reversed rune-wise left to right.
+func Reverse(s string) string {
+ r := []rune(s)
+ for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {
+ r[i], r[j] = r[j], r[i]
+ }
+ return string(r)
+}
+</pre>
+
+<p>
+Now, test that the package compiles with <code>go build</code>:
+</p>
+
+<pre>
+$ <b>go build github.com/user/stringutil</b>
+</pre>
+
+<p>
+Or, if you are working in the package's source directory, just:
+</p>
+
+<pre>
+$ <b>go build</b>
+</pre>
+
+<p>
+This won't produce an output file.
+Instead it saves the compiled package in the local build cache.
+</p>
+
+<p>
+After confirming that the <code>stringutil</code> package builds,
+modify your original <code>hello.go</code> (which is in
+<code>$GOPATH/src/github.com/user/hello</code>) to use it:
+</p>
+
+<pre>
+package main
+
+import (
+ "fmt"
+
+ <b>"github.com/user/stringutil"</b>
+)
+
+func main() {
+ fmt.Println(stringutil.Reverse("!oG ,olleH"))
+}
+</pre>
+
+<p>
+Install the <code>hello</code> program:
+</p>
+
+<pre>
+$ <b>go install github.com/user/hello</b>
+</pre>
+
+<p>
+Running the new version of the program, you should see a new, reversed message:
+</p>
+
+<pre>
+$ <b>hello</b>
+Hello, Go!
+</pre>
+
+<p>
+After the steps above, your workspace should look like this:
+</p>
+
+<pre>
+bin/
+ hello # command executable
+src/
+ github.com/user/
+ hello/
+ hello.go # command source
+ stringutil/
+ reverse.go # package source
+</pre>
+
+<h3 id="PackageNames">Package names</h3>
+
+<p>
+The first statement in a Go source file must be
+</p>
+
+<pre>
+package <i>name</i>
+</pre>
+
+<p>
+where <code><i>name</i></code> is the package's default name for imports.
+(All files in a package must use the same <code><i>name</i></code>.)
+</p>
+
+<p>
+Go's convention is that the package name is the last element of the
+import path: the package imported as "<code>crypto/rot13</code>"
+should be named <code>rot13</code>.
+</p>
+
+<p>
+Executable commands must always use <code>package main</code>.
+</p>
+
+<p>
+There is no requirement that package names be unique
+across all packages linked into a single binary,
+only that the import paths (their full file names) be unique.
+</p>
+
+<p>
+See <a href="/doc/effective_go.html#names">Effective Go</a> to learn more about
+Go's naming conventions.
+</p>
+
+
+<h2 id="Testing">Testing</h2>
+
+<p>
+Go has a lightweight test framework composed of the <code>go test</code>
+command and the <code>testing</code> package.
+</p>
+
+<p>
+You write a test by creating a file with a name ending in <code>_test.go</code>
+that contains functions named <code>TestXXX</code> with signature
+<code>func (t *testing.T)</code>.
+The test framework runs each such function;
+if the function calls a failure function such as <code>t.Error</code> or
+<code>t.Fail</code>, the test is considered to have failed.
+</p>
+
+<p>
+Add a test to the <code>stringutil</code> package by creating the file
+<code>$GOPATH/src/github.com/user/stringutil/reverse_test.go</code> containing
+the following Go code.
+</p>
+
+<pre>
+package stringutil
+
+import "testing"
+
+func TestReverse(t *testing.T) {
+ cases := []struct {
+ in, want string
+ }{
+ {"Hello, world", "dlrow ,olleH"},
+ {"Hello, 世界", "界世 ,olleH"},
+ {"", ""},
+ }
+ for _, c := range cases {
+ got := Reverse(c.in)
+ if got != c.want {
+ t.Errorf("Reverse(%q) == %q, want %q", c.in, got, c.want)
+ }
+ }
+}
+</pre>
+
+<p>
+Then run the test with <code>go test</code>:
+</p>
+
+<pre>
+$ <b>go test github.com/user/stringutil</b>
+ok github.com/user/stringutil 0.165s
+</pre>
+
+<p>
+As always, if you are running the <code>go</code> tool from the package
+directory, you can omit the package path:
+</p>
+
+<pre>
+$ <b>go test</b>
+ok github.com/user/stringutil 0.165s
+</pre>
+
+<p>
+Run <code><a href="/cmd/go/#hdr-Test_packages">go help test</a></code> and see the
+<a href="/pkg/testing/">testing package documentation</a> for more detail.
+</p>
+
+
+<h2 id="remote">Remote packages</h2>
+
+<p>
+An import path can describe how to obtain the package source code using a
+revision control system such as Git or Mercurial. The <code>go</code> tool uses
+this property to automatically fetch packages from remote repositories.
+For instance, the examples described in this document are also kept in a
+Git repository hosted at GitHub
+<code><a href="https://github.com/golang/example">github.com/golang/example</a></code>.
+If you include the repository URL in the package's import path,
+<code>go get</code> will fetch, build, and install it automatically:
+</p>
+
+<pre>
+$ <b>go get github.com/golang/example/hello</b>
+$ <b>$GOPATH/bin/hello</b>
+Hello, Go examples!
+</pre>
+
+<p>
+If the specified package is not present in a workspace, <code>go get</code>
+will place it inside the first workspace specified by <code>GOPATH</code>.
+(If the package does already exist, <code>go get</code> skips the remote
+fetch and behaves the same as <code>go install</code>.)
+</p>
+
+<p>
+After issuing the above <code>go get</code> command, the workspace directory
+tree should now look like this:
+</p>
+
+<pre>
+bin/
+ hello # command executable
+src/
+ github.com/golang/example/
+ .git/ # Git repository metadata
+ hello/
+ hello.go # command source
+ stringutil/
+ reverse.go # package source
+ reverse_test.go # test source
+ github.com/user/
+ hello/
+ hello.go # command source
+ stringutil/
+ reverse.go # package source
+ reverse_test.go # test source
+</pre>
+
+<p>
+The <code>hello</code> command hosted at GitHub depends on the
+<code>stringutil</code> package within the same repository. The imports in
+<code>hello.go</code> file use the same import path convention, so the
+<code>go get</code> command is able to locate and install the dependent
+package, too.
+</p>
+
+<pre>
+import "github.com/golang/example/stringutil"
+</pre>
+
+<p>
+This convention is the easiest way to make your Go packages available for
+others to use.
+<a href="//pkg.go.dev">Pkg.go.dev</a>
+and the <a href="//golang.org/wiki/Projects">Go Wiki</a>
+provide lists of external Go projects.
+</p>
+
+<p>
+For more information on using remote repositories with the <code>go</code> tool, see
+<code><a href="/cmd/go/#hdr-Remote_import_paths">go help importpath</a></code>.
+</p>
+
+
+<h2 id="next">What's next</h2>
+
+<p>
+Subscribe to the
+<a href="//groups.google.com/group/golang-announce">golang-announce</a>
+mailing list to be notified when a new stable version of Go is released.
+</p>
+
+<p>
+See <a href="/doc/effective_go.html">Effective Go</a> for tips on writing
+clear, idiomatic Go code.
+</p>
+
+<p>
+Take <a href="//tour.golang.org/">A Tour of Go</a> to learn the language
+proper.
+</p>
+
+<p>
+Visit the <a href="/doc/#articles">documentation page</a> for a set of in-depth
+articles about the Go language and its libraries and tools.
+</p>
+
+
+<h2 id="help">Getting help</h2>
+
+<p>
+For real-time help, ask the helpful gophers in <code>#go-nuts</code> on the
+<a href="https://freenode.net/">Freenode</a> IRC server.
+</p>
+
+<p>
+The official mailing list for discussion of the Go language is
+<a href="//groups.google.com/group/golang-nuts">Go Nuts</a>.
+</p>
+
+<p>
+Report bugs using the
+<a href="//golang.org/issue">Go issue tracker</a>.
+</p>
diff --git a/_content/doc/gopher/README b/_content/doc/gopher/README
new file mode 100644
index 0000000..d4ca8a1
--- /dev/null
+++ b/_content/doc/gopher/README
@@ -0,0 +1,3 @@
+The Go gopher was designed by Renee French. (http://reneefrench.blogspot.com/)
+The design is licensed under the Creative Commons 3.0 Attributions license.
+Read this article for more details: https://blog.golang.org/gopher
diff --git a/_content/doc/gopher/appenginegopher.jpg b/_content/doc/gopher/appenginegopher.jpg
new file mode 100644
index 0000000..0a64306
--- /dev/null
+++ b/_content/doc/gopher/appenginegopher.jpg
Binary files differ
diff --git a/_content/doc/gopher/appenginegophercolor.jpg b/_content/doc/gopher/appenginegophercolor.jpg
new file mode 100644
index 0000000..68795a9
--- /dev/null
+++ b/_content/doc/gopher/appenginegophercolor.jpg
Binary files differ
diff --git a/_content/doc/gopher/appenginelogo.gif b/_content/doc/gopher/appenginelogo.gif
new file mode 100644
index 0000000..46b3c1e
--- /dev/null
+++ b/_content/doc/gopher/appenginelogo.gif
Binary files differ
diff --git a/_content/doc/gopher/biplane.jpg b/_content/doc/gopher/biplane.jpg
new file mode 100644
index 0000000..d5e666f
--- /dev/null
+++ b/_content/doc/gopher/biplane.jpg
Binary files differ
diff --git a/_content/doc/gopher/bumper.png b/_content/doc/gopher/bumper.png
new file mode 100644
index 0000000..b357cdf
--- /dev/null
+++ b/_content/doc/gopher/bumper.png
Binary files differ
diff --git a/_content/doc/gopher/bumper192x108.png b/_content/doc/gopher/bumper192x108.png
new file mode 100644
index 0000000..925474e
--- /dev/null
+++ b/_content/doc/gopher/bumper192x108.png
Binary files differ
diff --git a/_content/doc/gopher/bumper320x180.png b/_content/doc/gopher/bumper320x180.png
new file mode 100644
index 0000000..611c417
--- /dev/null
+++ b/_content/doc/gopher/bumper320x180.png
Binary files differ
diff --git a/_content/doc/gopher/bumper480x270.png b/_content/doc/gopher/bumper480x270.png
new file mode 100644
index 0000000..cf18715
--- /dev/null
+++ b/_content/doc/gopher/bumper480x270.png
Binary files differ
diff --git a/_content/doc/gopher/bumper640x360.png b/_content/doc/gopher/bumper640x360.png
new file mode 100644
index 0000000..a5073e0
--- /dev/null
+++ b/_content/doc/gopher/bumper640x360.png
Binary files differ
diff --git a/_content/doc/gopher/doc.png b/_content/doc/gopher/doc.png
new file mode 100644
index 0000000..e15a323
--- /dev/null
+++ b/_content/doc/gopher/doc.png
Binary files differ
diff --git a/_content/doc/gopher/favicon.svg b/_content/doc/gopher/favicon.svg
new file mode 100644
index 0000000..e5a68fe
--- /dev/null
+++ b/_content/doc/gopher/favicon.svg
@@ -0,0 +1,238 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+ xmlns:dc="http://purl.org/dc/elements/1.1/"
+ xmlns:cc="http://creativecommons.org/ns#"
+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+ xmlns:svg="http://www.w3.org/2000/svg"
+ xmlns="http://www.w3.org/2000/svg"
+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+ width="32"
+ height="32"
+ viewBox="0 0 32 32.000001"
+ id="svg4416"
+ version="1.1"
+ inkscape:version="0.91 r13725"
+ sodipodi:docname="favicon.svg"
+ inkscape:export-filename="../../favicon.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90">
+ <defs
+ id="defs4418" />
+ <sodipodi:namedview
+ id="base"
+ pagecolor="#ffffff"
+ bordercolor="#666666"
+ borderopacity="1.0"
+ inkscape:pageopacity="0.0"
+ inkscape:pageshadow="2"
+ inkscape:zoom="15.839192"
+ inkscape:cx="17.966652"
+ inkscape:cy="9.2991824"
+ inkscape:document-units="px"
+ inkscape:current-layer="layer1"
+ showgrid="true"
+ units="px"
+ inkscape:snap-bbox="true"
+ inkscape:snap-bbox-edge-midpoints="false"
+ inkscape:bbox-nodes="true"
+ showguides="false"
+ inkscape:window-width="1920"
+ inkscape:window-height="1018"
+ inkscape:window-x="1912"
+ inkscape:window-y="-8"
+ inkscape:window-maximized="1"
+ inkscape:object-nodes="true"
+ inkscape:snap-smooth-nodes="true"
+ inkscape:snap-global="false">
+ <inkscape:grid
+ type="xygrid"
+ id="grid5148" />
+ </sodipodi:namedview>
+ <metadata
+ id="metadata4421">
+ <rdf:RDF>
+ <cc:Work
+ rdf:about="">
+ <dc:format>image/svg+xml</dc:format>
+ <dc:type
+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+ <dc:title />
+ </cc:Work>
+ </rdf:RDF>
+ </metadata>
+ <g
+ inkscape:label="icon"
+ inkscape:groupmode="layer"
+ id="layer1"
+ transform="translate(0,-1020.3622)">
+ <ellipse
+ style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#384e54;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+ id="ellipse4216"
+ cx="-907.35657"
+ cy="479.90009"
+ rx="3.5793996"
+ ry="3.8207953"
+ transform="matrix(-0.49169095,-0.87076978,-0.87076978,0.49169095,0,0)"
+ inkscape:transform-center-x="0.67794294"
+ inkscape:transform-center-y="-2.3634048" />
+ <ellipse
+ inkscape:transform-center-y="-2.3633882"
+ inkscape:transform-center-x="-0.67793718"
+ transform="matrix(0.49169095,-0.87076978,0.87076978,0.49169095,0,0)"
+ ry="3.8207953"
+ rx="3.5793996"
+ cy="507.8461"
+ cx="-891.57654"
+ id="ellipse4463"
+ style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#384e54;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate" />
+ <path
+ inkscape:connector-curvature="0"
+ style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#384e54;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+ d="m 16.091693,1021.3642 c -1.105749,0.01 -2.210341,0.049 -3.31609,0.09 C 6.8422558,1021.6738 2,1026.3942 2,1032.3622 c 0,2.9786 0,13 0,20 l 28,0 c 0,-8 0,-16 0,-20 0,-5.9683 -4.667345,-10.4912 -10.59023,-10.908 -1.10575,-0.078 -2.212328,-0.099 -3.318077,-0.09 z"
+ id="path4465"
+ sodipodi:nodetypes="ccsccscc" />
+ <path
+ inkscape:transform-center-y="-1.3604657"
+ inkscape:transform-center-x="-0.98424303"
+ sodipodi:nodetypes="sssssss"
+ inkscape:connector-curvature="0"
+ id="path4469"
+ d="m 4.6078867,1025.0462 c 0.459564,0.2595 1.818262,1.2013 1.980983,1.648 0.183401,0.5035 0.159385,1.0657 -0.114614,1.551 -0.346627,0.6138 -1.005341,0.9487 -1.696421,0.9365 -0.339886,-0.01 -1.720283,-0.6372 -2.042561,-0.8192 -0.97754,-0.5519 -1.350795,-1.7418 -0.833686,-2.6576 0.517109,-0.9158 1.728749,-1.2107 2.706299,-0.6587 z"
+ style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#76e1fe;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate" />
+ <rect
+ style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#000000;fill-opacity:0.32850246;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+ id="rect4473"
+ width="3.0866659"
+ height="3.5313663"
+ x="14.406213"
+ y="1035.6842"
+ ry="0.62426329" />
+ <path
+ inkscape:connector-curvature="0"
+ style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#76e1fe;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+ d="m 16,1023.3622 c -9,0 -12,3.7153 -12,9 l 0,20 24,0 c -0.04889,-7.3562 0,-18 0,-20 0,-5.2848 -3,-9 -12,-9 z"
+ id="path4471"
+ sodipodi:nodetypes="zsccsz" />
+ <path
+ style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#76e1fe;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+ d="m 27.074073,1025.0462 c -0.45957,0.2595 -1.818257,1.2013 -1.980979,1.648 -0.183401,0.5035 -0.159384,1.0657 0.114614,1.551 0.346627,0.6138 1.005335,0.9487 1.696415,0.9365 0.33988,-0.01 1.72029,-0.6372 2.04256,-0.8192 0.97754,-0.5519 1.35079,-1.7418 0.83369,-2.6576 -0.51711,-0.9158 -1.72876,-1.2107 -2.7063,-0.6587 z"
+ id="path4481"
+ inkscape:connector-curvature="0"
+ sodipodi:nodetypes="sssssss"
+ inkscape:transform-center-x="0.98424094"
+ inkscape:transform-center-y="-1.3604657" />
+ <circle
+ style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+ id="circle4477"
+ cx="21.175734"
+ cy="1030.3542"
+ r="4.6537542"
+ inkscape:export-filename=".\rect4485.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <circle
+ r="4.8316345"
+ cy="1030.3542"
+ cx="10.339486"
+ id="circle4483"
+ style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+ inkscape:export-filename=".\rect4485.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <rect
+ inkscape:export-ydpi="90"
+ inkscape:export-xdpi="90"
+ inkscape:export-filename=".\rect4485.png"
+ style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#000000;fill-opacity:0.32941176;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+ id="rect4246"
+ width="3.6673687"
+ height="4.1063409"
+ x="14.115863"
+ y="1035.9174"
+ ry="0.72590536" />
+ <rect
+ ry="0.72590536"
+ y="1035.2253"
+ x="14.115863"
+ height="4.1063409"
+ width="3.6673687"
+ id="rect4485"
+ style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#fffcfb;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+ inkscape:export-filename=".\rect4485.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <path
+ style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#000000;fill-opacity:0.32941176;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+ d="m 19.999735,1036.5289 c 0,0.838 -0.871228,1.2682 -2.144766,1.1659 -0.02366,0 -0.04795,-0.6004 -0.254147,-0.5832 -0.503669,0.042 -1.095902,-0.02 -1.685964,-0.02 -0.612939,0 -1.206342,0.1826 -1.68549,0.017 -0.110233,-0.038 -0.178298,0.5838 -0.261532,0.5816 -1.243685,-0.033 -2.078803,-0.3383 -2.078803,-1.1618 0,-1.2118 1.815635,-2.1941 4.055351,-2.1941 2.239704,0 4.055351,0.9823 4.055351,2.1941 z"
+ id="path4487"
+ inkscape:connector-curvature="0"
+ sodipodi:nodetypes="sssssssss"
+ inkscape:export-filename=".\rect4485.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <path
+ sodipodi:nodetypes="sssssssss"
+ inkscape:connector-curvature="0"
+ id="path4489"
+ d="m 19.977414,1035.7004 c 0,0.5685 -0.433659,0.8554 -1.138091,1.0001 -0.291933,0.06 -0.630371,0.096 -1.003719,0.1166 -0.56405,0.032 -1.207782,0.031 -1.89122,0.031 -0.672834,0 -1.307182,0 -1.864904,-0.029 -0.306268,-0.017 -0.589429,-0.043 -0.843164,-0.084 -0.813833,-0.1318 -1.324962,-0.417 -1.324962,-1.0344 0,-1.1601 1.805642,-2.1006 4.03303,-2.1006 2.227377,0 4.03303,0.9405 4.03303,2.1006 z"
+ style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#c38c74;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+ inkscape:export-filename=".\rect4485.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <ellipse
+ cy="1033.8501"
+ cx="15.944382"
+ id="ellipse4491"
+ style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#23201f;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+ rx="2.0801733"
+ ry="1.343747"
+ inkscape:export-filename=".\rect4485.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <circle
+ style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#171311;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+ id="circle4493"
+ cx="12.414201"
+ cy="1030.3542"
+ r="1.9630634"
+ inkscape:export-filename=".\rect4485.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <circle
+ r="1.9630634"
+ cy="1030.3542"
+ cx="23.110121"
+ id="circle4495"
+ style="color:#000000;clip-rule:nonzero;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:#000000;solid-opacity:1;fill:#171311;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto;enable-background:accumulate"
+ inkscape:export-filename=".\rect4485.png"
+ inkscape:export-xdpi="90"
+ inkscape:export-ydpi="90" />
+ <path
+ sodipodi:nodetypes="cc"
+ inkscape:connector-curvature="0"
+ id="path4497"
+ d="m 5.0055377,1027.2727 c -1.170435,-1.0835 -2.026973,-0.7721 -2.044172,-0.7463"
+ style="display:inline;fill:none;fill-rule:evenodd;stroke:#384e54;stroke-width:0.39730874;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
+ <path
+ style="display:inline;fill:none;fill-rule:evenodd;stroke:#384e54;stroke-width:0.39730874;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+ d="m 4.3852457,1026.9152 c -1.158557,0.036 -1.346704,0.6303 -1.33881,0.6523"
+ id="path4499"
+ inkscape:connector-curvature="0"
+ sodipodi:nodetypes="cc" />
+ <path
+ style="display:inline;fill:none;fill-rule:evenodd;stroke:#384e54;stroke-width:0.39730874;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+ d="m 26.630533,1027.1724 c 1.17043,-1.0835 2.02697,-0.7721 2.04417,-0.7463"
+ id="path4501"
+ inkscape:connector-curvature="0"
+ sodipodi:nodetypes="cc" />
+ <path
+ sodipodi:nodetypes="cc"
+ inkscape:connector-curvature="0"
+ id="path4503"
+ d="m 27.321773,1026.673 c 1.15856,0.036 1.3467,0.6302 1.3388,0.6522"
+ style="display:inline;fill:none;fill-rule:evenodd;stroke:#384e54;stroke-width:0.39730874;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
+ </g>
+</svg>
diff --git a/_content/doc/gopher/fiveyears.jpg b/_content/doc/gopher/fiveyears.jpg
new file mode 100644
index 0000000..df10648
--- /dev/null
+++ b/_content/doc/gopher/fiveyears.jpg
Binary files differ
diff --git a/_content/doc/gopher/frontpage.png b/_content/doc/gopher/frontpage.png
new file mode 100644
index 0000000..1eb81f0
--- /dev/null
+++ b/_content/doc/gopher/frontpage.png
Binary files differ
diff --git a/_content/doc/gopher/gopherbw.png b/_content/doc/gopher/gopherbw.png
new file mode 100644
index 0000000..3bfe85d
--- /dev/null
+++ b/_content/doc/gopher/gopherbw.png
Binary files differ
diff --git a/_content/doc/gopher/gophercolor.png b/_content/doc/gopher/gophercolor.png
new file mode 100644
index 0000000..b5f8d01
--- /dev/null
+++ b/_content/doc/gopher/gophercolor.png
Binary files differ
diff --git a/_content/doc/gopher/gophercolor16x16.png b/_content/doc/gopher/gophercolor16x16.png
new file mode 100644
index 0000000..ec7028c
--- /dev/null
+++ b/_content/doc/gopher/gophercolor16x16.png
Binary files differ
diff --git a/_content/doc/gopher/help.png b/_content/doc/gopher/help.png
new file mode 100644
index 0000000..6ee5238
--- /dev/null
+++ b/_content/doc/gopher/help.png
Binary files differ
diff --git a/_content/doc/gopher/modelsheet.jpg b/_content/doc/gopher/modelsheet.jpg
new file mode 100644
index 0000000..c31e35a
--- /dev/null
+++ b/_content/doc/gopher/modelsheet.jpg
Binary files differ
diff --git a/_content/doc/gopher/pencil/gopherhat.jpg b/_content/doc/gopher/pencil/gopherhat.jpg
new file mode 100644
index 0000000..f34d7b3
--- /dev/null
+++ b/_content/doc/gopher/pencil/gopherhat.jpg
Binary files differ
diff --git a/_content/doc/gopher/pencil/gopherhelmet.jpg b/_content/doc/gopher/pencil/gopherhelmet.jpg
new file mode 100644
index 0000000..c7b6c61
--- /dev/null
+++ b/_content/doc/gopher/pencil/gopherhelmet.jpg
Binary files differ
diff --git a/_content/doc/gopher/pencil/gophermega.jpg b/_content/doc/gopher/pencil/gophermega.jpg
new file mode 100644
index 0000000..779fb07
--- /dev/null
+++ b/_content/doc/gopher/pencil/gophermega.jpg
Binary files differ
diff --git a/_content/doc/gopher/pencil/gopherrunning.jpg b/_content/doc/gopher/pencil/gopherrunning.jpg
new file mode 100644
index 0000000..eeeddf1
--- /dev/null
+++ b/_content/doc/gopher/pencil/gopherrunning.jpg
Binary files differ
diff --git a/_content/doc/gopher/pencil/gopherswim.jpg b/_content/doc/gopher/pencil/gopherswim.jpg
new file mode 100644
index 0000000..2f32877
--- /dev/null
+++ b/_content/doc/gopher/pencil/gopherswim.jpg
Binary files differ
diff --git a/_content/doc/gopher/pencil/gopherswrench.jpg b/_content/doc/gopher/pencil/gopherswrench.jpg
new file mode 100644
index 0000000..93005f4
--- /dev/null
+++ b/_content/doc/gopher/pencil/gopherswrench.jpg
Binary files differ
diff --git a/_content/doc/gopher/pkg.png b/_content/doc/gopher/pkg.png
new file mode 100644
index 0000000..ac96551
--- /dev/null
+++ b/_content/doc/gopher/pkg.png
Binary files differ
diff --git a/_content/doc/gopher/project.png b/_content/doc/gopher/project.png
new file mode 100644
index 0000000..24603f3
--- /dev/null
+++ b/_content/doc/gopher/project.png
Binary files differ
diff --git a/_content/doc/gopher/ref.png b/_content/doc/gopher/ref.png
new file mode 100644
index 0000000..0508f6e
--- /dev/null
+++ b/_content/doc/gopher/ref.png
Binary files differ
diff --git a/_content/doc/gopher/run.png b/_content/doc/gopher/run.png
new file mode 100644
index 0000000..eb690e3
--- /dev/null
+++ b/_content/doc/gopher/run.png
Binary files differ
diff --git a/_content/doc/gopher/talks.png b/_content/doc/gopher/talks.png
new file mode 100644
index 0000000..589db47
--- /dev/null
+++ b/_content/doc/gopher/talks.png
Binary files differ
diff --git a/_content/doc/hats.js b/_content/doc/hats.js
new file mode 100644
index 0000000..6be29db
--- /dev/null
+++ b/_content/doc/hats.js
@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright 2021 The Go Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style
+ * license that can be found in the LICENSE file.
+ */
+
+(function () {
+ var cookieName = 'HaTS_BKT_DIST';
+ var inBucket;
+
+ var cookies = decodeURIComponent(document.cookie).split(';');
+
+ for (let i = 0; i < cookies.length; i++) {
+ var c = cookies[i];
+
+ while (c.charAt(0) == ' ') {
+ c = c.substring(1);
+ }
+
+ if (c.indexOf(cookieName + '=') == 0) {
+ inBucket = c.substring((cookieName + '=').length, c.length);
+ }
+ }
+
+ if (typeof inBucket === 'undefined') {
+ inBucket = String(Math.random() < 0.01);
+ document.cookie =
+ cookieName + '=' + inBucket + '; path=/; max-age=2592000;';
+ }
+
+ if (inBucket === 'true') {
+ document.cookie = cookieName + '=false ; path=/; max-age=2592000;';
+
+ var tag = document.createElement('script');
+ tag.src =
+ 'https://www.gstatic.com/feedback/js/help/prod/service/lazy.min.js';
+ tag.type = 'text/javascript';
+ document.head.appendChild(tag);
+
+ tag.onload = function () {
+ var helpApi = window.help.service.Lazy.create(0, {
+ apiKey: 'AIzaSyDfBPfajByU2G6RAjUf5sjkMSSLNTj7MMc',
+ locale: 'en-US',
+ });
+
+ helpApi.requestSurvey({
+ triggerId: 'dz6fkRxyz0njVvnD1rP0QxCXzhSX',
+ callback: function (requestSurveyCallbackParam) {
+ if (!requestSurveyCallbackParam.surveyData) {
+ return;
+ }
+ helpApi.presentSurvey({
+ surveyData: requestSurveyCallbackParam.surveyData,
+ colorScheme: 1, // light
+ customZIndex: 10000,
+ });
+ },
+ });
+ };
+ }
+})();
diff --git a/_content/doc/help.html b/_content/doc/help.html
new file mode 100644
index 0000000..ecfbbc6
--- /dev/null
+++ b/_content/doc/help.html
@@ -0,0 +1,96 @@
+<!--{
+ "Title": "Help",
+ "Path": "/help/",
+ "Template": true
+}-->
+
+<div id="manual-nav"></div>
+
+<h2 id="help">Get help</h2>
+
+<img class="gopher" src="/doc/gopher/help.png" alt=""/>
+
+{{if not $.GoogleCN}}
+<h3 id="mailinglist"><a href="https://groups.google.com/group/golang-nuts">Go Nuts Mailing List</a></h3>
+<p>
+Get help from Go users, and share your work on the official mailing list.
+</p>
+<p>
+Search the <a href="https://groups.google.com/group/golang-nuts">golang-nuts</a>
+archives and consult the <a href="/doc/go_faq.html">FAQ</a> and
+<a href="//golang.org/wiki">wiki</a> before posting.
+</p>
+
+<h3 id="forum"><a href="https://forum.golangbridge.org/">Go Forum</a></h3>
+<p>
+The <a href="https://forum.golangbridge.org/">Go Forum</a> is a discussion
+forum for Go programmers.
+</p>
+
+<h3 id="discord"><a href="https://discord.gg/golang">Gophers Discord</a></h3>
+<p>
+Get live support and talk with other gophers on the Go Discord.
+</p>
+
+<h3 id="slack"><a href="https://blog.gopheracademy.com/gophers-slack-community/">Gopher Slack</a></h3>
+<p>Get live support from other users in the Go slack channel.</p>
+
+<h3 id="irc"><a href="irc:irc.freenode.net/go-nuts">Go IRC Channel</a></h3>
+<p>Get live support at <b>#go-nuts</b> on <b>irc.freenode.net</b>, the official
+Go IRC channel.</p>
+{{end}}
+
+<h3 id="faq"><a href="/doc/faq">Frequently Asked Questions (FAQ)</a></h3>
+<p>Answers to common questions about Go.</p>
+
+{{if not $.GoogleCN}}
+<h2 id="inform">Stay informed</h2>
+
+<h3 id="announce"><a href="https://groups.google.com/group/golang-announce">Go Announcements Mailing List</a></h3>
+<p>
+Subscribe to
+<a href="https://groups.google.com/group/golang-announce">golang-announce</a>
+for important announcements, such as the availability of new Go releases.
+</p>
+
+<h3 id="blog"><a href="//blog.golang.org">Go Blog</a></h3>
+<p>The Go project's official blog.</p>
+
+<h3 id="twitter"><a href="https://twitter.com/golang">@golang at Twitter</a></h3>
+<p>The Go project's official Twitter account.</p>
+
+<h3 id="reddit"><a href="https://reddit.com/r/golang">golang sub-Reddit</a></h3>
+<p>
+The <a href="https://reddit.com/r/golang">golang sub-Reddit</a> is a place
+for Go news and discussion.
+</p>
+
+<h3 id="gotime"><a href="https://changelog.com/gotime">Go Time Podcast</a></h3>
+<p>
+The <a href="https://changelog.com/gotime">Go Time podcast</a> is a panel of Go experts and special guests
+discussing the Go programming language, the community, and everything in between.
+</p>
+{{end}}
+
+<h2 id="community">Community resources</h2>
+
+<h3 id="go_user_groups"><a href="/wiki/GoUserGroups">Go User Groups</a></h3>
+<p>
+Each month in places around the world, groups of Go programmers ("gophers")
+meet to talk about Go. Find a chapter near you.
+</p>
+
+{{if not $.GoogleCN}}
+<h3 id="playground"><a href="/play">Go Playground</a></h3>
+<p>A place to write, run, and share Go code.</p>
+
+<h3 id="wiki"><a href="/wiki">Go Wiki</a></h3>
+<p>A wiki maintained by the Go community.</p>
+{{end}}
+
+<h3 id="conduct"><a href="/conduct">Code of Conduct</a></h3>
+<p>
+Guidelines for participating in Go community spaces
+and a reporting process for handling issues.
+</p>
+
diff --git a/_content/doc/ie.css b/_content/doc/ie.css
new file mode 100644
index 0000000..bb89d54
--- /dev/null
+++ b/_content/doc/ie.css
@@ -0,0 +1 @@
+#nav-main li { display: inline; }
diff --git a/_content/doc/install-source.html b/_content/doc/install-source.html
new file mode 100644
index 0000000..3997694
--- /dev/null
+++ b/_content/doc/install-source.html
@@ -0,0 +1,782 @@
+<!--{
+ "Title": "Installing Go from source",
+ "Path": "/doc/install/source"
+}-->
+
+<p>
+This topic describes how to build and run Go from source code.
+To install with an installer, see <a href="/doc/install">Download and install</a>.
+</p>
+
+<h2 id="introduction">Introduction</h2>
+
+<p>
+Go is an open source project, distributed under a
+<a href="/LICENSE">BSD-style license</a>.
+This document explains how to check out the sources,
+build them on your own machine, and run them.
+</p>
+
+<p>
+Most users don't need to do this, and will instead install
+from precompiled binary packages as described in
+<a href="/doc/install">Download and install</a>,
+a much simpler process.
+If you want to help develop what goes into those precompiled
+packages, though, read on.
+</p>
+
+<div class="detail">
+
+<p>
+There are two official Go compiler toolchains.
+This document focuses on the <code>gc</code> Go
+compiler and tools.
+For information on how to work on <code>gccgo</code>, a more traditional
+compiler using the GCC back end, see
+<a href="/doc/install/gccgo">Setting up and using gccgo</a>.
+</p>
+
+<p>
+The Go compilers support the following instruction sets:
+
+<dl>
+<dt>
+ <code>amd64</code>, <code>386</code>
+</dt>
+<dd>
+ The <code>x86</code> instruction set, 64- and 32-bit.
+</dd>
+<dt>
+ <code>arm64</code>, <code>arm</code>
+</dt>
+<dd>
+ The <code>ARM</code> instruction set, 64-bit (<code>AArch64</code>) and 32-bit.
+</dd>
+<dt>
+ <code>mips64</code>, <code>mips64le</code>, <code>mips</code>, <code>mipsle</code>
+</dt>
+<dd>
+ The <code>MIPS</code> instruction set, big- and little-endian, 64- and 32-bit.
+</dd>
+<dt>
+ <code>ppc64</code>, <code>ppc64le</code>
+</dt>
+<dd>
+ The 64-bit PowerPC instruction set, big- and little-endian.
+</dd>
+<dt>
+ <code>riscv64</code>
+</dt>
+<dd>
+ The 64-bit RISC-V instruction set.
+</dd>
+<dt>
+ <code>s390x</code>
+</dt>
+<dd>
+ The IBM z/Architecture.
+</dd>
+<dt>
+ <code>wasm</code>
+</dt>
+<dd>
+ <a href="https://webassembly.org">WebAssembly</a>.
+</dd>
+</dl>
+</p>
+
+<p>
+The compilers can target the AIX, Android, DragonFly BSD, FreeBSD,
+Illumos, Linux, macOS/iOS (Darwin), NetBSD, OpenBSD, Plan 9, Solaris,
+and Windows operating systems (although not all operating systems
+support all architectures).
+</p>
+
+<p>
+A list of ports which are considered "first class" is available at the
+<a href="/wiki/PortingPolicy#first-class-ports">first class ports</a>
+wiki page.
+</p>
+
+<p>
+The full set of supported combinations is listed in the
+discussion of <a href="#environment">environment variables</a> below.
+</p>
+
+<p>
+See the main installation page for the <a href="/doc/install#requirements">overall system requirements</a>.
+The following additional constraints apply to systems that can be built only from source:
+</p>
+
+<ul>
+<li>For Linux on PowerPC 64-bit, the minimum supported kernel version is 2.6.37, meaning that
+Go does not support CentOS 6 on these systems.
+</li>
+</ul>
+
+</div>
+
+<h2 id="go14">Install Go compiler binaries for bootstrap</h2>
+
+<p>
+The Go toolchain is written in Go. To build it, you need a Go compiler installed.
+The scripts that do the initial build of the tools look for a "go" command
+in <code>$PATH</code>, so as long as you have Go installed in your
+system and configured in your <code>$PATH</code>, you are ready to build Go
+from source.
+Or if you prefer you can set <code>$GOROOT_BOOTSTRAP</code> to the
+root of a Go installation to use to build the new Go toolchain;
+<code>$GOROOT_BOOTSTRAP/bin/go</code> should be the go command to use.</p>
+
+<p>
+There are four possible ways to obtain a bootstrap toolchain:
+</p>
+
+<ul>
+<li>Download a recent binary release of Go.
+<li>Cross-compile a toolchain using a system with a working Go installation.
+<li>Use gccgo.
+<li>Compile a toolchain from Go 1.4, the last Go release with a compiler written in C.
+</ul>
+
+<p>
+These approaches are detailed below.
+</p>
+
+<h3 id="bootstrapFromBinaryRelease">Bootstrap toolchain from binary release</h3>
+
+<p>
+To use a binary release as a bootstrap toolchain, see
+<a href="/dl/">the downloads page</a> or use any other
+packaged Go distribution.
+</p>
+
+<h3 id="bootstrapFromCrosscompiledSource">Bootstrap toolchain from cross-compiled source</h3>
+
+<p>
+To cross-compile a bootstrap toolchain from source, which is
+necessary on systems Go 1.4 did not target (for
+example, <code>linux/ppc64le</code>), install Go on a different system
+and run <a href="/src/bootstrap.bash">bootstrap.bash</a>.
+</p>
+
+<p>
+When run as (for example)
+</p>
+
+<pre>
+$ GOOS=linux GOARCH=ppc64 ./bootstrap.bash
+</pre>
+
+<p>
+<code>bootstrap.bash</code> cross-compiles a toolchain for that <code>GOOS/GOARCH</code>
+combination, leaving the resulting tree in <code>../../go-${GOOS}-${GOARCH}-bootstrap</code>.
+That tree can be copied to a machine of the given target type
+and used as <code>GOROOT_BOOTSTRAP</code> to bootstrap a local build.
+</p>
+
+<h3 id="bootstrapFromGccgo">Bootstrap toolchain using gccgo</h3>
+
+<p>
+To use gccgo as the bootstrap toolchain, you need to arrange
+for <code>$GOROOT_BOOTSTRAP/bin/go</code> to be the go tool that comes
+as part of gccgo 5. For example on Ubuntu Vivid:
+</p>
+
+<pre>
+$ sudo apt-get install gccgo-5
+$ sudo update-alternatives --set go /usr/bin/go-5
+$ GOROOT_BOOTSTRAP=/usr ./make.bash
+</pre>
+
+<h3 id="bootstrapFromSource">Bootstrap toolchain from C source code</h3>
+
+<p>
+To build a bootstrap toolchain from C source code, use
+either the git branch <code>release-branch.go1.4</code> or
+<a href="https://dl.google.com/go/go1.4-bootstrap-20171003.tar.gz">go1.4-bootstrap-20171003.tar.gz</a>,
+which contains the Go 1.4 source code plus accumulated fixes
+to keep the tools running on newer operating systems.
+(Go 1.4 was the last distribution in which the toolchain was written in C.)
+After unpacking the Go 1.4 source, <code>cd</code> to
+the <code>src</code> subdirectory, set <code>CGO_ENABLED=0</code> in
+the environment, and run <code>make.bash</code> (or,
+on Windows, <code>make.bat</code>).
+</p>
+
+<p>
+Once the Go 1.4 source has been unpacked into your GOROOT_BOOTSTRAP directory,
+you must keep this git clone instance checked out to branch
+<code>release-branch.go1.4</code>. Specifically, do not attempt to reuse
+this git clone in the later step named "Fetch the repository." The go1.4
+bootstrap toolchain <b>must be able</b> to properly traverse the go1.4 sources
+that it assumes are present under this repository root.
+</p>
+
+<p>
+Note that Go 1.4 does not run on all systems that later versions of Go do.
+In particular, Go 1.4 does not support current versions of macOS.
+On such systems, the bootstrap toolchain must be obtained using one of the other methods.
+</p>
+
+<h2 id="git">Install Git, if needed</h2>
+
+<p>
+To perform the next step you must have Git installed. (Check that you
+have a <code>git</code> command before proceeding.)
+</p>
+
+<p>
+If you do not have a working Git installation,
+follow the instructions on the
+<a href="https://git-scm.com/downloads">Git downloads</a> page.
+</p>
+
+<h2 id="ccompiler">(Optional) Install a C compiler</h2>
+
+<p>
+To build a Go installation
+with <code><a href="/cmd/cgo">cgo</a></code> support, which permits Go
+programs to import C libraries, a C compiler such as <code>gcc</code>
+or <code>clang</code> must be installed first. Do this using whatever
+installation method is standard on the system.
+</p>
+
+<p>
+To build without <code>cgo</code>, set the environment variable
+<code>CGO_ENABLED=0</code> before running <code>all.bash</code> or
+<code>make.bash</code>.
+</p>
+
+<h2 id="fetch">Fetch the repository</h2>
+
+<p>Change to the directory where you intend to install Go, and make sure
+the <code>goroot</code> directory does not exist. Then clone the repository
+and check out the latest release tag (<code class="versionTag">go1.12</code>,
+for example):</p>
+
+<pre>
+$ git clone https://go.googlesource.com/go goroot
+$ cd goroot
+$ git checkout <span class="versionTag"><i><tag></i></span>
+</pre>
+
+<p class="whereTag">
+Where <code><tag></code> is the version string of the release.
+</p>
+
+<p>Go will be installed in the directory where it is checked out. For example,
+if Go is checked out in <code>$HOME/goroot</code>, executables will be installed
+in <code>$HOME/goroot/bin</code>. The directory may have any name, but note
+that if Go is checked out in <code>$HOME/go</code>, it will conflict with
+the default location of <code>$GOPATH</code>.
+See <a href="#gopath"><code>GOPATH</code></a> below.</p>
+
+<p>
+Reminder: If you opted to also compile the bootstrap binaries from source (in an
+earlier section), you still need to <code>git clone</code> again at this point
+(to checkout the latest <code><tag></code>), because you must keep your
+go1.4 repository distinct.
+</p>
+
+<h2 id="head">(Optional) Switch to the master branch</h2>
+
+<p>If you intend to modify the go source code, and
+<a href="/doc/contribute.html">contribute your changes</a>
+to the project, then move your repository
+off the release tag, and onto the master (development) branch.
+Otherwise, skip this step.</p>
+
+<pre>
+$ git checkout master
+</pre>
+
+<h2 id="install">Install Go</h2>
+
+<p>
+To build the Go distribution, run
+</p>
+
+<pre>
+$ cd src
+$ ./all.bash
+</pre>
+
+<p>
+(To build under Windows use <code>all.bat</code>.)
+</p>
+
+<p>
+If all goes well, it will finish by printing output like:
+</p>
+
+<pre>
+ALL TESTS PASSED
+
+---
+Installed Go for linux/amd64 in /home/you/go.
+Installed commands in /home/you/go/bin.
+*** You need to add /home/you/go/bin to your $PATH. ***
+</pre>
+
+<p>
+where the details on the last few lines reflect the operating system,
+architecture, and root directory used during the install.
+</p>
+
+<div class="detail">
+<p>
+For more information about ways to control the build, see the discussion of
+<a href="#environment">environment variables</a> below.
+<code>all.bash</code> (or <code>all.bat</code>) runs important tests for Go,
+which can take more time than simply building Go. If you do not want to run
+the test suite use <code>make.bash</code> (or <code>make.bat</code>)
+instead.
+</p>
+</div>
+
+
+<h2 id="testing">Testing your installation</h2>
+
+<p>
+Check that Go is installed correctly by building a simple program.
+</p>
+
+<p>
+Create a file named <code>hello.go</code> and put the following program in it:
+</p>
+
+<pre>
+package main
+
+import "fmt"
+
+func main() {
+ fmt.Printf("hello, world\n")
+}
+</pre>
+
+<p>
+Then run it with the <code>go</code> tool:
+</p>
+
+<pre>
+$ go run hello.go
+hello, world
+</pre>
+
+<p>
+If you see the "hello, world" message then Go is installed correctly.
+</p>
+
+<h2 id="gopath">Set up your work environment</h2>
+
+<p>
+You're almost done.
+You just need to do a little more setup.
+</p>
+
+<p>
+<a href="/doc/code.html" class="download" id="start">
+<span class="big">How to Write Go Code</span>
+<span class="desc">Learn how to set up and use the Go tools</span>
+</a>
+</p>
+
+<p>
+The <a href="/doc/code.html">How to Write Go Code</a> document
+provides <b>essential setup instructions</b> for using the Go tools.
+</p>
+
+
+<h2 id="tools">Install additional tools</h2>
+
+<p>
+The source code for several Go tools (including <a href="/cmd/godoc/">godoc</a>)
+is kept in <a href="https://golang.org/x/tools">the go.tools repository</a>.
+To install one of the tools (<code>godoc</code> in this case):
+</p>
+
+<pre>
+$ go get golang.org/x/tools/cmd/godoc
+</pre>
+
+<p>
+To install these tools, the <code>go</code> <code>get</code> command requires
+that <a href="#git">Git</a> be installed locally.
+</p>
+
+<p>
+You must also have a workspace (<code>GOPATH</code>) set up;
+see <a href="/doc/code.html">How to Write Go Code</a> for the details.
+</p>
+
+<h2 id="community">Community resources</h2>
+
+<p>
+The usual community resources such as
+<code>#go-nuts</code> on the <a href="https://freenode.net/">Freenode</a> IRC server
+and the
+<a href="//groups.google.com/group/golang-nuts">Go Nuts</a>
+mailing list have active developers that can help you with problems
+with your installation or your development work.
+For those who wish to keep up to date,
+there is another mailing list, <a href="//groups.google.com/group/golang-checkins">golang-checkins</a>,
+that receives a message summarizing each checkin to the Go repository.
+</p>
+
+<p>
+Bugs can be reported using the <a href="//golang.org/issue/new">Go issue tracker</a>.
+</p>
+
+
+<h2 id="releases">Keeping up with releases</h2>
+
+<p>
+New releases are announced on the
+<a href="//groups.google.com/group/golang-announce">golang-announce</a>
+mailing list.
+Each announcement mentions the latest release tag, for instance,
+<code class="versionTag">go1.9</code>.
+</p>
+
+<p>
+To update an existing tree to the latest release, you can run:
+</p>
+
+<pre>
+$ cd go/src
+$ git fetch
+$ git checkout <span class="versionTag"><i><tag></i></psan>
+$ ./all.bash
+</pre>
+
+<p class="whereTag">
+Where <code><tag></code> is the version string of the release.
+</p>
+
+
+<h2 id="environment">Optional environment variables</h2>
+
+<p>
+The Go compilation environment can be customized by environment variables.
+<i>None is required by the build</i>, but you may wish to set some
+to override the defaults.
+</p>
+
+<ul>
+<li><code>$GOROOT</code>
+<p>
+The root of the Go tree, often <code>$HOME/go1.X</code>.
+Its value is built into the tree when it is compiled, and
+defaults to the parent of the directory where <code>all.bash</code> was run.
+There is no need to set this unless you want to switch between multiple
+local copies of the repository.
+</p>
+</li>
+
+<li><code>$GOROOT_FINAL</code>
+<p>
+The value assumed by installed binaries and scripts when
+<code>$GOROOT</code> is not set explicitly.
+It defaults to the value of <code>$GOROOT</code>.
+If you want to build the Go tree in one location
+but move it elsewhere after the build, set
+<code>$GOROOT_FINAL</code> to the eventual location.
+</p>
+</li>
+
+<li id="gopath"><code>$GOPATH</code>
+<p>
+The directory where Go projects outside the Go distribution are typically
+checked out. For example, <code>golang.org/x/tools</code> might be checked out
+to <code>$GOPATH/src/golang.org/x/tools</code>. Executables outside the
+Go distribution are installed in <code>$GOPATH/bin</code> (or
+<code>$GOBIN</code>, if set). Modules are downloaded and cached in
+<code>$GOPATH/pkg/mod</code>.
+</p>
+
+<p>The default location of <code>$GOPATH</code> is <code>$HOME/go</code>,
+and it's not usually necessary to set <code>GOPATH</code> explicitly. However,
+if you have checked out the Go distribution to <code>$HOME/go</code>,
+you must set <code>GOPATH</code> to another location to avoid conflicts.
+</p>
+</li>
+
+<li><code>$GOBIN</code>
+<p>
+The directory where executables outside the Go distribution are installed
+using the <a href="/cmd/go">go command</a>. For example,
+<code>go get golang.org/x/tools/cmd/godoc</code> downloads, builds, and
+installs <code>$GOBIN/godoc</code>. By default, <code>$GOBIN</code> is
+<code>$GOPATH/bin</code> (or <code>$HOME/go/bin</code> if <code>GOPATH</code>
+is not set). After installing, you will want to add this directory to
+your <code>$PATH</code> so you can use installed tools.
+</p>
+
+<p>
+Note that the Go distribution's executables are installed in
+<code>$GOROOT/bin</code> (for executables invoked by people) or
+<code>$GOTOOLDIR</code> (for executables invoked by the go command;
+defaults to <code>$GOROOT/pkg/$GOOS_$GOARCH</code>) instead of
+<code>$GOBIN</code>.
+</p>
+</li>
+
+<li><code>$GOOS</code> and <code>$GOARCH</code>
+<p>
+The name of the target operating system and compilation architecture.
+These default to the values of <code>$GOHOSTOS</code> and
+<code>$GOHOSTARCH</code> respectively (described below).
+</li>
+
+<p>
+Choices for <code>$GOOS</code> are
+<code>android</code>, <code>darwin</code>, <code>dragonfly</code>,
+<code>freebsd</code>, <code>illumos</code>, <code>ios</code>, <code>js</code>,
+<code>linux</code>, <code>netbsd</code>, <code>openbsd</code>,
+<code>plan9</code>, <code>solaris</code> and <code>windows</code>.
+</p>
+
+<p>
+Choices for <code>$GOARCH</code> are
+<code>amd64</code> (64-bit x86, the most mature port),
+<code>386</code> (32-bit x86), <code>arm</code> (32-bit ARM), <code>arm64</code> (64-bit ARM),
+<code>ppc64le</code> (PowerPC 64-bit, little-endian), <code>ppc64</code> (PowerPC 64-bit, big-endian),
+<code>mips64le</code> (MIPS 64-bit, little-endian), <code>mips64</code> (MIPS 64-bit, big-endian),
+<code>mipsle</code> (MIPS 32-bit, little-endian), <code>mips</code> (MIPS 32-bit, big-endian),
+<code>s390x</code> (IBM System z 64-bit, big-endian), and
+<code>wasm</code> (WebAssembly 32-bit).
+</p>
+
+<p>
+The valid combinations of <code>$GOOS</code> and <code>$GOARCH</code> are:
+<table cellpadding="0">
+<tr>
+<th width="50"></th><th align="left" width="100"><code>$GOOS</code></th> <th align="left" width="100"><code>$GOARCH</code></th>
+</tr>
+<tr>
+<td></td><td><code>aix</code></td> <td><code>ppc64</code></td>
+</tr>
+<tr>
+<td></td><td><code>android</code></td> <td><code>386</code></td>
+</tr>
+<tr>
+<td></td><td><code>android</code></td> <td><code>amd64</code></td>
+</tr>
+<tr>
+<td></td><td><code>android</code></td> <td><code>arm</code></td>
+</tr>
+<tr>
+<td></td><td><code>android</code></td> <td><code>arm64</code></td>
+</tr>
+<tr>
+<td></td><td><code>darwin</code></td> <td><code>amd64</code></td>
+</tr>
+<tr>
+<td></td><td><code>darwin</code></td> <td><code>arm64</code></td>
+</tr>
+<tr>
+<td></td><td><code>dragonfly</code></td> <td><code>amd64</code></td>
+</tr>
+<tr>
+<td></td><td><code>freebsd</code></td> <td><code>386</code></td>
+</tr>
+<tr>
+<td></td><td><code>freebsd</code></td> <td><code>amd64</code></td>
+</tr>
+<tr>
+<td></td><td><code>freebsd</code></td> <td><code>arm</code></td>
+</tr>
+<tr>
+<td></td><td><code>illumos</code></td> <td><code>amd64</code></td>
+</tr>
+<tr>
+<td></td><td><code>ios</code></td> <td><code>arm64</code></td>
+</tr>
+<tr>
+<td></td><td><code>js</code></td> <td><code>wasm</code></td>
+</tr>
+<tr>
+<td></td><td><code>linux</code></td> <td><code>386</code></td>
+</tr>
+<tr>
+<td></td><td><code>linux</code></td> <td><code>amd64</code></td>
+</tr>
+<tr>
+<td></td><td><code>linux</code></td> <td><code>arm</code></td>
+</tr>
+<tr>
+<td></td><td><code>linux</code></td> <td><code>arm64</code></td>
+</tr>
+<tr>
+<td></td><td><code>linux</code></td> <td><code>ppc64</code></td>
+</tr>
+<tr>
+<td></td><td><code>linux</code></td> <td><code>ppc64le</code></td>
+</tr>
+<tr>
+<td></td><td><code>linux</code></td> <td><code>mips</code></td>
+</tr>
+<tr>
+<td></td><td><code>linux</code></td> <td><code>mipsle</code></td>
+</tr>
+<tr>
+<td></td><td><code>linux</code></td> <td><code>mips64</code></td>
+</tr>
+<tr>
+<td></td><td><code>linux</code></td> <td><code>mips64le</code></td>
+</tr>
+<tr>
+<td></td><td><code>linux</code></td> <td><code>riscv64</code></td>
+</tr>
+<tr>
+<td></td><td><code>linux</code></td> <td><code>s390x</code></td>
+</tr>
+<tr>
+<td></td><td><code>netbsd</code></td> <td><code>386</code></td>
+</tr>
+<tr>
+<td></td><td><code>netbsd</code></td> <td><code>amd64</code></td>
+</tr>
+<tr>
+<td></td><td><code>netbsd</code></td> <td><code>arm</code></td>
+</tr>
+<tr>
+<td></td><td><code>openbsd</code></td> <td><code>386</code></td>
+</tr>
+<tr>
+<td></td><td><code>openbsd</code></td> <td><code>amd64</code></td>
+</tr>
+<tr>
+<td></td><td><code>openbsd</code></td> <td><code>arm</code></td>
+</tr>
+<tr>
+<td></td><td><code>openbsd</code></td> <td><code>arm64</code></td>
+</tr>
+<tr>
+<td></td><td><code>plan9</code></td> <td><code>386</code></td>
+</tr>
+<tr>
+<td></td><td><code>plan9</code></td> <td><code>amd64</code></td>
+</tr>
+<tr>
+<td></td><td><code>plan9</code></td> <td><code>arm</code></td>
+</tr>
+<tr>
+<td></td><td><code>solaris</code></td> <td><code>amd64</code></td>
+</tr>
+<tr>
+<td></td><td><code>windows</code></td> <td><code>386</code></td>
+</tr>
+<tr>
+<td></td><td><code>windows</code></td> <td><code>amd64</code></td>
+</tr>
+</table>
+<br>
+
+<li><code>$GOHOSTOS</code> and <code>$GOHOSTARCH</code>
+<p>
+The name of the host operating system and compilation architecture.
+These default to the local system's operating system and
+architecture.
+</p>
+</li>
+
+<p>
+Valid choices are the same as for <code>$GOOS</code> and
+<code>$GOARCH</code>, listed above.
+The specified values must be compatible with the local system.
+For example, you should not set <code>$GOHOSTARCH</code> to
+<code>arm</code> on an x86 system.
+</p>
+
+<li><code>$GO386</code> (for <code>386</code> only, defaults to <code>sse2</code>)
+<p>
+This variable controls how gc implements floating point computations.
+</p>
+<ul>
+ <li><code>GO386=softfloat</code>: use software floating point operations; should support all x86 chips (Pentium MMX or later).</li>
+ <li><code>GO386=sse2</code>: use SSE2 for floating point operations; has better performance but only available on Pentium 4/Opteron/Athlon 64 or later.</li>
+</ul>
+</li>
+
+<li><code>$GOARM</code> (for <code>arm</code> only; default is auto-detected if building
+on the target processor, 6 if not)
+<p>
+This sets the ARM floating point co-processor architecture version the run-time
+should target. If you are compiling on the target system, its value will be auto-detected.
+</p>
+<ul>
+ <li><code>GOARM=5</code>: use software floating point; when CPU doesn't have VFP co-processor</li>
+ <li><code>GOARM=6</code>: use VFPv1 only; default if cross compiling; usually ARM11 or better cores (VFPv2 or better is also supported)</li>
+ <li><code>GOARM=7</code>: use VFPv3; usually Cortex-A cores</li>
+</ul>
+<p>
+If in doubt, leave this variable unset, and adjust it if required
+when you first run the Go executable.
+The <a href="//golang.org/wiki/GoArm">GoARM</a> page
+on the <a href="//golang.org/wiki">Go community wiki</a>
+contains further details regarding Go's ARM support.
+</p>
+</li>
+
+<li><code>$GOMIPS</code> (for <code>mips</code> and <code>mipsle</code> only) <br> <code>$GOMIPS64</code> (for <code>mips64</code> and <code>mips64le</code> only)
+<p>
+ These variables set whether to use floating point instructions. Set to "<code>hardfloat</code>" to use floating point instructions; this is the default. Set to "<code>softfloat</code>" to use soft floating point.
+</p>
+</li>
+
+<li><code>$GOPPC64</code> (for <code>ppc64</code> and <code>ppc64le</code> only)
+<p>
+This variable sets the processor level (i.e. Instruction Set Architecture version)
+for which the compiler will target. The default is <code>power8</code>.
+</p>
+<ul>
+ <li><code>GOPPC64=power8</code>: generate ISA v2.07 instructions</li>
+ <li><code>GOPPC64=power9</code>: generate ISA v3.00 instructions</li>
+</ul>
+</li>
+
+
+<li><code>$GOWASM</code> (for <code>wasm</code> only)
+ <p>
+ This variable is a comma separated list of <a href="https://github.com/WebAssembly/proposals">experimental WebAssembly features</a> that the compiled WebAssembly binary is allowed to use.
+ The default is to use no experimental features.
+ </p>
+ <ul>
+ <li><code>GOWASM=satconv</code>: generate <a href="https://github.com/WebAssembly/nontrapping-float-to-int-conversions/blob/master/proposals/nontrapping-float-to-int-conversion/Overview.md">saturating (non-trapping) float-to-int conversions</a></li>
+ <li><code>GOWASM=signext</code>: generate <a href="https://github.com/WebAssembly/sign-extension-ops/blob/master/proposals/sign-extension-ops/Overview.md">sign-extension operators</a></li>
+ </ul>
+</li>
+
+</ul>
+
+<p>
+Note that <code>$GOARCH</code> and <code>$GOOS</code> identify the
+<em>target</em> environment, not the environment you are running on.
+In effect, you are always cross-compiling.
+By architecture, we mean the kind of binaries
+that the target environment can run:
+an x86-64 system running a 32-bit-only operating system
+must set <code>GOARCH</code> to <code>386</code>,
+not <code>amd64</code>.
+</p>
+
+<p>
+If you choose to override the defaults,
+set these variables in your shell profile (<code>$HOME/.bashrc</code>,
+<code>$HOME/.profile</code>, or equivalent). The settings might look
+something like this:
+</p>
+
+<pre>
+export GOARCH=amd64
+export GOOS=linux
+</pre>
+
+<p>
+although, to reiterate, none of these variables needs to be set to build,
+install, and develop the Go tree.
+</p>
diff --git a/_content/doc/install.html b/_content/doc/install.html
new file mode 100644
index 0000000..f669542
--- /dev/null
+++ b/_content/doc/install.html
@@ -0,0 +1,206 @@
+<!--{
+ "Title": "Download and install"
+}-->
+<p>
+ Download and install Go quickly with the steps described here.
+</p>
+<p>For other content on installing, you might be interested in:</p>
+<ul>
+ <li>
+ <a href="/doc/manage-install.html">Managing Go installations</a> -- How to
+ install multiple versions and uninstall.
+ </li>
+ <li>
+ <a href="/doc/install-source.html">Installing Go from source</a> -- How to
+ check out the sources, build them on your own machine, and run them.
+ </li>
+</ul>
+<h2 id="download">1. Go download.</h2>
+<p>
+ Click the button below to download the Go installer.
+</p>
+<p>
+ <a href="/dl/" id="start" class="download js-download">
+ <span id="download-button" class="big js-downloadButton">Download Go</span>
+ <span id="download-description" class="desc js-downloadDescription"></span>
+ </a>
+</p>
+<p>
+ Don't see your operating system here? Try one of the
+ <a href="https://golang.org/dl/">other downloads</a>.
+</p>
+<aside class="Note">
+ <strong>Note:</strong> By default, the <code>go</code> command downloads and
+ authenticates modules using the Go module mirror and Go checksum database
+ run by Google. <a href="https://golang.org/dl">Learn more.</a>
+</aside>
+<h2 id="install">2. Go install.</h2>
+<p>
+ Select the tab for your computer's operating system below, then follow its
+ installation instructions.
+</p>
+<div id="os-install-tabs" class="TabSection js-tabSection">
+ <div id="os-install-tablist" class="TabSection-tabList" role="tablist">
+ <button
+ role="tab"
+ aria-selected="true"
+ aria-controls="linux-tab"
+ id="linux"
+ tabindex="0"
+ class="TabSection-tab active"
+ >
+ Linux
+ </button>
+ <button
+ role="tab"
+ aria-selected="false"
+ aria-controls="mac-tab"
+ id="mac"
+ tabindex="-1"
+ class="TabSection-tab"
+ >
+ Mac
+ </button>
+ <button
+ role="tab"
+ aria-selected="false"
+ aria-controls="windows-tab"
+ id="windows"
+ tabindex="-1"
+ class="TabSection-tab"
+ >
+ Windows
+ </button>
+ </div>
+ <div
+ role="tabpanel"
+ id="linux-tab"
+ class="TabSection-tabPanel"
+ aria-labelledby="linux"
+ >
+ <ol>
+ <li>
+ Extract the archive you downloaded into /usr/local, creating a Go tree
+ in /usr/local/go.
+ <p>
+ <strong>Important:</strong> This step will remove a previous
+ installation at /usr/local/go, if any, prior to extracting.
+ Please back up any data before proceeding.
+ </p>
+ <p>
+ For example, run the following as root or through <code>sudo</code>:
+ </p>
+ <pre>
+rm -rf /usr/local/go && tar -C /usr/local -xzf <span id="linux-filename">go1.14.3.linux-amd64.tar.gz</span>
+</pre
+ >
+ </li>
+ <li>
+ Add /usr/local/go/bin to the <code>PATH</code> environment variable.
+ <p>
+ You can do this by adding the following line to your $HOME/.profile or
+ /etc/profile (for a system-wide installation):
+ </p>
+ <pre>
+export PATH=$PATH:/usr/local/go/bin
+</pre
+ >
+ <p>
+ <strong>Note:</strong> Changes made to a profile file may not apply
+ until the next time you log into your computer. To apply the changes
+ immediately, just run the shell commands directly or execute them from
+ the profile using a command such as
+ <code>source $HOME/.profile</code>.
+ </p>
+ </li>
+ <li>
+ Verify that you've installed Go by opening a command prompt and typing
+ the following command:
+ <pre>
+$ go version
+</pre
+ >
+ </li>
+ <li>Confirm that the command prints the installed version of Go.</li>
+ </ol>
+ </div>
+ <div
+ role="tabpanel"
+ id="mac-tab"
+ class="TabSection-tabPanel"
+ aria-labelledby="mac"
+ hidden
+ >
+ <ol>
+ <li>
+ Open the package file you downloaded and follow the prompts to install
+ Go.
+ <p>
+ The package installs the Go distribution to /usr/local/go. The package
+ should put the /usr/local/go/bin directory in your
+ <code>PATH</code> environment variable. You may need to restart any
+ open Terminal sessions for the change to take effect.
+ </p>
+ </li>
+ <li>
+ Verify that you've installed Go by opening a command prompt and typing
+ the following command:
+ <pre>
+$ go version
+</pre
+ >
+ </li>
+ <li>Confirm that the command prints the installed version of Go.</li>
+ </ol>
+ </div>
+ <div
+ role="tabpanel"
+ id="windows-tab"
+ class="TabSection-tabPanel"
+ aria-labelledby="windows"
+ hidden
+ >
+ <ol>
+ <li>
+ Open the MSI file you downloaded and follow the prompts to install Go.
+ <p>
+ By default, the installer will install Go to <code>Program Files</code>
+ or <code>Program Files (x86)</code>. You can change the
+ location as needed. After installing, you will need to close and
+ reopen any open command prompts so that changes to the environment
+ made by the installer are reflected at the command prompt.
+ </p>
+ </li>
+ <li>
+ Verify that you've installed Go.
+ <ol>
+ <li>
+ In <strong>Windows</strong>, click the <strong>Start</strong> menu.
+ </li>
+ <li>
+ In the menu's search box, type <code>cmd</code>, then press the
+ <strong>Enter</strong> key.
+ </li>
+ <li>
+ In the Command Prompt window that appears, type the following
+ command:
+ <pre>
+$ go version
+</pre
+ >
+ </li>
+ <li>Confirm that the command prints the installed version of Go.</li>
+ </ol>
+ </li>
+ </ol>
+ </div>
+</div>
+<h2 id="code">3. Go code.</h2>
+<p>
+ You're set up! Visit the
+ <a href="tutorial/getting-started.html">Getting Started tutorial</a> to write
+ some simple Go code. It takes about 10 minutes to complete.
+</p>
+
+<script async src="/doc/download.js"></script>
+<script async src="/doc/hats.js"></script>
diff --git a/_content/doc/manage-install.html b/_content/doc/manage-install.html
new file mode 100644
index 0000000..c1ff35b
--- /dev/null
+++ b/_content/doc/manage-install.html
@@ -0,0 +1,116 @@
+<!--{
+ "Title": "Managing Go installations"
+}-->
+
+<p>
+This topic describes how to install multiple versions of Go on the same machine, as well as how to uninstall Go.
+</p>
+
+<p>For other content on installing, you might be interested in:</p>
+<ul>
+<li><a href="/doc/install.html">Download and install</a> -- The simplest way to get installed and running.</li>
+<li><a href="/doc/install-source.html">Installing Go from source</a> -- How to check out the sources, build them on your own machine, and run them.</li>
+</ul>
+
+<h2 id="installing-multiple">Installing multiple Go versions</h2>
+
+<p>
+You can install multiple Go versions on the same machine. For example, you might want to test your code on multiple Go versions. For a list of versions you can install this way, see the <a href="https://golang.org/dl/">download page</a>.
+</p>
+
+<p>
+<strong>Note:</strong> To install using the method described here, you'll need to have <a href="https://git-scm.com/">git</a> installed.
+</p>
+
+<p>
+To install additional Go versions, run the <a href="/cmd/go/#hdr-Add_dependencies_to_current_module_and_install_them"><code>go get</code> command</a>, specifying the download location of the version you want to install. The following example illustrates with version 1.10.7:
+</p>
+
+<pre>
+$ go get golang.org/dl/go1.10.7
+$ go1.10.7 download
+</pre>
+
+<p>
+To run <code>go</code> commands with the newly-downloaded version, append the version number to the <code>go</code> command, as follows:
+</p>
+
+<pre>
+$ go1.10.7 version
+go version go1.10.7 linux/amd64
+</pre>
+
+<p>
+When you have multiple versions installed, you can discover where each is installed, look at the version's <code>GOROOT</code> value. For example, run a command such as the following:
+</p>
+
+<pre>
+$ go1.10.7 env GOROOT
+</pre>
+
+<p>
+To uninstall a downloaded version, just remove the directory specified by its <code>GOROOT</code> environment variable and the goX.Y.Z binary.
+</p>
+
+<h2 id="uninstalling">Uninstalling Go</h2>
+
+<p>
+You can remove Go from your system using the steps described in this topic.
+</p>
+
+<h3 id="linux-mac-bsd">Linux / macOS / FreeBSD</h3>
+
+<ol>
+
+<li>Delete the go directory.
+
+<p>
+This is usually /usr/local/go.
+</p>
+
+</li>
+
+<li>Remove the Go bin directory from your <code>PATH</code> environment variable.
+
+<p>
+Under Linux and FreeBSD, edit /etc/profile or $HOME/.profile. If you installed Go with the macOS package, remove the /etc/paths.d/go file.
+</p>
+
+</li>
+
+</ol>
+
+<h3 id="windows">Windows</h3>
+
+<p>
+The simplest way to remove Go is via Add/Remove Programs in the Windows control panel:
+</p>
+
+<ol>
+
+<li>In Control Panel, double-click <strong>Add/Remove Programs</strong>.</li>
+<li>In <strong>Add/Remove Programs</strong>, select <strong>Go Programming Language,</strong> click Uninstall, then follow the prompts.</li>
+
+</ol>
+
+<p>
+For removing Go with tools, you can also use the command line:
+</p>
+
+<ul>
+
+<li>Uninstall using the command line by running the following command:
+
+<pre>
+msiexec /x go{{version}}.windows-{{cpu-arch}}.msi /q
+</pre>
+
+<p>
+
+<strong>Note:</strong> Using this uninstall process for Windows will automatically remove windows environment variables created by the original installation.
+</p>
+
+</li>
+
+</ul>
+
diff --git a/_content/doc/mod.md b/_content/doc/mod.md
new file mode 100644
index 0000000..c2faf26
--- /dev/null
+++ b/_content/doc/mod.md
@@ -0,0 +1,3940 @@
+<!--{
+ "Title": "Go Modules Reference",
+ "Path": "/ref/mod"
+}-->
+<!-- TODO(golang.org/issue/33637): Write focused "guide" articles on specific
+module topics and tasks. Link to those instead of the blog, which will probably
+not be updated over time. -->
+
+## Introduction {#introduction}
+
+Modules are how Go manages dependencies.
+
+This document is a detailed reference manual for Go's module system. For an
+introduction to creating Go projects, see [How to Write Go
+Code](https://golang.org/doc/code.html). For information on using modules,
+migrating projects to modules, and other topics, see the blog series starting
+with [Using Go Modules](https://blog.golang.org/using-go-modules).
+
+## Modules, packages, and versions {#modules-overview}
+
+A <dfn>module</dfn> is a collection of packages that are released, versioned,
+and distributed together. Modules may be downloaded directly from version
+control repositories or from module proxy servers.
+
+A module is identified by a [module path](#glos-module-path), which is declared
+in a [`go.mod` file](#go-mod-file), together with information about the
+module's dependencies. The <dfn>module root directory</dfn> is the directory
+that contains the `go.mod` file. The <dfn>main module</dfn> is the module
+containing the directory where the `go` command is invoked.
+
+Each <dfn>package</dfn> within a module is a collection of source files in the
+same directory that are compiled together. A <dfn>package path</dfn> is the
+module path joined with the subdirectory containing the package (relative to the
+module root). For example, the module `"golang.org/x/net"` contains a package in
+the directory `"html"`. That package's path is `"golang.org/x/net/html"`.
+
+### Module paths {#module-path}
+
+A <dfn>module path</dfn> is the canonical name for a module, declared with the
+[`module` directive](#go-mod-file-module) in the module's [`go.mod`
+file](#glos-go-mod-file). A module's path is the prefix for package paths within
+the module.
+
+A module path should describe both what the module does and where to find it.
+Typically, a module path consists of a repository root path, a directory within
+the repository (usually empty), and a major version suffix (only for major
+version 2 or higher).
+
+* The <dfn>repository root path</dfn> is the portion of the module path that
+ corresponds to the root directory of the version control repository where the
+ module is developed. Most modules are defined in their repository's root
+ directory, so this is usually the entire path. For example,
+ `golang.org/x/net` is the repository root path for the module of the same
+ name. See [Finding a repository for a module path](#vcs-find) for information
+ on how the `go` command locates a repository using HTTP requests derived
+ from a module path.
+* If the module is not defined in the repository's root directory, the
+ <dfn>module subdirectory</dfn> is the part of the module path that names the
+ directory, not including the major version suffix. This also serves as a
+ prefix for semantic version tags. For example, the module
+ `golang.org/x/tools/gopls` is in the `gopls` subdirectory of the repository
+ with root path `golang.org/x/tools`, so it has the module subdirectory
+ `gopls`. See [Mapping versions to commits](#vcs-version) and [Module
+ directories within a repository](#vcs-dir).
+* If the module is released at major version 2 or higher, the module path must
+ end with a [major version suffix](#major-version-suffixes) like
+ `/v2`. This may or may not be part of the subdirectory name. For example, the
+ module with path `golang.org/x/repo/sub/v2` could be in the `/sub` or
+ `/sub/v2` subdirectory of the repository `golang.org/x/repo`.
+
+If a module might be depended on by other modules, these rules must be followed
+so that the `go` command can find and download the module. There are also
+several [lexical restrictions](#go-mod-file-ident) on characters allowed in
+module paths.
+
+### Versions {#versions}
+
+A <dfn>version</dfn> identifies an immutable snapshot of a module, which may be
+either a [release](#glos-release-version) or a
+[pre-release](#glos-pre-release-version). Each version starts with the letter
+`v`, followed by a semantic version. See [Semantic Versioning
+2.0.0](https://semver.org/spec/v2.0.0.html) for details on how versions are
+formatted, interpreted, and compared.
+
+To summarize, a semantic version consists of three non-negative integers (the
+major, minor, and patch versions, from left to right) separated by dots. The
+patch version may be followed by an optional pre-release string starting with a
+hyphen. The pre-release string or patch version may be followed by a build
+metadata string starting with a plus. For example, `v0.0.0`, `v1.12.134`,
+`v8.0.5-pre`, and `v2.0.9+meta` are valid versions.
+
+Each part of a version indicates whether the version is stable and whether it is
+compatible with previous versions.
+
+* The [major version](#glos-major-version) must be incremented and the minor
+ and patch versions must be set to zero after a backwards incompatible change
+ is made to the module's public interface or documented functionality, for
+ example, after a package is removed.
+* The [minor version](#glos-minor-version) must be incremented and the patch
+ version set to zero after a backwards compatible change, for example, after a
+ new function is added.
+* The [patch version](#glos-patch-version) must be incremented after a change
+ that does not affect the module's public interface, such as a bug fix or
+ optimization.
+* The pre-release suffix indicates a version is a
+ [pre-release](#glos-pre-release-version). Pre-release versions sort before
+ the corresponding release versions. For example, `v1.2.3-pre` comes before
+ `v1.2.3`.
+* The build metadata suffix is ignored for the purpose of comparing versions.
+ Tags with build metadata are ignored in version control repositories, but
+ build metadata is preserved in versions specified in `go.mod` files. The
+ suffix `+incompatible` denotes a version released before migrating to modules
+ version major version 2 or later (see [Compatibility with non-module
+ repositories](#non-module-compat).
+
+A version is considered unstable if its major version is 0 or it has a
+pre-release suffix. Unstable versions are not subject to compatibility
+requirements. For example, `v0.2.0` may not be compatible with `v0.1.0`, and
+`v1.5.0-beta` may not be compatible with `v1.5.0`.
+
+Go may access modules in version control systems using tags, branches, or
+revisions that don't follow these conventions. However, within the main module,
+the `go` command will automatically convert revision names that don't follow
+this standard into canonical versions. The `go` command will also remove build
+metadata suffixes (except for `+incompatible`) as part of this process. This may
+result in a [pseudo-version](#glos-pseudo-version), a pre-release version that
+encodes a revision identifier (such as a Git commit hash) and a timestamp from a
+version control system. For example, the command `go get -d
+golang.org/x/net@daa7c041` will convert the commit hash `daa7c041` into the
+pseudo-version `v0.0.0-20191109021931-daa7c04131f5`. Canonical versions are
+required outside the main module, and the `go` command will report an error if a
+non-canonical version like `master` appears in a `go.mod` file.
+
+### Pseudo-versions {#pseudo-versions}
+
+A <dfn>pseudo-version</dfn> is a specially formatted
+[pre-release](#glos-pre-release-version) [version](#glos-version) that encodes
+information about a specific revision in a version control repository. For
+example, `v0.0.0-20191109021931-daa7c04131f5` is a pseudo-version.
+
+Pseudo-versions may refer to revisions for which no [semantic version
+tags](#glos-semantic-version-tag) are available. They may be used to test
+commits before creating version tags, for example, on a development branch.
+
+Each pseudo-version has three parts:
+
+* A base version prefix (`vX.0.0` or `vX.Y.Z-0`), which is either derived from a
+ semantic version tag that precedes the revision or `vX.0.0` if there is no
+ such tag.
+* A timestamp (`yyyymmddhhmmss`), which is the UTC time the revision was
+ created. In Git, this is the commit time, not the author time.
+* A revision identifier (`abcdefabcdef`), which is a 12-character prefix of the
+ commit hash, or in Subversion, a zero-padded revision number.
+
+Each pseudo-version may be in one of three forms, depending on the base version.
+These forms ensure that a pseudo-version compares higher than its base version,
+but lower than the next tagged version.
+
+* `vX.0.0-yyyymmddhhmmss-abcdefabcdef` is used when there is no known base
+ version. As with all versions, the major version `X` must match the module's
+ [major version suffix](#glos-major-version-suffix).
+* `vX.Y.Z-pre.0.yyyymmddhhmmss-abcdefabcdef` is used when the base version is
+ a pre-release version like `vX.Y.Z-pre`.
+* `vX.Y.(Z+1)-0.yyyymmddhhmmss-abcdefabcdef` is used when the base version is
+ a release version like `vX.Y.Z`. For example, if the base version is
+ `v1.2.3`, a pseudo-version might be `v1.2.4-0.20191109021931-daa7c04131f5`.
+
+More than one pseudo-version may refer to the same commit by using different
+base versions. This happens naturally when a lower version is tagged after a
+pseudo-version is written.
+
+These forms give pseudo-versions two useful properties:
+
+* Pseudo-versions with known base versions sort higher than those versions but
+ lower than other pre-release for later versions.
+* Pseudo-versions with the same base version prefix sort chronologically.
+
+The `go` command performs several checks to ensure that module authors have
+control over how pseudo-versions are compared with other versions and that
+pseudo-versions refer to revisions that are actually part of a module's
+commit history.
+
+* If a base version is specified, there must be a corresponding semantic version
+ tag that is an ancestor of the revision described by the pseudo-version. This
+ prevents developers from bypassing [minimal version
+ selection](#glos-minimal-version-selection) using a pseudo-version that
+ compares higher than all tagged versions like
+ `v1.999.999-99999999999999-daa7c04131f5`.
+* The timestamp must match the revision's timestamp. This prevents attackers
+ from flooding [module proxies](#glos-module-proxy) with an unbounded number
+ of otherwise identical pseudo-versions. This also prevents module consumers
+ from changing the relative ordering of versions.
+* The revision must be an ancestor of one of the module repository's branches or
+ tags. This prevents attackers from referring to unapproved changes or pull
+ requests.
+
+Pseudo-versions never need to be typed by hand. Many commands accept
+a commit hash or a branch name and will translate it into a pseudo-version
+(or tagged version if available) automatically. For example:
+
+```
+go get -d example.com/mod@master
+go list -m -json example.com/mod@abcd1234
+```
+
+### Major version suffixes {#major-version-suffixes}
+
+Starting with major version 2, module paths must have a <dfn>major version
+suffix</dfn> like `/v2` that matches the major version. For example, if a module
+has the path `example.com/mod` at `v1.0.0`, it must have the path
+`example.com/mod/v2` at version `v2.0.0`.
+
+Major version suffixes implement the [<dfn>import compatibility
+rule</dfn>](https://research.swtch.com/vgo-import):
+
+> If an old package and a new package have the same import path,
+> the new package must be backwards compatible with the old package.
+
+By definition, packages in a new major version of a module are not backwards
+compatible with the corresponding packages in the previous major version.
+Consequently, starting with `v2`, packages need new import paths. This is
+accomplished by adding a major version suffix to the module path. Since the
+module path is a prefix of the import path for each package within the module,
+adding the major version suffix to the module path provides a distinct import
+path for each incompatible version.
+
+Major version suffixes are not allowed at major versions `v0` or `v1`. There is
+no need to change the module path between `v0` and `v1` because `v0` versions
+are unstable and have no compatibility guarantee. Additionally, for most
+modules, `v1` is backwards compatible with the last `v0` version; a `v1` version
+acts as a commitment to compatibility, rather than an indication of
+incompatible changes compared with `v0`.
+
+As a special case, modules paths starting with `gopkg.in/` must always have a
+major version suffix, even at `v0` and `v1`. The suffix must start with a dot
+rather than a slash (for example, `gopkg.in/yaml.v2`).
+
+Major version suffixes let multiple major versions of a module coexist in the
+same build. This may be necessary due to a [diamond dependency
+problem](https://research.swtch.com/vgo-import#dependency_story). Ordinarily, if
+a module is required at two different versions by transitive dependencies, the
+higher version will be used. However, if the two versions are incompatible,
+neither version will satisfy all clients. Since incompatible versions must have
+different major version numbers, they must also have different module paths due
+to major version suffixes. This resolves the conflict: modules with distinct
+suffixes are treated as separate modules, and their packages—even packages in
+same subdirectory relative to their module roots—are distinct.
+
+Many Go projects released versions at `v2` or higher without using a major
+version suffix before migrating to modules (perhaps before modules were even
+introduced). These versions are annotated with a `+incompatible` build tag (for
+example, `v2.0.0+incompatible`). See [Compatibility with non-module
+repositories](#non-module-compat) for more information.
+
+### Resolving a package to a module {#resolve-pkg-mod}
+
+When the `go` command loads a package using a [package
+path](#glos-package-path), it needs to determine which module provides the
+package.
+
+The `go` command starts by searching the [build list](#glos-build-list) for
+modules with paths that are prefixes of the package path. For example, if the
+package `example.com/a/b` is imported, and the module `example.com/a` is in the
+build list, the `go` command will check whether `example.com/a` contains the
+package, in the directory `b`. At least one file with the `.go` extension must
+be present in a directory for it to be considered a package. [Build
+constraints](/pkg/go/build/#hdr-Build_Constraints) are not applied for this
+purpose. If exactly one module in the build list provides the package, that
+module is used. If no modules provide the package or if two or more modules
+provide the package, the `go` command reports an error. The `-mod=mod` flag
+instructs the `go` command to attempt to find new modules providing missing
+packages and to update `go.mod` and `go.sum`. The [`go get`](#go-get) and [`go
+mod tidy`](#go-mod-tidy) commands do this automatically.
+
+<!-- NOTE(golang.org/issue/27899): the go command reports an error when two
+or more modules provide a package with the same path as above. In the future,
+we may try to upgrade one (or all) of the colliding modules.
+-->
+
+When the `go` command looks up a new module for a package path, it checks the
+`GOPROXY` environment variable, which is a comma-separated list of proxy URLs or
+the keywords `direct` or `off`. A proxy URL indicates the `go` command should
+contact a [module proxy](#glos-module-proxy) using the [`GOPROXY`
+protocol](#goproxy-protocol). `direct` indicates that the `go` command should
+[communicate with a version control system](#vcs). `off` indicates that no
+communication should be attempted. The `GOPRIVATE` and `GONOPROXY` [environment
+variables](#environment-variables) can also be used to control this behavior.
+
+For each entry in the `GOPROXY` list, the `go` command requests the latest
+version of each module path that might provide the package (that is, each prefix
+of the package path). For each successfully requested module path, the `go`
+command will download the module at the latest version and check whether the
+module contains the requested package. If one or more modules contain the
+requested package, the module with the longest path is used. If one or more
+modules are found but none contain the requested package, an error is
+reported. If no modules are found, the `go` command tries the next entry in the
+`GOPROXY` list. If no entries are left, an error is reported.
+
+For example, suppose the `go` command is looking for a module that provides the
+package `golang.org/x/net/html`, and `GOPROXY` is set to
+`https://corp.example.com,https://proxy.golang.org`. The `go` command may make
+the following requests:
+
+* To `https://corp.example.com/` (in parallel):
+ * Request for latest version of `golang.org/x/net/html`
+ * Request for latest version of `golang.org/x/net`
+ * Request for latest version of `golang.org/x`
+ * Request for latest version of `golang.org`
+* To `https://proxy.golang.org/`, if all requests to `https://corp.example.com/`
+ have failed with 404 or 410:
+ * Request for latest version of `golang.org/x/net/html`
+ * Request for latest version of `golang.org/x/net`
+ * Request for latest version of `golang.org/x`
+ * Request for latest version of `golang.org`
+
+After a suitable module has been found, the `go` command will add a new
+[requirement](#go-mod-file-require) with the new module's path and version to
+the main module's `go.mod` file. This ensures that when the same package is
+loaded in the future, the same module will be used at the same version. If the
+resolved package is not imported by a package in the main module, the new
+requirement will have an `// indirect` comment.
+
+## `go.mod` files {#go-mod-file}
+
+A module is defined by a UTF-8 encoded text file named `go.mod` in its root
+directory. The `go.mod` file is line-oriented. Each line holds a single
+directive, made up of a keyword followed by arguments. For example:
+
+```
+module example.com/my/thing
+
+go 1.12
+
+require example.com/other/thing v1.0.2
+require example.com/new/thing/v2 v2.3.4
+exclude example.com/old/thing v1.2.3
+replace example.com/bad/thing v1.4.5 => example.com/good/thing v1.4.5
+retract [v1.9.0, v1.9.5]
+```
+
+The leading keyword can be factored out of adjacent lines to create a block,
+like in Go imports.
+
+```
+require (
+ example.com/new/thing/v2 v2.3.4
+ example.com/old/thing v1.2.3
+)
+```
+
+The `go.mod` file is designed to be human readable and machine writable. The
+`go` command provides several subcommands that change `go.mod` files. For
+example, [`go get`](#go-get) can upgrade or downgrade specific dependencies.
+Commands that load the module graph will [automatically
+update](#go-mod-file-updates) `go.mod` when needed. [`go mod
+edit`](#go-mod-edit) can perform low-level edits. The
+[`golang.org/x/mod/modfile`](https://pkg.go.dev/golang.org/x/mod/modfile?tab=doc)
+package can be used by Go programs to make the same changes programmatically.
+
+### Lexical elements {#go-mod-file-lexical}
+
+When a `go.mod` file is parsed, its content is broken into a sequence of tokens.
+There are several kinds of tokens: whitespace, comments, punctuation,
+keywords, identifiers, and strings.
+
+*White space* consists of spaces (U+0020), tabs (U+0009), carriage returns
+(U+000D), and newlines (U+000A). White space characters other than newlines have
+no effect except to separate tokens that would otherwise be combined. Newlines
+are significant tokens.
+
+*Comments* start with `//` and run to the end of a line. `/* */` comments are
+not allowed.
+
+*Punctuation* tokens include `(`, `)`, and `=>`.
+
+*Keywords* distinguish different kinds of directives in a `go.mod` file. Allowed
+keywords are `module`, `go`, `require`, `replace`, `exclude`, and `retract`.
+
+*Identifiers* are sequences of non-whitespace characters, such as module paths
+or semantic versions.
+
+*Strings* are quoted sequences of characters. There are two kinds of strings:
+interpreted strings beginning and ending with quotation marks (`"`, U+0022) and
+raw strings beginning and ending with grave accents (<code><</code>,
+U+0060). Interpreted strings may contain escape sequences consisting of a
+backslash (`\`, U+005C) followed by another character. An escaped quotation
+mark (`\"`) does not terminate an interpreted string. The unquoted value
+of an interpreted string is the sequence of characters between quotation
+marks with each escape sequence replaced by the character following the
+backslash (for example, `\"` is replaced by `"`, `\n` is replaced by `n`).
+In contrast, the unquoted value of a raw string is simply the sequence of
+characters between grave accents; backslashes have no special meaning within
+raw strings.
+
+Identifiers and strings are interchangeable in the `go.mod` grammar.
+
+### Module paths and versions {#go-mod-file-ident}
+
+Most identifiers and strings in a `go.mod` file are either module paths or
+versions.
+
+A module path must satisfy the following requirements:
+
+* The path must consist of one or more path elements separated by slashes
+ (`/`, U+002F). It must not begin or end with a slash.
+* Each path element is a non-empty string made of up ASCII letters, ASCII
+ digits, and limited ASCII punctuation (`-`, `.`, `_`, and `~`).
+* A path element may not begin or end with a dot (`.`, U+002E).
+* The element prefix up to the first dot must not be a reserved file name on
+ Windows, regardless of case (`CON`, `com1`, `NuL`, and so on).
+
+If the module path appears in a `require` directive and is not replaced, or
+if the module paths appears on the right side of a `replace` directive,
+the `go` command may need to download modules with that path, and some
+additional requirements must be satisfied.
+
+* The leading path element (up to the first slash, if any), by convention a
+ domain name, must contain only lower-case ASCII letters, ASCII digits, dots
+ (`.`, U+002E), and dashes (`-`, U+002D); it must contain at least one dot and
+ cannot start with a dash.
+* For a final path element of the form `/vN` where `N` looks numeric (ASCII
+ digits and dots), `N` must not begin with a leading zero, must not be `/v1`,
+ and must not contain any dots.
+ * For paths beginning with `gopkg.in/`, this requirement is replaced by a
+ requirement that the path follow the [gopkg.in](https://gopkg.in) service's
+ conventions.
+
+Versions in `go.mod` files may be [canonical](#glos-canonical-version) or
+non-canonical.
+
+A canonical version starts with the letter `v`, followed by a semantic version
+following the [Semantic Versioning 2.0.0](https://semver.org/spec/v2.0.0.html)
+specification. See [Versions](#versions) for more information.
+
+Most other identifiers and strings may be used as non-canonical versions, though
+there are some restrictions to avoid problems with file systems, repositories,
+and [module proxies](#glos-module-proxy). Non-canonical versions are only
+allowed in the main module's `go.mod` file. The `go` command will attempt to
+replace each non-canonical version with an equivalent canonical version when it
+automatically [updates](#go-mod-file-updates) the `go.mod` file.
+
+In places where a module path is associated with a version (as in `require`,
+`replace`, and `exclude` directives), the final path element must be consistent
+with the version. See [Major version suffixes](#major-version-suffixes).
+
+### Grammar {#go-mod-file-grammar}
+
+`go.mod` syntax is specified below using Extended Backus-Naur Form (EBNF).
+See the [Notation section in the Go Language Specification](/ref/spec#Notation)
+for details on EBNF syntax.
+
+```
+GoMod = { Directive } .
+Directive = ModuleDirective |
+ GoDirective |
+ RequireDirective |
+ ExcludeDirective |
+ ReplaceDirective |
+ RetractDirective .
+```
+
+Newlines, identifiers, and strings are denoted with `newline`, `ident`, and
+`string`, respectively.
+
+Module paths and versions are denoted with `ModulePath` and `Version`.
+
+```
+ModulePath = ident | string . /* see restrictions above */
+Version = ident | string . /* see restrictions above */
+```
+
+### `module` directive {#go-mod-file-module}
+
+A `module` directive defines the main module's [path](#glos-module-path). A
+`go.mod` file must contain exactly one `module` directive.
+
+```
+ModuleDirective = "module" ( ModulePath | "(" newline ModulePath newline ")" ) newline .
+```
+
+Example:
+
+```
+module golang.org/x/net
+```
+
+#### Deprecation {#go-mod-file-module-deprecation}
+
+A module can be marked as deprecated in a block of comments containing the
+string `Deprecated:` (case-sensitive) at the beginning of a paragraph. The
+deprecation message starts after the colon and runs to the end of the paragraph.
+The comments may appear immediately before the `module` directive or afterward
+on the same line.
+
+Example:
+
+```
+// Deprecated: use example.com/mod/v2 instead.
+module example.com/mod
+```
+
+Since Go 1.17, [`go list -m -u`](#go-list-m) checks for information on all
+deprecated modules in the [build list](#glos-build-list). [`go get`](#go-get)
+checks for deprecated modules needed to build packages named on the command
+line.
+
+When the `go` command retrieves deprecation information for a module, it loads
+the `go.mod` file from the version matching the `@latest` [version
+query](#version-queries) without considering retractions or exclusions. The `go`
+command loads [retractions](#glos-retracted-version) from the same `go.mod`
+file.
+
+To deprecate a module, an author may add a `// Deprecated:` comment and tag a
+new release. The author may change or remove the deprecation message in a higher
+release.
+
+A deprecation applies to all minor versions of a module. Major versions higher
+than `v2` are considered separate modules for this purpose, since their [major
+version suffixes](#glos-major-version-suffix) give them distinct module paths.
+
+Deprecation messages are intended to inform users that the module is no longer
+supported and to provide migration instructions, for example, to the latest
+major version. Individual minor and patch versions cannot be deprecated;
+[`retract`](#go-mod-file-retract) may be more appropriate for that.
+
+### `go` directive {#go-mod-file-go}
+
+A `go` directive indicates that a module was written assuming the semantics of a
+given version of Go. The version must be a valid Go release version: a positive
+integer followed by a dot and a non-negative integer (for example, `1.9`,
+`1.14`).
+
+The `go` directive was originally intended to support backward incompatible
+changes to the Go language (see [Go 2
+transition](/design/28221-go2-transitions)). There have been no incompatible
+language changes since modules were introduced, but the `go` directive still
+affects use of new language features:
+
+* For packages within the module, the compiler rejects use of language features
+ introduced after the version specified by the `go` directive. For example, if
+ a module has the directive `go 1.12`, its packages may not use numeric
+ literals like `1_000_000`, which were introduced in Go 1.13.
+* If an older Go version builds one of the module's packages and encounters a
+ compile error, the error notes that the module was written for a newer Go
+ version. For example, suppose a module has `go 1.13` and a package uses the
+ numeric literal `1_000_000`. If that package is built with Go 1.12, the
+ compiler notes that the code is written for Go 1.13.
+
+Additionally, the `go` command changes its behavior based on the version
+specified by the `go` directive. This has the following effects:
+
+* At `go 1.14` or higher, automatic [vendoring](#vendoring) may be enabled.
+ If the file `vendor/modules.txt` is present and consistent with `go.mod`,
+ there is no need to explicitly use the `-mod=vendor` flag.
+* At `go 1.16` or higher, the `all` package pattern matches only packages
+ transitively imported by packages and tests in the [main
+ module](#glos-main-module). This is the same set of packages retained by
+ [`go mod vendor`](#go-mod-vendor) since modules were introduced. In lower
+ versions, `all` also includes tests of packages imported by packages in
+ the main module, tests of those packages, and so on.
+
+A `go.mod` file may contain at most one `go` directive. Most commands will add a
+`go` directive with the current Go version if one is not present.
+
+```
+GoDirective = "go" GoVersion newline .
+GoVersion = string | ident . /* valid release version; see above */
+```
+
+Example:
+
+```
+go 1.14
+```
+
+### `require` directive {#go-mod-file-require}
+
+A `require` directive declares a minimum required version of a given module
+dependency. For each required module version, the `go` command loads the
+`go.mod` file for that version and incorporates the requirements from that
+file. Once all requirements have been loaded, the `go` command resolves them
+using [minimal version selection (MVS)](#minimal-version-selection) to produce
+the [build list](#glos-build-list).
+
+The `go` command automatically adds `// indirect` comments for some
+requirements. An `// indirect` comment indicates that no package from the
+required module is directly imported by any package in the main module.
+The `go` command adds an indirect requirement when the selected version of a
+module is higher than what is already implied (transitively) by the main
+module's other dependencies. That may occur because of an explicit upgrade
+(`go get -u`), removal of some other dependency that previously imposed the
+requirement (`go mod tidy`), or a dependency that imports a package without
+a corresponding requirement in its own `go.mod` file (such as a dependency
+that lacks a `go.mod` file altogether).
+
+```
+RequireDirective = "require" ( RequireSpec | "(" newline { RequireSpec } ")" newline ) .
+RequireSpec = ModulePath Version newline .
+```
+
+Example:
+
+```
+require golang.org/x/net v1.2.3
+
+require (
+ golang.org/x/crypto v1.4.5 // indirect
+ golang.org/x/text v1.6.7
+)
+```
+
+### `exclude` directive {#go-mod-file-exclude}
+
+An `exclude` directive prevents a module version from being loaded by the `go`
+command.
+
+Since Go 1.16, if a version referenced by a `require` directive in any `go.mod`
+file is excluded by an `exclude` directive in the main module's `go.mod` file,
+the requirement is ignored. This may be cause commands like [`go get`](#go-get)
+and [`go mod tidy`](#go-mod-tidy) to add new requirements on higher versions
+to `go.mod`, with an `// indirect` comment if appropriate.
+
+Before Go 1.16, if an excluded version was referenced by a `require` directive,
+the `go` command listed available versions for the module (as shown with [`go
+list -m -versions`](#go-list-m)) and loaded the next higher non-excluded version
+instead. This could result in non-deterministic version selection, since the
+next higher version could change over time. Both release and pre-release
+versions were considered for this purpose, but pseudo-versions were not. If
+there were no higher versions, the `go` command reported an error.
+
+`exclude` directives only apply in the main module's `go.mod` file and are
+ignored in other modules. See [Minimal version
+selection](#minimal-version-selection) for details.
+
+```
+ExcludeDirective = "exclude" ( ExcludeSpec | "(" newline { ExcludeSpec } ")" newline ) .
+ExcludeSpec = ModulePath Version newline .
+```
+
+Example:
+
+```
+exclude golang.org/x/net v1.2.3
+
+exclude (
+ golang.org/x/crypto v1.4.5
+ golang.org/x/text v1.6.7
+)
+```
+
+### `replace` directive {#go-mod-file-replace}
+
+A `replace` directive replaces the contents of a specific version of a module,
+or all versions of a module, with contents found elsewhere. The replacement
+may be specified with either another module path and version, or a
+platform-specific file path.
+
+If a version is present on the left side of the arrow (`=>`), only that specific
+version of the module is replaced; other versions will be accessed normally.
+If the left version is omitted, all versions of the module are replaced.
+
+If the path on the right side of the arrow is an absolute or relative path
+(beginning with `./` or `../`), it is interpreted as the local file path to the
+replacement module root directory, which must contain a `go.mod` file. The
+replacement version must be omitted in this case.
+
+If the path on the right side is not a local path, it must be a valid module
+path. In this case, a version is required. The same module version must not
+also appear in the build list.
+
+Regardless of whether a replacement is specified with a local path or module
+path, if the replacement module has a `go.mod` file, its `module` directive
+must match the module path it replaces.
+
+`replace` directives only apply in the main module's `go.mod` file
+and are ignored in other modules. See [Minimal version
+selection](#minimal-version-selection) for details.
+
+```
+ReplaceDirective = "replace" ( ReplaceSpec | "(" newline { ReplaceSpec } ")" newline ) .
+ReplaceSpec = ModulePath [ Version ] "=>" FilePath newline
+ | ModulePath [ Version ] "=>" ModulePath Version newline .
+FilePath = /* platform-specific relative or absolute file path */
+```
+
+Example:
+
+```
+replace golang.org/x/net v1.2.3 => example.com/fork/net v1.4.5
+
+replace (
+ golang.org/x/net v1.2.3 => example.com/fork/net v1.4.5
+ golang.org/x/net => example.com/fork/net v1.4.5
+ golang.org/x/net v1.2.3 => ./fork/net
+ golang.org/x/net => ./fork/net
+)
+```
+
+### `retract` directive {#go-mod-file-retract}
+
+A `retract` directive indicates that a version or range of versions of the
+module defined by `go.mod` should not be depended upon. A `retract` directive is
+useful when a version was published prematurely or a severe problem was
+discovered after the version was published. Retracted versions should remain
+available in version control repositories and on [module
+proxies](#glos-module-proxy) to ensure that builds that depend on them are not
+broken. The word *retract* is borrowed from academic literature: a retracted
+research paper is still available, but it has problems and should not be the
+basis of future work.
+
+When a module version is retracted, users will not upgrade to it automatically
+using [`go get`](#go-get), [`go mod tidy`](#go-mod-tidy), or other
+commands. Builds that depend on retracted versions should continue to work, but
+users will be notified of retractions when they check for updates with [`go list
+-m -u`](#go-list-m) or update a related module with [`go get`](#go-get).
+
+To retract a version, a module author should add a `retract` directive to
+`go.mod`, then publish a new version containing that directive. The new version
+must be higher than other release or pre-release versions; that is, the
+`@latest` [version query](#version-queries) should resolve to the new version
+before retractions are considered. The `go` command loads and applies
+retractions from the version shown by `go list -m -retracted $modpath@latest`
+(where `$modpath` is the module path).
+
+Retracted versions are hidden from the version list printed by [`go list -m
+-versions`](#go-list-m) unless the `-retracted` flag is used. Retracted
+versions are excluded when resolving version queries like `@>=v1.2.3` or
+`@latest`.
+
+A version containing retractions may retract itself. If the highest release
+or pre-release version of a module retracts itself, the `@latest` query
+resolves to a lower version after retracted versions are excluded.
+
+As an example, consider a case where the author of module `example.com/m`
+publishes version `v1.0.0` accidentally. To prevent users from upgrading to
+`v1.0.0`, the author can add two `retract` directives to `go.mod`, then tag
+`v1.0.1` with the retractions.
+
+```
+retract (
+ v1.0.0 // Published accidentally.
+ v1.0.1 // Contains retractions only.
+)
+```
+
+When a user runs `go get example.com/m@latest`, the `go` command reads
+retractions from `v1.0.1`, which is now the highest version. Both `v1.0.0` and
+`v1.0.1` are retracted, so the `go` command will upgrade (or downgrade!) to
+the next highest version, perhaps `v0.9.5`.
+
+`retract` directives may be written with either a single version (like `v1.0.0`)
+or with a closed interval of versions with an upper and lower bound, delimited by
+`[` and `]` (like `[v1.1.0, v1.2.0]`). A single version is equivalent to an
+interval where the upper and lower bound are the same. Like other directives,
+multiple `retract` directives may be grouped together in a block delimited by
+`(` at the end of a line and `)` on its own line.
+
+Each `retract` directive should have a comment explaining the rationale for the
+retraction, though this is not mandatory. The `go` command may display rationale
+comments in warnings about retracted versions and in `go list` output. A
+rationale comment may be written immediately above a `retract` directive
+(without a blank line in between) or afterward on the same line. If a comment
+appears above a block, it applies to all `retract` directives within the block
+that don't have their own comments. A rationale comment may span multiple lines.
+
+```
+RetractDirective = "retract" ( RetractSpec | "(" newline { RetractSpec } ")" newline ) .
+RetractSpec = ( Version | "[" Version "," Version "]" ) newline .
+```
+
+Example:
+
+```
+retract v1.0.0
+retract [v1.0.0, v1.9.9]
+retract (
+ v1.0.0
+ [v1.0.0, v1.9.9]
+)
+```
+
+The `retract` directive was added in Go 1.16. Go 1.15 and lower will report an
+error if a `retract` directive is written in the [main
+module's](#glos-main-module) `go.mod` file and will ignore `retract` directives
+in `go.mod` files of dependencies.
+
+### Automatic updates {#go-mod-file-updates}
+
+Most commands report an error if `go.mod` is missing information or doesn't
+accurately reflect reality. The [`go get`](#go-get) and
+[`go mod tidy`](#go-mod-tidy) commands may be used to fix most of these
+problems. Additionally, the `-mod=mod` flag may be used with most module-aware
+commands (`go build`, `go test`, and so on) to instruct the `go` command to
+fix problems in `go.mod` and `go.sum` automatically.
+
+For example, consider this `go.mod` file:
+
+```
+module example.com/M
+
+require (
+ example.com/A v1
+ example.com/B v1.0.0
+ example.com/C v1.0.0
+ example.com/D v1.2.3
+ example.com/E dev
+)
+
+exclude example.com/D v1.2.3
+```
+
+The update triggered with `-mod=mod` rewrites non-canonical version identifiers
+to [canonical](#glos-canonical-version) semver form, so `example.com/A`'s `v1`
+becomes `v1.0.0`, and `example.com/E`'s `dev` becomes the pseudo-version for the
+latest commit on the `dev` branch, perhaps `v0.0.0-20180523231146-b3f5c0f6e5f1`.
+
+The update modifies requirements to respect exclusions, so the requirement on
+the excluded `example.com/D v1.2.3` is updated to use the next available version
+of `example.com/D`, perhaps `v1.2.4` or `v1.3.0`.
+
+The update removes redundant or misleading requirements. For example, if
+`example.com/A v1.0.0` itself requires `example.com/B v1.2.0` and `example.com/C
+v1.0.0`, then `go.mod`'s requirement of `example.com/B v1.0.0` is misleading
+(superseded by `example.com/A`'s need for `v1.2.0`), and its requirement of
+`example.com/C v1.0.0` is redundant (implied by `example.com/A`'s need for the
+same version), so both will be removed. If the main module contains packages
+that directly import packages from `example.com/B` or `example.com/C`, then the
+requirements will be kept but updated to the actual versions being used.
+
+Finally, the update reformats the `go.mod` in a canonical formatting, so
+that future mechanical changes will result in minimal diffs. The `go` command
+will not update `go.mod` if only formatting changes are needed.
+
+Because the module graph defines the meaning of import statements, any commands
+that load packages also use `go.mod` and can therefore update it, including
+`go build`, `go get`, `go install`, `go list`, `go test`, `go mod tidy`.
+
+In Go 1.15 and lower, the `-mod=mod` flag was enabled by default, so updates
+were performed automatically. Since Go 1.16, the `go` command acts as
+if `-mod=readonly` were set instead: if any changes to `go.mod` are needed,
+the `go` command reports an error and suggests a fix.
+
+## Minimal version selection (MVS) {#minimal-version-selection}
+
+Go uses an algorithm called <dfn>Minimal version selection (MVS)</dfn> to select
+a set of module versions to use when building packages. MVS is described in
+detail in [Minimal Version Selection](https://research.swtch.com/vgo-mvs) by
+Russ Cox.
+
+Conceptually, MVS operates on a directed graph of modules, specified with
+[`go.mod` files](#glos-go-mod-file). Each vertex in the graph represents a
+module version. Each edge represents a minimum required version of a dependency,
+specified using a [`require`](#go-mod-file-require)
+directive. [`replace`](#go-mod-file-replace) and [`exclude`](#go-mod-file-exclude)
+directives in the main module's `go.mod` file modify the graph.
+
+MVS produces the [build list](#glos-build-list) as output, the list of module
+versions used for a build.
+
+MVS starts at the main module (a special vertex in the graph that has no
+version) and traverses the graph, tracking the highest required version of each
+module. At the end of the traversal, the highest required versions comprise the
+build list: they are the minimum versions that satisfy all requirements.
+
+The build list may be inspected with the command [`go list -m
+all`](#go-list-m). Unlike other dependency management systems, the build list is
+not saved in a "lock" file. MVS is deterministic, and the build list doesn't
+change when new versions of dependencies are released, so MVS is used to compute
+it at the beginning of every module-aware command.
+
+Consider the example in the diagram below. The main module requires module A
+at version 1.2 or higher and module B at version 1.2 or higher. A 1.2 and B 1.2
+require C 1.3 and C 1.4, respectively. C 1.3 and C 1.4 both require D 1.2.
+
+
+
+MVS visits and loads the `go.mod` file for each of the module versions
+highlighted in blue. At the end of the graph traversal, MVS returns a build list
+containing the bolded versions: A 1.2, B 1.2, C 1.4, and D 1.2. Note that higher
+versions of B and D are available but MVS does not select them, since nothing
+requires them.
+
+### Replacement {#mvs-replace}
+
+The content of a module (including its `go.mod` file) may be replaced using a
+[`replace` directive](#go-mod-file-replace) in the main module's `go.mod` file.
+A `replace` directive may apply to a specific version of a module or to all
+versions of a module.
+
+Replacements change the module graph, since a replacement module may have
+different dependencies than replaced versions.
+
+Consider the example below, where C 1.4 has been replaced with R. R depends on D
+1.3 instead of D 1.2, so MVS returns a build list containing A 1.2, B 1.2, C 1.4
+(replaced with R), and D 1.3.
+
+
+
+### Exclusion {#mvs-exclude}
+
+A module may also be excluded at specific versions using an [`exclude`
+directive](#go-mod-file-exclude) in the main module's `go.mod` file.
+
+Exclusions also change the module graph. When a version is excluded, it is
+removed from the module graph, and requirements on it are redirected to the
+next higher version.
+
+Consider the example below. C 1.3 has been excluded. MVS will act as if A 1.2
+required C 1.4 (the next higher version) instead of C 1.3.
+
+
+
+### Upgrades {#mvs-upgrade}
+
+The [`go get`](#go-get) command may be used to upgrade a set of modules. To
+perform an upgrade, the `go` command changes the module graph before running MVS
+by adding edges from visited versions to upgraded versions.
+
+Consider the example below. Module B may be upgraded from 1.2 to 1.3, C may be
+upgraded from 1.3 to 1.4, and D may be upgraded from 1.2 to 1.3.
+
+
+
+Upgrades (and downgrades) may add or remove indirect dependencies. In this case,
+E 1.1 and F 1.1 appear in the build list after the upgrade, since E 1.1 is
+required by B 1.3.
+
+To preserve upgrades, the `go` command updates the requirements in `go.mod`. It
+will change the requirement on B to version 1.3. It will also add requirements
+on C 1.4 and D 1.3 with `// indirect` comments, since those versions would not
+be selected otherwise.
+
+### Downgrade {#mvs-downgrade}
+
+The [`go get`](#go-get) command may also be used to downgrade a set of
+modules. To perform a downgrade, the `go` command changes the module graph by
+removing versions above the downgraded versions. It also removes versions of
+other modules that depend on removed versions, since they may not be compatible
+with the downgraded versions of their dependencies. If the main module requires
+a module version removed by downgrading, the requirement is changed to a
+previous version that has not been removed. If no previous version is available,
+the requirement is dropped.
+
+Consider the example below. Suppose that a problem was found with C 1.4, so we
+downgrade to C 1.3. C 1.4 is removed from the module graph. B 1.2 is also
+removed, since it requires C 1.4 or higher. The main module's requirement on B
+is changed to 1.1.
+
+
+
+[`go get`](#go-get) can also remove dependencies entirely, using an `@none`
+suffix after an argument. This works similarly to a downgrade. All versions
+of the named module are removed from the module graph.
+
+## Compatibility with non-module repositories {#non-module-compat}
+
+To ensure a smooth transition from `GOPATH` to modules, the `go` command can
+download and build packages in module-aware mode from repositories that have not
+migrated to modules by adding a [`go.mod` file](#glos-go-mod-file).
+
+When the `go` command downloads a module at a given version [directly](#vcs)
+from a repository, it looks up a repository URL for the module path, maps the
+version to a revision within the repository, then extracts an archive of the
+repository at that revision. If the [module's path](#glos-module-path) is equal
+to the [repository root path](#glos-repository-root-path), and the repository
+root directory does not contain a `go.mod` file, the `go` command synthesizes a
+`go.mod` file in the module cache that contains a [`module`
+directive](#go-mod-file-module) and nothing else. Since synthetic `go.mod` files
+do not contain [`require` directives](#go-mod-file-require) for their
+dependencies, other modules that depend on them may need additional `require`
+directives (with `// indirect` comments) to ensure each dependency is fetched at
+the same version on every build.
+
+When the `go` command downloads a module from a
+[proxy](#communicating-with-proxies), it downloads the `go.mod` file separately
+from the rest of the module content. The proxy is expected to serve a synthetic
+`go.mod` file if the original module didn't have one.
+
+### `+incompatible` versions {#incompatible-versions}
+
+A module released at major version 2 or higher must have a matching [major
+version suffix](#major-version-suffixes) on its module path. For example, if a
+module is released at `v2.0.0`, its path must have a `/v2` suffix. This allows
+the `go` command to treat multiple major versions of a project as distinct
+modules, even if they're developed in the same repository.
+
+The major version suffix requirement was introduced when module support was
+added to the `go` command, and many repositories had already tagged releases
+with major version `2` or higher before that. To maintain compatibility with
+these repositories, the `go` command adds an `+incompatible` suffix to versions
+with major version 2 or higher without a `go.mod` file. `+incompatible`
+indicates that a version is part of the same module as versions with lower major
+version numbers; consequently, the `go` command may automatically upgrade to
+higher `+incompatible` versions even though it may break the build.
+
+Consider the example requirement below:
+
+```
+require example.com/m v4.1.2+incompatible
+```
+
+The version `v4.1.2+incompatible` refers to the [semantic version
+tag](#glos-semantic-version-tag) `v4.1.2` in the repository that provides the
+module `example.com/m`. The module must be in the repository root directory
+(that is, the [repository root path](#glos-module-path) must also be
+`example.com/m`), and a `go.mod` file must not be present. The module may have
+versions with lower major version numbers like `v1.5.2`, and the `go` command
+may upgrade automatically to `v4.1.2+incompatible` from those versions (see
+[minimal version selection (MVS)](#minimal-version-selection) for information
+on how upgrades work).
+
+A repository that migrates to modules after version `v2.0.0` is tagged should
+usually release a new major version. In the example above, the author should
+create a module with the path `example.com/m/v5` and should release version
+`v5.0.0`. The author should also update imports of packages in the module to use
+the prefix `example.com/m/v5` instead of `example.com/m`. See [Go Modules: v2
+and Beyond](https://blog.golang.org/v2-go-modules) for a more detailed example.
+
+Note that the `+incompatible` suffix should not appear on a tag in a repository;
+a tag like `v4.1.2+incompatible` will be ignored. The suffix only appears in
+versions used by the `go` command. See [Mapping versions to
+commits](#vcs-version) for details on the distinction between versions and tags.
+
+Note also that the `+incompatible` suffix may appear on
+[pseudo-versions](#glos-pseudo-version). For example,
+`v2.0.1-20200722182040-012345abcdef+incompatible` may be a valid pseudo-version.
+
+### Minimal module compatibility {#minimal-module-compatibility}
+
+A module released at major version 2 or higher is required to have a [major
+version suffix](#glos-major-version-suffix) on its [module
+path](#glos-module-path). The module may or may not be developed in a [major
+version subdirectory](#glos-major-version-subdirectory) within its repository.
+This has implications for packages that import packages within the module when
+building `GOPATH` mode.
+
+Normally in `GOPATH` mode, a package is stored in a directory matching its
+[repository's root path](#glos-repository-root-path) joined with its directory
+within the repository. For example, a package in the repository with root path
+`example.com/repo` in the subdirectory `sub` would be stored in
+`$GOPATH/src/example.com/repo/sub` and would be imported as
+`example.com/repo/sub`.
+
+For a module with a major version suffix, one might expect to find the package
+`example.com/repo/v2/sub` in the directory
+`$GOPATH/src/example.com/repo/v2/sub`. This would require the module to be
+developed in the `v2` subdirectory of its repository. The `go` command supports
+this but does not require it (see [Mapping versions to commits](#vcs-version)).
+
+If a module is *not* developed in a major version subdirectory, then its
+directory in `GOPATH` will not contain the major version suffix, and its
+packages may be imported without the major version suffix. In the example above,
+the package would be found in the directory `$GOPATH/src/example.com/repo/sub`
+and would be imported as `example.com/repo/sub`.
+
+This creates a problem for packages intended to be built in both module mode
+and `GOPATH` mode: module mode requires a suffix, while `GOPATH` mode does not.
+
+To fix this, <dfn>minimal module compatibility</dfn> was added in Go 1.11 and
+was backported to Go 1.9.7 and 1.10.3. When an import path is resolved to a
+directory in `GOPATH` mode:
+
+* When resolving an import of the form `$modpath/$vn/$dir` where:
+ * `$modpath` is a valid module path,
+ * `$vn` is a major version suffix,
+ * `$dir` is a possibly empty subdirectory,
+* If all of the following are true:
+ * The package `$modpath/$vn/$dir` is not present in any relevant [`vendor`
+ directory](#glos-vendor-directory).
+ * A `go.mod` file is present in the same directory as the importing file
+ or in any parent directory up to the `$GOPATH/src` root,
+ * No `$GOPATH[i]/src/$modpath/$vn/$suffix` directory exists (for any root
+ `$GOPATH[i]`),
+ * The file `$GOPATH[d]/src/$modpath/go.mod` exists (for some root
+ `$GOPATH[d]`) and declares the module path as `$modpath/$vn`,
+* Then the import of `$modpath/$vn/$dir` is resolved to the directory
+ `$GOPATH[d]/src/$modpath/$dir`.
+
+This rules allow packages that have been migrated to modules to import other
+packages that have been migrated to modules when built in `GOPATH` mode even
+when a major version subdirectory was not used.
+
+## Module-aware commands {#mod-commands}
+
+Most `go` commands may run in *Module-aware mode* or *`GOPATH` mode*. In
+module-aware mode, the `go` command uses `go.mod` files to find versioned
+dependencies, and it typically loads packages out of the [module
+cache](#glos-module-cache), downloading modules if they are missing. In `GOPATH`
+mode, the `go` command ignores modules; it looks in [`vendor`
+directories](#glos-vendor-directory) and in `GOPATH` to find dependencies.
+
+As of Go 1.16, module-aware mode is enabled by default, regardless of whether a
+`go.mod` file is present. In lower versions, module-aware mode was enabled when
+a `go.mod` file was present in the current directory or any parent directory.
+
+Module-aware mode may be controlled with the `GO111MODULE` environment variable,
+which can be set to `on`, `off`, or `auto`.
+
+* If `GO111MODULE=off`, the `go` command ignores `go.mod` files and runs in
+ `GOPATH` mode.
+* If `GO111MODULE=on` or is unset, the `go` command runs in module-aware mode,
+ even when no `go.mod` file is present. Not all commands work without a
+ `go.mod` file: see [Module commands outside a module](#commands-outside).
+* If `GO111MODULE=auto`, the `go` command runs in module-aware mode if a
+ `go.mod` file is present in the current directory or any parent directory.
+ In Go 1.15 and lower, this was the default behavior. `go mod` subcommands
+ and `go install` with a [version query](#version-queries) run in module-aware
+ mode even if no `go.mod` file is present.
+
+In module-aware mode, `GOPATH` no longer defines the meaning of imports during a
+build, but it still stores downloaded dependencies (in `GOPATH/pkg/mod`; see
+[Module cache](#module-cache)) and installed commands (in `GOPATH/bin`, unless
+`GOBIN` is set).
+
+### Build commands {#build-commands}
+
+All commands that load information about packages are module-aware. This
+includes:
+
+* `go build`
+* `go fix`
+* `go generate`
+* `go get`
+* `go install`
+* `go list`
+* `go run`
+* `go test`
+* `go vet`
+
+When run in module-aware mode, these commands use `go.mod` files to interpret
+import paths listed on the command line or written in Go source files. These
+commands accept the following flags, common to all module commands.
+
+* The `-mod` flag controls whether `go.mod` may be automatically updated and
+ whether the `vendor` directory is used.
+ * `-mod=mod` tells the `go` command to ignore the vendor directory and to
+ [automatically update](#go-mod-file-updates) `go.mod`, for example, when an
+ imported package is not provided by any known module.
+ * `-mod=readonly` tells the `go` command to ignore the `vendor` directory and
+ to report an error if `go.mod` needs to be updated.
+ * `-mod=vendor` tells the `go` command to use the `vendor` directory. In this
+ mode, the `go` command will not use the network or the module cache.
+ * By default, if the [`go` version](#go-mod-file-go) in `go.mod` is `1.14` or
+ higher and a `vendor` directory is present, the `go` command acts as if
+ `-mod=vendor` were used. Otherwise, the `go` command acts as if
+ `-mod=readonly` were used.
+* The `-modcacherw` flag instructs the `go` command to create new directories
+ in the module cache with read-write permissions instead of making them
+ read-only. When this flag is used consistently (typically by setting
+ `GOFLAGS=-modcacherw` in the environment or by running
+ `go env -w GOFLAGS=-modcacherw`), the module cache may be deleted with
+ commands like `rm -r` without changing permissions first. The
+ [`go clean -modcache`](#go-clean-modcache) command may be used to delete the
+ module cache, whether or not `-modcacherw` was used.
+* The `-modfile=file.mod` flag instructs the `go` command to read (and possibly
+ write) an alternate file instead of `go.mod` in the module root directory. The
+ file's name must end with `.mod`. A file named `go.mod` must still be present
+ in order to determine the module root directory, but it is not accessed. When
+ `-modfile` is specified, an alternate `go.sum` file is also used: its path is
+ derived from the `-modfile` flag by trimming the `.mod` extension and
+ appending `.sum`.
+
+### Vendoring {#vendoring}
+
+When using modules, the `go` command typically satisfies dependencies by
+downloading modules from their sources into the module cache, then loading
+packages from those downloaded copies. <dfn>Vendoring</dfn> may be used to allow
+interoperation with older versions of Go, or to ensure that all files used for a
+build are stored in a single file tree.
+
+The `go mod vendor` command constructs a directory named `vendor` in the [main
+module's](#glos-main-module) root directory containing copies of all packages
+needed to build and test packages in the main module. Packages that are only
+imported by tests of packages outside the main module are not included. As with
+[`go mod tidy`](#go-mod-tidy) and other module commands, [build
+constraints](#glos-build-constraint) except for `ignore` are not considered when
+constructing the `vendor` directory.
+
+`go mod vendor` also creates the file `vendor/modules.txt` that contains a list
+of vendored packages and the module versions they were copied from. When
+vendoring is enabled, this manifest is used as a source of module version
+information, as reported by [`go list -m`](#go-list-m) and [`go version
+-m`](#go-version-m). When the `go` command reads `vendor/modules.txt`, it checks
+that the module versions are consistent with `go.mod`. If `go.mod` has changed
+since `vendor/modules.txt` was generated, the `go` command will report an error.
+`go mod vendor` should be run again to update the `vendor` directory.
+
+If the `vendor` directory is present in the main module's root directory, it
+will be used automatically if the [`go` version](#go-mod-file-go) in the main
+module's [`go.mod` file](#glos-go-mod-file) is `1.14` or higher. To explicitly
+enable vendoring, invoke the `go` command with the flag `-mod=vendor`. To
+disable vendoring, use the flag `-mod=readonly` or `-mod=mod`.
+
+When vendoring is enabled, [build commands](#build-commands) like `go build` and
+`go test` load packages from the `vendor` directory instead of accessing the
+network or the local module cache. The [`go list -m`](#go-list-m) command only
+prints information about modules listed in `go.mod`. `go mod` commands such as
+[`go mod download`](#go-mod-download) and [`go mod tidy`](#go-mod-tidy) do not
+work differently when vendoring is enabled and will still download modules and
+access the module cache. [`go get`](#go-get) also does not work differently when
+vendoring is enabled.
+
+Unlike [vendoring in `GOPATH`](https://golang.org/s/go15vendor), the `go`
+command ignores vendor directories in locations other than the main module's
+root directory.
+
+### `go get` {#go-get}
+
+Usage:
+
+```
+go get [-d] [-t] [-u] [build flags] [packages]
+```
+
+Examples:
+
+```
+# Upgrade a specific module.
+$ go get -d golang.org/x/net
+
+# Upgrade modules that provide packages imported by packages in the main module.
+$ go get -d -u ./...
+
+# Upgrade or downgrade to a specific version of a module.
+$ go get -d golang.org/x/text@v0.3.2
+
+# Update to the commit on the module's master branch.
+$ go get -d golang.org/x/text@master
+
+# Remove a dependency on a module and downgrade modules that require it
+# to versions that don't require it.
+$ go get -d golang.org/x/text@none
+```
+
+The `go get` command updates module dependencies in the [`go.mod`
+file](#go-mod-file) for the [main module](#glos-main-module), then builds and
+installs packages listed on the command line.
+
+The first step is to determine which modules to update. `go get` accepts a list
+of packages, package patterns, and module paths as arguments. If a package
+argument is specified, `go get` updates the module that provides the package.
+If a package pattern is specified (for example, `all` or a path with a `...`
+wildcard), `go get` expands the pattern to a set of packages, then updates the
+modules that provide the packages. If an argument names a module but not a
+package (for example, the module `golang.org/x/net` has no package in its root
+directory), `go get` will update the module but will not build a package. If no
+arguments are specified, `go get` acts as if `.` were specified (the package in
+the current directory); this may be used together with the `-u` flag to update
+modules that provide imported packages.
+
+Each argument may include a <dfn>version query suffix</dfn> indicating the
+desired version, as in `go get golang.org/x/text@v0.3.0`. A version query
+suffix consists of an `@` symbol followed by a [version query](#version-queries),
+which may indicate a specific version (`v0.3.0`), a version prefix (`v0.3`),
+a branch or tag name (`master`), a revision (`1234abcd`), or one of the special
+queries `latest`, `upgrade`, `patch`, or `none`. If no version is given,
+`go get` uses the `@upgrade` query.
+
+Once `go get` has resolved its arguments to specific modules and versions, `go
+get` will add, change, or remove [`require` directives](#go-mod-file-require) in
+the main module's `go.mod` file to ensure the modules remain at the desired
+versions in the future. Note that required versions in `go.mod` files are
+*minimum versions* and may be increased automatically as new dependencies are
+added. See [Minimal version selection (MVS)](#minimal-version-selection) for
+details on how versions are selected and conflicts are resolved by module-aware
+commands.
+
+Other modules may be upgraded when a module named on the command line is added,
+upgraded, or downgraded if the new version of the named module requires other
+modules at higher versions. For example, suppose module `example.com/a` is
+upgraded to version `v1.5.0`, and that version requires module `example.com/b`
+at version `v1.2.0`. If module `example.com/b` is currently required at version
+`v1.1.0`, `go get example.com/a@v1.5.0` will also upgrade `example.com/b` to
+`v1.2.0`.
+
+
+
+Other modules may be downgraded when a module named on the command line is
+downgraded or removed. To continue the above example, suppose module
+`example.com/b` is downgraded to `v1.1.0`. Module `example.com/a` would also be
+downgraded to a version that requires `example.com/b` at version `v1.1.0` or
+lower.
+
+
+
+A module requirement may be removed using the version suffix `@none`. This is a
+special kind of downgrade. Modules that depend on the removed module will be
+downgraded or removed as needed. A module requirement may be removed even if one
+or more of its packages are imported by packages in the main module. In this
+case, the next build command may add a new module requirement.
+
+If a module is needed at two different versions (specified explicitly in command
+line arguments or to satisfy upgrades and downgrades), `go get` will report an
+error.
+
+After `go get` has selected a new set of versions, it checks whether any newly
+selected module versions or any modules providing packages named on the command
+line are [retracted](#glos-retracted-version) or
+[deprecated](#glos-deprecated-module). `go get` prints a warning for each
+retracted version or deprecated module it finds. [`go list -m -u
+all`](#go-list-m) may be used to check for retractions and deprecations in all
+dependencies.
+
+After `go get` updates the `go.mod` file, it builds the packages named
+on the command line. Executables will be installed in the directory named by
+the `GOBIN` environment variable, which defaults to `$GOPATH/bin` or
+`$HOME/go/bin` if the `GOPATH` environment variable is not set.
+
+`go get` supports the following flags:
+
+* The `-d` flag tells `go get` not to build or install packages. When `-d` is
+ used, `go get` will only manage dependencies in `go.mod`.
+* The `-u` flag tells `go get` to upgrade modules providing packages
+ imported directly or indirectly by packages named on the command line.
+ Each module selected by `-u` will be upgraded to its latest version unless
+ it is already required at a higher version (a pre-release).
+* The `-u=patch` flag (not `-u patch`) also tells `go get` to upgrade
+ dependencies, but `go get` will upgrade each dependency to the latest patch
+ version (similar to the `@patch` version query).
+* The `-t` flag tells `go get` to consider modules needed to build tests
+ of packages named on the command line. When `-t` and `-u` are used together,
+ `go get` will update test dependencies as well.
+* The `-insecure` flag should no longer be used. It permits `go get` to resolve
+ custom import paths and fetch from repositories and module proxies using
+ insecure schemes such as HTTP. The `GOINSECURE` [environment
+ variable](#environment-variables) provides more fine-grained control and
+ should be used instead.
+
+Since Go 1.16, [`go install`](#go-install) is the recommended command for
+building and installing programs. When used with a version suffix (like
+`@latest` or `@v1.4.6`), `go install` builds packages in module-aware mode,
+ignoring the `go.mod` file in the current directory or any parent directory,
+if there is one.
+
+`go get` is more focused on managing requirements in `go.mod`. The `-d` flag
+is deprecated, and in a future release, it will always be enabled.
+
+### `go install` {#go-install}
+
+Usage:
+
+```
+go install [build flags] [packages]
+```
+
+Examples:
+
+```
+# Install the latest version of a program,
+# ignoring go.mod in the current directory (if any).
+$ go install golang.org/x/tools/gopls@latest
+
+# Install a specific version of a program.
+$ go install golang.org/x/tools/gopls@v0.6.4
+
+# Install a program at the version selected by the module in the current directory.
+$ go install golang.org/x/tools/gopls
+
+# Install all programs in a directory.
+$ go install ./cmd/...
+```
+
+The `go install` command builds and installs the packages named by the paths
+on the command line. Executables (`main` packages) are installed to the
+directory named by the `GOBIN` environment variable, which defaults to
+`$GOPATH/bin` or `$HOME/go/bin` if the `GOPATH` environment variable is not set.
+Executables in `$GOROOT` are installed in `$GOROOT/bin` or `$GOTOOLDIR` instead
+of `$GOBIN`.
+
+Since Go 1.16, if the arguments have version suffixes (like `@latest` or
+`@v1.0.0`), `go install` builds packages in module-aware mode, ignoring the
+`go.mod` file in the current directory or any parent directory if there is
+one. This is useful for installing executables without affecting the
+dependencies of the main module.
+
+To eliminate ambiguity about which module versions are used in the build, the
+arguments must satisfy the following constraints:
+
+* Arguments must be package paths or package patterns (with "`...`" wildcards).
+ They must not be standard packages (like `fmt`), meta-patterns (`std`, `cmd`,
+ `all`), or relative or absolute file paths.
+* All arguments must have the same version suffix. Different queries are not
+ allowed, even if they refer to the same version.
+* All arguments must refer to packages in the same module at the same version.
+* No module is considered the [main module](#glos-main-module). If the module
+ containing packages named on the command line has a `go.mod` file, it must not
+ contain directives (`replace` and `exclude`) that would cause it to be
+ interpreted differently than if it were the main module. The module must not
+ require a higher version of itself.
+* Package path arguments must refer to `main` packages. Pattern arguments
+ will only match `main` packages.
+
+See [Version queries](#version-queries) for supported version query syntax.
+Go 1.15 and lower did not support using version queries with `go install`.
+
+If the arguments don't have version suffixes, `go install` may run in
+module-aware mode or `GOPATH` mode, depending on the `GO111MODULE` environment
+variable and the presence of a `go.mod` file. See [Module-aware
+commands](#mod-commands) for details. If module-aware mode is enabled, `go
+install` runs in the context of the main module, which may be different from the
+module containing the package being installed.
+
+### `go list -m` {#go-list-m}
+
+Usage:
+
+```
+go list -m [-u] [-retracted] [-versions] [list flags] [modules]
+```
+
+Example:
+
+```
+$ go list -m all
+$ go list -m -versions example.com/m
+$ go list -m -json example.com/m@latest
+```
+
+The `-m` flag causes `go list` to list modules instead of packages. In this
+mode, the arguments to `go list` may be modules, module patterns (containing the
+`...` wildcard), [version queries](#version-queries), or the special pattern
+`all`, which matches all modules in the [build list](#glos-build-list). If no
+arguments are specified, the [main module](#glos-main-module) is listed.
+
+When listing modules, the `-f` flag still specifies a format template applied
+to a Go struct, but now a `Module` struct:
+
+```
+type Module struct {
+ Path string // module path
+ Version string // module version
+ Versions []string // available module versions (with -versions)
+ Replace *Module // replaced by this module
+ Time *time.Time // time version was created
+ Update *Module // available update, if any (with -u)
+ Main bool // is this the main module?
+ Indirect bool // is this module only an indirect dependency of main module?
+ Dir string // directory holding files for this module, if any
+ GoMod string // path to go.mod file for this module, if any
+ GoVersion string // go version used in module
+ Deprecated string // deprecation message, if any (with -u)
+ Error *ModuleError // error loading module
+}
+
+type ModuleError struct {
+ Err string // the error itself
+}
+```
+
+The default output is to print the module path and then information about the
+version and replacement if any. For example, `go list -m all` might print:
+
+```
+example.com/main/module
+golang.org/x/net v0.1.0
+golang.org/x/text v0.3.0 => /tmp/text
+rsc.io/pdf v0.1.1
+```
+
+The `Module` struct has a `String` method that formats this line of output, so
+that the default format is equivalent to `-f '{{.String}}'`.
+
+Note that when a module has been replaced, its `Replace` field describes the
+replacement module module, and its `Dir` field is set to the replacement
+module's source code, if present. (That is, if `Replace` is non-nil, then `Dir`
+is set to `Replace.Dir`, with no access to the replaced source code.)
+
+The `-u` flag adds information about available upgrades. When the latest version
+of a given module is newer than the current one, `list -u` sets the module's
+`Update` field to information about the newer module. `list -u` also prints
+whether the currently selected version is [retracted](#glos-retracted-version)
+and whether the module is [deprecated](#go-mod-file-module-deprecation). The
+module's `String` method indicates an available upgrade by formatting the newer
+version in brackets after the current version. For example, `go list -m -u all`
+might print:
+
+```
+example.com/main/module
+golang.org/x/old v1.9.9 (deprecated)
+golang.org/x/net v0.1.0 (retracted) [v0.2.0]
+golang.org/x/text v0.3.0 [v0.4.0] => /tmp/text
+rsc.io/pdf v0.1.1 [v0.1.2]
+```
+
+(For tools, `go list -m -u -json all` may be more convenient to parse.)
+
+The `-versions` flag causes `list` to set the module's `Versions` field to a
+list of all known versions of that module, ordered according to semantic
+versioning, lowest to highest. The flag also changes the default output format
+to display the module path followed by the space-separated version list.
+Retracted versions are omitted from this list unless the `-retracted` flag
+is also specified.
+
+The `-retracted` flag instructs `list` to show retracted versions in the list
+printed with the `-versions` flag and to consider retracted versions when
+resolving [version queries](#version-queries). For example, `go list -m
+-retracted example.com/m@latest` shows the highest release or pre-release
+version of the module `example.com/m`, even if that version is retracted.
+[`retract` directives](#go-mod-file-retract) and
+[deprecations](#go-mod-file-module-deprecation) are loaded from the `go.mod`
+file at this version. The `-retracted` flag was added in Go 1.16.
+
+The template function `module` takes a single string argument that must be a
+module path or query and returns the specified module as a `Module` struct. If
+an error occurs, the result will be a `Module` struct with a non-nil `Error`
+field.
+
+### `go mod download` {#go-mod-download}
+
+Usage:
+
+```
+go mod download [-json] [-x] [modules]
+```
+
+Example:
+
+```
+$ go mod download
+$ go mod download golang.org/x/mod@v0.2.0
+```
+
+The `go mod download` command downloads the named modules into the [module
+cache](#glos-module-cache). Arguments can be module paths or module
+patterns selecting dependencies of the main module or [version
+queries](#version-queries) of the form `path@version`. With no arguments,
+`download` applies to all dependencies of the [main module](#glos-main-module).
+
+The `go` command will automatically download modules as needed during ordinary
+execution. The `go mod download` command is useful mainly for pre-filling the
+module cache or for loading data to be served by a [module
+proxy](#glos-module-proxy).
+
+By default, `download` writes nothing to standard output. It prints progress
+messages and errors to standard error.
+
+The `-json` flag causes `download` to print a sequence of JSON objects to
+standard output, describing each downloaded module (or failure), corresponding
+to this Go struct:
+
+```
+type Module struct {
+ Path string // module path
+ Version string // module version
+ Error string // error loading module
+ Info string // absolute path to cached .info file
+ GoMod string // absolute path to cached .mod file
+ Zip string // absolute path to cached .zip file
+ Dir string // absolute path to cached source root directory
+ Sum string // checksum for path, version (as in go.sum)
+ GoModSum string // checksum for go.mod (as in go.sum)
+}
+```
+
+The `-x` flag causes `download` to print the commands `download` executes
+to standard error.
+
+### `go mod edit` {#go-mod-edit}
+
+Usage:
+
+```
+go mod edit [editing flags] [-fmt|-print|-json] [go.mod]
+```
+
+Example:
+
+```
+# Add a replace directive.
+$ go mod edit -replace example.com/a@v1.0.0=./a
+
+# Remove a replace directive.
+$ go mod edit -dropreplace example.com/a@v1.0.0
+
+# Set the go version, add a requirement, and print the file
+# instead of writing it to disk.
+$ go mod edit -go=1.14 -require=example.com/m@v1.0.0 -print
+
+# Format the go.mod file.
+$ go mod edit -fmt
+
+# Format and print a different .mod file.
+$ go mod edit -print tools.mod
+
+# Print a JSON representation of the go.mod file.
+$ go mod edit -json
+```
+
+The `go mod edit` command provides a command-line interface for editing and
+formatting `go.mod` files, for use primarily by tools and scripts. `go mod edit`
+reads only one `go.mod` file; it does not look up information about other
+modules. By default, `go mod edit` reads and writes the `go.mod` file of the
+main module, but a different target file can be specified after the editing
+flags.
+
+The editing flags specify a sequence of editing operations.
+
+* The `-module` flag changes the module's path (the `go.mod` file's module
+ line).
+* The `-go=version` flag sets the expected Go language version.
+* The `-require=path@version` and `-droprequire=path` flags add and drop a
+ requirement on the given module path and version. Note that `-require`
+ overrides any existing requirements on `path`. These flags are mainly for
+ tools that understand the module graph. Users should prefer `go get
+ path@version` or `go get path@none`, which make other `go.mod` adjustments as
+ needed to satisfy constraints imposed by other modules. See [`go
+ get`](#go-get).
+* The `-exclude=path@version` and `-dropexclude=path@version` flags add and drop
+ an exclusion for the given module path and version. Note that
+ `-exclude=path@version` is a no-op if that exclusion already exists.
+* The `-replace=old[@v]=new[@v]` flag adds a replacement of the given module
+ path and version pair. If the `@v` in `old@v` is omitted, a replacement
+ without a version on the left side is added, which applies to all versions of
+ the old module path. If the `@v` in `new@v` is omitted, the new path should be
+ a local module root directory, not a module path. Note that `-replace`
+ overrides any redundant replacements for `old[@v]`, so omitting `@v` will drop
+ replacements for specific versions.
+* The `-dropreplace=old[@v]` flag drops a replacement of the given module path
+ and version pair. If the `@v` is provided, a replacement with the given
+ version is dropped. An existing replacement without a version on the left side
+ may still replace the module. If the `@v` is omitted, a replacement without a
+ version is dropped.
+* The `-retract=version` and `-dropretract=version` flags add and drop a
+ retraction for the given version, which may be a single version (like
+ `v1.2.3`) or an interval (like `[v1.1.0,v1.2.0]`). Note that the `-retract`
+ flag cannot add a rationale comment for the `retract` directive. Rationale
+ comments are recommended and may be shown by `go list -m -u` and other
+ commands.
+
+The editing flags may be repeated. The changes are applied in the order given.
+
+`go mod edit` has additional flags that control its output.
+
+* The `-fmt` flag reformats the `go.mod` file without making other changes.
+ This reformatting is also implied by any other modifications that use or
+ rewrite the `go.mod` file. The only time this flag is needed is if no
+ other flags are specified, as in `go mod edit -fmt`.
+* The `-print` flag prints the final `go.mod` in its text format instead of
+ writing it back to disk.
+* The `-json` flag prints the final `go.mod` in JSON format instead of writing
+ it back to disk in text format. The JSON output corresponds to these Go types:
+
+```
+type Module struct {
+ Path string
+ Version string
+}
+
+type GoMod struct {
+ Module Module
+ Go string
+ Require []Require
+ Exclude []Module
+ Replace []Replace
+}
+
+type Require struct {
+ Path string
+ Version string
+ Indirect bool
+}
+
+type Replace struct {
+ Old Module
+ New Module
+}
+
+type Retract struct {
+ Low string
+ High string
+ Rationale string
+}
+
+```
+
+Note that this only describes the `go.mod` file itself, not other modules
+referred to indirectly. For the full set of modules available to a build,
+use `go list -m -json all`. See [`go list -m`](#go-list-m).
+
+For example, a tool can obtain the `go.mod` file as a data structure by
+parsing the output of `go mod edit -json` and can then make changes by invoking
+`go mod edit` with `-require`, `-exclude`, and so on.
+
+Tools may also use the package
+[`golang.org/x/mod/modfile`](https://pkg.go.dev/golang.org/x/mod/modfile?tab=doc)
+to parse, edit, and format `go.mod` files.
+
+### `go mod graph` {#go-mod-graph}
+
+Usage:
+
+```
+go mod graph
+```
+
+The `go mod graph` command prints the [module requirement
+graph](#glos-module-graph) (with replacements applied) in text form. For
+example:
+
+```
+example.com/main example.com/a@v1.1.0
+example.com/main example.com/b@v1.2.0
+example.com/a@v1.1.0 example.com/b@v1.1.1
+example.com/a@v1.1.0 example.com/c@v1.3.0
+example.com/b@v1.1.0 example.com/c@v1.1.0
+example.com/b@v1.2.0 example.com/c@v1.2.0
+```
+
+Each vertex in the module graph represents a specific version of a module.
+Each edge in the graph represents a requirement on a minimum version of a
+dependency.
+
+`go mod graph` prints the edges of the graph, one per line. Each line has two
+space-separated fields: a module version and one of its dependencies. Each
+module version is identified as a string of the form `path@version`. The main
+module has no `@version` suffix, since it has no version.
+
+See [Minimal version selection (MVS)](#minimal-version-selection) for more
+information on how versions are chosen. See also [`go list -m`](#go-list-m) for
+printing selected versions and [`go mod why`](#go-mod-why) for understanding
+why a module is needed.
+
+### `go mod init` {#go-mod-init}
+
+Usage:
+
+```
+go mod init [module-path]
+```
+
+Example:
+
+```
+go mod init
+go mod init example.com/m
+```
+
+The `go mod init` command initializes and writes a new `go.mod` file in the
+current directory, in effect creating a new module rooted at the current
+directory. The `go.mod` file must not already exist.
+
+`init` accepts one optional argument, the [module path](#glos-module-path) for
+the new module. See [Module paths](#module-path) for instructions on choosing
+a module path. If the module path argument is omitted, `init` will attempt
+to infer the module path using import comments in `.go` files, vendoring tool
+configuration files, and the current directory (if in `GOPATH`).
+
+If a configuration file for a vendoring tool is present, `init` will attempt to
+import module requirements from it. `init` supports the following configuration
+files.
+
+* `GLOCKFILE` (Glock)
+* `Godeps/Godeps.json` (Godeps)
+* `Gopkg.lock` (dep)
+* `dependencies.tsv` (godeps)
+* `glide.lock` (glide)
+* `vendor.conf` (trash)
+* `vendor.yml` (govend)
+* `vendor/manifest` (gvt)
+* `vendor/vendor.json` (govendor)
+
+Vendoring tool configuration files can't always be translated with perfect
+fidelity. For example, if multiple packages within the same repository are
+imported at different versions, and the repository only contains one module, the
+imported `go.mod` can only require the module at one version. You may wish to
+run [`go list -m all`](#go-list-m) to check all versions in the [build
+list](#glos-build-list), and [`go mod tidy`](#go-mod-tidy) to add missing
+requirements and to drop unused requirements.
+
+### `go mod tidy` {#go-mod-tidy}
+
+Usage:
+
+```
+go mod tidy [-e] [-v]
+```
+
+`go mod tidy` ensures that the `go.mod` file matches the source code in the
+module. It adds any missing module requirements necessary to build the current
+module's packages and dependencies, and it removes requirements on modules that
+don't provide any relevant packages. It also adds any missing entries to
+`go.sum` and removes unnecessary entries.
+
+The `-e` flag (added in Go 1.16) causes `go mod tidy` to attempt to proceed
+despite errors encountered while loading packages.
+
+The `-v` flag causes `go mod tidy` to print information about removed modules
+to standard error.
+
+`go mod tidy` works by loading all of the packages in the [main
+module](#glos-main-module) and all of the packages they import,
+recursively. This includes packages imported by tests (including tests in other
+modules). `go mod tidy` acts as if all build tags are enabled, so it will
+consider platform-specific source files and files that require custom build
+tags, even if those source files wouldn't normally be built. There is one
+exception: the `ignore` build tag is not enabled, so a file with the build
+constraint `// +build ignore` will not be considered. Note that `go mod tidy`
+will not consider packages in the main module in directories named `testdata` or
+with names that start with `.` or `_` unless those packages are explicitly
+imported by other packages.
+
+Once `go mod tidy` has loaded this set of packages, it ensures that each module
+that provides one or more packages either has a `require` directive in the main
+module's `go.mod` file or is required by another required module. `go mod tidy`
+will add a requirement on the latest version on each missing module (see
+[Version queries](#version-queries) for the definition of the `latest`
+version). `go mod tidy` will remove `require` directives for modules that don't
+provide any packages in the set described above.
+
+`go mod tidy` may also add or remove `// indirect` comments on `require`
+directives. An `// indirect` comment denotes a module that does not provide
+packages imported by packages in the main module. These requirements will be
+present if the module that imports packages in the indirect dependency has
+no `go.mod` file. They may also be present if the indirect dependency is
+required at a higher version than is implied by the module graph; this usually
+happens after running a command like `go get -u ./...`.
+
+### `go mod vendor` {#go-mod-vendor}
+
+Usage:
+
+```
+go mod vendor [-e] [-v]
+```
+
+The `go mod vendor` command constructs a directory named `vendor` in the [main
+module's](#glos-main-module) root directory that contains copies of all packages
+needed to support builds and tests of packages in the main module. Packages
+that are only imported by tests of packages outside the main module are not
+included. As with [`go mod tidy`](#go-mod-tidy) and other module commands,
+[build constraints](#glos-build-constraint) except for `ignore` are not
+considered when constructing the `vendor` directory.
+
+When vendoring is enabled, the `go` command will load packages from the `vendor`
+directory instead of downloading modules from their sources into the module
+cache and using packages those downloaded copies. See [Vendoring](#vendoring)
+for more information.
+
+`go mod vendor` also creates the file `vendor/modules.txt` that contains a list
+of vendored packages and the module versions they were copied from. When
+vendoring is enabled, this manifest is used as a source of module version
+information, as reported by [`go list -m`](#go-list-m) and [`go version
+-m`](#go-version-m). When the `go` command reads `vendor/modules.txt`, it checks
+that the module versions are consistent with `go.mod`. If `go.mod` changed since
+`vendor/modules.txt` was generated, `go mod vendor` should be run again.
+
+Note that `go mod vendor` removes the `vendor` directory if it exists before
+re-constructing it. Local changes should not be made to vendored packages.
+The `go` command does not check that packages in the `vendor` directory have
+not been modified, but one can verify the integrity of the `vendor` directory
+by running `go mod vendor` and checking that no changes were made.
+
+The `-e` flag (added in Go 1.16) causes `go mod vendor` to attempt to proceed
+despite errors encountered while loading packages.
+
+The `-v` flag causes `go mod vendor` to print the names of vendored modules
+and packages to standard error.
+
+### `go mod verify` {#go-mod-verify}
+
+Usage:
+
+```
+go mod verify
+```
+
+`go mod verify` checks that dependencies of the [main module](#glos-main-module)
+stored in the [module cache](#glos-module-cache) have not been modified since
+they were downloaded. To perform this check, `go mod verify` hashes each
+downloaded module [`.zip` file](#zip-files) and extracted directory, then
+compares those hashes with a hash recorded when the module was first
+downloaded. `go mod verify` checks each module in the [build
+list](#glos-build-list) (which may be printed with [`go list -m
+all`](#go-list-m)).
+
+If all the modules are unmodified, `go mod verify` prints "all modules
+verified". Otherwise, it reports which modules have been changed and exits with
+a non-zero status.
+
+Note that all module-aware commands verify that hashes in the main module's
+`go.sum` file match hashes recorded for modules downloaded into the module
+cache. If a hash is missing from `go.sum` (for example, because the module is
+being used for the first time), the `go` command verifies its hash using the
+[checksum database](#checksum-database) (unless the module path is matched by
+`GOPRIVATE` or `GONOSUMDB`). See [Authenticating modules](#authenticating) for
+details.
+
+In contrast, `go mod verify` checks that module `.zip` files and their extracted
+directories have hashes that match hashes recorded in the module cache when they
+were first downloaded. This is useful for detecting changes to files in the
+module cache *after* a module has been downloaded and verified. `go mod verify`
+does not download content for modules not in the cache, and it does not use
+`go.sum` files to verify module content. However, `go mod verify` may download
+`go.mod` files in order to perform [minimal version
+selection](#minimal-version-selection). It will use `go.sum` to verify those
+files, and it may add `go.sum` entries for missing hashes.
+
+### `go mod why` {#go-mod-why}
+
+Usage:
+
+```
+go mod why [-m] [-vendor] packages...
+```
+
+`go mod why` shows a shortest path in the import graph from the main module to
+each of the listed packages.
+
+The output is a sequence of stanzas, one for each package or module named on the
+command line, separated by blank lines. Each stanza begins with a comment line
+starting with `#` giving the target package or module. Subsequent lines give a
+path through the import graph, one package per line. If the package or module
+is not referenced from the main module, the stanza will display a single
+parenthesized note indicating that fact.
+
+For example:
+
+```
+$ go mod why golang.org/x/text/language golang.org/x/text/encoding
+# golang.org/x/text/language
+rsc.io/quote
+rsc.io/sampler
+golang.org/x/text/language
+
+# golang.org/x/text/encoding
+(main module does not need package golang.org/x/text/encoding)
+```
+
+The `-m` flag causes `go mod why` to treat its arguments as a list of modules.
+`go mod why` will print a path to any package in each of the modules. Note that
+even when `-m` is used, `go mod why` queries the package graph, not the
+module graph printed by [`go mod graph`](#go-mod-graph).
+
+The `-vendor` flag causes `go mod why` to ignore imports in tests of packages
+outside the main module (as [`go mod vendor`](#go-mod-vendor) does). By default,
+`go mod why` considers the graph of packages matched by the `all` pattern. This
+flag has no effect after Go 1.16 in modules that declare `go 1.16` or higher
+(using the [`go` directive](#go-mod-file-go) in `go.mod`), since the meaning of
+`all` changed to match the set of packages matched by `go mod vendor`.
+
+### `go version -m` {#go-version-m}
+
+Usage:
+
+```
+go version [-m] [-v] [file ...]
+```
+
+Example:
+
+```
+# Print Go version used to build go.
+$ go version
+
+# Print Go version used to build a specific executable.
+$ go version ~/go/bin/gopls
+
+# Print Go version and module versions used to build a specific executable.
+$ go version -m ~/go/bin/gopls
+
+# Print Go version and module versions used to build executables in a directory.
+$ go version -m ~/go/bin/
+```
+
+`go version` reports the Go version used to build each executable file named
+on the command line.
+
+If no files are named on the command line, `go version` prints its own version
+information.
+
+If a directory is named, `go version` walks that directory, recursively, looking
+for recognized Go binaries and reporting their versions. By default, `go
+version` does not report unrecognized files found during a directory scan. The
+`-v` flag causes it to report unrecognized files.
+
+The `-m` flag causes `go version` to print each executable's embedded module
+version information, when available. For each executable, `go version -m` prints
+a table with tab-separated columns like the one below.
+
+```
+$ go version -m ~/go/bin/goimports
+/home/jrgopher/go/bin/goimports: go1.14.3
+ path golang.org/x/tools/cmd/goimports
+ mod golang.org/x/tools v0.0.0-20200518203908-8018eb2c26ba h1:0Lcy64USfQQL6GAJma8BdHCgeofcchQj+Z7j0SXYAzU=
+ dep golang.org/x/mod v0.2.0 h1:KU7oHjnv3XNWfa5COkzUifxZmxp1TyI7ImMXqFxLwvQ=
+ dep golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+```
+
+The format of the table may change in the future. The same information may be
+obtained from
+[`runtime/debug.ReadBuildInfo`](https://pkg.go.dev/runtime/debug?tab=doc#ReadBuildInfo).
+
+The meaning of each row in the table is determined by the word in the first
+column.
+
+* **`path`**: the path of the `main` package used to build the executable.
+* **`mod`**: the module containing the `main` package. The columns are the
+ module path, version, and sum, respectively. The [main
+ module](#glos-main-module) has the version `(devel)` and no sum.
+* **`dep`**: a module that provided one or more packages linked into the
+ executable. Same format as `mod`.
+* **`=>`**: a [replacement](#go-mod-file-replace) for the module on the previous
+ line. If the replacement is a local directory, only the directory path is
+ listed (no version or sum). If the replacement is a module version, the path,
+ version, and sum are listed, as with `mod` and `dep`. A replaced module has
+ no sum.
+
+### `go clean -modcache` {#go-clean-modcache}
+
+Usage:
+
+```
+go clean [-modcache]
+```
+
+The `-modcache` flag causes [`go
+clean`](/cmd/go/#hdr-Remove_object_files_and_cached_files) to remove the entire
+[module cache](#glos-module-cache), including unpacked source code of versioned
+dependencies.
+
+This is usually the best way to remove the module cache. By default, most files
+and directories in the module cache are read-only to prevent tests and editors
+from unintentionally changing files after they've been
+[authenticated](#authenticating). Unfortunately, this causes commands like
+`rm -r` to fail, since files can't be removed without first making their parent
+directories writable.
+
+The `-modcacherw` flag (accepted by [`go
+build`](https://golang.org/cmd/go/#hdr-Compile_packages_and_dependencies) and
+other module-aware commands) causes new directories in the module cache to
+be writable. To pass `-modcacherw` to all module-aware commands, add it to the
+`GOFLAGS` variable. `GOFLAGS` may be set in the environment or with [`go env
+-w`](https://golang.org/cmd/go/#hdr-Print_Go_environment_information). For
+example, the command below sets it permanently:
+
+```
+go env -w GOFLAGS=-modcacherw
+```
+
+`-modcacherw` should be used with caution; developers should be careful not
+to make changes to files in the module cache. [`go mod verify`](#go-mod-verify)
+may be used to check that files in the cache match hashes in the main module's
+`go.sum` file.
+
+### Version queries {#version-queries}
+
+Several commands allow you to specify a version of a module using a *version
+query*, which appears after an `@` character following a module or package path
+on the command line.
+
+Examples:
+
+```
+go get example.com/m@latest
+go mod download example.com/m@master
+go list -m -json example.com/m@e3702bed2
+```
+
+A version query may be one of the following:
+
+* A fully-specified semantic version, such as `v1.2.3`, which selects a
+ specific version. See [Versions](#versions) for syntax.
+* A semantic version prefix, such as `v1` or `v1.2`, which selects the highest
+ available version with that prefix.
+* A semantic version comparison, such as `<v1.2.3` or `>=v1.5.6`, which selects
+ the nearest available version to the comparison target (the lowest version
+ for `>` and `>=`, and the highest version for `<` and `<=`).
+* A revision identifier for the underlying source repository, such as a commit
+ hash prefix, revision tag, or branch name. If the revision is tagged with a
+ semantic version, this query selects that version. Otherwise, this query
+ selects a [pseudo-version](#glos-pseudo-version) for the underlying
+ commit. Note that branches and tags with names matched by other version
+ queries cannot be selected this way. For example, the query `v2` selects the
+ latest version starting with `v2`, not the branch named `v2`.
+* The string `latest`, which selects the highest available release version. If
+ there are no release versions, `latest` selects the highest pre-release
+ version. If there no tagged versions, `latest` selects a pseudo-version for
+ the commit at the tip of the repository's default branch.
+* The string `upgrade`, which is like `latest` except that if the module is
+ currently required at a higher version than the version `latest` would select
+ (for example, a pre-release), `upgrade` will select the current version.
+* The string `patch`, which selects the latest available version with the same
+ major and minor version numbers as the currently required version. If no
+ version is currently required, `patch` is equivalent to `latest`. Since
+ Go 1.16, [`go get`](#go-get) requires a current version when using `patch`
+ (but the `-u=patch` flag does not have this requirement).
+
+Except for queries for specific named versions or revisions, all queries
+consider available versions reported by `go list -m -versions` (see [`go list
+-m`](#go-list-m)). This list contains only tagged versions, not pseudo-versions.
+Module versions disallowed by [`exclude` directives](#go-mod-file-exclude) in
+the main module's [`go.mod` file](#glos-go-mod-file) are not considered.
+Versions covered by [`retract` directives](#go-mod-file-retract) in the `go.mod`
+file from the `latest` version of the same module are also ignored except when
+the `-retracted` flag is used with [`go list -m`](#go-list-m) and except when
+loading `retract` directives.
+
+[Release versions](#glos-release-version) are preferred over pre-release
+versions. For example, if versions `v1.2.2` and `v1.2.3-pre` are available, the
+`latest` query will select `v1.2.2`, even though `v1.2.3-pre` is higher. The
+`<v1.2.4` query would also select `v1.2.2`, even though `v1.2.3-pre` is closer
+to `v1.2.4`. If no release or pre-release version is available, the `latest`,
+`upgrade`, and `patch` queries will select a pseudo-version for the commit
+at the tip of the repository's default branch. Other queries will report
+an error.
+
+### Module commands outside a module {#commands-outside}
+
+Module-aware Go commands normally run in the context of a [main
+module](#glos-main-module) defined by a `go.mod` file in the working directory
+or a parent directory. Some commands may be run in module-aware mode without a
+`go.mod` file, but most commands work differently or report an error when no
+`go.mod` file is present.
+
+See [Module-aware commands](#mod-commands) for information on enabling and
+disabling module-aware mode.
+
+<table class="ModTable">
+ <thead>
+ <tr>
+ <th>Command</th>
+ <th>Behavior</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr>
+ <td>
+ <code>go build</code><br>
+ <code>go doc</code><br>
+ <code>go fix</code><br>
+ <code>go fmt</code><br>
+ <code>go generate</code><br>
+ <code>go install</code><br>
+ <code>go list</code><br>
+ <code>go run</code><br>
+ <code>go test</code><br>
+ <code>go vet</code>
+ </td>
+ <td>
+ Only packages in the standard library and packages specified as
+ <code>.go</code> files on the command line can be loaded, imported, and
+ built. Packages from other modules cannot be built, since there is no
+ place to record module requirements and ensure deterministic builds.
+ </td>
+ </tr>
+ <tr>
+ <td><code>go get</code></td>
+ <td>
+ Packages and executables may be built and installed as usual. Note that
+ there is no main module when <code>go get</code> is run without a
+ <code>go.mod</code> file, so <code>replace</code> and
+ <code>exclude</code> directives are not applied.
+ </td>
+ </tr>
+ <tr>
+ <td><code>go list -m</code></td>
+ <td>
+ Explicit <a href="#version-queries">version queries</a> are required
+ for most arguments, except when the <code>-versions</code> flag is used.
+ </td>
+ </tr>
+ <tr>
+ <td><code>go mod download</code></td>
+ <td>
+ Explicit <a href="#version-queries">version queries</a> are required
+ for most arguments.
+ </td>
+ </tr>
+ <tr>
+ <td><code>go mod edit</code></td>
+ <td>An explicit file argument is required.</td>
+ </tr>
+ <tr>
+ <td>
+ <code>go mod graph</code><br>
+ <code>go mod tidy</code><br>
+ <code>go mod vendor</code><br>
+ <code>go mod verify</code><br>
+ <code>go mod why</code>
+ </td>
+ <td>
+ These commands require a <code>go.mod</code> file and will report
+ an error if one is not present.
+ </td>
+ </tr>
+ </tbody>
+</table>
+
+## Module proxies {#module-proxy}
+
+### `GOPROXY` protocol {#goproxy-protocol}
+
+A <dfn>module proxy</dfn> is an HTTP server that can respond to `GET` requests
+for paths specified below. The requests have no query parameters, and no
+specific headers are required, so even a site serving from a fixed file system
+(including a `file://` URL) can be a module proxy.
+
+Successful HTTP responses must have the status code 200 (OK). Redirects (3xx)
+are followed. Responses with status codes 4xx and 5xx are treated as errors.
+The error codes 404 (Not Found) and 410 (Gone) indicate that the
+requested module or version is not available on the proxy, but it may be found
+elsewhere. Error responses should have content type `text/plain` with
+`charset` either `utf-8` or `us-ascii`.
+
+The `go` command may be configured to contact proxies or source control servers
+using the `GOPROXY` environment variable, which accepts a list of proxy URLs.
+The list may include the keywords `direct` or `off` (see [Environment
+variables](#environment-variables) for details). List elements may be separated
+by commas (`,`) or pipes (`|`), which determine error fallback behavior. When a
+URL is followed by a comma, the `go` command falls back to later sources only
+after a 404 (Not Found) or 410 (Gone) response. When a URL is followed by a
+pipe, the `go` command falls back to later sources after any error, including
+non-HTTP errors such as timeouts. This error handling behavior lets a proxy act
+as a gatekeeper for unknown modules. For example, a proxy could respond with
+error 403 (Forbidden) for modules not on an approved list (see [Private proxy
+serving private modules](#private-module-proxy-private)).
+
+The table below specifies queries that a module proxy must respond to. For each
+path, `$base` is the path portion of a proxy URL,`$module` is a module path, and
+`$version` is a version. For example, if the proxy URL is
+`https://example.com/mod`, and the client is requesting the `go.mod` file for
+the module `golang.org/x/text` at version `v0.3.2`, the client would send a
+`GET` request for `https://example.com/mod/golang.org/x/text/@v/v0.3.2.mod`.
+
+To avoid ambiguity when serving from case-insensitive file systems,
+the `$module` and `$version` elements are case-encoded by replacing every
+uppercase letter with an exclamation mark followed by the corresponding
+lower-case letter. This allows modules `example.com/M` and `example.com/m` to
+both be stored on disk, since the former is encoded as `example.com/!m`.
+
+<table class="ModTable">
+ <thead>
+ <tr>
+ <th>Path</th>
+ <th>Description</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr>
+ <td><code>$base/$module/@v/list</code></td>
+ <td>
+ Returns a list of known versions of the given module in plain text, one
+ per line. This list should not include pseudo-versions.
+ </td>
+ </tr>
+ <tr>
+ <td><code>$base/$module/@v/$version.info</code></td>
+ <td>
+ <p>
+ Returns JSON-formatted metadata about a specific version of a module.
+ The response must be a JSON object that corresponds to the Go data
+ structure below:
+ </p>
+ <pre>
+type Info struct {
+ Version string // version string
+ Time time.Time // commit time
+}
+</pre>
+ <p>
+ The <code>Version</code> field is required and must contain a valid,
+ <a href="#glos-canonical-version">canonical version</a> (see
+ <a href="#versions">Versions</a>). The <code>$version</code> in the
+ request path does not need to be the same version or even a valid
+ version; this endpoint may be used to find versions for branch names
+ or revision identifiers. However, if <code>$version</code> is a
+ canonical version with a major version compatible with
+ <code>$module</code>, the <code>Version</code> field in a successful
+ response must be the same.
+ </p>
+ <p>
+ The <code>Time</code> field is optional. If present, it must be a
+ string in RFC 3339 format. It indicates the time when the version
+ was created.
+ </p>
+ <p>
+ More fields may be added in the future, so other names are reserved.
+ </p>
+ </td>
+ </tr>
+ <tr>
+ <td><code>$base/$module/@v/$version.mod</code></td>
+ <td>
+ Returns the <code>go.mod</code> file for a specific version of a
+ module. If the module does not have a <code>go.mod</code> file at the
+ requested version, a file containing only a <code>module</code>
+ statement with the requested module path must be returned. Otherwise,
+ the original, unmodified <code>go.mod</code> file must be returned.
+ </td>
+ </tr>
+ <tr>
+ <td><code>$base/$module/@v/$version.zip</code></td>
+ <td>
+ Returns a zip file containing the contents of a specific version of
+ a module. See <a href="#zip-files">Module zip files</a> for details
+ on how this zip file must be formatted.
+ </td>
+ </tr>
+ <tr>
+ <td><code>$base/$module/@latest</code></td>
+ <td>
+ Returns JSON-formatted metadata about the latest known version of a
+ module in the same format as
+ <code>$base/$module/@v/$version.info</code>. The latest version should
+ be the version of the module that the <code>go</code> command should use
+ if <code>$base/$module/@v/list</code> is empty or no listed version is
+ suitable. This endpoint is optional, and module proxies are not required
+ to implement it.
+ </td>
+ </tr>
+ </tbody>
+</table>
+
+When resolving the latest version of a module, the `go` command will request
+`$base/$module/@v/list`, then, if no suitable versions are found,
+`$base/$module/@latest`. The `go` command prefers, in order: the semantically
+highest release version, the semantically highest pre-release version, and the
+chronologically most recent pseudo-version. In Go 1.12 and earlier, the `go`
+command considered pseudo-versions in `$base/$module/@v/list` to be pre-release
+versions, but this is no longer true since Go 1.13.
+
+A module proxy must always serve the same content for successful
+responses for `$base/$module/$version.mod` and `$base/$module/$version.zip`
+queries. This content is [cryptographically authenticated](#authenticating)
+using [`go.sum` files](go-sum-files) and, by default, the
+[checksum database](#checksum-database).
+
+The `go` command caches most content it downloads from module proxies in its
+module cache in `$GOPATH/pkg/mod/cache/download`. Even when downloading directly
+from version control systems, the `go` command synthesizes explicit `info`,
+`mod`, and `zip` files and stores them in this directory, the same as if it had
+downloaded them directly from a proxy. The cache layout is the same as the proxy
+URL space, so serving `$GOPATH/pkg/mod/cache/download` at (or copying it to)
+`https://example.com/proxy` would let users access cached module versions by
+setting `GOPROXY` to `https://example.com/proxy`.
+
+### Communicating with proxies {#communicating-with-proxies}
+
+The `go` command may download module source code and metadata from a [module
+proxy](#glos-module-proxy). The `GOPROXY` [environment
+variable](#environment-variables) may be used to configure which proxies the
+`go` command may connect to and whether it may communicate directly with
+[version control systems](#vcs). Downloaded module data is saved in the [module
+cache](#glos-module-cache). The `go` command will only contact a proxy when it
+needs information not already in the cache.
+
+The [`GOPROXY` protocol](#goproxy-protocol) section describes requests that
+may be sent to a `GOPROXY` server. However, it's also helpful to understand
+when the `go` command makes these requests. For example, `go build` follows
+the procedure below:
+
+* Compute the [build list](#glos-build-list) by reading [`go.mod`
+ files](#glos-go-mod-file) and performing [minimal version selection
+ (MVS)](#glos-minimal-version-selection).
+* Read the packages named on the command line and the packages they import.
+* If a package is not provided by any module in the build list, find a module
+ that provides it. Add a module requirement on its latest version to `go.mod`,
+ and start over.
+* Build packages after everything is loaded.
+
+When the `go` command computes the build list, it loads the `go.mod` file for
+each module in the [module graph](#glos-module-graph). If a `go.mod` file is not
+in the cache, the `go` command will download it from the proxy using a
+`$module/@v/$version.mod` request (where `$module` is the module path and
+`$version` is the version). These requests can be tested with a tool like
+`curl`. For example, the command below downloads the `go.mod` file for
+`golang.org/x/mod` at version `v0.2.0`:
+
+```
+$ curl https://proxy.golang.org/golang.org/x/mod/@v/v0.2.0.mod
+module golang.org/x/mod
+
+go 1.12
+
+require (
+ golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550
+ golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e
+ golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898
+)
+```
+
+In order to load a package, the `go` command needs the source code for the
+module that provides it. Module source code is distributed in `.zip` files which
+are extracted into the module cache. If a module `.zip` is not in the cache,
+the `go` command will download it using a `$module/@v/$version.zip` request.
+
+```
+$ curl -O https://proxy.golang.org/golang.org/x/mod/@v/v0.2.0.zip
+$ unzip -l v0.2.0.zip | head
+Archive: v0.2.0.zip
+ Length Date Time Name
+--------- ---------- ----- ----
+ 1479 00-00-1980 00:00 golang.org/x/mod@v0.2.0/LICENSE
+ 1303 00-00-1980 00:00 golang.org/x/mod@v0.2.0/PATENTS
+ 559 00-00-1980 00:00 golang.org/x/mod@v0.2.0/README
+ 21 00-00-1980 00:00 golang.org/x/mod@v0.2.0/codereview.cfg
+ 214 00-00-1980 00:00 golang.org/x/mod@v0.2.0/go.mod
+ 1476 00-00-1980 00:00 golang.org/x/mod@v0.2.0/go.sum
+ 5224 00-00-1980 00:00 golang.org/x/mod@v0.2.0/gosumcheck/main.go
+```
+
+Note that `.mod` and `.zip` requests are separate, even though `go.mod` files
+are usually contained within `.zip` files. The `go` command may need to download
+`go.mod` files for many different modules, and `.mod` files are much smaller
+than `.zip` files. Additionally, if a Go project does not have a `go.mod` file,
+the proxy will serve a synthetic `go.mod` file that only contains a [`module`
+directive](#go-mod-file-module). Synthetic `go.mod` files are generated by the
+`go` command when downloading from a [version control system](#vcs).
+
+If the `go` command needs to load a package not provided by any module in the
+build list, it will attempt to find a new module that provides it. The section
+[Resolving a package to a module](#resolve-pkg-mod) describes this process. In
+summary, the `go` command requests information about the latest version of each
+module path that could possibly contain the package. For example, for the
+package `golang.org/x/net/html`, the `go` command would try to find the latest
+versions of the modules `golang.org/x/net/html`, `golang.org/x/net`,
+`golang.org/x/`, and `golang.org`. Only `golang.org/x/net` actually exists and
+provides that package, so the `go` command uses the latest version of that
+module. If more than one module provides the package, the `go` command will use
+the module with the longest path.
+
+When the `go` command requests the latest version of a module, it first sends a
+request for `$module/@v/list`. If the list is empty or none of the returned
+versions can be used, it sends a request for `$module/@latest`. Once a version
+is chosen, the `go` command sends a `$module/@v/$version.info` request for
+metadata. It may then send `$module/@v/$version.mod` and
+`$module/@v/$version.zip` requests to load the `go.mod` file and source code.
+
+```
+$ curl https://proxy.golang.org/golang.org/x/mod/@v/list
+v0.1.0
+v0.2.0
+
+$ curl https://proxy.golang.org/golang.org/x/mod/@v/v0.2.0.info
+{"Version":"v0.2.0","Time":"2020-01-02T17:33:45Z"}
+```
+
+After downloading a `.mod` or `.zip` file, the `go` command computes a
+cryptographic hash and checks that it matches a hash in the main module's
+`go.sum` file. If the hash is not present in `go.sum`, by default, the `go`
+command retrieves it from the [checksum database](#checksum-database). If the
+computed hash does not match, the `go` command reports a security error and does
+not install the file in the module cache. The `GOPRIVATE` and `GONOSUMDB`
+[environment variables](#environment-variables) may be used to disable requests
+to the checksum database for specific modules. The `GOSUMDB` environment
+variable may also be set to `off` to disable requests to the checksum database
+entirely. See [Authenticating modules](#authenticating) for more
+information. Note that version lists and version metadata returned for `.info`
+requests are not authenticated and may change over time.
+
+## Version control systems {#vcs}
+
+The `go` command may download module source code and metadata directly from a
+version control repository. Downloading a module from a
+[proxy](#communicating-with-proxies) is usually faster, but connecting directly
+to a repository is necessary if a proxy is not available or if a module's
+repository is not accessible to a proxy (frequently true for private
+repositories). Git, Subversion, Mercurial, Bazaar, and Fossil are supported. A
+version control tool must be installed in a directory in `PATH` in order for the
+`go` command to use it.
+
+To download specific modules from source repositories instead of a proxy, set
+the `GOPRIVATE` or `GONOPROXY` environment variables. To configure the `go`
+command to download all modules directly from source repositories, set `GOPROXY`
+to `direct`. See [Environment variables](#environment-variables) for more
+information.
+
+### Finding a repository for a module path {#vcs-find}
+
+When the `go` command downloads a module in `direct` mode, it starts by locating
+the repository that contains the module.
+
+If the module path has a VCS qualifier (one of `.bzr`, `.fossil`, `.git`, `.hg`,
+`.svn`) at the end of a path component, the `go` command will use everything up
+to that path qualifier as the repository URL. For example, for the module
+`example.com/foo.git/bar`, the `go` command downloads the repository at
+`example.com/foo.git` using git, expecting to find the module in the `bar`
+subdirectory. The `go` command will guess the protocol to use based on the
+protocols supported by the version control tool.
+
+If the module path does not have a qualifier, the `go` command sends an HTTP
+`GET` request to a URL derived from the module path with a `?go-get=1` query
+string. For example, for the module `golang.org/x/mod`, the `go` command may
+send the following requests:
+
+```
+https://golang.org/x/mod?go-get=1 (preferred)
+http://golang.org/x/mod?go-get=1 (fallback, only with GOINSECURE)
+```
+
+The `go` command follows redirects but otherwise ignores response status
+codes, so the server may respond with a 404 or any other error status. The
+`GOINSECURE` environment variable may be set to allow fallback and redirects to
+unencrypted HTTP for specific modules.
+
+The server must respond with an HTML document containing a `<meta>` tag in the
+document's `<head>`. The `<meta>` tag should appear early in the document to
+avoid confusing the `go` command's restricted parser. In particular, it should
+appear before any raw JavaScript or CSS. The `<meta>` tag must have the form:
+
+```
+<meta name="go-import" content="root-path vcs repo-url">
+```
+
+`root-path` is the repository root path, the portion of the module path that
+corresponds to the repository's root directory. It must be a prefix or an exact
+match of the requested module path. If it's not an exact match, another request
+is made for the prefix to verify the `<meta>` tags match.
+
+`vcs` is the version control system. It must be one of `bzr`, `fossil`, `git`,
+`hg`, `svn`, `mod`. The `mod` scheme instructs the `go` command to download the
+module from the given URL using the [`GOPROXY`
+protocol](#goproxy-protocol). This allows developers to distribute modules
+without exposing source repositories.
+
+`repo-url` is the repository's URL. If the URL does not include a scheme (either
+because the module path has a VCS qualifier or because the `<meta>` tag lacks a
+scheme), the `go` command will try each protocol supported by the version
+control system. For example, with Git, the `go` command will try `https://` then
+`git+ssh://`. Insecure protocols (like `http://` and `git://`) may only be used
+if the module path is matched by the `GOINSECURE` environment variable.
+
+As an example, consider `golang.org/x/mod` again. The `go` command sends
+a request to `https://golang.org/x/mod?go-get=1`. The server responds
+with an HTML document containing the tag:
+
+```
+<meta name="go-import" content="golang.org/x/mod git https://go.googlesource.com/mod">
+```
+
+From this response, the `go` command will use the Git repository at
+the remote URL `https://go.googlesource.com/mod`.
+
+GitHub and other popular hosting services respond to `?go-get=1` queries for
+all repositories, so usually no server configuration is necessary for modules
+hosted at those sites.
+
+After the repository URL is found, the `go` command will clone the repository
+into the module cache. In general, the `go` command tries to avoid fetching
+unneeded data from a repository. However, the actual commands used vary by
+version control system and may change over time. For Git, the `go` command can
+list most available versions without downloading commits. It will usually fetch
+commits without downloading ancestor commits, but doing so is sometimes
+necessary.
+
+### Mapping versions to commits {#vcs-version}
+
+The `go` command may check out a module within a repository at a specific
+[canonical version](#glos-canonical-version) like `v1.2.3`, `v2.4.0-beta`, or
+`v3.0.0+incompatible`. Each module version should have a <dfn>semantic version
+tag</dfn> within the repository that indicates which revision should be checked
+out for a given version.
+
+If a module is defined in the repository root directory or in a major version
+subdirectory of the root directory, then each version tag name is equal to the
+corresponding version. For example, the module `golang.org/x/text` is defined in
+the root directory of its repository, so the version `v0.3.2` has the tag
+`v0.3.2` in that repository. This is true for most modules.
+
+If a module is defined in a subdirectory within the repository, that is, the
+[module subdirectory](#glos-module-subdirectory) portion of the module path is
+not empty, then each tag name must be prefixed with the module subdirectory,
+followed by a slash. For example, the module `golang.org/x/tools/gopls` is
+defined in the `gopls` subdirectory of the repository with root path
+`golang.org/x/tools`. The version `v0.4.0` of that module must have the tag
+named `gopls/v0.4.0` in that repository.
+
+The major version number of a semantic version tag must be consistent with the
+module path's major version suffix (if any). For example, the tag `v1.0.0` could
+belong to the module `example.com/mod` but not `example.com/mod/v2`, which would
+have tags like `v2.0.0`.
+
+A tag with major version `v2` or higher may belong to a module without a major
+version suffix if no `go.mod` file is present, and the module is in the
+repository root directory. This kind of version is denoted with the suffix
+`+incompatible`. The version tag itself must not have the suffix. See
+[Compatibility with non-module repositories](#non-module-compat).
+
+Once a tag is created, it should not be deleted or changed to a different
+revision. Versions are [authenticated](#authenticating) to ensure safe,
+repeatable builds. If a tag is modified, clients may see a security error when
+downloading it. Even after a tag is deleted, its content may remain
+available on [module proxies](#glos-module-proxy).
+
+### Mapping pseudo-versions to commits {#vcs-pseudo}
+
+The `go` command may check out a module within a repository at a specific
+revision, encoded as a [pseudo-version](#glos-pseudo-version) like
+`v1.3.2-0.20191109021931-daa7c04131f5`.
+
+The last 12 characters of the pseudo-version (`daa7c04131f5` in the example
+above) indicate a revision in the repository to check out. The meaning of this
+depends on the version control system. For Git and Mercurial, this is a prefix
+of a commit hash. For Subversion, this is a zero-padded revision number.
+
+Before checking out a commit, the `go` command verifies that the timestamp
+(`20191109021931` above) matches the commit date. It also verifies that the base
+version (`v1.3.1`, the version before `v1.3.2` in the example above) corresponds
+to a semantic version tag that is an ancestor of the commit. These checks ensure
+that module authors have full control over how pseudo-versions compare with
+other released versions.
+
+See [Pseudo-versions](#pseudo-versions) for more information.
+
+### Mapping branches and commits to versions {#vcs-branch}
+
+A module may be checked out at a specific branch, tag, or revision using a
+[version query](#version-queries).
+
+```
+go get example.com/mod@master
+```
+
+The `go` command converts these names into [canonical
+versions](#glos-canonical-version) that can be used with [minimal version
+selection (MVS)](#minimal-version-selection). MVS depends on the ability to
+order versions unambiguously. Branch names and revisions can't be compared
+reliably over time, since they depend on repository structure which may change.
+
+If a revision is tagged with one or more semantic version tags like `v1.2.3`,
+the tag for the highest valid version will be used. The `go` command only
+considers semantic version tags that could belong to the target module; for
+example, the tag `v1.5.2` would not be considered for `example.com/mod/v2` since
+the major version doesn't match the module path's suffix.
+
+If a revision is not tagged with a valid semantic version tag, the `go` command
+will generate a [pseudo-version](#glos-pseudo-version). If the revision has
+ancestors with valid semantic version tags, the highest ancestor version will be
+used as the pseudo-version base. See [Pseudo-versions](#pseudo-versions).
+
+### Module directories within a repository {#vcs-dir}
+
+Once a module's repository has been checked out at a specific revision, the `go`
+command must locate the directory that contains the module's `go.mod` file
+(the module's root directory).
+
+Recall that a [module path](#module-path) consists of three parts: a
+repository root path (corresponding to the repository root directory),
+a module subdirectory, and a major version suffix (only for modules released at
+`v2` or higher).
+
+For most modules, the module path is equal to the repository root path, so
+the module's root directory is the repository's root directory.
+
+Modules are sometimes defined in repository subdirectories. This is typically
+done for large repositories with multiple components that need to be released
+and versioned independently. Such a module is expected to be found in a
+subdirectory that matches the part of the module's path after the repository
+root path. For example, suppose the module `example.com/monorepo/foo/bar` is in
+the repository with root path `example.com/monorepo`. Its `go.mod` file must be
+in the `foo/bar` subdirectory.
+
+If a module is released at major version `v2` or higher, its path must have a
+[major version suffix](#major-version-suffixes). A module with a major version
+suffix may be defined in one of two subdirectories: one with the suffix,
+and one without. For example, suppose a new version of the module above is
+released with the path `example.com/monorepo/foo/bar/v2`. Its `go.mod` file
+may be in either `foo/bar` or `foo/bar/v2`.
+
+Subdirectories with a major version suffix are <dfn>major version
+subdirectories</dfn>. They may be used to develop multiple major versions of a
+module on a single branch. This may be unnecessary when development of multiple
+major versions proceeds on separate branches. However, major version
+subdirectories have an important property: in `GOPATH` mode, package import
+paths exactly match directories under `GOPATH/src`. The `go` command provides
+minimal module compatibility in `GOPATH` mode (see [Compatibility with
+non-module repositories](#non-module-compat)), so major version
+subdirectories aren't always necessary for compatibility with projects built in
+`GOPATH` mode. Older tools that don't support minimal module compatibility
+may have problems though.
+
+Once the `go` command has found the module root directory, it creates a `.zip`
+file of the contents of the directory, then extracts the `.zip` file into the
+module cache. See [File path and size constraints](#zip-path-size-constraints))
+for details on what files may be included in the `.zip` file. The contents of
+the `.zip` file are [authenticated](#authenticating) before extraction into the
+module cache the same way they would be if the `.zip` file were downloaded from
+a proxy.
+
+### Controlling version control tools with `GOVCS` {#vcs-govcs}
+
+The `go` command's ability to download modules with version control commands
+like `git` is critical to the decentralized package ecosystem, in which
+code can be imported from any server. It is also a potential security problem
+if a malicious server finds a way to cause the invoked version control command
+to run unintended code.
+
+To balance the functionality and security concerns, the `go` command by default
+will only use `git` and `hg` to download code from public servers. It will use
+any known version control system (`bzr`, `fossil`, `git`, `hg`, `svn`) to
+download code from private servers, defined as those hosting packages matching
+the `GOPRIVATE` [environment variable](#environment-variables). The rationale
+behind allowing only Git and Mercurial is that these two systems have had the
+most attention to issues of being run as clients of untrusted servers. In
+contrast, Bazaar, Fossil, and Subversion have primarily been used in trusted,
+authenticated environments and are not as well scrutinized as attack surfaces.
+
+The version control command restrictions only apply when using direct version
+control access to download code. When downloading modules from a proxy, the `go`
+command uses the [`GOPROXY` protocol](#goproxy-protocol) instead, which is
+always permitted. By default, the `go` command uses the Go module mirror
+([proxy.golang.org](https://proxy.golang.org)) for public modules and only
+falls back to version control for private modules or when the mirror refuses to
+serve a public package (typically for legal reasons). Therefore, clients can
+still access public code served from Bazaar, Fossil, or Subversion repositories
+by default, because those downloads use the Go module mirror, which takes on the
+security risk of running the version control commands using a custom sandbox.
+
+The `GOVCS` variable can be used to change the allowed version control systems
+for specific modules. The `GOVCS` variable applies when building packages
+in both module-aware mode and GOPATH mode. When using modules, the patterns match
+against the module path. When using GOPATH, the patterns match against the
+import path corresponding to the root of the version control repository.
+
+The general form of the `GOVCS` variable is a comma-separated list of
+`pattern:vcslist` rules. The pattern is a [glob pattern](/pkg/path#Match) that
+must match one or more leading elements of the module or import path. The
+vcslist is a pipe-separated list of allowed version control commands, or `all`
+to allow use of any known command, or `off` to allow nothing. Note that if a
+module matches a pattern with vcslist `off`, it may still be downloaded if the
+origin server uses the `mod` scheme, which instructs the go command to download
+the module using the [`GOPROXY` protocol](#goproxy-protocol). The earliest
+matching pattern in the list applies, even if later patterns might also match.
+
+For example, consider:
+
+```
+GOVCS=github.com:git,evil.com:off,*:git|hg
+```
+
+With this setting, code with a module or import path beginning with
+`github.com/` can only use `git`; paths on `evil.com` cannot use any version
+control command, and all other paths (`*` matches everything) can use
+only `git` or `hg`.
+
+The special patterns `public` and `private` match public and private
+module or import paths. A path is private if it matches the `GOPRIVATE`
+variable; otherwise it is public.
+
+If no rules in the `GOVCS` variable match a particular module or import path,
+the `go` command applies its default rule, which can now be summarized
+in `GOVCS` notation as `public:git|hg,private:all`.
+
+To allow unfettered use of any version control system for any package, use:
+
+```
+GOVCS=*:all
+```
+
+To disable all use of version control, use:
+
+```
+GOVCS=*:off
+```
+
+The [`go env -w`
+command](/cmd/go/#hdr-Print_Go_environment_information) can be
+used to set the `GOVCS` variable for future go command invocations.
+
+`GOVCS` was introduced in Go 1.16. Earlier versions of Go may use any known
+version control tool for any module.
+
+## Module zip files {#zip-files}
+
+Module versions are distributed as `.zip` files. There is rarely any need to
+interact directly with these files, since the `go` command creates, downloads,
+and extracts them automatically from [module proxies](#glos-module-proxy) and
+version control repositories. However, it's still useful to know about these
+files to understand cross-platform compatibility constraints or when
+implementing a module proxy.
+
+The [`go mod download`](#go-mod-download) command downloads zip files
+for one or more modules, then extracts those files into the [module
+cache](#glos-module-cache). Depending on `GOPROXY` and other [environment
+variables](#environment-variables), the `go` command may either download
+zip files from a proxy or clone source control repositories and create
+zip files from them. The `-json` flag may be used to find the location of
+download zip files and their extracted contents in the module cache.
+
+The [`golang.org/x/mod/zip`](https://pkg.go.dev/golang.org/x/mod/zip?tab=doc)
+package may be used to create, extract, or check contents of zip files
+programmatically.
+
+### File path and size constraints {#zip-path-size-constraints}
+
+There are a number of restrictions on the content of module zip files. These
+constraints ensure that zip files can be extracted safely and consistently on
+a wide range of platforms.
+
+* A module zip file may be at most 500 MiB in size. The total uncompressed size
+ of its files is also limited to 500 MiB. `go.mod` files are limited to 16 MiB.
+ `LICENSE` files are also limited to 16 MiB. These limits exist to mitigate
+ denial of service attacks on users, proxies, and other parts of the module
+ ecosystem. Repositories that contain more than 500 MiB of files in a module
+ directory tree should tag module versions at commits that only include files
+ needed to build the module's packages; videos, models, and other large assets
+ are usually not needed for builds.
+* Each file within a module zip file must begin with the prefix
+ `$module@$version/` where `$module` is the module path and `$version` is the
+ version, for example, `golang.org/x/mod@v0.3.0/`. The module path must be
+ valid, the version must be valid and canonical, and the version must match the
+ module path's major version suffix. See [Module paths and
+ versions](#go-mod-file-ident) for specific definitions and restrictions.
+* File modes, timestamps, and other metadata are ignored.
+* Empty directories (entries with paths ending with a slash) may be included
+ in module zip files but are not extracted. The `go` command does not include
+ empty directories in zip files it creates.
+* Symbolic links and other irregular files are ignored when creating zip files,
+ since they aren't portable across operating systems and file systems, and
+ there's no portable way to represent them in the zip file format.
+* No two files within a zip file may have paths equal under Unicode case-folding
+ (see [`strings.EqualFold`](https://pkg.go.dev/strings?tab=doc#EqualFold)).
+ This ensures that zip files can be extracted on case-insensitive file systems
+ without collisions.
+* A `go.mod` file may or may not appear in the top-level directory
+ (`$module@$version/go.mod`). If present, it must have the name `go.mod` (all
+ lowercase). Files named `go.mod` are not allowed in any other directory.
+* File and directory names within a module may consist of Unicode letters, ASCII
+ digits, the ASCII space character (U+0020), and the ASCII punctuation
+ characters `!#$%&()+,-.=@[]^_{}~`. Note that package paths may not contain all
+ these characters. See
+ [`module.CheckFilePath`](https://pkg.go.dev/golang.org/x/mod/module?tab=doc#CheckFilePath)
+ and
+ [`module.CheckImportPath`](https://pkg.go.dev/golang.org/x/mod/module?tab=doc#CheckImportPath)
+ for the differences.
+* A file or directory name up to the first dot must not be a reserved file name
+ on Windows, regardless of case (`CON`, `com1`, `NuL`, and so on).
+
+## Private modules {#private-modules}
+
+Go modules are frequently developed and distributed on version control servers
+and module proxies that aren't available on the public internet. The `go`
+command can download and build modules from private sources, though it usually
+requires some configuration.
+
+The environment variables below may be used to configure access to private
+modules. See [Environment variables](#environment-variables) for details. See
+also [Privacy](#private-module-privacy) for information on controlling
+information sent to public servers.
+
+* `GOPROXY` — list of module proxy URLs. The `go` command will attempt to
+ download modules from each server in sequence. The keyword `direct` instructs
+ the `go` command to download modules from version control repositories
+ where they're developed instead of using a proxy.
+* `GOPRIVATE` — list of glob patterns of module path prefixes that should be
+ considered private. Acts as a default value for `GONOPROXY` and `GONOSUMDB`.
+* `GONOPROXY` — list of glob patterns of module path prefixes that should not be
+ downloaded from a proxy. The `go` command will download matching modules from
+ version control repositories where they're developed, regardless of `GOPROXY`.
+* `GONOSUMDB` — list of glob patterns of module path prefixes that should not be
+ checked using the public checksum database,
+ [sum.golang.org](https://sum.golang.org).
+* `GOINSECURE` — list of glob patterns of module path prefixes that may be
+ retrieved over HTTP and other insecure protocols.
+
+These variables may be set in the development environment (for example, in a
+`.profile` file), or they may be set permanently with [`go env
+-w`](https://golang.org/cmd/go/#hdr-Print_Go_environment_information).
+
+The rest of this section describes common patterns for providing access to
+private module proxies and version control repositories.
+
+### Private proxy serving all modules {#private-module-proxy-all}
+
+A central private proxy server that serves all modules (public and private)
+provides the most control for administrators and requires the least
+configuration for individual developers.
+
+To configure the `go` command to use such a server, set the following
+environment variables, replacing `https://proxy.corp.example.com` with your
+proxy URL and `corp.example.com` with your module prefix:
+
+```
+GOPROXY=https://proxy.corp.example.com
+GONOSUMDB=corp.example.com
+```
+
+The `GOPROXY` setting instructs the `go` command to only download modules from
+`https://proxy.corp.example.com`; the `go` command will not connect to other
+proxies or version control repositories.
+
+The `GONOSUMDB` setting instructs the `go` command not to use the public
+checksum database to authenticate modules with paths starting with
+`corp.example.com`.
+
+A proxy running in this configuration will likely need read access to
+private version control servers. It will also need access to the public internet
+to download new versions of public modules.
+
+There are several existing implementations of `GOPROXY` servers that may be used
+this way. A minimal implementation would serve files from a [module
+cache](#glos-module-cache) directory and would use [`go mod
+download`](#go-mod-download) (with suitable configuration) to retrieve missing
+modules.
+
+### Private proxy serving private modules {#private-module-proxy-private}
+
+A private proxy server may serve private modules without also serving publicly
+available modules. The `go` command can be configured to fall back to
+public sources for modules that aren't available on the private server.
+
+To configure the `go` command to work this way, set the following environment
+variables, replacing `https://proxy.corp.example.com` with the proxy URL and
+`corp.example.com` with the module prefix:
+
+```
+GOPROXY=https://proxy.corp.example.com,https://proxy.golang.org,direct
+GONOSUMDB=corp.example.com
+```
+
+The `GOPROXY` setting instructs the `go` command to try to download modules from
+`https://proxy.corp.example.com` first. If that server responds with 404 (Not
+Found) or 410 (Gone), the `go` command will fall back to
+`https://proxy.golang.org`, then to direct connections to repositories.
+
+The `GONOSUMDB` setting instructs the `go` command not to use the public
+checksum database to authenticate modules whose paths start with
+`corp.example.com`.
+
+Note that a proxy used in this configuration may still control access to public
+modules, even though it doesn't serve them. If the proxy responds to a request
+with an error status other than 404 or 410, the `go` command will not fall back
+to later entries in the `GOPROXY` list. For example, the proxy could respond
+with 403 (Forbidden) for a module with an unsuitable license or with known
+security vulnerabilities.
+
+### Direct access to private modules {#private-module-proxy-direct}
+
+The `go` command may be configured to bypass public proxies and download private
+modules directly from version control servers. This is useful when running a
+private proxy server is not feasible.
+
+To configure the `go` command to work this way, set `GOPRIVATE`, replacing
+`corp.example.com` the private module prefix:
+
+```
+GOPRIVATE=corp.example.com
+```
+
+The `GOPROXY` variable does not need to be changed in this situation. It
+defaults to `https://proxy.golang.org,direct`, which instructs the `go` command
+to attempt to download modules from `https://proxy.golang.org` first, then fall
+back to a direct connection if that proxy responds with 404 (Not Found) or 410
+(Gone).
+
+The `GOPRIVATE` setting instructs the `go` command not to connect to a proxy or
+to the checksum database for modules starting with `corp.example.com`.
+
+An internal HTTP server may still be needed to [resolve module paths to
+repository URLs](#vcs-find). For example, when the `go` command downloads the
+module `corp.example.com/mod`, it will send a GET request to
+`https://corp.example.com/mod?go-get=1`, and it will look for the repository URL
+in the response. To avoid this requirement, ensure that each private module path
+has a VCS suffix (like `.git`) marking the repository root prefix. For example,
+when the `go` command downloads the module `corp.example.com/repo.git/mod`, it
+will clone the Git repository at `https://corp.example.com/repo.git` or
+`ssh://corp.example.com/repo.git` without needing to make additional requests.
+
+Developers will need read access to repositories containing private modules.
+This may be configured in global VCS configuration files like `.gitconfig`.
+It's best if VCS tools are configured not to need interactive authentication
+prompts. By default, when invoking Git, the `go` command disables interactive
+prompts by setting `GIT_TERMINAL_PROMPT=0`, but it respects explicit settings.
+
+### Passing credentials to private proxies {#private-module-proxy-auth}
+
+The `go` command supports HTTP [basic
+authentication](https://en.wikipedia.org/wiki/Basic_access_authentication) when
+communicating with proxy servers.
+
+Credentials may be specified in a [`.netrc`
+file](https://www.gnu.org/software/inetutils/manual/html_node/The-_002enetrc-file.html).
+For example, a `.netrc` file containing the lines below would configure the `go`
+command to connect to the machine `proxy.corp.example.com` with the given
+username and password.
+
+```
+machine proxy.corp.example.com
+login jrgopher
+password hunter2
+```
+
+The location of the file may be set with the `NETRC` environment variable. If
+`NETRC` is not set, the `go` command will read `$HOME/.netrc` on UNIX-like
+platforms or `%USERPROFILE%\_netrc` on Windows.
+
+Fields in `.netrc` are separated with spaces, tabs, and newlines. Unfortunately,
+these characters cannot be used in usernames or passwords. Note also that the
+machine name cannot be a full URL, so it's not possible to specify different
+usernames and passwords for different paths on the same machine.
+
+Alternatively, credentials may be specified directly in `GOPROXY` URLs. For
+example:
+
+```
+GOPROXY=https://jrgopher:hunter2@proxy.corp.example.com
+```
+
+Use caution when taking this approach: environment variables may be appear
+in shell history and in logs.
+
+### Passing credentials to private repositories {#private-module-repo-auth}
+
+The `go` command may download a module directly from a version control
+repository. This is necessary for private modules if a private proxy is
+not used. See [Direct access to private modules](#private-module-proxy-direct)
+for configuration.
+
+The `go` command runs version control tools like `git` when downloading
+modules directly. These tools perform their own authentication, so you may
+need to configure credentials in a tool-specific configuration file like
+`.gitconfig`.
+
+To ensure this works smoothly, make sure the `go` command uses the correct
+repository URL and that the version control tool doesn't require a password to
+be entered interactively. The `go` command prefers `https://` URLs over other
+schemes like `ssh://` unless the scheme was specified when [looking up the
+repository URL](#vcs-find). For GitHub repositories specifically, the `go`
+command assumes `https://`.
+
+<!-- TODO(golang.org/issue/26134): if this issue is fixed, we can remove the
+mention of the special case for GitHub above. -->
+
+For most servers, you can configure your client to authenticate over HTTP. For
+example, GitHub supports using [OAuth personal access tokens as HTTP
+passwords](https://docs.github.com/en/free-pro-team@latest/github/extending-github/git-automation-with-oauth-tokens).
+You can store HTTP passwords in a `.netrc` file, as when [passing credentials to
+private proxies](#private-module-proxy-auth).
+
+Alternatively, you can rewrite `https://` URLs to another scheme. For example,
+in `.gitconfig`:
+
+```
+[url "git@github.com:"]
+ insteadOf = https://github.com/
+```
+
+For more information, see [Why does "go get" use HTTPS when cloning a
+repository?](/doc/faq#git_https)
+
+### Privacy {#private-module-privacy}
+
+The `go` command may download modules and metadata from module proxy
+servers and version control systems. The environment variable `GOPROXY`
+controls which servers are used. The environment variables `GOPRIVATE` and
+`GONOPROXY` control which modules are fetched from proxies.
+
+The default value of `GOPROXY` is:
+
+```
+https://proxy.golang.org,direct
+```
+
+With this setting, when the `go` command downloads a module or module metadata,
+it will first send a request to `proxy.golang.org`, a public module proxy
+operated by Google ([privacy policy](https://proxy.golang.org/privacy)). See
+[`GOPROXY` protocol](#goproxy-protocol) for details on what information is sent
+in each request. The `go` command does not transmit personally identifiable
+information, but it does transmit the full module path being requested. If the
+proxy responds with a 404 (Not Found) or 410 (Gone) status, the `go` command
+will attempt to connect directly to the version control system providing the
+module. See [Version control systems](#vcs) for details.
+
+The `GOPRIVATE` or `GONOPROXY` environment variables may be set to lists of glob
+patterns matching module prefixes that are private and should not be requested
+from any proxy. For example:
+
+```
+GOPRIVATE=*.corp.example.com,*.research.example.com
+```
+
+`GOPRIVATE` simply acts as a default for `GONOPROXY` and `GONOSUMDB`, so it's
+not necessary to set `GONOPROXY` unless `GONOSUMDB` should have a different
+value. When a module path is matched by `GONOPROXY`, the `go` command ignores
+`GOPROXY` for that module and fetches it directly from its version control
+repository. This is useful when no proxy serves private modules. See [Direct
+access to private modules](#private-module-proxy-direct).
+
+If there is a [trusted proxy serving all modules](#private-module-proxy-all),
+then `GONOPROXY` should not be set. For example, if `GOPROXY` is set to one
+source, the `go` command will not download modules from other sources.
+`GONOSUMDB` should still be set in this situation.
+
+```
+GOPROXY=https://proxy.corp.example.com
+GONOSUMDB=*.corp.example.com,*.research.example.com
+```
+
+If there is a [trusted proxy serving only private
+modules](#private-module-proxy-private), `GONOPROXY` should not be set, but care
+must be taken to ensure the proxy responds with the correct status codes. For
+example, consider the following configuration:
+
+```
+GOPROXY=https://proxy.corp.example.com,https://proxy.golang.org
+GONOSUMDB=*.corp.example.com,*.research.example.com
+```
+
+Suppose that due to a typo, a developer attempts to download a module that
+doesn't exist.
+
+```
+go mod download corp.example.com/secret-product/typo@latest
+```
+
+The `go` command first requests this module from `proxy.corp.example.com`. If
+that proxy responds with 404 (Not Found) or 410 (Gone), the `go` command will
+fall back to `proxy.golang.org`, transmitting the `secret-product` path in the
+request URL. If the private proxy responds with any other error code, the `go`
+command prints the error and will not fall back to other sources.
+
+In addition to proxies, the `go` command may connect to the checksum database to
+verify cryptographic hashes of modules not listed in `go.sum`. The `GOSUMDB`
+environment variable sets the name, URL, and public key of the checksum
+database. The default value of `GOSUMDB` is `sum.golang.org`, the public
+checksum database operated by Google ([privacy
+policy](https://sum.golang.org/privacy)). See [Checksum
+database](#checksum-database) for details on what is transmitted with each
+request. As with proxies, the `go` command does not transmit personally
+identifiable information, but it does transmit the full module path being
+requested, and the checksum database cannot compute checksums for non-public
+modules.
+
+The `GONOSUMDB` environment variable may be set to patterns indicating which
+modules are private and should not be requested from the checksum
+database. `GOPRIVATE` acts as a default for `GONOSUMDB` and `GONOPROXY`, so it's
+not necessary to set `GONOSUMDB` unless `GONOPROXY` should have a
+different value.
+
+A proxy may [mirror the checksum
+database](https://go.googlesource.com/proposal/+/master/design/25530-sumdb.md#proxying-a-checksum-database).
+If a proxy in `GOPROXY` does this, the `go` command will not connect to the
+checksum database directly.
+
+`GOSUMDB` may be set to `off` to disable use of the checksum database
+entirely. With this setting, the `go` command will not authenticate downloaded
+modules unless they're already in `go.sum`. See [Authenticating
+modules](#authenticating).
+
+## Module cache {#module-cache}
+
+The <dfn>module cache</dfn> is the directory where the `go` command stores
+downloaded module files. The module cache is distinct from the build cache,
+which contains compiled packages and other build artifacts.
+
+The default location of the module cache is `$GOPATH/pkg/mod`. To use a
+different location, set the `GOMODCACHE` [environment
+variable](#environment-variables).
+
+The module cache has no maximum size, and the `go` command does not remove its
+contents automatically.
+
+The cache may be shared by multiple Go projects developed on the same machine.
+The `go` command will use the same cache regardless of the location of the
+main module. Multiple instances of the `go` command may safely access the
+same module cache at the same time.
+
+The `go` command creates module source files and directories in the cache with
+read-only permissions to prevent accidental changes to modules after they're
+downloaded. This has the unfortunate side-effect of making the cache difficult
+to delete with commands like `rm -rf`. The cache may instead be deleted with
+[`go clean -modcache`](#go-clean-modcache). Alternatively, when the
+`-modcacherw` flag is used, the `go` command will create new directories with
+read-write permissions. This increases the risk of editors, tests, and other
+programs modifying files in the module cache. The [`go mod
+verify`](#go-mod-verify) command may be used to detect modifications to
+dependencies of the main module. It scans the extracted contents of each
+module dependency and confirms they match the expected hash in `go.sum`.
+
+The table below explains the purpose of most files in the module cache. Some
+transient files (lock files, temporary directories) are omitted. For each path,
+`$module` is a module path, and `$version` is a version. Paths ending with
+slashes (`/`) are directories. Capital letters in module paths and versions are
+escaped using exclamation points (`Azure` is escaped as `!azure`) to avoid
+conflicts on case-insensitive file systems.
+
+<table class="ModTable">
+ <thead>
+ <tr>
+ <th>Path</th>
+ <th>Description</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr>
+ <td><code>$module@$version/</code></td>
+ <td>
+ Directory containing extracted contents of a module <code>.zip</code>
+ file. This serves as a module root directory for a downloaded module. It
+ won't contain contain a <code>go.mod</code> file if the original module
+ didn't have one.
+ </td>
+ </tr>
+ <tr>
+ <td><code>cache/download/</code></td>
+ <td>
+ Directory containing files downloaded from module proxies and files
+ derived from <a href="#vcs">version control systems</a>. The layout of
+ this directory follows the
+ <a href="#goproxy-protocol"><code>GOPROXY</code> protocol</a>, so
+ this directory may be used as a proxy when served by an HTTP file
+ server or when referenced with a <code>file://</code> URL.
+ </td>
+ </tr>
+ <tr>
+ <td><code>cache/download/$module/@v/list</code></td>
+ <td>
+ List of known versions (see
+ <a href="#goproxy-protocol"><code>GOPROXY</code> protocol</a>). This
+ may change over time, so the <code>go</code> command usually fetches a
+ new copy instead of re-using this file.
+ </td>
+ </tr>
+ <tr>
+ <td><code>cache/download/$module/@v/$version.info</code></td>
+ <td>
+ JSON metadata about the version. (see
+ <a href="#goproxy-protocol"><code>GOPROXY</code> protocol</a>). This
+ may change over time, so the <code>go</code> command usually fetches a
+ new copy instead of re-using this file.
+ </td>
+ </tr>
+ <tr>
+ <td><code>cache/download/$module/@v/$version.mod</code></td>
+ <td>
+ The <code>go.mod</code> file for this version (see
+ <a href="#goproxy-protocol"><code>GOPROXY</code> protocol</a>). If
+ the original module did not have a <code>go.mod</code> file, this is
+ a synthesized file with no requirements.
+ </td>
+ </tr>
+ <tr>
+ <td><code>cache/download/$module/@v/$version.zip</code></td>
+ <td>
+ The zipped contents of the module (see
+ <a href="#goproxy-protocol"><code>GOPROXY</code> protocol</a> and
+ <a href="#zip-files">Module zip files</a>).
+ </td>
+ </tr>
+ <tr>
+ <td><code>cache/download/$module/@v/$version.ziphash</code></td>
+ <td>
+ A cryptographic hash of the files in the <code>.zip</code> file.
+ Note that the <code>.zip</code> file itself is not hashed, so file
+ order, compression, alignment, and metadata don't affect the hash.
+ When using a module, the <code>go</code> command verifies this hash
+ matches the corresponding line in
+ <a href="go-sum-files"><code>go.sum</code></a>. The
+ <a href="#go-mod-verify"><code>go mod verify</code></a> command checks
+ that the hashes of module <code>.zip</code> files and extracted
+ directories match these files.
+ </td>
+ </tr>
+ <tr>
+ <td><code>cache/download/sumdb/</code></td>
+ <td>
+ Directory containing files downloaded from a
+ <a href="#checksum-database">checksum database</a> (typically
+ <code>sum.golang.org</code>).
+ </td>
+ </tr>
+ <tr>
+ <td><code>cache/vcs/</code></td>
+ <td>
+ Contains cloned version control repositories for modules fetched
+ directly from their sources. Directory names are hex-encoded hashes
+ derived from the repository type and URL. Repositories are optimized
+ for size on disk. For example, cloned Git repositories are bare and
+ shallow when possible.
+ </td>
+ </tr>
+ </tbody>
+</table>
+
+## Authenticating modules {#authenticating}
+
+When the `go` command downloads a module [zip file](#zip-files) or [`go.mod`
+file](#go-mod-file) into the [module cache](#module-cache), it computes a
+cryptographic hash and compares it with a known value to verify the file hasn't
+changed since it was first downloaded. The `go` command reports a security error
+if a downloaded file does not have the correct hash.
+
+For `go.mod` files, the `go` command computes the hash from the file
+content. For module zip files, the `go` command computes the hash from the names
+and contents of files within the archive in a deterministic order. The hash is
+not affected by file order, compression, alignment, and other metadata. See
+[`golang.org/x/mod/sumdb/dirhash`](https://pkg.go.dev/golang.org/x/mod/sumdb/dirhash?tab=doc)
+for hash implementation details.
+
+The `go` command compares each hash with the corresponding line in the main
+module's [`go.sum` file](go-sum-files). If the hash is different from the hash
+in `go.sum`, the `go` command reports a security error and deletes the
+downloaded file without adding it into the module cache.
+
+If the `go.sum` file is not present, or if it doesn't contain a hash for the
+downloaded file, the `go` command may verify the hash using the [checksum
+database](#checksum-database), a global source of hashes for publicly available
+modules. Once the hash is verified, the `go` command adds it to `go.sum` and
+adds the downloaded file in the module cache. If a module is private (matched by
+the `GOPRIVATE` or `GONOSUMDB` environment variables) or if the checksum
+database is disabled (by setting `GOSUMDB=off`), the `go` command accepts the
+hash and adds the file to the module cache without verifying it.
+
+The module cache is usually shared by all Go projects on a system, and each
+module may have its own `go.sum` file with potentially different hashes. To
+avoid the need to trust other modules, the `go` command verifies hashes using
+the main module's `go.sum` whenever it accesses a file in the module cache. Zip
+file hashes are expensive to compute, so the `go` command checks pre-computed
+hashes stored alongside zip files instead of re-hashing the files. The [`go mod
+verify`](#go-mod-verify) command may be used to check that zip files and
+extracted directories have not been modified since they were added to the module
+cache.
+
+### go.sum files {#go-sum-files}
+
+A module may have a text file named `go.sum` in its root directory, alongside
+its `go.mod` file. The `go.sum` file contains cryptographic hashes of the
+module's direct and indirect dependencies. When the `go` command downloads a
+module `.mod` or `.zip` file into the [module cache](#module-cache), it computes
+a hash and checks that the hash matches the corresponding hash in the main
+module's `go.sum` file. `go.sum` may be empty or absent if the module has no
+dependencies or if all dependencies are replaced with local directories using
+[`replace` directives](#go-mod-file-replace).
+
+Each line in `go.sum` has three fields separated by spaces: a module path,
+a version (possibly ending with `/go.mod`), and a hash.
+
+* The module path is the name of the module the hash belongs to.
+* The version is the version of the module the hash belongs to. If the version
+ ends with `/go.mod`, the hash is for the module's `go.mod` file only;
+ otherwise, the hash is for the files within the module's `.zip` file.
+* The hash column consists of an algorithm name (like `h1`) and a base64-encoded
+ cryptographic hash, separated by a colon (`:`). Currently, SHA-256 (`h1`) is
+ the only supported hash algorithm. If a vulnerability in SHA-256 is discovered
+ in the future, support will be added for another algorithm (named `h2` and
+ so on).
+
+The `go.sum` file may contain hashes for multiple versions of a module. The `go`
+command may need to load `go.mod` files from multiple versions of a dependency
+in order to perform [minimal version selection](#minimal-version-selection).
+`go.sum` may also contain hashes for module versions that aren't needed anymore
+(for example, after an upgrade). [`go mod tidy`](#go-mod-tidy) will add missing
+hashes and will remove unnecessary hashes from `go.sum`.
+
+### Checksum database {#checksum-database}
+
+The checksum database is a global source of `go.sum` lines. The `go` command can
+use this in many situations to detect misbehavior by proxies or origin servers.
+
+The checksum database allows for global consistency and reliability for all
+publicly available module versions. It makes untrusted proxies possible since
+they can't serve the wrong code without it going unnoticed. It also ensures
+that the bits associated with a specific version do not change from one day to
+the next, even if the module's author subsequently alters the tags in their
+repository.
+
+The checksum database is served by [sum.golang.org](https://sum.golang.org),
+which is run by Google. It is a [Transparent
+Log](https://research.swtch.com/tlog) (or “Merkle Tree”) of `go.sum` line
+hashes, which is backed by [Trillian](https://github.com/google/trillian). The
+main advantage of a Merkle tree is that independent auditors can verify that it
+hasn't been tampered with, so it is more trustworthy than a simple database.
+
+The `go` command interacts with the checksum database using the protocol
+originally outlined in [Proposal: Secure the Public Go Module
+Ecosystem](https://go.googlesource.com/proposal/+/master/design/25530-sumdb.md#checksum-database).
+
+The table below specifies queries that the checksum database must respond to.
+For each path, `$base` is the path portion of the checksum database URL,
+`$module` is a module path, and `$version` is a version. For example, if the
+checksum database URL is `https://sum.golang.org`, and the client is requesting
+the record for the module `golang.org/x/text` at version `v0.3.2`, the client
+would send a `GET` request for
+`https://sum.golang.org/lookup/golang.org/x/text@v0.3.2`.
+
+To avoid ambiguity when serving from case-insensitive file systems,
+the `$module` and `$version` elements are
+[case-encoded](https://pkg.go.dev/golang.org/x/mod/module#EscapePath)
+by replacing every uppercase letter with an exclamation mark followed by the
+corresponding lower-case letter. This allows modules `example.com/M` and
+`example.com/m` to both be stored on disk, since the former is encoded as
+`example.com/!m`.
+
+Parts of the path surrounded by square brackets, like `[.p/$W]` denote optional
+values.
+
+<table class="ModTable">
+ <thead>
+ <tr>
+ <th>Path</th>
+ <th>Description</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr>
+ <td><code>$base/latest</code></td>
+ <td>
+ Returns a signed, encoded tree description for the latest log. This
+ signed description is in the form of a
+ <a href="https://pkg.go.dev/golang.org/x/mod/sumdb/note">note</a>,
+ which is text that has been signed by one or more server keys and can
+ be verified using the server's public key. The tree description
+ provides the size of the tree and the hash of the tree head at that
+ size. This encoding is described in
+ <code><a href="https://pkg.go.dev/golang.org/x/mod/sumdb/tlog#FormatTree">
+ golang.org/x/mod/sumdb/tlog#FormatTree</a></code>.
+ </td>
+ </tr>
+ <tr>
+ <tr>
+ <td><code>$base/lookup/$module@$version</code></td>
+ <td>
+ Returns the log record number for the entry about <code>$module</code>
+ at <code>$version</code>, followed by the data for the record (that is,
+ the <code>go.sum</code> lines for <code>$module</code> at
+ <code>$version</code>) and a signed, encoded tree description that
+ contains the record.
+ </td>
+ </tr>
+ <tr>
+ <tr>
+ <td><code>$base/tile/$H/$L/$K[.p/$W]</code></td>
+ <td>
+ Returns a [log tile](https://research.swtch.com/tlog#serving_tiles),
+ which is a set of hashes that make up a section of the log. Each tile
+ is defined in a two-dimensional coordinate at tile level
+ <code>$L</code>, <code>$K</code>th from the left, with a tile height of
+ <code>$H</code>. The optional <code>.p/$W</code> suffix indicates a
+ partial log tile with only <code>$W</code> hashes. Clients must fall
+ back to fetching the full tile if a partial tile is not found.
+ </td>
+ </tr>
+ <tr>
+ <tr>
+ <td><code>$base/tile/$H/data/$K[.p/$W]</code></td>
+ <td>
+ Returns the record data for the leaf hashes in
+ <code>/tile/$H/0/$K[.p/$W]</code> (with a literal <code>data</code> path
+ element).
+ </td>
+ </tr>
+ <tr>
+ </tbody>
+</table>
+
+If the `go` command consults the checksum database, then the first
+step is to retrieve the record data through the `/lookup` endpoint. If the
+module version is not yet recorded in the log, the checksum database will try
+to fetch it from the origin server before replying. This `/lookup` data
+provides the sum for this module version as well as its position in the log,
+which informs the client of which tiles should be fetched to perform proofs.
+The `go` command performs “inclusion” proofs (that a specific record exists in
+the log) and “consistency” proofs (that the tree hasn’t been tampered with)
+before adding new `go.sum` lines to the main module’s `go.sum` file. It's
+important that the data from `/lookup` should never be used without first
+authenticating it against the signed tree hash and authenticating the signed
+tree hash against the client's timeline of signed tree hashes.
+
+Signed tree hashes and new tiles served by the checksum database are stored
+in the module cache, so the `go` command only needs to fetch tiles that are
+missing.
+
+The `go` command doesn't need to directly connect to the checksum database. It
+can request module sums via a module proxy that [mirrors the checksum
+database](https://go.googlesource.com/proposal/+/master/design/25530-sumdb.md#proxying-a-checksum-database)
+and supports the protocol above. This can be particularly helpful for private,
+corporate proxies which block requests outside the organization.
+
+The `GOSUMDB` environment variable identifies the name of checksum database to
+use and optionally its public key and URL, as in:
+
+```
+GOSUMDB="sum.golang.org"
+GOSUMDB="sum.golang.org+<publickey>"
+GOSUMDB="sum.golang.org+<publickey> https://sum.golang.org"
+```
+
+The `go` command knows the public key of `sum.golang.org`, and also that the
+name `sum.golang.google.cn` (available inside mainland China) connects to the
+`sum.golang.org` checksum database; use of any other database requires giving
+the public key explicitly. The URL defaults to `https://` followed by the
+database name.
+
+`GOSUMDB` defaults to `sum.golang.org`, the Go checksum database run by Google.
+See https://sum.golang.org/privacy for the service's privacy policy.
+
+If `GOSUMDB` is set to `off`, or if `go get` is invoked with the `-insecure`
+flag, the checksum database is not consulted, and all unrecognized modules are
+accepted, at the cost of giving up the security guarantee of verified
+repeatable downloads for all modules. A better way to bypass the checksum
+database for specific modules is to use the `GOPRIVATE` or `GONOSUMDB`
+environment variables. See [Private Modules](#private-modules) for details.
+
+The `go env -w` command can be used to
+[set these variables](/pkg/cmd/go/#hdr-Print_Go_environment_information)
+for future `go` command invocations.
+
+## Environment variables {#environment-variables}
+
+Module behavior in the `go` command may be configured using the environment
+variables listed below. This list only includes module-related environment
+variables. See [`go help
+environment`](https://golang.org/cmd/go/#hdr-Environment_variables) for a list
+of all environment variables recognized by the `go` command.
+
+<table class="ModTable">
+ <thead>
+ <tr>
+ <th>Variable</th>
+ <th>Description</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr>
+ <td><code>GO111MODULE</code></td>
+ <td>
+ <p>
+ Controls whether the <code>go</code> command runs in module-aware mode
+ or <code>GOPATH</code> mode. Three values are recognized:
+ </p>
+ <ul>
+ <li>
+ <code>off</code>: the <code>go</code> command ignores
+ <code>go.mod</code> files and runs in <code>GOPATH</code> mode.
+ </li>
+ <li>
+ <code>on</code> (or unset): the <code>go</code> command runs in
+ module-aware mode, even when no <code>go.mod</code> file is present.
+ </li>
+ <li>
+ <code>auto</code>: the <code>go</code> command runs in module-aware
+ mode if a <code>go.mod</code> file is present in the current
+ directory or any parent directory. In Go 1.15 and lower, this was
+ the default.
+ </li>
+ </ul>
+ <p>
+ See <a href="#mod-commands">Module-aware commands</a> for more
+ information.
+ </p>
+ </td>
+ </tr>
+ <tr>
+ <td><code>GOMODCACHE</code></td>
+ <td>
+ <p>
+ The directory where the <code>go</code> command will store downloaded
+ modules and related files. See <a href="#module-cache">Module
+ cache</a> for details on the structure of this directory.
+ </p>
+ <p>
+ If <code>GOMODCACHE</code> is not set, it defaults to
+ <code>$GOPATH/pkg/mod</code>.
+ </p>
+ </td>
+ </tr>
+ <tr>
+ <td><code>GOINSECURE</code></td>
+ <td>
+ <p>
+ Comma-separated list of glob patterns (in the syntax of Go's
+ <a href="/pkg/path/#Match"><code>path.Match</code></a>) of module path
+ prefixes that may always be fetched in an insecure manner. Only
+ applies to dependencies that are being fetched directly.
+ </p>
+ <p>
+ Unlike the <code>-insecure</code> flag on <code>go get</code>,
+ <code>GOINSECURE</code> does not disable module checksum database
+ validation. <code>GOPRIVATE</code> or <code>GONOSUMDB</code> may be
+ used to achieve that.
+ </p>
+ </td>
+ </tr>
+ <tr>
+ <td><code>GONOPROXY</code></td>
+ <td>
+ <p>
+ Comma-separated list of glob patterns (in the syntax of Go's
+ <a href="/pkg/path/#Match"><code>path.Match</code></a>) of module path
+ prefixes that should always be fetched directly from version control
+ repositories, not from module proxies.
+ </p>
+ <p>
+ If <code>GONOPROXY</code> is not set, it defaults to
+ <code>GOPRIVATE</code>. See
+ <a href="#private-module-privacy">Privacy</a>.
+ </p>
+ </td>
+ </tr>
+ <tr>
+ <td><code>GONOSUMDB</code></td>
+ <td>
+ <p>
+ Comma-separated list of glob patterns (in the syntax of Go's
+ <a href="/pkg/path/#Match"><code>path.Match</code></a>) of module path
+ prefixes for which the <code>go</code> should not verify checksums
+ using the checksum database.
+ </p>
+ <p>
+ If <code>GONOSUMDB</code> is not set, it defaults to
+ <code>GOPRIVATE</code>. See
+ <a href="#private-module-privacy">Privacy</a>.
+ </p>
+ </td>
+ </tr>
+ <tr>
+ <td><code>GOPATH</code></td>
+ <td>
+ <p>
+ In <code>GOPATH</code> mode, the <code>GOPATH</code> variable is a
+ list of directories that may contain Go code.
+ </p>
+ <p>
+ In module-aware mode, the <a href="#glos-module-cache">module
+ cache</a> is stored in the <code>pkg/mod</code> subdirectory of the
+ first <code>GOPATH</code> directory. Module source code outside the
+ cache may be stored in any directory.
+ </p>
+ <p>
+ If <code>GOPATH</code> is not set, it defaults to the <code>go</code>
+ subdirectory of the user's home directory.
+ </p>
+ </td>
+ </tr>
+ <tr>
+ <td><code>GOPRIVATE</code></td>
+ <td>
+ Comma-separated list of glob patterns (in the syntax of Go's
+ <a href="/pkg/path/#Match"><code>path.Match</code></a>) of module path
+ prefixes that should be considered private. <code>GOPRIVATE</code>
+ is a default value for <code>GONOPROXY</code> and
+ <code>GONOSUMDB</code>. See
+ <a href="#private-module-privacy">Privacy</a>. <code>GOPRIVATE</code>
+ also determines whether a module is considered private for
+ <code>GOVCS</code>.
+ </td>
+ </tr>
+ <tr>
+ <td><code>GOPROXY</code></td>
+ <td>
+ <p>
+ List of module proxy URLs, separated by commas (<code>,</code>) or
+ pipes (<code>|</code>). When the <code>go</code> command looks up
+ information about a module, it contacts each proxy in the list in
+ sequence until it receives a successful response or a terminal error.
+ A proxy may respond with a 404 (Not Found) or 410 (Gone) status to
+ indicate the module is not available on that server.
+ </p>
+ <p>
+ The <code>go</code> command's error fallback behavior is determined
+ by the separator characters between URLs. If a proxy URL is followed
+ by a comma, the <code>go</code> command falls back to the next URL
+ after a 404 or 410 error; all other errors are considered terminal.
+ If the proxy URL is followed by a pipe, the <code>go</code> command
+ falls back to the next source after any error, including non-HTTP
+ errors like timeouts.
+ </p>
+ <p>
+ <code>GOPROXY</code> URLs may have the schemes <code>https</code>,
+ <code>http</code>, or <code>file</code>. If a URL has no scheme,
+ <code>https</code> is assumed. A module cache may be used directly as
+ a file proxy:
+ </p>
+ <pre>GOPROXY=file://$(go env GOMODCACHE)/cache/download</pre>
+ <p>Two keywords may be used in place of proxy URLs:</p>
+ <ul>
+ <li>
+ <code>off</code>: disallows downloading modules from any source.
+ </li>
+ <li>
+ <code>direct</code>: download directly from version control
+ repositories instead of using a module proxy.
+ </li>
+ </ul>
+ <p>
+ <code>GOPROXY</code> defaults to
+ <code>https://proxy.golang.org,direct</code>. Under that
+ configuration, the <code>go</code> command first contacts the Go
+ module mirror run by Google, then falls back to a direct connection if
+ the mirror does not have the module. See
+ <a href="https://proxy.golang.org/privacy">https://proxy.golang.org/privacy</a>
+ for the mirror's privacy policy. The <code>GOPRIVATE</code> and
+ <code>GONOPROXY</code> environment variables may be set to prevent
+ specific modules from being downloaded using proxies. See
+ <a href="#private-module-privacy">Privacy</a> for information on
+ private proxy configuration.
+ </p>
+ <p>
+ See <a href="#module-proxy">Module proxies</a> and
+ <a href="#resolve-pkg-mod">Resolving a package to a module</a> for
+ more information on how proxies are used.
+ </p>
+ </td>
+ </tr>
+ <tr>
+ <td><code>GOSUMDB</code></td>
+ <td>
+ <p>
+ Identifies the name of the checksum database to use and optionally
+ its public key and URL. For example:
+ </p>
+ <pre>
+GOSUMDB="sum.golang.org"
+GOSUMDB="sum.golang.org+<publickey>"
+GOSUMDB="sum.golang.org+<publickey> https://sum.golang.org"
+</pre>
+ <p>
+ The <code>go</code> command knows the public key of
+ <code>sum.golang.org</code> and also that the name
+ <code>sum.golang.google.cn</code> (available inside mainland China)
+ connects to the <code>sum.golang.org</code> database; use of any other
+ database requires giving the public key explicitly. The URL defaults
+ to <code>https://</code> followed by the database name.
+ </p>
+ <p>
+ <code>GOSUMDB</code> defaults to <code>sum.golang.org</code>, the
+ Go checksum database run by Google. See
+ <a href="https://sum.golang.org/privacy">https://sum.golang.org/privacy</a>
+ for the service's privacy policy.
+ <p>
+ <p>
+ If <code>GOSUMDB</code> is set to <code>off</code> or if
+ <code>go get</code> is invoked with the <code>-insecure</code> flag,
+ the checksum database is not consulted, and all unrecognized modules
+ are accepted, at the cost of giving up the security guarantee of
+ verified repeatable downloads for all modules. A better way to bypass
+ the checksum database for specific modules is to use the
+ <code>GOPRIVATE</code> or <code>GONOSUMDB</code> environment
+ variables.
+ </p>
+ <p>
+ See <a href="#authenticating">Authenticating modules</a> and
+ <a href="#private-module-privacy">Privacy</a> for more information.
+ </p>
+ </td>
+ </tr>
+ <tr>
+ <td><code>GOVCS</code></td>
+ <td>
+ <p>
+ Controls the set of version control tools the <code>go</code> command
+ may use to download public and private modules (defined by whether
+ their paths match a pattern in <code>GOPRIVATE</code>) or other
+ modules matching a glob pattern.
+ </p>
+ <p>
+ If <code>GOVCS</code> is not set, or if a module does not match any
+ pattern in <code>GOVCS</code>, the <code>go</code> command may use
+ <code>git</code> and <code>hg</code> for a public module, or any known
+ version control tool for a private module. Concretely, the
+ <code>go</code> command acts as if <code>GOVCS</code> were set to:
+ </p>
+ <pre>public:git|hg,private:all</pre>
+ <p>
+ See <a href="#vcs-govcs">Controlling version control tools with
+ <code>GOVCS</code></a> for a complete explanation.
+ </p>
+ </td>
+ </tr>
+ </tbody>
+</table>
+
+## Glossary {#glossary}
+
+<a id="glos-build-constraint"></a>
+**build constraint:** A condition that determines whether a Go source file is
+used when compiling a package. Build constraints may be expressed with file name
+suffixes (for example, `foo_linux_amd64.go`) or with build constraint comments
+(for example, `// +build linux,amd64`). See [Build
+Constraints](https://golang.org/pkg/go/build/#hdr-Build_Constraints).
+
+<a id="glos-build-list"></a>
+**build list:** The list of module versions that will be used for a build
+command such as `go build`, `go list`, or `go test`. The build list is
+determined from the [main module's](#glos-main-module) [`go.mod`
+file](#glos-go-mod-file) and `go.mod` files in transitively required modules
+using [minimal version selection](#glos-minimal-version-selection). The build
+list contains versions for all modules in the [module
+graph](#glos-module-graph), not just those relevant to a specific command.
+
+<a id="glos-canonical-version"></a>
+**canonical version:** A correctly formatted [version](#glos-version) without
+a build metadata suffix other than `+incompatible`. For example, `v1.2.3`
+is a canonical version, but `v1.2.3+meta` is not.
+
+<a id="glos-current-module"></a>
+**current module:** Synonym for [main module](#glos-main-module).
+
+<a id="glos-deprecated-module"></a>
+**deprecated module:** A module that is no longer supported by its authors
+(though major versions are considered distinct modules for this purpose).
+A deprecated module is marked with a [deprecation
+comment](#go-mod-file-module-deprecation) in the latest version of its
+[`go.mod` file](#glos-go-mod-file).
+
+<a id="glos-go-mod-file"></a>
+**`go.mod` file:** The file that defines a module's path, requirements, and
+other metadata. Appears in the [module's root
+directory](#glos-module-root-directory). See the section on [`go.mod`
+files](#go-mod-file).
+
+<a id="glos-import-path"></a>
+**import path:** A string used to import a package in a Go source file.
+Synonymous with [package path](#glos-package-path).
+
+<a id="glos-main-module"></a>
+**main module:** The module in which the `go` command is invoked. The main
+module is defined by a [`go.mod` file](#glos-go-mod-file) in the current
+directory or a parent directory. See [Modules, packages, and
+versions](#modules-overview).
+
+<a id="glos-major-version"></a>
+**major version:** The first number in a semantic version (`1` in `v1.2.3`). In
+a release with incompatible changes, the major version must be incremented, and
+the minor and patch versions must be set to 0. Semantic versions with major
+version 0 are considered unstable.
+
+<a id="glos-major-version-subdirectory"></a>
+**major version subdirectory:** A subdirectory within a version control
+repository matching a module's [major version
+suffix](#glos-major-version-suffix) where a module may be defined. For example,
+the module `example.com/mod/v2` in the repository with [root
+path](#glos-repository-root-path) `example.com/mod` may be defined in the
+repository root directory or the major version subdirectory `v2`. See [Module
+directories within a repository](#vcs-dir).
+
+<a id="glos-major-version-suffix"></a>
+**major version suffix:** A module path suffix that matches the major version
+number. For example, `/v2` in `example.com/mod/v2`. Major version suffixes are
+required at `v2.0.0` and later and are not allowed at earlier versions. See
+the section on [Major version suffixes](#major-version-suffixes).
+
+<a id="glos-minimal-version-selection"></a>
+**minimal version selection (MVS):** The algorithm used to determine the
+versions of all modules that will be used in a build. See the section on
+[Minimal version selection](#minimal-version-selection) for details.
+
+<a id="glos-minor-version"></a>
+**minor version:** The second number in a semantic version (`2` in `v1.2.3`). In
+a release with new, backwards compatible functionality, the minor version must
+be incremented, and the patch version must be set to 0.
+
+<a id="glos-module"></a>
+**module:** A collection of packages that are released, versioned, and
+distributed together.
+
+<a id="glos-module-cache"></a>
+**module cache:** A local directory storing downloaded modules, located in
+`GOPATH/pkg/mod`. See [Module cache](#module-cache).
+
+<a id="glos-module-graph"></a>
+**module graph:** The directed graph of module requirements, rooted at the [main
+module](#glos-main-module). Each vertex in the graph is a module; each edge is a
+version from a `require` statement in a `go.mod` file (subject to `replace` and
+`exclude` statements in the main module's `go.mod` file.
+
+<a id="glos-module-path"></a>
+**module path:** A path that identifies a module and acts as a prefix for
+package import paths within the module. For example, `"golang.org/x/net"`.
+
+<a id="glos-module-proxy"></a>
+**module proxy:** A web server that implements the [`GOPROXY`
+protocol](#goproxy-protocol). The `go` command downloads version information,
+`go.mod` files, and module zip files from module proxies.
+
+<a id="glos-module-root-directory"></a>
+**module root directory:** The directory that contains the `go.mod` file that
+defines a module.
+
+<a id="glos-module-subdirectory"></a>
+**module subdirectory:** The portion of a [module path](#glos-module-path) after
+the [repository root path](#glos-repository-root-path) that indicates the
+subdirectory where the module is defined. When non-empty, the module
+subdirectory is also a prefix for [semantic version
+tags](#glos-semantic-version-tag). The module subdirectory does not include the
+[major version suffix](#glos-major-version-suffix), if there is one, even if the
+module is in a [major version subdirectory](#glos-major-version-subdirectory).
+See [Module paths](#module-path).
+
+<a id="glos-package"></a>
+**package:** A collection of source files in the same directory that are
+compiled together. See the [Packages section](/ref/spec#Packages) in the Go
+Language Specification.
+
+<a id="glos-package-path"></a>
+**package path:** The path that uniquely identifies a package. A package path is
+a [module path](#glos-module-path) joined with a subdirectory within the module.
+For example `"golang.org/x/net/html"` is the package path for the package in the
+module `"golang.org/x/net"` in the `"html"` subdirectory. Synonym of
+[import path](#glos-import-path).
+
+<a id="glos-patch-version"></a>
+**patch version:** The third number in a semantic version (`3` in `v1.2.3`). In
+a release with no changes to the module's public interface, the patch version
+must be incremented.
+
+<a id="glos-pre-release-version"></a>
+**pre-release version:** A version with a dash followed by a series of
+dot-separated identifiers immediately following the patch version, for example,
+`v1.2.3-beta4`. Pre-release versions are considered unstable and are not
+assumed to be compatible with other versions. A pre-release version sorts before
+the corresponding release version: `v1.2.3-pre` comes before `v1.2.3`. See also
+[release version](#glos-release-version).
+
+<a id="glos-pseudo-version"></a>
+**pseudo-version:** A version that encodes a revision identifier (such as a Git
+commit hash) and a timestamp from a version control system. For example,
+`v0.0.0-20191109021931-daa7c04131f5`. Used for [compatibility with non-module
+repositories](#non-module-compat) and in other situations when a tagged
+version is not available.
+
+<a id="glos-release-version"></a>
+**release version:** A version without a pre-release suffix. For example,
+`v1.2.3`, not `v1.2.3-pre`. See also [pre-release
+version](#glos-pre-release-version).
+
+<a id="glos-repository-root-path"></a>
+**repository root path:** The portion of a [module path](#glos-module-path) that
+corresponds to a version control repository's root directory. See [Module
+paths](#module-path).
+
+<a id="glos-retracted-version"></a>
+**retracted version:** A version that should not be depended upon, either
+because it was published prematurely or because a severe problem was discovered
+after it was published. See [`retract` directive](#go-mod-file-retract).
+
+<a id="glos-semantic-version-tag"></a>
+**semantic version tag:** A tag in a version control repository that maps a
+[version](#glos-version) to a specific revision. See [Mapping versions to
+commits](#vcs-version).
+
+<a id="glos-vendor-directory"></a>
+**vendor directory:** A directory named `vendor` that contains packages from
+other modules needed to build packages in the main module. Maintained with
+[`go mod vendor`](#go-mod-vendor). See [Vendoring](#vendoring).
+
+<a id="glos-version"></a>
+**version:** An identifier for an immutable snapshot of a module, written as the
+letter `v` followed by a semantic version. See the section on
+[Versions](#versions).
diff --git a/_content/doc/modules/developing.md b/_content/doc/modules/developing.md
new file mode 100644
index 0000000..1ab4770
--- /dev/null
+++ b/_content/doc/modules/developing.md
@@ -0,0 +1,118 @@
+<!--{
+ "Title": "Developing and publishing modules"
+}-->
+
+You can collect related packages into modules, then publish the modules for
+other developers to use. This topic gives an overview of developing and
+publishing modules.
+
+To support developing, publishing, and using modules, you use:
+
+* A **workflow** through which you develop and publish modules, revising them
+ with new versions over time. See [Workflow for developing and publishing
+ modules](#workflow).
+* **Design practices** that help a module's users understand it and upgrade
+ to new versions in a stable way. See [Design and development](#design).
+* A **decentralized system for publishing** modules and retrieving their code.
+ You make your module available for other developers to use from your own
+ repository and publish with a version number. See [Decentralized
+ publishing](#decentralized).
+* A **package search engine** and documentation browser (pkg.go.dev) at which
+ developers can find your module. See [Package discovery](#discovery).
+* A module **version numbering convention** to communicate expectations of
+ stability and backward compatibility to developers using your module. See
+ [Versioning](#versioning).
+* **Go tools** that make it easier for other developers to manage
+ dependencies, including getting your module's source, upgrading, and so on.
+ See [Managing dependencies](/doc/modules/managing-dependencies).
+
+**See also**
+
+* If you're interested simply in using packages developed by others, this
+ isn't the topic for you. Instead, see [Managing
+ dependencies](managing-dependencies).
+* For a tutorial that includes a few module development basics, see
+ [Tutorial: Create a Go module](/doc/tutorial/create-module).
+
+## Workflow for developing and publishing modules {#workflow}
+
+When you want to publish your modules for others, you adopt a few conventions to
+make using those modules easier.
+
+The following high-level steps are described in more detail in [Module release
+and versioning workflow](release-workflow).
+
+1. Design and code the packages that the module will include.
+1. Commit code to your repository using conventions that ensure it's available
+ to others via Go tools.
+1. Publish the module to make it discoverable by developers.
+1. Over time, revise the module with versions that use a version numbering
+ convention that signals each version's stability and backward compatibility.
+
+## Design and development {#design}
+
+Your module will be easier for developers to find and use if the functions and
+packages in it form a coherent whole. When you're designing a module's public
+API, try to keep its functionality focused and discrete.
+
+Also, designing and developing your module with backward compatibility in mind
+helps its users upgrade while minimizing churn to their own code. You can use
+certain techniques in code to avoid releasing a version that breaks backward
+compatibility. For more about those techniques, see [Keeping your modules
+compatible](https://blog.golang.org/module-compatibility) on the Go blog.
+
+Before you publish a module, you can reference it on the local file system using
+the replace directive. This makes it easier to write client code that calls
+functions in the module while the module is still in development. For more
+information, see "Coding against an unpublished module" in [Module release and
+versioning workflow](release-workflow#unpublished).
+
+## Decentralized publishing {#decentralized}
+
+In Go, you publish your module by tagging its code in your repository to make it
+available for other developers to use. You don't need to push your module to a
+centralized service because Go tools can download your module directly from your
+repository (located using the module's path, which is a URL with the scheme
+omitted) or from a proxy server.
+
+After importing your package in their code, developers use Go tools (including
+the `go get` command) to download your module's code to compile with. To support
+this model, you follow conventions and best practices that make it possible for
+Go tools (on behalf of another developer) to retrieve your module's source from
+your repository. For example, Go tools use the module's module path you specify,
+along with the module version number you use to tag the module for release, to
+locate and download the module for its users.
+
+For more about source and publishing conventions and best practices, see
+[Managing module source](/doc/modules/managing-source).
+
+For step-by-step instructions on publishing a module, see [Publishing a
+module](publishing).
+
+## Package discovery {#discovery}
+
+After you've published your module and someone has fetched it with Go tools, it
+will become visible on the Go package discovery site at
+[pkg.go.dev](https://pkg.go.dev/). There, developers can search the site to find
+it and read its documentation.
+
+To begin using the module, a developer imports packages from the module, then
+runs the `go get` command to download its source code to compile with.
+
+For more about how developers find and use modules, see [Managing
+dependencies](managing-dependencies).
+
+## Versioning {#versioning}
+
+As you revise and improve your module over time, you assign version numbers
+(based on the semantic versioning model) designed to signal each version's
+stability and backward compatibility. This helps developers using your module
+determine when the module is stable and whether an upgrade may include
+significant changes in behavior. You indicate a module's version number by
+tagging the module's source in the repository with the number.
+
+For more on developing major version updates, see [Developing a major version
+update](major-version).
+
+For more about how you use the semantic versioning model for Go modules, see
+[Module version numbering](/doc/modules/version-numbers).
diff --git a/_content/doc/modules/gomod-ref.md b/_content/doc/modules/gomod-ref.md
new file mode 100644
index 0000000..737327c
--- /dev/null
+++ b/_content/doc/modules/gomod-ref.md
@@ -0,0 +1,389 @@
+<!--{
+ "Title": "go.mod file reference"
+}-->
+
+Each Go module is defined by a go.mod file that describes the module's
+properties, including its dependencies on other modules and on versions of Go.
+
+These properties include:
+
+* The current module's **module path**. This should be a location from which
+the module can be downloaded by Go tools, such as the module code's
+repository location. This serves as a unique identifier, when combined
+with the module's version number. It is also the prefix of the package path for
+all packages in the module. For more about how Go locates the module, see the
+<a href="/ref/mod#vcs-find">Go Modules Reference</a>.
+* The minimum **version of Go** required by the current module.
+* A list of minimum versions of other **modules required** by the current module.
+* Instructions, optionally, to **replace** a required module with another
+ module version or a local directory, or to **exclude** a specific version of
+ a required module.
+
+Go generates a go.mod file when you run the [`go mod init`
+command](/ref/mod#go-mod-init). The following example creates a go.mod file,
+setting the module's module path to example.com/mymodule:
+
+```
+$ go mod init example.com/mymodule
+```
+
+Use `go` commands to manage dependencies. The commands ensure that the
+requirements described in your go.mod file remain consistent and the content of
+your go.mod file is valid. These commands include the [`go get`](/ref/mod#go-get)
+and [`go mod tidy`](/ref/mod#go-mod-tidy) and [`go mod edit`](/ref/mod#go-mod-edit)
+commands.
+
+For reference on `go` commands, see [Command go](/cmd/go/).
+You can get help from the command line by typing `go help` _command-name_, as
+with `go help mod tidy`.
+
+**See also**
+
+* Go tools make changes to your go.mod file as you use them to manage
+ dependencies. For more, see [Managing dependencies](/doc/modules/managing-dependencies).
+* For more details and constraints related to go.mod files, see the [Go modules
+ reference](/ref/mod#go-mod-file).
+
+## Example {#example}
+
+A go.mod file includes directives shown in the following example. These are
+described in this topic.
+
+```
+module example.com/mymodule
+
+go 1.14
+
+require (
+ example.com/othermodule v1.2.3
+ example.com/thismodule v1.2.3
+ example.com/thatmodule v1.2.3
+)
+
+replace example.com/thatmodule => ../thatmodule
+exclude example.com/thismodule v1.3.0
+```
+
+## module {#module}
+
+Declares the module's module path, which is the module's unique identifier
+(when combined with the module version number). This becomes the import prefix
+for all packages the module contains.
+
+### Syntax {#module-syntax}
+
+<pre>module <var>module-path</var></pre>
+
+<dl>
+ <dt>module-path</dt>
+ <dd>The module's module path, usually the repository location from which
+ the module can be downloaded by Go tools. For module versions v2 and
+ later, this value must end with the major version number, such as
+ <code>/v2</code>.</dd>
+</dl>
+
+### Examples {#module-examples}
+
+The following examples substitute `example.com` for a repository domain from
+which the module could be downloaded.
+
+* Module declaration for a v0 or v1 module:
+ ```
+ module example.com/mymodule
+ ```
+* Module path for a v2 module:
+ ```
+ module example.com/mymodule/v2
+ ```
+
+### Notes {#module-notes}
+
+The module path should be a path from which Go tools can download the module
+source. In practice, this is typically the module source's repository domain
+and path to the module code within the repository. The <code>go</code> command
+relies on this form when downloading module versions to resolve dependencies
+on the module user's behalf.
+
+Even if you're not at first intending to make your module available for use
+from other code, using its repository path is a best practice that will help
+you avoid having to rename the module if you publish it later.
+
+If at first you don't know the module's eventual repository location, consider
+temporarily using a safe substitute, such as the name of a domain you own or
+`example.com`, along with a path following from the module's name or source
+directory.
+
+For example, if you're developing in a `stringtools` directory, your temporary
+module path might be `example.com/stringtools`, as in the following example:
+
+```
+go mod init example.com/stringtools
+```
+
+## go {#go}
+
+Indicates that the module was written assuming the semantics of the Go version
+specified by the directive.
+
+### Syntax {#go-syntax}
+
+<pre>go <var>minimum-go-version</var></pre>
+
+<dl>
+ <dt>minimum-go-version</dt>
+ <dd>The minimum version of Go required to compile packages in this module.</dd>
+</dl>
+
+### Examples {#go-examples}
+
+* Module must run on Go version 1.14 or later:
+ ```
+ go 1.14
+ ```
+
+### Notes {#go-notes}
+
+The `go` directive was originally intended to support backward incompatible
+changes to the Go language (see [Go 2
+transition](/design/28221-go2-transitions)). There have been no incompatible
+language changes since modules were introduced, but the `go` directive still
+affects use of new language features:
+
+* For packages within the module, the compiler rejects use of language features
+ introduced after the version specified by the `go` directive. For example, if
+ a module has the directive `go 1.12`, its packages may not use numeric
+ literals like `1_000_000`, which were introduced in Go 1.13.
+* If an older Go version builds one of the module's packages and encounters a
+ compile error, the error notes that the module was written for a newer Go
+ version. For example, suppose a module has `go 1.13` and a package uses the
+ numeric literal `1_000_000`. If that package is built with Go 1.12, the
+ compiler notes that the code is written for Go 1.13.
+
+Additionally, the `go` command changes its behavior based on the version
+specified by the `go` directive. This has the following effects:
+
+* At `go 1.14` or higher, automatic [vendoring](/ref/mod#vendoring) may be
+ enabled. If the file `vendor/modules.txt` is present and consistent with
+ `go.mod`, there is no need to explicitly use the `-mod=vendor` flag.
+* At `go 1.16` or higher, the `all` package pattern matches only packages
+ transitively imported by packages and tests in the [main
+ module](/ref/mod#glos-main-module). This is the same set of packages retained
+ by [`go mod vendor`](/ref/mod#go-mod-vendor) since modules were introduced. In
+ lower versions, `all` also includes tests of packages imported by packages in
+ the main module, tests of those packages, and so on.
+
+A `go.mod` file may contain at most one `go` directive. Most commands will add a
+`go` directive with the current Go version if one is not present.
+
+## require {#require}
+
+Declares a module as dependency required by the current module, specifying the
+minimum version of the module required.
+
+### Syntax {#require-syntax}
+
+<pre>require <var>module-path</var> <var>module-version</var></pre>
+
+<dl>
+ <dt>module-path</dt>
+ <dd>The module's module path, usually a concatenation of the module source's
+ repository domain and the module name. For module versions v2 and later,
+ this value must end with the major version number, such as <code>/v2</code>.</dd>
+ <dt>module-version</dt>
+ <dd>The module's version. This can be either a release version number, such
+ as v1.2.3, or a Go-generated pseudo-version number, such as
+ v0.0.0-20200921210052-fa0125251cc4.</dd>
+</dl>
+
+### Examples {#require-examples}
+
+* Requiring a released version v1.2.3:
+ ```
+ require example.com/othermodule v1.2.3
+ ```
+* Requiring a version not yet tagged in its repository by using a pseudo-version
+ number generated by Go tools:
+ ```
+ require example.com/othermodule v0.0.0-20200921210052-fa0125251cc4
+ ```
+
+### Notes {#require-notes}
+
+When you run a `go` command such as `go get`, Go inserts `require` directives
+for each module containing imported packages. When a module isn't yet tagged in
+its repository, Go assigns a pseudo-version number it generates when you run the
+command.
+
+You can have Go require a module from a location other than its repository by
+using the [`replace` directive](#replace).
+
+For more about version numbers, see [Module version numbering](/doc/modules/version-numbers).
+
+For more about managing dependencies, see the following:
+
+* [Adding a dependency](/doc/modules/managing-dependencies#adding_dependency)
+* [Getting a specific dependency version](/doc/modules/managing-dependencies#getting_version)
+* [Discovering available updates](/doc/modules/managing-dependencies#discovering_updates)
+* [Upgrading or downgrading a dependency](/doc/modules/managing-dependencies#upgrading)
+* [Synchronizing your code's dependencies](/doc/modules/managing-dependencies#synchronizing)
+
+## replace {#replace}
+
+Replaces the content of a module at a specific version (or all versions) with
+another module version or with a local directory. Go tools will use the
+replacement path when resolving the dependency.
+
+### Syntax {#replace-syntax}
+
+<pre>replace <var>module-path</var> <var>[module-version]</var> => <var>replacement-path</var> <var>[replacement-version]</var></pre>
+
+<dl>
+ <dt>module-path</dt>
+ <dd>The module path of the module to replace.</dd>
+ <dt>module-version</dt>
+ <dd>Optional. A specific version to replace. If this version number is
+ omitted, all versions of the module are replaced with the content on the
+ right side of the arrow.</dd>
+ <dt>replacement-path</dt>
+ <dd>The path at which Go should look for the required module. This can be a
+ module path or a path to a directory on the file system local to the
+ replacement module. If this is a module path, you must specify a
+ <em>replacement-version</em> value. If this is a local path, you may not use a
+ <em>replacement-version</em> value.</dd>
+ <dt>replacement-version</dt>
+ <dd>The version of the replacement module. The replacement version may only
+ be specified if <em>replacement-path</em> is a module path (not a local directory).</dd>
+</dl>
+
+### Examples {#replace-examples}
+
+* Replacing with a fork of the module repository
+
+ In the following example, any version of example.com/othermodule is replaced
+ with the specified fork of its code.
+
+ ```
+ require example.com/othermodule v1.2.3
+
+ replace example.com/othermodule => example.com/myfork/othermodule v1.2.3-fixed
+ ```
+
+ When you replace one module path with another, do not change import statements
+ for packages in the module you're replacing.
+
+ For more on using a forked copy of module code, see [Requiring external module
+ code from your own repository fork](/doc/modules/managing-dependencies#external_fork).
+
+* Replacing with a different version number
+
+ The following example specifies that version v1.2.3 should be used instead of
+ any other version of the module.
+
+ ```
+ require example.com/othermodule v1.2.2
+
+ replace example.com/othermodule => example.com/othermodule v1.2.3
+ ```
+
+ The following example replaces module version v1.2.5 with version v1.2.3 of
+ the same module.
+
+ ```
+ replace example.com/othermodule v1.2.5 => example.com/othermodule v1.2.3
+ ```
+
+* Replacing with local code
+
+ The following example specifies that a local directory should be used as a
+ replacement for all versions of the module.
+
+ ```
+ require example.com/othermodule v1.2.3
+
+ replace example.com/othermodule => ../othermodule
+ ```
+
+ The following example specifies that a local directory should be used as a
+ replacement for v1.2.5 only.
+
+ ```
+ require example.com/othermodule v1.2.5
+
+ replace example.com/othermodule v1.2.5 => ../othermodule
+ ```
+
+ For more on using a local copy of module code, see [Requiring module code in a
+ local directory](/doc/modules/managing-dependencies#local_directory).
+
+### Notes {#replace-notes}
+
+Use the `replace` directive to temporarily substitute a module path value with
+another value when you want Go to use the other path to find the module's
+source. This has the effect of redirecting Go's search for the module to the
+replacement's location. You needn't change package import paths to use the
+replacement path.
+
+Use the `exclude` and `replace` directives to control build-time dependency
+resolution when building the current module. These directives are ignored in
+modules that depend on the current module.
+
+The `replace` directive can be useful in situations such as the following:
+
+* You're developing a new module whose code is not yet in the repository. You
+ want to test with clients using a local version.
+* You've identified an issue with a dependency, have cloned the dependency's
+ repository, and you're testing a fix with the local repository.
+
+For more on replacing a required module, including using Go tools to make the
+change, see:
+
+* [Requiring external module code from your own repository
+fork](/doc/modules/managing-dependencies#external_fork)
+* [Requiring module code in a local
+directory](/doc/modules/managing-dependencies#local_directory)
+
+For more about version numbers, see [Module version
+numbering](/doc/modules/version-numbers).
+
+## exclude {#exclude}
+
+Specifies a module or module version to exclude from the current module's
+dependency graph.
+
+### Syntax {#exclude-syntax}
+
+<pre>exclude <var>module-path</var> <var>module-version</var></pre>
+
+<dl>
+ <dt>module-path</dt>
+ <dd>The module path of the module to exclude.</dd>
+ <dt>module-version</dt>
+ <dd>The specific version to exclude.</dd>
+</dl>
+
+### Example {#exclude-example}
+
+* Exclude example.com/theirmodule version v1.3.0
+
+ ```
+ exclude example.com/theirmodule v1.3.0
+ ```
+
+### Notes {#exclude-notes}
+
+Use the `exclude` directive to exclude a specific version of a module that is
+indirectly required but can't be loaded for some reason. For example, you might
+use it to exclude a version of a module that has an invalid checksum.
+
+Use the `exclude` and `replace` directives to control build-time dependency
+resolution when building the current module (the main module you're building).
+These directives are ignored in modules that depend on the current module.
+
+You can use the [`go mod edit`](/ref/mod#go-mod-edit) command
+to exclude a module, as in the following example.
+
+```
+go mod edit -exclude=example.com/theirmodule@v1.3.0
+```
+
+For more about version numbers, see [Module version numbering](/doc/modules/version-numbers).
diff --git a/_content/doc/modules/images/multiple-modules.png b/_content/doc/modules/images/multiple-modules.png
new file mode 100644
index 0000000..7f684d4
--- /dev/null
+++ b/_content/doc/modules/images/multiple-modules.png
Binary files differ
diff --git a/_content/doc/modules/images/single-module.png b/_content/doc/modules/images/single-module.png
new file mode 100644
index 0000000..c39b1e1
--- /dev/null
+++ b/_content/doc/modules/images/single-module.png
Binary files differ
diff --git a/_content/doc/modules/images/source-hierarchy.png b/_content/doc/modules/images/source-hierarchy.png
new file mode 100644
index 0000000..9244981
--- /dev/null
+++ b/_content/doc/modules/images/source-hierarchy.png
Binary files differ
diff --git a/_content/doc/modules/images/v2-branch-module.png b/_content/doc/modules/images/v2-branch-module.png
new file mode 100644
index 0000000..ad7b60f
--- /dev/null
+++ b/_content/doc/modules/images/v2-branch-module.png
Binary files differ
diff --git a/_content/doc/modules/images/v2-module.png b/_content/doc/modules/images/v2-module.png
new file mode 100644
index 0000000..7a4fb31
--- /dev/null
+++ b/_content/doc/modules/images/v2-module.png
Binary files differ
diff --git a/_content/doc/modules/images/version-number.png b/_content/doc/modules/images/version-number.png
new file mode 100644
index 0000000..1d459b2
--- /dev/null
+++ b/_content/doc/modules/images/version-number.png
Binary files differ
diff --git a/_content/doc/modules/major-version.md b/_content/doc/modules/major-version.md
new file mode 100644
index 0000000..2a43002
--- /dev/null
+++ b/_content/doc/modules/major-version.md
@@ -0,0 +1,87 @@
+<!--{
+ "Title": "Developing a major version update"
+}-->
+
+You must update to a major version when changes you're making in a potential new
+version can't guarantee backward compatibility for the module's users. For
+example, you'll make this change if you change your module's public API such
+that it breaks client code using previous versions of the module.
+
+> **Note:** Each release type -- major, minor, patch, or pre-release -- has a
+different meaning for a module's users. Those users rely on these differences to
+understand the level of risk a release represents to their own code. In other
+words, when preparing a release, be sure that its version number accurately
+reflects the nature of the changes since the preceding release. For more on
+version numbers, see [Module version numbering](/doc/modules/version-numbers).
+
+**See also**
+
+* For an overview of module development, see [Developing and publishing
+ modules](developing).
+* For an end-to-end view, see [Module release and versioning
+ workflow](release-workflow).
+
+## Considerations for a major version update {#considerations}
+
+You should only update to a new major version when it's absolutely necessary.
+A major version update represents significant churn for both you and your
+module's users. When you're considering a major version update, think about
+the following:
+
+* Be clear with your users about what releasing the new major version means
+ for your support of previous major versions.
+
+ Are previous versions deprecated? Supported as they were before? Will you be
+ maintaining previous versions, including with bug fixes?
+
+* Be ready to take on the maintenance of two versions: the old and the new.
+ For example, if you fix bugs in one, you'll often be porting those fixes into
+ the other.
+
+* Remember that a new major version is a new module from a dependency management
+ perspective. Your users will need to update to use a new module after you
+ release, rather than simply upgrading.
+
+ That's because a new major version has a different module path from the
+ preceding major version. For example, for a module whose module path is
+ example.com/mymodule, a v2 version would have the module path
+ example.com/mymodule/v2.
+
+* When you're developing a new major version, you must also update import paths
+ wherever code imports packages from the new module. Your module's users must
+ also update their import paths if they want to upgrade to the new major version.
+
+## Branching for a major release {#branching}
+
+The most straightforward approach to handling source when preparing to develop a
+new major version is to branch the repository at the latest version of the
+previous major version.
+
+For example, in a command prompt you might change to your module's root
+directory, then create a new v2 branch there.
+
+```
+$ cd mymodule
+$ git checkout -b v2
+Switched to a new branch "v2"
+```
+
+<img src="images/v2-branch-module.png"
+ alt="Diagram illustrating a repository branched from master to v2"
+ style="width: 600px;" />
+
+
+Once you have the source branched, you'll need to make the following changes to
+the source for your new version:
+
+* In the new version's go.mod file, append new major version number to the
+ module path, as in the following example:
+ * Existing version: `example.com/mymodule`
+ * New version: `example.com/mymodule/v2`
+
+* In your Go code, update every imported package path where you import a package
+ from the module, appending the major version number to the module path portion.
+ * Old import statement: `import "example.com/mymodule/package1"`
+ * New import statement: `import "example.com/mymodule/v2/package1"`
+
+For publishing steps, see [Publishing a module](/doc/modules/publishing).
diff --git a/_content/doc/modules/managing-dependencies.md b/_content/doc/modules/managing-dependencies.md
new file mode 100644
index 0000000..5f848a6
--- /dev/null
+++ b/_content/doc/modules/managing-dependencies.md
@@ -0,0 +1,461 @@
+<!--{
+ "Title": "Managing dependencies"
+}-->
+
+When your code uses external packages, those packages (distributed as modules)
+become dependencies. Over time, you may need to upgrade them or replace them. Go
+provides dependency management tools that help you keep your Go applications
+secure as you incorporate external dependencies.
+
+This topic describes how to perform tasks to manage dependencies you take on in
+your code. You can perform most of these with Go tools. This topic also
+describes how to perform a few other dependency-related tasks you might find
+useful.
+
+**See also**
+
+* If you're new to working with dependencies as modules, take a look at the
+ [Getting started tutorial](/doc/tutorial/getting-started)
+ for a brief introduction.
+* Using the `go` command to manage dependencies helps ensure that your
+ requirements remain consistent and the content of your go.mod file is valid.
+ For reference on the commands, see [Command go](/cmd/go/).
+ You can also get help from the command line by typing `go help`
+ _command-name_, as with `go help mod tidy`.
+* Go commands you use to make dependency changes edit your go.mod file. For
+ more about the contents of the file, see [go.mod file reference](/doc/modules/gomod-ref).
+* Making your editor or IDE aware of Go modules can make the work of managing
+ them easier. For more on editors that support Go, see [Editor plugins and
+ IDEs](/doc/editors.html).
+* This topic doesn't describe how to develop, publish, and version modules for
+ others to use. For more on that, see [Developing and publishing
+ modules](developing).
+
+## Workflow for using and managing dependencies {#workflow}
+
+You can get and use useful packages with Go tools. On
+[pkg.go.dev](https://pkg.go.dev), you can search for packages you might find
+useful, then use the `go` command to import those packages into your own code to
+call their functions.
+
+The following lists the most common dependency management steps. For more about
+each, see the sections in this topic.
+
+1. [Locate useful packages](#locating_packages) on [pkg.go.dev](https://pkg.go.dev).
+1. [Import the packages](#locating_packages) you want in your code.
+1. Add your code to a module for dependency tracking (if it isn't in a module
+ already). See [Enabling dependency tracking](#enable_tracking)
+1. [Add external packages as dependencies](#adding_dependency) so you can manage
+ them.
+1. [Upgrade or downgrade dependency versions](#upgrading) as needed over time.
+
+## Managing dependencies as modules {#modules}
+
+In Go, you manage dependencies as modules that contain the packages you import.
+This process is supported by:
+
+* A **decentralized system for publishing** modules and retrieving their code.
+ Developers make their modules available for other developers to use from
+ their own repository and publish with a version number.
+* A **package search engine** and documentation browser (pkg.go.dev) at which
+ you can find modules. See [Locating and importing useful packages](#locating_packages).
+* A module **version numbering convention** to help you understand a module's
+ stability and backward compatibility guarantees. See [Module version
+ numbering](version-numbers).
+* **Go tools** that make it easier for you to manage dependencies, including
+ getting a module's source, upgrading, and so on. See sections of this topic
+ for more.
+
+## Locating and importing useful packages {#locating_packages}
+
+You can search [pkg.go.dev](https://pkg.go.dev) to find packages with functions
+you might find useful.
+
+When you've found a package you want to use in your code, locate the package
+path at the top of the page and click the Copy path button to copy the path to
+your clipboard. In your own code, paste the path into an import statement, as in
+the following example:
+
+```
+import "rsc.io/quote"
+```
+
+After your code imports the package, enable dependency tracking and get the
+package's code to compile with. For more, see [Enabling dependency tracking in
+your code](#enable_tracking) and [Adding a dependency](#adding_dependency).
+
+## Enabling dependency tracking in your code {#enable_tracking}
+
+To track and manage the dependencies you add, you begin by putting your code in
+its own module. This creates a go.mod file at the root of your source tree.
+Dependencies you add will be listed in that file.
+
+To add your code to its own module, use the [`go mod init`
+command](/ref/mod#go-mod-init).
+For example, from the command line, change to your code's root directory, then
+run the command as in the following example:
+
+```
+$ go mod init example.com/mymodule
+```
+
+The `go mod init` command's argument is your module's module path. If possible,
+the module path should be the repository location of your source code. If at
+first you don't know the module's eventual repository location, consider
+temporarily using a safe substitute, such as the name of a domain you own or
+`example.com`, along with a path following from the module's name or source
+directory.
+
+As you use Go tools to manage dependencies, the tools update the go.mod file so
+that it maintains a current list of your dependencies.
+
+When you add dependencies, Go tools also create a go.sum file that contains
+checksums of modules you depend on. Go uses this to verify the integrity of
+downloaded module files, especially for other developers working on your
+project.
+
+Include the go.mod and go.sum files in your repository with your code.
+
+See the [go.mod reference](/doc/modules/gomod-ref) for more.
+
+## Adding a dependency {#adding_dependency}
+
+Once you're importing packages from a published module, you can add that module
+to manage as a dependency by using the [`go get`
+command](/cmd/go/#hdr-Add_dependencies_to_current_module_and_install_them).
+
+The command does the following:
+
+* If needed, it adds `require` directives to your go.mod file for modules
+ needed to build packages named on the command line. A `require` directive
+ tracks the minimum version of a module that your module depends on. See the
+ [go.mod reference](/doc/modules/gomod-ref) for more.
+* If needed, it downloads module source code so you can compile packages that
+ depend on them. It can download modules from a module proxy like
+ proxy.golang.org or directly from version control repositories. The source
+ is cached locally.
+
+ You can set the location from which Go tools download modules. For more, see
+ [Specifying a module proxy server](#proxy_server).
+
+The following describes a few examples.
+
+* To add all dependencies for a package in your module, run a command like the
+ one below ("." refers to the package in the current directory):
+
+ ```
+ $ go get .
+ ```
+
+* To add a specific dependency, specify its module path as an argument to the
+ command.
+
+ ```
+ $ go get example.com/theirmodule
+ ```
+
+The command also authenticates each module it downloads. This ensures that it's
+unchanged from when the module was published. If the module has changed since it
+was published -- for example, the developer changed the contents of the commit
+-- Go tools will present a security error. This authentication check protects
+you from modules that might have been tampered with.
+
+## Getting a specific dependency version {#getting_version}
+
+You can get a specific version of a dependency module by specifying its version
+in the `go get` command. The command updates the `require` directive in your
+go.mod file (though you can also update that manually).
+
+You might want to do this if:
+
+* You want to get a specific pre-release version of a module to try out.
+* You've discovered that the version you're currently requiring isn't working
+ for you, so you want to get a version you know you can rely on.
+* You want to upgrade or downgrade a module you're already requiring.
+
+Here are examples for using the [`go get`
+command](/ref/mod#go-get):
+
+* To get a specific numbered version, append the module path with an @ sign
+ followed by the version you want:
+
+ ```
+ $ go get example.com/theirmodule@v1.3.4
+ ```
+
+* To get the latest version, append the module path with `@latest`:
+
+ ```
+ $ go get example.com/theirmodule@latest
+ ```
+
+The following go.mod file `require` directive example (see the [go.mod
+reference]/doc/modules/gomod-ref) for more) illustrates how to require a specific version
+number:
+
+```
+require example.com/theirmodule v1.3.4
+```
+
+## Discovering available updates {#discovering_updates}
+
+You can check to see if there are newer versions of dependencies you're already
+using in your current module. Use the `go list` command to display a list of
+your module's dependencies, along with the latest version available for that
+module. Once you've discovered available upgrades, you can try them out with your
+code to decide whether or not to upgrade to new versions.
+
+For more about the `go list` command, see [`go list -m`](/ref/mod#go-list-m).
+
+Here are a couple of examples.
+
+* List all of the modules that are dependencies of your current module,
+ along with the latest version available for each:
+
+ ```
+ $ go list -m -u all
+ ```
+
+* Display the latest version available for a specific module:
+
+ ```
+ $ go list -m -u example.com/theirmodule
+ ```
+
+## Upgrading or downgrading a dependency {#upgrading}
+
+You can upgrade or downgrade a dependency module by using Go tools to discover
+available versions, then add a different version as a dependency.
+
+1. To discover new versions use the `go list` command as described in
+ [Discovering available updates](#discovering_updates).
+
+1. To add a particular version as a dependency, use the `go get` command as
+ described in [Getting a specific dependency version](#getting_version).
+
+## Synchronizing your code's dependencies {#synchronizing}
+
+You can ensure that you're managing dependencies for all of your code's imported
+packages while also removing dependencies for packages you're no longer
+importing.
+
+This can be useful when you've been making changes to your code and
+dependencies, possibly creating a collection of managed dependencies and
+downloaded modules that no longer match the collection specifically required by
+the packages imported in your code.
+
+To keep your managed dependency set tidy, use the `go mod tidy` command. Using
+the set of packages imported in your code, this command edits your go.mod file
+to add modules that are necessary but missing. It also removes unused modules
+that don't provide any relevant packages.
+
+The command has no arguments except for one flag, -v, that prints information
+about removed modules.
+
+```
+$ go mod tidy
+```
+
+## Developing and testing against unpublished module code {#unpublished}
+
+You can specify that your code should use dependency modules that may not be
+published. The code for these modules might be in their respective repositories,
+in a fork of those repositories, or on a drive with the current module that
+consumes them.
+
+You might want to do this when:
+
+* You want to make your own changes to an external module's code, such as
+ after forking and/or cloning it. For example, you might want to prepare a
+ fix to the module, then send it as a pull request to the module's developer.
+* You're building a new module and haven't yet published it, so it's
+ unavailable on a repository where the `go get` command can reach it.
+
+### Requiring module code in a local directory {#local_directory}
+
+You can specify that the code for a required module is on the same local drive
+as the code that requires it. You might find this useful when you are:
+
+* Developing your own separate module and want to test from the current module.
+* Fixing issues in or adding features to an external module and want to test
+ from the current module. (Note that you can also require the external module
+ from your own fork of its repository. For more, see [Requiring external
+ module code from your own repository fork](#external_fork).)
+
+To tell Go commands to use the local copy of the module's code, use the
+`replace` directive in your go.mod file to replace the module path given in a
+`require` directive. See the [go.mod reference](/doc/modules/gomod-ref) for
+more about directives.
+
+In the following go.mod file example, the current module requires the external
+module `example.com/theirmodule`, with a nonexistent version number
+(`v0.0.0-unpublished`) used to ensure the replacement works correctly. The
+`replace` directive then replaces the original module path with
+`../theirmodule`, a directory that is at the same level as the current module's
+directory.
+
+```
+module example.com/mymodule
+
+go 1.16
+
+require example.com/theirmodule v0.0.0-unpublished
+
+replace example.com/theirmodule v0.0.0-unpublished => ../theirmodule
+```
+
+When setting up a `require`/`replace` pair, use the
+[`go mod edit`](/ref/mod#go-mod-edit) and [`go get`](/ref/mod#go-get) commands
+to ensure that requirements described by the file remain consistent:
+
+```
+$ go mod edit -replace=example.com/theirmodule@v0.0.0-unpublished=../theirmodule
+$ go get -d example.com/theirmodule@v0.0.0-unpublished
+```
+
+**Note:** When you use the replace directive, Go tools don't authenticate
+external modules as described in [Adding a dependency](#adding_dependency).
+
+For more about version numbers, see [Module version numbering](/doc/modules/version-numbers).
+
+### Requiring external module code from your own repository fork {#external_fork}
+
+When you have forked an external module's repository (such as to fix an issue in
+the module's code or to add a feature), you can have Go tools use your fork for
+the module's source. This can be useful for testing changes from your own code.
+(Note that you can also require the module code in a directory that's on the
+local drive with the module that requires it. For more, see [Requiring module
+code in a local directory](#local_directory).)
+
+You do this by using a `replace` directive in your go.mod file to replace the
+external module's original module path with a path to the fork in your
+repository. This directs Go tools to use the replacement path (the fork's
+location) when compiling, for example, while allowing you to leave `import`
+statements unchanged from the original module path.
+
+For more about the `replace` directive, see the [go.mod file
+reference](gomod-ref).
+
+In the following go.mod file example, the current module requires the external
+module `example.com/theirmodule`. The `replace` directive then replaces the
+original module path with `example.com/myfork/theirmodule`, a fork of the
+module's own repository.
+
+```
+module example.com/mymodule
+
+go 1.16
+
+require example.com/theirmodule v1.2.3
+
+replace example.com/theirmodule v1.2.3 => example.com/myfork/theirmodule v1.2.3-fixed
+```
+
+When setting up a `require`/`replace` pair, use Go tool commands to ensure that
+requirements described by the file remain consistent. Use the [`go
+list`](/ref/mod#go-list-m) command to get the version in use by the current
+module. Then use the [`go mod edit`](/ref/mod#go-mod-edit) command to replace
+the required module with the fork:
+
+```
+$ go list -m example.com/theirmodule
+example.com/theirmodule v1.2.3
+$ go mod edit -replace=example.com/theirmodule@v1.2.3=example.com/myfork/theirmodule v1.2.3-fixed
+```
+
+**Note:** When you use the `replace` directive, Go tools don't authenticate
+external modules as described in [Adding a dependency](#adding_dependency).
+
+For more about version numbers, see [Module version numbering](/doc/modules/version-numbers).
+
+## Getting a specific commit using a repository identifier {#repo_identifier}
+
+You can use the `go get` command to add unpublished code for a module from a
+specific commit in its repository.
+
+To do this, you use the `go get` command, specifying the code you want with an
+`@` sign. When you use `go get`, the command will add to your go.mod file a
+`require` directive that requires the external module, using a pseudo-version
+number based on details about the commit.
+
+The following examples provide a few illustrations. These are based on a module
+whose source is in a git repository.
+
+* To get the module at a specific commit, append the form @<em>commithash</em>:
+
+ ```
+ $ go get example.com/theirmodule@4cf76c2
+ ```
+
+* To get the module at a specific branch, append the form @<em>branchname</em>:
+
+ ```
+ $ go get example.com/theirmodule@bugfixes
+ ```
+
+## Removing a dependency {#removing_dependency}
+
+When your code no longer uses any packages in a module, you can stop tracking
+the module as a dependency.
+
+To stop tracking all unused modules, run the [`go mod tidy`
+command](/ref/mod#go-mod-tidy). This command may also add missing dependencies
+needed to build packages in your module.
+
+```
+$ go mod tidy
+```
+
+To remove a specific dependency, use the [`go get`
+command](/ref/mod#go-get), specifying the module's module path and appending
+`@none`, as in the following example:
+
+```
+$ go get example.com/theirmodule@none
+```
+
+The `go get` command will also downgrade or remove other dependencies that
+depend on the removed module.
+
+## Specifying a module proxy server {#proxy_server}
+
+When you use Go tools to work with modules, the tools by default download
+modules from proxy.golang.org (a public Google-run module mirror) or directly
+from the module's repository. You can specify that Go tools should instead use
+another proxy server for downloading and authenticating modules.
+
+You might want to do this if you (or your team) have set up or chosen a
+different module proxy server that you want to use. For example, some set up a
+module proxy server in order to have greater control over how dependencies are
+used.
+
+To specify another module proxy server for Go tools use, set the `GOPROXY`
+environment variable to the URL of one or more servers. Go tools will try each
+URL in the order you specify. By default, `GOPROXY` specifies a public
+Google-run module proxy first, then direct download from the module's repository
+(as specified in its module path):
+
+```
+GOPROXY="https://proxy.golang.org,direct"
+```
+
+For more about the `GOPROXY` environment variable, including values to support
+other behavior, see the [`go` command
+reference](https://golang.org/cmd/go/#hdr-Module_downloading_and_verification).
+
+You can set the variable to URLs for other module proxy servers, separating URLs
+with either a comma or a pipe.
+
+* When you use a comma, Go tools will try the next URL in the list only if the
+ current URL returns an HTTP 404 or 410.
+
+ ```
+ GOPROXY="https://proxy.example.com,https://proxy2.example.com"
+ ```
+
+* When you use a pipe, Go tools will try the next URL in the list regardless
+ of the HTTP error code.
+
+ ```
+ GOPROXY="https://proxy.example.com|https://proxy2.example.com"
+ ```
diff --git a/_content/doc/modules/managing-source.md b/_content/doc/modules/managing-source.md
new file mode 100644
index 0000000..63ebc41
--- /dev/null
+++ b/_content/doc/modules/managing-source.md
@@ -0,0 +1,165 @@
+<!--{
+ "Title": "Managing module source"
+}-->
+
+When you're developing modules to publish for others to use, you can help ensure
+that your modules are easier for other developers to use by following the
+repository conventions described in this topic.
+
+This topic describes actions you might take when managing your module
+repository. For information about the sequence of workflow steps you'd take when
+revising from version to version, see [Module release and versioning
+workflow](release-workflow).
+
+Some of the conventions described here are required in modules, while others are
+best practices. This content assumes you're familiar with the basic module use
+practices described in [Managing dependencies](/doc/modules/managing-dependencies).
+
+Go supports the following repositories for publishing modules: Git, Subversion,
+Mercurial, Bazaar, and Fossil.
+
+For an overview of module development, see [Developing and publishing
+modules](developing).
+
+## How Go tools find your published module {#tools}
+
+In Go's decentralized system for publishing modules and retrieving their code,
+you can publish your module while leaving the code in your repository. Go tools
+rely on naming rules that have repository paths and repository tags indicating a
+module's name and version number. When your repository follows these
+requirements, your module code is downloadable from your repository by Go tools
+such as the [`go get`
+command](/ref/mod#go-get).
+
+When a developer uses the `go get` command to get source code for packages their
+code imports, the command does the following:
+
+1. From `import` statements in Go source code, `go get` identifies the module
+ path within the package path.
+1. Using a URL derived from the module path, the command locates the module
+ source on a module proxy server or at its repository directly.
+1. Locates source for the module version to download by matching the module's
+ version number to a repository tag to discover the code in the repository.
+ When a version number to use is not yet known, `go get` locates the latest
+ release version.
+1. Retrieves module source and downloads it to the developer's local module cache.
+
+## Organizing code in the repository {#repository}
+
+You can keep maintenance simple and improve developers' experience with your
+module by following the conventions described here. Getting your module code
+into a repository is generally as simple as with other code.
+
+The following diagram illustrates a source hierarchy for a simple module with
+two packages.
+
+<img src="images/source-hierarchy.png"
+ alt="Diagram illustrating a module source code hierarchy"
+ style="width: 250px;" />
+
+Your initial commit should include files listed in the following table:
+
+<table id="module-files" class="DocTable">
+ <thead>
+ <tr class="DocTable-head">
+ <th class="DocTable-cell" width="20%">File</td>
+ <th class="DocTable-cell">Description</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr class="DocTable-row">
+ <td class="DocTable-cell">LICENSE</td>
+ <td class="DocTable-cell">The module's license.</td>
+ </tr>
+ <tr class="DocTable-row">
+ <td class="DocTable-cell">go.mod</td>
+ <td class="DocTable-cell"><p>Describes the module, including its module
+ path (in effect, its name) and its dependencies. For more, see the
+ <a href="gomod-ref">go.mod reference</a>.</p>
+ <p>The module path will be given in a module directive, such as:</p>
+ <pre>module example.com/mymodule</pre>
+ <p>Though you can edit this file, much of it is maintained for you by go
+ commands.</p>
+ </td>
+ </tr>
+ <tr class="DocTable-row">
+ <td class="DocTable-cell">go.sum</td>
+ <td class="DocTable-cell"><p>Contains cryptographic hashes that represent
+ the module's dependencies. Go tools use these hashes to authenticate
+ downloaded modules, attempting to confirm that the downloaded module is
+ authentic. Where this confirmation fails, Go will display a security error.<p>
+ <p>The file will be empty or not present when there are no dependencies.
+ You shouldn't edit this file except by using the <code>go mod tidy</code>
+ command, which removes unneeded entries.</p>
+ </td>
+ </tr>
+ <tr class="DocTable-row">
+ <td class="DocTable-cell">Package directories and .go sources.</td>
+ <td class="DocTable-cell">Directories and .go files that comprise the Go
+ packages and sources in the module.</td>
+ </tr>
+ </tbody>
+</table>
+
+From the command-line, you can create an empty repository, add the files that
+will be part of your initial commit, and commit with a message. Here's an
+example using git:
+
+
+```
+$ git init
+$ git add --all
+$ git commit -m "mycode: initial commit"
+$ git push
+```
+
+## Choosing repository scope {#repository-scope}
+
+You publish code in a module when the code should be versioned independently
+from code in other modules.
+
+Designing your repository so that it hosts a single module at its root directory
+will help keep maintenance simpler, particularly over time as you publish new
+minor and patch versions, branch into new major versions, and so on. However, if
+your needs require it, you can instead maintain a collection of modules in a
+single repository.
+
+### Sourcing one module per repository {#one-module-source}
+
+You can maintain a repository that has a single module's source in it. In this
+model, you place your go.mod file at the repository root, with package
+subdirectories containing Go source beneath.
+
+This is the simplest approach, making your module likely easier to manage over
+time. It helps you avoid the need to prefix a module version number with a
+directory path.
+
+<img src="images/single-module.png"
+ alt="Diagram illustrating a single module's source in its repository"
+ style="width: 425px;" />
+
+### Sourcing multiple modules in a single repository {#multiple-module-source}
+
+You can publish multiple modules from a single repository. For example, you
+might have code in a single repository that constitutes multiple modules, but
+want to version those modules separately.
+
+Each subdirectory that is a module root directory must have its own go.mod file.
+
+Sourcing module code in subdirectories changes the form of the version tag you
+must use when publishing a module. You must prefix the version number part of
+the tag with the name of the subdirectory that is the module root. For more
+about version numbers, see [Module version numbering](/doc/modules/version-numbers).
+
+For example, for module `example.com/mymodules/module1` below, you would have
+the following for version v1.2.3:
+
+* Module path: `example.com/mymodules/module1`
+* Version tag: `module1/v1.2.3`
+* Package path imported by a user: `example.com/mymodules/module1/package1`
+* Module path as given in a user's require directive: `example.com/mymodules/module1 module1/v1.2.3`
+
+<img src="images/multiple-modules.png"
+ alt="Diagram illustrating two modules in a single repository"
+ style="width: 480px;" />
+
diff --git a/_content/doc/modules/publishing.md b/_content/doc/modules/publishing.md
new file mode 100644
index 0000000..29b13df
--- /dev/null
+++ b/_content/doc/modules/publishing.md
@@ -0,0 +1,83 @@
+<!--{
+ "Title": "Publishing a module"
+}-->
+
+When you want to make a module available for other developers, you publish it so
+that it's visible to Go tools. Once you've published the module, developers
+importing its packages will be able to resolve a dependency on the module by
+running commands such as `go get`.
+
+> **Note:** Don't change a tagged version of a module after publishing it. For
+developers using the module, Go tools authenticate a downloaded module against
+the first downloaded copy. If the two differ, Go tools will return a security
+error. Instead of changing the code for a previously published version, publish
+a new version.
+
+**See also**
+
+* For an overview of module development, see [Developing and publishing
+ modules](developing)
+* For a high-level module development workflow -- which includes publishing --
+ see [Module release and versioning workflow](release-workflow).
+
+## Publishing steps
+
+Use the following steps to publish a module.
+
+1. Open a command prompt and change to your module's root directory in the local
+ repository.
+
+1. Run `go mod tidy`, which removes any dependencies the module might have
+ accumulated that are no longer necessary.
+
+ ```
+ $ go mod tidy
+ ```
+
+1. Run `go test ./...` a final time to make sure everything is working.
+
+ This runs the unit tests you've written to use the Go testing framework.
+
+ ```
+ $ go test ./...
+ ok example.com/mymodule 0.015s
+ ```
+
+1. Tag the project with a new version number using the `git tag` command.
+
+ For the version number, use a number that signals to users the nature of
+ changes in this release. For more, see [Module version
+ numbering](version-numbers).
+
+ ```
+ $ git commit -m "mymodule: changes for v0.1.0"
+ $ git tag v0.1.0
+ ```
+
+1. Push the new tag to the origin repository.
+
+ ```
+ $ git push origin v0.1.0
+ ```
+
+1. Make the module available by running the [`go list`
+ command](https://golang.org/cmd/go/#hdr-List_packages_or_modules) to prompt
+ Go to update its index of modules with information about the module you're
+ publishing.
+
+ Precede the command with a statement to set the `GOPROXY` environment
+ variable to a Go proxy. This will ensure that your request reaches the
+ proxy.
+
+ ```
+ $ GOPROXY=proxy.golang.org go list -m example.com/mymodule@v0.1.0
+ ```
+
+Developers interested in your module import a package from it and run the [`go
+get` command]() just as they would with any other module. They can run the [`go
+get` command]() for latest versions or they can specify a particular version, as
+in the following example:
+
+```
+$ go get example.com/mymodule@v0.1.0
+```
diff --git a/_content/doc/modules/release-workflow.md b/_content/doc/modules/release-workflow.md
new file mode 100644
index 0000000..030ffbf
--- /dev/null
+++ b/_content/doc/modules/release-workflow.md
@@ -0,0 +1,293 @@
+<!--{
+ "Title": "Module release and versioning workflow"
+}-->
+
+When you develop modules for use by other developers, you can follow a workflow
+that helps ensure a reliable, consistent experience for developers using the
+module. This topic describes the high-level steps in that workflow.
+
+For an overview of module development, see [Developing and publishing
+modules](developing).
+
+**See also**
+
+* If you're merely wanting to use external packages in your code, be sure to
+ see [Managing dependencies](/doc/modules/managing-dependencies).
+* With each new version, you signal the changes to your module with its
+ version number. For more, see [Module version numbering](/doc/modules/version-numbers).
+
+## Common workflow steps {#common-steps}
+
+The following sequence illustrates release and versioning workflow steps for an
+example new module. For more about each step, see the sections in this topic.
+
+1. **Begin a module** and organize its sources to make it easier for developers
+ to use and for you to maintain.
+
+ If you're brand new to developing modules, check out [Tutorial: Create a Go
+ module](/doc/tutorial/create-module).
+
+ In Go's decentralized module publishing system, how you organize your code
+ matters. For more, see [Managing module source](/doc/modules/managing-source).
+
+1. Set up to **write local client code** that calls functions in the
+ unpublished module.
+
+ Before you publish a module, it's unavailable for the typical dependency
+ management workflow using commands such as `go get`. A good way to test your
+ module code at this stage is to try it while it is in a directory local to
+ your calling code.
+
+ See [Coding against an unpublished module](#unpublished) for more about
+ local development.
+
+1. When the module's code is ready for other developers to try it out,
+ **begin publishing v0 pre-releases** such as alphas and betas. See
+ [Publishing pre-release versions](#pre-release) for more.
+
+1. **Release a v0** that's not guaranteed to be stable, but which users can try
+ out. For more, see [Publishing the first (unstable) version](#first-unstable).
+
+1. After your v0 version is published, you can (and should!) continue to
+ **release new versions** of it.
+
+ These new versions might include bug fixes (patch releases), additions to
+ the module's public API (minor releases), and even breaking changes. Because
+ a v0 release makes no guarantees of stability or backward compatibility, you
+ can make breaking changes in its versions.
+
+ For more, see [Publishing bug fixes](#bug-fixes) and [Publishing
+ non-breaking API changes](#non-breaking).
+
+1. When you're getting a stable version ready for release, you **publish
+ pre-releases as alphas and betas**. For more, see [Publishing pre-release
+ versions](#pre-release).
+
+1. Release a v1 as the **first stable release**.
+
+ This is the first release that makes commitments about the module's
+ stability. For more, see [Publishing the first stable
+ version](#first-stable).
+
+1. In the v1 version, **continue to fix bugs** and, where necessary, make
+ additions to the module's public API.
+
+ For more, see [Publishing bug fixes](#bug-fixes) and [Publishing
+ non-breaking API changes](#non-breaking).
+
+1. When it can't be avoided, publish breaking changes in a **new major version**.
+
+ A major version update -- such as from v1.x.x to v2.x.x -- can be a very
+ disruptive upgrade for your module's users. It should be a last resort. For
+ more, see [Publishing breaking API changes](#breaking).
+
+## Coding against an unpublished module {#unpublished}
+
+When you begin developing a module or a new version of a module, you won't yet
+have published it. Before you publish a module, you won't be able to use Go
+commands to add the module as a dependency. Instead, at first, when writing
+client code in a different module that calls functions in the unpublished
+module, you'll need to reference a copy of the module on the local file system.
+
+You can reference a module locally from the client module's go.mod file by using
+the `replace` directive in the client module's go.mod file. For more
+information, see in [Requiring module code in a local
+directory](managing-dependencies#local_directory).
+
+## Publishing pre-release versions {#pre-release}
+
+You can publish pre-release versions to make a module available for others to
+try it out and give you feedback. A pre-release version includes no guarantee of
+stability.
+
+Pre-release version numbers are appended with a pre-release identifier. For more
+on version numbers, see [Module version numbering](/doc/modules/version-numbers).
+
+Here are two examples:
+
+```
+v0.2.1-beta.1
+v1.2.3-alpha
+```
+
+When making a pre-release available, keep in mind that developers using the
+pre-release will need to explicitly specify it by version with the `go get`
+command. That's because, by default, the `go` command prefers release versions
+over pre-release versions when locating the module you're asking for. So
+developers must get the pre-release by specifying it explicitly, as in the
+following example:
+
+```
+go get example.com/theirmodule@v1.2.3-alpha
+```
+
+You publish a pre-release by tagging the module code in your repository,
+specifying the pre-release identifier in the tag. For more, see [Publishing a
+module](publishing).
+
+## Publishing the first (unstable) version {#first-unstable}
+
+As when you publish a pre-release version, you can publish release versions that
+don't guarantee stability or backward compatibility, but give your users an
+opportunity to try out the module and give you feedback.
+
+Unstable releases are those whose version numbers are in the v0.x.x range. A v0
+version makes no stability or backward compatibility guarantees. But it gives
+you a way to get feedback and refine your API before making stability
+commitments with v1 and later. For more see, [Module version
+numbering](version-numbers).
+
+As with other published versions, you can increment the minor and patch parts of
+the v0 version number as you make changes toward releasing a stable v1 version.
+For example, after releasing a v.0.0.0, you might release a v0.0.1 with the
+first set of bug fixes.
+
+Here's an example version number:
+
+```
+v0.1.3
+```
+
+You publish an unstable release by tagging the module code in your repository,
+specifying a v0 version number in the tag. For more, see [Publishing a
+module](publishing).
+
+## Publishing the first stable version {#first-stable}
+
+Your first stable release will have a v1.x.x version number. The first stable
+release follows pre-release and v0 releases through which you got feedback,
+fixed bugs, and stabilized the module for users.
+
+With a v1 release, you're making the following commitments to developers using
+your module:
+
+* They can upgrade to the major version's subsequent minor and patch releases
+ without breaking their own code.
+* You won't be making further changes to the module's public API -- including
+ its function and method signatures -- that break backward compatibility.
+* You won't be removing any exported types, which would break backward
+ compatibility.
+* Future changes to your API (such as adding a new field to a struct) will be
+ backward compatible and will be included in a new minor release.
+* Bug fixes (such as a security fix) will be included in a patch release or as
+ part of a minor release.
+
+**Note:** While your first major version might be a v0 release, a v0 version
+does not signal stability or backward compatibility guarantees. As a result,
+when you increment from v0 to v1, you needn't be mindful of breaking backward
+compatibility because the v0 release was not considered stable.
+
+For more about version numbers, see [Module version numbering](/doc/modules/version-numbers).
+
+Here's an example of a stable version number:
+
+```
+v1.0.0
+```
+
+You publish a first stable release by tagging the module code in your
+repository, specifying a v1 version number in the tag. For more, see [Publishing
+a module](publishing).
+
+## Publishing bug fixes {#bug-fixes}
+
+You can publish a release in which the changes are limited to bug fixes. This is
+known as a patch release.
+
+A _patch release_ includes only minor changes. In particular, it includes no
+changes to the module's public API. Developers of consuming code can upgrade to
+this version safely and without needing to change their code.
+
+**Note:** Your patch release should try not to upgrade any of that module's own
+transitive dependencies by more than a patch release. Otherwise, someone
+upgrading to the patch of your module could wind up accidentally pulling in a
+more invasive change to a transitive dependency that they use.
+
+A patch release increments the patch part of the module's version number. For
+more see, [Module version numbering](/doc/modules/version-numbers).
+
+In the following example, v1.0.1 is a patch release.
+
+Old version: `v1.0.0`
+
+New version: `v1.0.1`
+
+You publish a patch release by tagging the module code in your repository,
+incrementing the patch version number in the tag. For more, see [Publishing a
+module](publishing).
+
+## Publishing non-breaking API changes {#non-breaking}
+
+You can make non-breaking changes to your module's public API and publish those
+changes in a _minor_ version release.
+
+This version changes the API, but not in a way that breaks calling code. This
+might include changes to a module’s own dependencies or the addition of new
+functions, methods, struct fields, or types. Even with the changes it includes,
+this kind of release guarantees backward compatibility and stability for
+existing code that calls the module's functions.
+
+A minor release increments the minor part of the module's version number. For
+more, see [Module version numbering](/doc/modules/version-numbers).
+
+In the following example, v1.1.0 is a minor release.
+
+Old version: `v1.0.1`
+
+New version: `v1.1.0`
+
+You publish a minor release by tagging the module code in your repository,
+incrementing the minor version number in the tag. For more, see [Publishing a
+module](publishing).
+
+## Publishing breaking API changes {#breaking}
+
+You can publish a version that breaks backward compatibility by publishing a
+_major_ version release.
+
+A major version release doesn't guarantee backward compatibility, typically
+because it includes changes to the module's public API that would break code
+using the module's previous versions.
+
+Given the disruptive effect a major version upgrade can have on code relying on
+the module, you should avoid a major version update if you can. For more about
+major version updates, see [Developing a major version update](/doc/modules/major-version).
+For strategies to avoid making breaking changes, see the blog post [Keeping your
+modules compatible](https://blog.golang.org/module-compatibility).
+
+Where publishing other kinds of versions requires essentially tagging the module
+code with the version number, publishing a major version update requires more
+steps.
+
+1. Before beginning development of the new major version, in your repository
+ create a place for the new version's source.
+
+ One way to do this is to create a new branch in your repository that is
+ specifically for the new major version and its subsequent minor and patch
+ versions. For more, see [Managing module source](/doc/modules/managing-source).
+
+1. In the module's go.mod file, revise the module path to append the new major
+ version number, as in the following example:
+
+ ```
+ example.com/mymodule/v2
+ ```
+
+ Given that the module path is the module's identifier, this change
+ effectively creates a new module. It also changes the package path, ensuring
+ that developers won't unintentionally import a version that breaks their
+ code. Instead, those wanting to upgrade will explicitly replace occurrences
+ of the old path with the new one.
+
+1. In your code, change any package paths where you're importing packages in
+ the module you're updating, including packages in the module you're updating.
+ You need to do this because you changed your module path.
+
+1. As with any new release, you should publish pre-release versions to get
+ feedback and bug reports before publishing an official release.
+
+1. Publish the new major version by tagging the module code in your repository,
+ incrementing the major version number in the tag -- such as from v1.5.2 to
+ v2.0.0.
+
+ For more, see [Publishing a module](/doc/modules/publishing).
diff --git a/_content/doc/modules/version-numbers.md b/_content/doc/modules/version-numbers.md
new file mode 100644
index 0000000..26b8638
--- /dev/null
+++ b/_content/doc/modules/version-numbers.md
@@ -0,0 +1,234 @@
+<!--{
+ "Title": "Module version numbering"
+}-->
+
+A module's developer uses each part of a module's version number to signal the
+version’s stability and backward compatibility. For each new release, a
+module's release version number specifically reflects the nature of the module's
+changes since the preceding release.
+
+When you're developing code that uses external modules, you can use the version
+numbers to understand an external module's stability when you're considering an
+upgrade. When you're developing your own modules, your version numbers will
+signal your modules' stability and backward compatibility to other developers.
+
+This topic describes what module version numbers mean.
+
+**See also**
+
+* When you're using external packages in your code, you can manage those
+ dependencies with Go tools. For more, see [Managingdependencies](managing-dependencies).
+* If you're developing modules for others to use, you apply a version number
+ when you publish the module, tagging the module in its repository. For more,
+ see [Publishing a module](publishing).
+
+A released module is published with a version number in the semantic versioning
+model, as in the following illustration:
+
+<img src="images/version-number.png"
+ alt="Diagram illustrating a semantic version number showing major version 1, minor version 4, patch version 0, and pre-release version beta 2"
+ style="width: 300px;" />
+
+The following table describes how the parts of a version number signify a
+module's stability and backward compatibility.
+
+<table class="DocTable">
+ <thead>
+ <tr class="DocTable-head">
+ <th class="DocTable-cell" width="20%">Version stage</th>
+ <th class="DocTable-cell">Example</th>
+ <th class="DocTable-cell">Message to developers</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr class="DocTable-row">
+ <td class="DocTable-cell"><a href="#in-development">In development</a></td>
+ <td class="DocTable-cell">Automatic pseudo-version number
+ <p>v<strong>0</strong>.x.x</td>
+ <td class="DocTable-cell">Signals that the module is still <strong>in
+ development and unstable</strong>. This release carries no backward
+ compatibility or stability guarantees.</td>
+ </tr>
+ <tr class="DocTable-row">
+ <td class="DocTable-cell"><a href="#major">Major version</a></td>
+ <td class="DocTable-cell">v<strong>1</strong>.x.x</td>
+ <td class="DocTable-cell">Signals <strong>backward-incompatible public API
+ changes</strong>. This release carries no guarantee that it will be
+ backward compatible with preceding major versions.</td>
+ </tr>
+ <tr class="DocTable-row">
+ <td class="DocTable-cell"><a href="#minor">Minor version</a></td>
+ <td class="DocTable-cell">vx.<strong>4</strong>.x</td>
+ <td class="DocTable-cell">Signals <strong>backward-compatible public API
+ changes</strong>. This release guarantees backward compatibility and
+ stability.</td>
+ </tr>
+ <tr class="DocTable-row">
+ <td class="DocTable-cell"><a href="#patch">Patch version</a></td>
+ <td class="DocTable-cell">vx.x.<strong>1</strong></td>
+ <td class="DocTable-cell">Signals <strong>changes that don't affect the
+ module's public API</strong> or its dependencies. This release
+ guarantees backward compatibility and stability.</td>
+ </tr>
+ <tr class="DocTable-row">
+ <td class="DocTable-cell"><a href="#pre-release">Pre-release version</a></td>
+ <td class="DocTable-cell">vx.x.x-<strong>beta.2</strong></td>
+ <td class="DocTable-cell">Signals that this is a <strong>pre-release
+ milestone, such as an alpha or beta</strong>. This release carries no
+ stability guarantees.</td>
+ </tr>
+ </tbody>
+</table>
+
+<a id="in-development" ></a>
+## In development
+
+Signals that the module is still in development and **unstable**. This release
+carries no backward compatibility or stability guarantees.
+
+The version number can take one of the following forms:
+
+**Pseudo-version number**
+
+> v0.0.0-20170915032832-14c0d48ead0c
+
+**v0 number**
+
+> v0.x.x
+
+<a id="pseudo" ></a>
+### Pseudo-version number
+
+When a module has not been tagged in its repository, Go tools will generate a
+pseudo-version number for use in the go.mod file of code that calls functions in
+the module.
+
+**Note:** As a best practice, always allow Go tools to generate the
+pseudo-version number rather than creating your own.
+
+Pseudo-versions are useful when a developer of code consuming the module's
+functions needs to develop against a commit that hasn't been tagged with a
+semantic version tag yet.
+
+A pseudo-version number has three parts separated by dashes, as shown in the
+following form:
+
+#### Syntax
+
+_baseVersionPrefix_-_timestamp_-_revisionIdentifier_
+
+#### Parts
+
+* **baseVersionPrefix** (vX.0.0 or vX.Y.Z-0) is a value derived either from a
+ semantic version tag that precedes the revision or from vX.0.0 if there is no
+ such tag.
+
+* **timestamp** (yymmddhhmmss) is the UTC time the revision was created. In Git,
+ this is the commit time, not the author time.
+
+* **revisionIdentifier** (abcdefabcdef) is a 12-character prefix of the commit
+ hash, or in Subversion, a zero-padded revision number.
+
+<a id="v0" ></a>
+### v0 number
+
+A module published with a v0 number will have a formal semantic version number
+with a major, minor, and patch part, as well as an optional pre-release
+identifier.
+
+Though a v0 version can be used in production, it makes no stability or backward
+compatibility guarantees. In addition, versions v1 and later are allowed to
+break backward compatibility for code using the v0 versions. For this reason, a
+developer with code consuming functions in a v0 module is responsible for
+adapting to incompatible changes until v1 is released.
+
+<a id="pre-release" ></a>
+## Pre-release version
+
+Signals that this is a pre-release milestone, such as an alpha or beta. This
+release carries no stability guarantees.
+
+#### Example
+
+```
+vx.x.x-beta.2
+```
+
+A module's developer can use a pre-release identifier with any major.minor.patch
+combination by appending a hyphen and the pre-release identifier.
+
+<a id="minor" ></a>
+## Minor version
+
+Signals backward-compatible changes to the module’s public API. This release
+guarantees backward compatibility and stability.
+
+#### Example
+
+```
+vx.4.x
+```
+
+This version changes the module's public API, but not in a way that breaks
+calling code. This might include changes to a module’s own dependencies or the
+addition of new functions, methods, struct fields, or types.
+
+In other words, this version might include enhancements through new functions
+that another developer might want to use. However, a developer using previous
+minor versions needn’t change their code otherwise.
+
+<a id="patch" ></a>
+## Patch version
+
+Signals changes that don't affect the module's public API or its dependencies.
+This release guarantees backward compatibility and stability.
+
+#### Example
+
+```
+vx.x.1
+```
+
+An update that increments this number is only for minor changes such as bug
+fixes. Developers of consuming code can upgrade to this version safely without
+needing to change their code.
+
+<a id="major" ></a>
+## Major version
+
+Signals backward-incompatible changes in a module’s public API. This release
+carries no guarantee that it will be backward compatible with preceding major
+versions.
+
+#### Example
+
+v1.x.x
+
+A v1 or above version number signals that the module is stable for use (with
+exceptions for its pre-release versions).
+
+Note that because a version 0 makes no stability or backward compatibility
+guarantees, a developer upgrading a module from v0 to v1 is responsible for
+adapting to changes that break backward compatibility.
+
+A module developer should increment this number past v1 only when necessary
+because the version upgrade represents significant disruption for developers
+whose code uses function in the upgraded module. This disruption includes
+backward-incompatible changes to the public API, as well as the need for
+developers using the module to update the package path wherever they import
+packages from the module.
+
+A major version update to a number higher than v1 will also have a new module
+path. That's because the module path will have the major version number
+appended, as in the following example:
+
+```
+module example.com/mymodule/v2 v2.0.0
+```
+
+A major version update makes this a new module with a separate history from the
+module's previous version. If you're developing modules to publish for others,
+see "Publishing breaking API changes" in [Module release and versioning
+workflow](release-workflow).
+
+For more on the module directive, see [go.mod reference](gomod-ref).
diff --git a/_content/doc/mvs/buildlist.svg b/_content/doc/mvs/buildlist.svg
new file mode 100644
index 0000000..85f129a
--- /dev/null
+++ b/_content/doc/mvs/buildlist.svg
@@ -0,0 +1,231 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xl="http://www.w3.org/1999/xlink" version="1.1" xmlns:dc="http://purl.org/dc/elements/1.1/" viewBox="-1 -5 528 276" width="528" height="276">
+ <defs>
+ <font-face font-family="Roboto" font-size="16" panose-1="2 0 0 0 0 0 0 0 0 0" units-per-em="1000" underline-position="-73.24219" underline-thickness="48.828125" slope="0" x-height="528.3203" cap-height="710.9375" ascent="927.7344" descent="-244.14062" font-weight="700">
+ <font-face-src>
+ <font-face-name name="Roboto-Bold"/>
+ </font-face-src>
+ </font-face>
+ <font-face font-family="Roboto" font-size="16" panose-1="2 0 0 0 0 0 0 0 0 0" units-per-em="1000" underline-position="-73.24219" underline-thickness="48.828125" slope="0" x-height="528.3203" cap-height="710.9375" ascent="927.7344" descent="-244.14062" font-weight="400">
+ <font-face-src>
+ <font-face-name name="Roboto-Regular"/>
+ </font-face-src>
+ </font-face>
+ <marker orient="auto" overflow="visible" markerUnits="strokeWidth" id="FilledArrow_Marker" stroke-linejoin="miter" stroke-miterlimit="10" viewBox="-1 -4 10 8" markerWidth="10" markerHeight="8" color="black">
+ <g>
+ <path d="M 8 0 L 0 -3 L 0 3 Z" fill="currentColor" stroke="currentColor" stroke-width="1"/>
+ </g>
+ </marker>
+ <font-face font-family="Helvetica Neue" font-size="14" panose-1="2 0 5 3 0 0 0 2 0 4" units-per-em="1000" underline-position="-100" underline-thickness="50" slope="0" x-height="517" cap-height="714" ascent="951.9958" descent="-212.99744" font-weight="400">
+ <font-face-src>
+ <font-face-name name="HelveticaNeue"/>
+ </font-face-src>
+ </font-face>
+ </defs>
+ <metadata> Produced by OmniGraffle 7.16
+ <dc:date>2020-06-16 22:16:38 +0000</dc:date>
+ </metadata>
+ <g id="Canvas_1" stroke-opacity="1" stroke-dasharray="none" stroke="none" fill-opacity="1" fill="none">
+ <title>Canvas 1</title>
+ <g id="Canvas_1: Layer 1">
+ <title>Layer 1</title>
+ <g id="Graphic_2">
+ <rect x="130" y="0" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="130" y="0" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(135 5.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="2.1015625" y="15">Main</tspan>
+ </text>
+ </g>
+ <g id="Graphic_3">
+ <rect x="180" y="60" width="190" height="50" fill="white"/>
+ <path d="M 180 60 L 370 60 L 370 110 L 180 110 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_4">
+ <rect x="190" y="70" width="50" height="30" fill="white"/>
+ <rect x="190" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(195 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.9492188" y="15">B 1.1</tspan>
+ </text>
+ </g>
+ <g id="Graphic_10">
+ <rect x="250" y="70" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="250" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(255 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="1.3984375" y="15">B 1.2</tspan>
+ </text>
+ </g>
+ <g id="Graphic_11">
+ <rect x="310" y="70" width="50" height="30" fill="white"/>
+ <rect x="310" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(315 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.9492188" y="15">B 1.3</tspan>
+ </text>
+ </g>
+ <g id="Graphic_17">
+ <rect x="0" y="60" width="130" height="50" fill="white"/>
+ <path d="M 0 60 L 130 60 L 130 110 L 0 110 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_16">
+ <rect x="10" y="70" width="50" height="30" fill="white"/>
+ <rect x="10" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(15 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.7109375" y="15">A 1.1</tspan>
+ </text>
+ </g>
+ <g id="Graphic_15">
+ <rect x="70" y="70" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="70" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(75 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="1.1210938" y="15">A 1.2</tspan>
+ </text>
+ </g>
+ <g id="Line_27">
+ <line x1="141.07143" y1="31.25" x2="115.3714" y2="61.23336" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_28">
+ <line x1="181.25" y1="30.3125" x2="240.1986" y2="64.69918" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Graphic_32">
+ <rect x="0" y="140" width="250" height="50" fill="white"/>
+ <path d="M 0 140 L 250 140 L 250 190 L 0 190 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_31">
+ <rect x="10" y="150" width="50" height="30" fill="white"/>
+ <rect x="10" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(15 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.7226562" y="15">C 1.1</tspan>
+ </text>
+ </g>
+ <g id="Graphic_30">
+ <rect x="70" y="150" width="50" height="30" fill="white"/>
+ <rect x="70" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(75 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.7226562" y="15">C 1.2</tspan>
+ </text>
+ </g>
+ <g id="Graphic_33">
+ <rect x="130" y="150" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="130" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(135 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.7226562" y="15">C 1.3</tspan>
+ </text>
+ </g>
+ <g id="Graphic_34">
+ <rect x="190" y="150" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="190" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(195 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="1.2695312" y="15">C 1.4</tspan>
+ </text>
+ </g>
+ <g id="Graphic_40">
+ <rect x="60" y="220" width="190" height="50" fill="white"/>
+ <path d="M 60 220 L 250 220 L 250 270 L 60 270 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_39">
+ <rect x="69" y="230" width="50" height="30" fill="white"/>
+ <rect x="69" y="230" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(74 235.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.6835938" y="15">D 1.1</tspan>
+ </text>
+ </g>
+ <g id="Graphic_38">
+ <rect x="129" y="230" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="129" y="230" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(134 235.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="1.3046875" y="15">D 1.2</tspan>
+ </text>
+ </g>
+ <g id="Graphic_37">
+ <rect x="189" y="230" width="50" height="30" fill="white"/>
+ <rect x="189" y="230" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(194 235.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.6835938" y="15">D 1.3</tspan>
+ </text>
+ </g>
+ <g id="Group_45">
+ <g id="Graphic_44">
+ <rect x="300" y="140" width="70" height="50" fill="white"/>
+ <path d="M 300 140 L 370 140 L 370 190 L 300 190 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_43">
+ <rect x="310" y="150" width="50" height="30" fill="white"/>
+ <rect x="310" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(315 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="2.3828125" y="15">E 1.1</tspan>
+ </text>
+ </g>
+ </g>
+ <g id="Group_46">
+ <g id="Graphic_48">
+ <rect x="300" y="220" width="70" height="50" fill="white"/>
+ <path d="M 300 220 L 370 220 L 370 270 L 300 270 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_47">
+ <rect x="310" y="230" width="50" height="30" fill="white"/>
+ <rect x="310" y="230" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(315 235.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="2.5078125" y="15">F 1.1</tspan>
+ </text>
+ </g>
+ </g>
+ <g id="Line_50">
+ <line x1="107.1875" y1="101.25" x2="137.81" y2="142.08" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_51">
+ <line x1="262.8125" y1="101.25" x2="233.1275" y2="140.83" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_52">
+ <line x1="35" y1="100" x2="35" y2="140.1" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_53">
+ <line x1="46.0625" y1="180" x2="77.06143" y2="222.03245" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_54">
+ <line x1="94.8125" y1="180" x2="94.31124" y2="220.10077" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_55">
+ <line x1="154.8125" y1="180" x2="154.32687" y2="218.85077" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_56">
+ <line x1="202.60938" y1="181.25" x2="172.39342" y2="220.87749" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_57">
+ <line x1="335" y1="100" x2="335" y2="140.1" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_58">
+ <path d="M 330.8284 180 C 329.32873 187.07273 328 196.12552 328 206 C 328 211.10463 328.3551 215.88823 328.9053 220.23645" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_59">
+ <path d="M 341.33417 230 C 343.3183 223.5244 345 215.29436 345 206 C 345 200.16788 344.33784 194.6224 343.3543 189.60223" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Graphic_64">
+ <rect x="390" y="0" width="16" height="16" fill="#e0ebf5"/>
+ <rect x="390" y="0" width="16" height="16" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ </g>
+ <g id="Graphic_65">
+ <text transform="translate(417 0)" fill="black">
+ <tspan font-family="Helvetica Neue" font-size="14" font-weight="400" fill="black" x="0" y="13">Selected version</tspan>
+ </text>
+ </g>
+ <g id="Graphic_67">
+ <rect x="390" y="26" width="16" height="16" fill="#e0ebf5"/>
+ <rect x="390" y="26" width="16" height="16" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Graphic_68">
+ <text transform="translate(417 26)" fill="black">
+ <tspan font-family="Helvetica Neue" font-size="14" font-weight="400" fill="black" x="0" y="13">go.mod loaded</tspan>
+ </text>
+ </g>
+ <g id="Graphic_69">
+ <rect x="390" y="52" width="16" height="16" fill="white"/>
+ <rect x="390" y="52" width="16" height="16" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Graphic_70">
+ <text transform="translate(417 52)" fill="black">
+ <tspan font-family="Helvetica Neue" font-size="14" font-weight="400" fill="black" x="0" y="13">Available version</tspan>
+ </text>
+ </g>
+ </g>
+ </g>
+</svg>
diff --git a/_content/doc/mvs/downgrade.svg b/_content/doc/mvs/downgrade.svg
new file mode 100644
index 0000000..3dc789e
--- /dev/null
+++ b/_content/doc/mvs/downgrade.svg
@@ -0,0 +1,260 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xl="http://www.w3.org/1999/xlink" version="1.1" xmlns:dc="http://purl.org/dc/elements/1.1/" viewBox="-1 -5 531 276" width="531" height="276">
+ <defs>
+ <font-face font-family="Roboto" font-size="16" panose-1="2 0 0 0 0 0 0 0 0 0" units-per-em="1000" underline-position="-73.24219" underline-thickness="48.828125" slope="0" x-height="528.3203" cap-height="710.9375" ascent="927.7344" descent="-244.14062" font-weight="700">
+ <font-face-src>
+ <font-face-name name="Roboto-Bold"/>
+ </font-face-src>
+ </font-face>
+ <font-face font-family="Roboto" font-size="16" panose-1="2 0 0 0 0 0 0 0 0 0" units-per-em="1000" underline-position="-73.24219" underline-thickness="48.828125" slope="0" x-height="528.3203" cap-height="710.9375" ascent="927.7344" descent="-244.14062" font-weight="400">
+ <font-face-src>
+ <font-face-name name="Roboto-Regular"/>
+ </font-face-src>
+ </font-face>
+ <marker orient="auto" overflow="visible" markerUnits="strokeWidth" id="FilledArrow_Marker" stroke-linejoin="miter" stroke-miterlimit="10" viewBox="-1 -4 10 8" markerWidth="10" markerHeight="8" color="black">
+ <g>
+ <path d="M 8 0 L 0 -3 L 0 3 Z" fill="currentColor" stroke="currentColor" stroke-width="1"/>
+ </g>
+ </marker>
+ <marker orient="auto" overflow="visible" markerUnits="strokeWidth" id="FilledArrow_Marker_2" stroke-linejoin="miter" stroke-miterlimit="10" viewBox="-1 -3 6 6" markerWidth="6" markerHeight="6" color="black">
+ <g>
+ <path d="M 4 0 L 0 -1.5 L 0 1.5 Z" fill="currentColor" stroke="currentColor" stroke-width="1"/>
+ </g>
+ </marker>
+ <font-face font-family="Helvetica Neue" font-size="14" panose-1="2 0 5 3 0 0 0 2 0 4" units-per-em="1000" underline-position="-100" underline-thickness="50" slope="0" x-height="517" cap-height="714" ascent="951.9958" descent="-212.99744" font-weight="400">
+ <font-face-src>
+ <font-face-name name="HelveticaNeue"/>
+ </font-face-src>
+ </font-face>
+ </defs>
+ <metadata> Produced by OmniGraffle 7.16
+ <dc:date>2020-06-16 22:22:34 +0000</dc:date>
+ </metadata>
+ <g id="Canvas_1" stroke-opacity="1" stroke-dasharray="none" stroke="none" fill-opacity="1" fill="none">
+ <title>Canvas 1</title>
+ <g id="Canvas_1: Layer 1">
+ <title>Layer 1</title>
+ <g id="Graphic_2">
+ <rect x="130" y="0" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="130" y="0" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(135 5.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="2.1015625" y="15">Main</tspan>
+ </text>
+ </g>
+ <g id="Graphic_3">
+ <rect x="180" y="60" width="190" height="50" fill="white"/>
+ <path d="M 180 60 L 370 60 L 370 110 L 180 110 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_4">
+ <rect x="190" y="70" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="190" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(195 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="1.3984375" y="15">B 1.1</tspan>
+ </text>
+ </g>
+ <g id="Graphic_10">
+ <rect x="250" y="70" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="250" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(255 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.9492188" y="15">B 1.2</tspan>
+ </text>
+ </g>
+ <g id="Graphic_11">
+ <rect x="310" y="70" width="50" height="30" fill="white"/>
+ <rect x="310" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(315 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.9492188" y="15">B 1.3</tspan>
+ </text>
+ </g>
+ <g id="Graphic_17">
+ <rect x="0" y="60" width="130" height="50" fill="white"/>
+ <path d="M 0 60 L 130 60 L 130 110 L 0 110 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_16">
+ <rect x="10" y="70" width="50" height="30" fill="white"/>
+ <rect x="10" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(15 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.7109375" y="15">A 1.1</tspan>
+ </text>
+ </g>
+ <g id="Graphic_15">
+ <rect x="70" y="70" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="70" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(75 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="1.1210938" y="15">A 1.2</tspan>
+ </text>
+ </g>
+ <g id="Line_27">
+ <line x1="141.07143" y1="31.25" x2="115.3714" y2="61.23336" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_28">
+ <line x1="181.25" y1="30.3125" x2="241.4486" y2="65.42834" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="1.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_32">
+ <rect x="0" y="140" width="250" height="50" fill="white"/>
+ <path d="M 0 140 L 250 140 L 250 190 L 0 190 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_31">
+ <rect x="10" y="150" width="50" height="30" fill="white"/>
+ <rect x="10" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(15 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.7226562" y="15">C 1.1</tspan>
+ </text>
+ </g>
+ <g id="Graphic_30">
+ <rect x="70" y="150" width="50" height="30" fill="white"/>
+ <rect x="70" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(75 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.7226562" y="15">C 1.2</tspan>
+ </text>
+ </g>
+ <g id="Graphic_33">
+ <rect x="130" y="150" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="130" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(135 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="1.2695312" y="15">C 1.3</tspan>
+ </text>
+ </g>
+ <g id="Graphic_34">
+ <rect x="190" y="150" width="50" height="30" fill="white"/>
+ <rect x="190" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(195 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.7226562" y="15">C 1.4</tspan>
+ </text>
+ </g>
+ <g id="Graphic_40">
+ <rect x="60" y="220" width="190" height="50" fill="white"/>
+ <path d="M 60 220 L 250 220 L 250 270 L 60 270 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_39">
+ <rect x="69" y="230" width="50" height="30" fill="white"/>
+ <rect x="69" y="230" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(74 235.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.6835938" y="15">D 1.1</tspan>
+ </text>
+ </g>
+ <g id="Graphic_38">
+ <rect x="129" y="230" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="129" y="230" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(134 235.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="1.3046875" y="15">D 1.2</tspan>
+ </text>
+ </g>
+ <g id="Graphic_37">
+ <rect x="189" y="230" width="50" height="30" fill="white"/>
+ <rect x="189" y="230" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(194 235.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.6835938" y="15">D 1.3</tspan>
+ </text>
+ </g>
+ <g id="Group_45">
+ <g id="Graphic_44">
+ <rect x="300" y="140" width="70" height="50" fill="white"/>
+ <path d="M 300 140 L 370 140 L 370 190 L 300 190 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_43">
+ <rect x="310" y="150" width="50" height="30" fill="white"/>
+ <rect x="310" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(315 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="2.3828125" y="15">E 1.1</tspan>
+ </text>
+ </g>
+ </g>
+ <g id="Group_46">
+ <g id="Graphic_48">
+ <rect x="300" y="220" width="70" height="50" fill="white"/>
+ <path d="M 300 220 L 370 220 L 370 270 L 300 270 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_47">
+ <rect x="310" y="230" width="50" height="30" fill="white"/>
+ <rect x="310" y="230" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(315 235.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="2.5078125" y="15">F 1.1</tspan>
+ </text>
+ </g>
+ </g>
+ <g id="Line_50">
+ <line x1="107.1875" y1="101.25" x2="136.8725" y2="140.83" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_51">
+ <line x1="263.75" y1="100" x2="232.19" y2="142.08" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_52">
+ <line x1="35" y1="100" x2="35" y2="140.1" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_53">
+ <line x1="46.0625" y1="180" x2="77.06143" y2="222.03245" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_54">
+ <line x1="94.8125" y1="180" x2="94.31124" y2="220.10077" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_55">
+ <line x1="154.79688" y1="181.25" x2="154.32687" y2="218.85077" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_56">
+ <line x1="203.5625" y1="180" x2="172.39342" y2="220.87749" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_57">
+ <line x1="335" y1="100" x2="335" y2="140.1" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_58">
+ <path d="M 330.8284 180 C 329.32873 187.07273 328 196.12552 328 206 C 328 211.10463 328.3551 215.88823 328.9053 220.23645" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_59">
+ <path d="M 341.33417 230 C 343.3183 223.5244 345 215.29436 345 206 C 345 200.16788 344.33784 194.6224 343.3543 189.60223" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_60">
+ <line x1="199" y1="174.5" x2="229" y2="155.5" stroke="#666" stroke-linecap="round" stroke-linejoin="round" stroke-width="6"/>
+ </g>
+ <g id="Line_61">
+ <line x1="260" y1="94" x2="290" y2="75" stroke="#666" stroke-linecap="round" stroke-linejoin="round" stroke-width="6"/>
+ </g>
+ <g id="Line_63">
+ <line x1="168.92857" y1="31.25" x2="194.6286" y2="61.23336" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_64">
+ <line x1="250" y1="85" x2="247.15" y2="85" marker-end="url(#FilledArrow_Marker_2)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Graphic_73">
+ <rect x="390" y="0" width="16" height="16" fill="#e0ebf5"/>
+ <rect x="390" y="0" width="16" height="16" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ </g>
+ <g id="Graphic_72">
+ <text transform="translate(417 0)" fill="black">
+ <tspan font-family="Helvetica Neue" font-size="14" font-weight="400" fill="black" x="0" y="13">Selected version</tspan>
+ </text>
+ </g>
+ <g id="Graphic_71">
+ <rect x="390" y="26" width="16" height="16" fill="#e0ebf5"/>
+ <rect x="390" y="26" width="16" height="16" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Graphic_70">
+ <text transform="translate(417 26)" fill="black">
+ <tspan font-family="Helvetica Neue" font-size="14" font-weight="400" fill="black" x="0" y="13">go.mod loaded</tspan>
+ </text>
+ </g>
+ <g id="Graphic_69">
+ <rect x="390" y="52" width="16" height="16" fill="white"/>
+ <rect x="390" y="52" width="16" height="16" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Graphic_68">
+ <text transform="translate(417 52)" fill="black">
+ <tspan font-family="Helvetica Neue" font-size="14" font-weight="400" fill="black" x="0" y="13">Available version</tspan>
+ </text>
+ </g>
+ <g id="Graphic_67">
+ <rect x="390" y="78" width="16" height="16" fill="white"/>
+ <rect x="390" y="78" width="16" height="16" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Graphic_66">
+ <text transform="translate(417 78.608)" fill="black">
+ <tspan font-family="Helvetica Neue" font-size="14" font-weight="400" fill="black" x="0" y="13">Excluded version</tspan>
+ </text>
+ </g>
+ <g id="Line_65">
+ <line x1="390" y1="94" x2="406" y2="78" stroke="#666" stroke-linecap="round" stroke-linejoin="round" stroke-width="6"/>
+ </g>
+ </g>
+ </g>
+</svg>
diff --git a/_content/doc/mvs/exclude.svg b/_content/doc/mvs/exclude.svg
new file mode 100644
index 0000000..cf7e778
--- /dev/null
+++ b/_content/doc/mvs/exclude.svg
@@ -0,0 +1,249 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xl="http://www.w3.org/1999/xlink" version="1.1" xmlns:dc="http://purl.org/dc/elements/1.1/" viewBox="-1 -5 531 276" width="531" height="276">
+ <defs>
+ <font-face font-family="Roboto" font-size="16" panose-1="2 0 0 0 0 0 0 0 0 0" units-per-em="1000" underline-position="-73.24219" underline-thickness="48.828125" slope="0" x-height="528.3203" cap-height="710.9375" ascent="927.7344" descent="-244.14062" font-weight="700">
+ <font-face-src>
+ <font-face-name name="Roboto-Bold"/>
+ </font-face-src>
+ </font-face>
+ <font-face font-family="Roboto" font-size="16" panose-1="2 0 0 0 0 0 0 0 0 0" units-per-em="1000" underline-position="-73.24219" underline-thickness="48.828125" slope="0" x-height="528.3203" cap-height="710.9375" ascent="927.7344" descent="-244.14062" font-weight="400">
+ <font-face-src>
+ <font-face-name name="Roboto-Regular"/>
+ </font-face-src>
+ </font-face>
+ <marker orient="auto" overflow="visible" markerUnits="strokeWidth" id="FilledArrow_Marker" stroke-linejoin="miter" stroke-miterlimit="10" viewBox="-1 -4 10 8" markerWidth="10" markerHeight="8" color="black">
+ <g>
+ <path d="M 8 0 L 0 -3 L 0 3 Z" fill="currentColor" stroke="currentColor" stroke-width="1"/>
+ </g>
+ </marker>
+ <font-face font-family="Helvetica Neue" font-size="14" panose-1="2 0 5 3 0 0 0 2 0 4" units-per-em="1000" underline-position="-100" underline-thickness="50" slope="0" x-height="517" cap-height="714" ascent="951.9958" descent="-212.99744" font-weight="400">
+ <font-face-src>
+ <font-face-name name="HelveticaNeue"/>
+ </font-face-src>
+ </font-face>
+ </defs>
+ <metadata> Produced by OmniGraffle 7.16
+ <dc:date>2020-06-16 22:20:41 +0000</dc:date>
+ </metadata>
+ <g id="Canvas_1" stroke-opacity="1" stroke-dasharray="none" stroke="none" fill-opacity="1" fill="none">
+ <title>Canvas 1</title>
+ <g id="Canvas_1: Layer 1">
+ <title>Layer 1</title>
+ <g id="Graphic_2">
+ <rect x="130" y="0" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="130" y="0" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(135 5.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="2.1015625" y="15">Main</tspan>
+ </text>
+ </g>
+ <g id="Graphic_3">
+ <rect x="180" y="60" width="190" height="50" fill="white"/>
+ <path d="M 180 60 L 370 60 L 370 110 L 180 110 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_4">
+ <rect x="190" y="70" width="50" height="30" fill="white"/>
+ <rect x="190" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(195 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.9492188" y="15">B 1.1</tspan>
+ </text>
+ </g>
+ <g id="Graphic_10">
+ <rect x="250" y="70" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="250" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(255 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="1.3984375" y="15">B 1.2</tspan>
+ </text>
+ </g>
+ <g id="Graphic_11">
+ <rect x="310" y="70" width="50" height="30" fill="white"/>
+ <rect x="310" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(315 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.9492188" y="15">B 1.3</tspan>
+ </text>
+ </g>
+ <g id="Graphic_17">
+ <rect x="0" y="60" width="130" height="50" fill="white"/>
+ <path d="M 0 60 L 130 60 L 130 110 L 0 110 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_16">
+ <rect x="10" y="70" width="50" height="30" fill="white"/>
+ <rect x="10" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(15 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.7109375" y="15">A 1.1</tspan>
+ </text>
+ </g>
+ <g id="Graphic_15">
+ <rect x="70" y="70" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="70" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(75 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="1.1210938" y="15">A 1.2</tspan>
+ </text>
+ </g>
+ <g id="Line_27">
+ <line x1="141.07143" y1="31.25" x2="115.3714" y2="61.23336" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_28">
+ <line x1="181.25" y1="30.3125" x2="240.1986" y2="64.69918" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Graphic_32">
+ <rect x="0" y="140" width="250" height="50" fill="white"/>
+ <path d="M 0 140 L 250 140 L 250 190 L 0 190 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_31">
+ <rect x="10" y="150" width="50" height="30" fill="white"/>
+ <rect x="10" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(15 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.7226562" y="15">C 1.1</tspan>
+ </text>
+ </g>
+ <g id="Graphic_30">
+ <rect x="70" y="150" width="50" height="30" fill="white"/>
+ <rect x="70" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(75 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.7226562" y="15">C 1.2</tspan>
+ </text>
+ </g>
+ <g id="Graphic_33">
+ <rect x="130" y="150" width="50" height="30" fill="white"/>
+ <rect x="130" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(135 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.7226562" y="15">C 1.3</tspan>
+ </text>
+ </g>
+ <g id="Graphic_34">
+ <rect x="190" y="150" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="190" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(195 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="1.2695312" y="15">C 1.4</tspan>
+ </text>
+ </g>
+ <g id="Graphic_40">
+ <rect x="60" y="220" width="190" height="50" fill="white"/>
+ <path d="M 60 220 L 250 220 L 250 270 L 60 270 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_39">
+ <rect x="69" y="230" width="50" height="30" fill="white"/>
+ <rect x="69" y="230" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(74 235.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.6835938" y="15">D 1.1</tspan>
+ </text>
+ </g>
+ <g id="Graphic_38">
+ <rect x="129" y="230" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="129" y="230" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(134 235.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="1.3046875" y="15">D 1.2</tspan>
+ </text>
+ </g>
+ <g id="Graphic_37">
+ <rect x="189" y="230" width="50" height="30" fill="white"/>
+ <rect x="189" y="230" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(194 235.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.6835938" y="15">D 1.3</tspan>
+ </text>
+ </g>
+ <g id="Group_45">
+ <g id="Graphic_44">
+ <rect x="300" y="140" width="70" height="50" fill="white"/>
+ <path d="M 300 140 L 370 140 L 370 190 L 300 190 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_43">
+ <rect x="310" y="150" width="50" height="30" fill="white"/>
+ <rect x="310" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(315 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="2.3828125" y="15">E 1.1</tspan>
+ </text>
+ </g>
+ </g>
+ <g id="Group_46">
+ <g id="Graphic_48">
+ <rect x="300" y="220" width="70" height="50" fill="white"/>
+ <path d="M 300 220 L 370 220 L 370 270 L 300 270 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_47">
+ <rect x="310" y="230" width="50" height="30" fill="white"/>
+ <rect x="310" y="230" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(315 235.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="2.5078125" y="15">F 1.1</tspan>
+ </text>
+ </g>
+ </g>
+ <g id="Line_50">
+ <line x1="107.1875" y1="101.25" x2="137.81" y2="142.08" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="1.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Line_51">
+ <line x1="262.8125" y1="101.25" x2="233.1275" y2="140.83" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_52">
+ <line x1="35" y1="100" x2="35" y2="140.1" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_53">
+ <line x1="46.0625" y1="180" x2="77.06143" y2="222.03245" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_54">
+ <line x1="94.8125" y1="180" x2="94.31124" y2="220.10077" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_55">
+ <line x1="154.8125" y1="180" x2="154.32687" y2="218.85077" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_56">
+ <line x1="202.60938" y1="181.25" x2="172.39342" y2="220.87749" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_57">
+ <line x1="335" y1="100" x2="335" y2="140.1" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_58">
+ <path d="M 330.8284 180 C 329.32873 187.07273 328 196.12552 328 206 C 328 211.10463 328.3551 215.88823 328.9053 220.23645" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_59">
+ <path d="M 341.33417 230 C 343.3183 223.5244 345 215.29436 345 206 C 345 200.16788 344.33784 194.6224 343.3543 189.60223" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_65">
+ <line x1="140" y1="175" x2="170" y2="156" stroke="#666" stroke-linecap="round" stroke-linejoin="round" stroke-width="6"/>
+ </g>
+ <g id="Line_66">
+ <line x1="119.375" y1="101.25" x2="182.3877" y2="143.25847" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Graphic_72">
+ <rect x="390" y="0" width="16" height="16" fill="#e0ebf5"/>
+ <rect x="390" y="0" width="16" height="16" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ </g>
+ <g id="Graphic_71">
+ <text transform="translate(417 0)" fill="black">
+ <tspan font-family="Helvetica Neue" font-size="14" font-weight="400" fill="black" x="0" y="13">Selected version</tspan>
+ </text>
+ </g>
+ <g id="Graphic_70">
+ <rect x="390" y="26" width="16" height="16" fill="#e0ebf5"/>
+ <rect x="390" y="26" width="16" height="16" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Graphic_69">
+ <text transform="translate(417 26)" fill="black">
+ <tspan font-family="Helvetica Neue" font-size="14" font-weight="400" fill="black" x="0" y="13">go.mod loaded</tspan>
+ </text>
+ </g>
+ <g id="Graphic_68">
+ <rect x="390" y="52" width="16" height="16" fill="white"/>
+ <rect x="390" y="52" width="16" height="16" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Graphic_67">
+ <text transform="translate(417 52)" fill="black">
+ <tspan font-family="Helvetica Neue" font-size="14" font-weight="400" fill="black" x="0" y="13">Available version</tspan>
+ </text>
+ </g>
+ <g id="Graphic_73">
+ <rect x="390" y="78" width="16" height="16" fill="white"/>
+ <rect x="390" y="78" width="16" height="16" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Graphic_74">
+ <text transform="translate(417 78.608)" fill="black">
+ <tspan font-family="Helvetica Neue" font-size="14" font-weight="400" fill="black" x="0" y="13">Excluded version</tspan>
+ </text>
+ </g>
+ <g id="Line_75">
+ <line x1="390" y1="94" x2="406" y2="78" stroke="#666" stroke-linecap="round" stroke-linejoin="round" stroke-width="6"/>
+ </g>
+ </g>
+ </g>
+</svg>
diff --git a/_content/doc/mvs/get-downgrade.svg b/_content/doc/mvs/get-downgrade.svg
new file mode 100644
index 0000000..18bcd6c
--- /dev/null
+++ b/_content/doc/mvs/get-downgrade.svg
@@ -0,0 +1,127 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:xl="http://www.w3.org/1999/xlink" version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="9 -5 545 196" width="545" height="196">
+ <defs>
+ <font-face font-family="Roboto" font-size="16" panose-1="2 0 0 0 0 0 0 0 0 0" units-per-em="1000" underline-position="-73.24219" underline-thickness="48.828125" slope="0" x-height="528.3203" cap-height="710.9375" ascent="927.7344" descent="-244.14062" font-weight="700">
+ <font-face-src>
+ <font-face-name name="Roboto-Bold"/>
+ </font-face-src>
+ </font-face>
+ <font-face font-family="Helvetica Neue" font-size="14" panose-1="2 0 5 3 0 0 0 2 0 4" units-per-em="1000" underline-position="-100" underline-thickness="50" slope="0" x-height="517" cap-height="714" ascent="951.9958" descent="-212.99744" font-weight="400">
+ <font-face-src>
+ <font-face-name name="HelveticaNeue"/>
+ </font-face-src>
+ </font-face>
+ <font-face font-family="Roboto" font-size="16" panose-1="2 0 0 0 0 0 0 0 0 0" units-per-em="1000" underline-position="-73.24219" underline-thickness="48.828125" slope="0" x-height="528.3203" cap-height="710.9375" ascent="927.7344" descent="-244.14062" font-weight="400">
+ <font-face-src>
+ <font-face-name name="Roboto-Regular"/>
+ </font-face-src>
+ </font-face>
+ <marker orient="auto" overflow="visible" markerUnits="strokeWidth" id="FilledArrow_Marker" stroke-linejoin="miter" stroke-miterlimit="10" viewBox="-1 -4 10 8" markerWidth="10" markerHeight="8" color="black">
+ <g>
+ <path d="M 8 0 L 0 -3 L 0 3 Z" fill="currentColor" stroke="currentColor" stroke-width="1"/>
+ </g>
+ </marker>
+ <marker orient="auto" overflow="visible" markerUnits="strokeWidth" id="FilledArrow_Marker_2" stroke-linejoin="miter" stroke-miterlimit="10" viewBox="-1 -4 10 8" markerWidth="10" markerHeight="8" color="black">
+ <g>
+ <path d="M 8 0 L 0 -3 L 0 3 Z" fill="currentColor" stroke="currentColor" stroke-width="1"/>
+ </g>
+ </marker>
+ </defs>
+ <metadata> Produced by OmniGraffle 7.17.2\n2020-08-10 18:29:02 +0000</metadata>
+ <g id="Canvas_1" stroke-opacity="1" fill-opacity="1" stroke-dasharray="none" fill="none" stroke="none">
+ <title>Canvas 1</title>
+ <g id="Canvas_1_Layer_1">
+ <title>Layer 1</title>
+ <g id="Graphic_2">
+ <rect x="130" y="0" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="130" y="0" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(135 5.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="2.1015625" y="15">Main</tspan>
+ </text>
+ </g>
+ <g id="Group_87">
+ <g id="Graphic_68">
+ <rect x="330" y="0" width="16" height="16" fill="#e0ebf5"/>
+ <rect x="330" y="0" width="16" height="16" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ </g>
+ <g id="Graphic_67">
+ <text transform="translate(357 0)" fill="black">
+ <tspan font-family="Helvetica Neue" font-size="14" font-weight="400" fill="black" x="0" y="13">New selected version</tspan>
+ </text>
+ </g>
+ </g>
+ <g id="Graphic_17">
+ <rect x="170" y="60" width="130" height="50" fill="white"/>
+ <path d="M 170 60 L 300 60 L 300 110 L 170 110 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_16">
+ <rect x="180" y="70" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="180" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(185 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="1.1210938" y="15">A 1.4</tspan>
+ </text>
+ </g>
+ <g id="Graphic_15">
+ <rect x="240" y="70" width="50" height="30" fill="white"/>
+ <rect x="240" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(245 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.7109375" y="15">A 1.5</tspan>
+ </text>
+ </g>
+ <g id="Graphic_70">
+ <rect x="10" y="140" width="130" height="50" fill="white"/>
+ <path d="M 10 140 L 140 140 L 140 190 L 10 190 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_71">
+ <rect x="20" y="150" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="20" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(25 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="1.3984375" y="15">B 1.1</tspan>
+ </text>
+ </g>
+ <g id="Graphic_72">
+ <rect x="80" y="150" width="50" height="30" fill="white"/>
+ <rect x="80" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(85 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.9492188" y="15">B 1.2</tspan>
+ </text>
+ </g>
+ <g id="Line_75">
+ <line x1="240" y1="97.5" x2="138.85483" y2="148.07259" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_27">
+ <line x1="180.53571" y1="31.25" x2="233.07632" y2="64.68493" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="1.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Line_78">
+ <line x1="166.60714" y1="31.25" x2="187.6386" y2="60.69404" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Group_94">
+ <g id="Graphic_84">
+ <rect x="330" y="25.391998" width="16" height="16" fill="white"/>
+ <rect x="330" y="25.391998" width="16" height="16" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Graphic_83">
+ <text transform="translate(357 26)" fill="black">
+ <tspan font-family="Helvetica Neue" font-size="14" font-weight="400" fill="black" x="0" y="13">Unavailable due to downgrade</tspan>
+ </text>
+ </g>
+ <g id="Line_82">
+ <line x1="330" y1="41.392" x2="346" y2="25.391998" stroke="#666" stroke-linecap="round" stroke-linejoin="round" stroke-width="6"/>
+ </g>
+ </g>
+ <g id="Line_90">
+ <line x1="250" y1="93" x2="280" y2="74" stroke="#666" stroke-linecap="round" stroke-linejoin="round" stroke-width="6"/>
+ </g>
+ <g id="Line_91">
+ <line x1="149.58333" y1="31.25" x2="113.13065" y2="140.60804" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="1.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Line_93">
+ <line x1="90" y1="174" x2="120" y2="155" stroke="#666" stroke-linecap="round" stroke-linejoin="round" stroke-width="6"/>
+ </g>
+ <g id="Line_95">
+ <line x1="143.08333" y1="31.25" x2="62.77117" y2="140.76659" marker-end="url(#FilledArrow_Marker_2)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ </g>
+ </g>
+</svg>
diff --git a/_content/doc/mvs/get-upgrade.svg b/_content/doc/mvs/get-upgrade.svg
new file mode 100644
index 0000000..f7d2389
--- /dev/null
+++ b/_content/doc/mvs/get-upgrade.svg
@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:xl="http://www.w3.org/1999/xlink" version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="9 -5 488 196" width="488" height="196">
+ <defs>
+ <font-face font-family="Roboto" font-size="16" panose-1="2 0 0 0 0 0 0 0 0 0" units-per-em="1000" underline-position="-73.24219" underline-thickness="48.828125" slope="0" x-height="528.3203" cap-height="710.9375" ascent="927.7344" descent="-244.14062" font-weight="700">
+ <font-face-src>
+ <font-face-name name="Roboto-Bold"/>
+ </font-face-src>
+ </font-face>
+ <font-face font-family="Helvetica Neue" font-size="14" panose-1="2 0 5 3 0 0 0 2 0 4" units-per-em="1000" underline-position="-100" underline-thickness="50" slope="0" x-height="517" cap-height="714" ascent="951.9958" descent="-212.99744" font-weight="400">
+ <font-face-src>
+ <font-face-name name="HelveticaNeue"/>
+ </font-face-src>
+ </font-face>
+ <font-face font-family="Roboto" font-size="16" panose-1="2 0 0 0 0 0 0 0 0 0" units-per-em="1000" underline-position="-73.24219" underline-thickness="48.828125" slope="0" x-height="528.3203" cap-height="710.9375" ascent="927.7344" descent="-244.14062" font-weight="400">
+ <font-face-src>
+ <font-face-name name="Roboto-Regular"/>
+ </font-face-src>
+ </font-face>
+ <marker orient="auto" overflow="visible" markerUnits="strokeWidth" id="FilledArrow_Marker" stroke-linejoin="miter" stroke-miterlimit="10" viewBox="-1 -4 10 8" markerWidth="10" markerHeight="8" color="black">
+ <g>
+ <path d="M 8 0 L 0 -3 L 0 3 Z" fill="currentColor" stroke="currentColor" stroke-width="1"/>
+ </g>
+ </marker>
+ <marker orient="auto" overflow="visible" markerUnits="strokeWidth" id="FilledArrow_Marker_2" stroke-linejoin="miter" stroke-miterlimit="10" viewBox="-1 -4 10 8" markerWidth="10" markerHeight="8" color="black">
+ <g>
+ <path d="M 8 0 L 0 -3 L 0 3 Z" fill="currentColor" stroke="currentColor" stroke-width="1"/>
+ </g>
+ </marker>
+ </defs>
+ <metadata> Produced by OmniGraffle 7.17.2\n2020-08-10 18:28:19 +0000</metadata>
+ <g id="Canvas_1" stroke-opacity="1" fill-opacity="1" stroke-dasharray="none" fill="none" stroke="none">
+ <title>Canvas 1</title>
+ <g id="Canvas_1_Layer_1">
+ <title>Layer 1</title>
+ <g id="Graphic_2">
+ <rect x="130" y="0" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="130" y="0" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(135 5.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="2.1015625" y="15">Main</tspan>
+ </text>
+ </g>
+ <g id="Group_81">
+ <g id="Graphic_68">
+ <rect x="330" y="0" width="16" height="16" fill="#e0ebf5"/>
+ <rect x="330" y="0" width="16" height="16" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ </g>
+ <g id="Graphic_67">
+ <text transform="translate(357 0)" fill="black">
+ <tspan font-family="Helvetica Neue" font-size="14" font-weight="400" fill="black" x="0" y="13">New selected version</tspan>
+ </text>
+ </g>
+ <g id="Graphic_66">
+ <rect x="330" y="26" width="16" height="16" fill="#e0ebf5"/>
+ <rect x="330" y="26" width="16" height="16" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Graphic_65">
+ <text transform="translate(357 26)" fill="black">
+ <tspan font-family="Helvetica Neue" font-size="14" font-weight="400" fill="black" x="0" y="13">Old selected version</tspan>
+ </text>
+ </g>
+ </g>
+ <g id="Group_80">
+ <g id="Graphic_17">
+ <rect x="170" y="60" width="130" height="50" fill="white"/>
+ <path d="M 170 60 L 300 60 L 300 110 L 170 110 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_16">
+ <rect x="180" y="70" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="180" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(185 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.7109375" y="15">A 1.4</tspan>
+ </text>
+ </g>
+ <g id="Graphic_15">
+ <rect x="240" y="70" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="240" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(245 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="1.1210938" y="15">A 1.5</tspan>
+ </text>
+ </g>
+ </g>
+ <g id="Group_76">
+ <g id="Graphic_70">
+ <rect x="10" y="140" width="130" height="50" fill="white"/>
+ <path d="M 10 140 L 140 140 L 140 190 L 10 190 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_71">
+ <rect x="20" y="150" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="20" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(25 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.9492188" y="15">B 1.1</tspan>
+ </text>
+ </g>
+ <g id="Graphic_72">
+ <rect x="80" y="150" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="80" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(85 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="1.3984375" y="15">B 1.2</tspan>
+ </text>
+ </g>
+ </g>
+ <g id="Line_74">
+ <line x1="143.08333" y1="31.25" x2="61.8545" y2="142.01659" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="1.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Line_75">
+ <line x1="238.75" y1="98.125" x2="140.10483" y2="147.44759" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_27">
+ <line x1="180.53571" y1="31.25" x2="231.11204" y2="63.43493" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_78">
+ <line x1="166.60714" y1="31.25" x2="188.53146" y2="61.94404" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="1.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Line_82">
+ <line x1="149.58333" y1="31.25" x2="113.54732" y2="139.35804" marker-end="url(#FilledArrow_Marker_2)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ </g>
+ </g>
+</svg>
diff --git a/_content/doc/mvs/replace.svg b/_content/doc/mvs/replace.svg
new file mode 100644
index 0000000..732ba96
--- /dev/null
+++ b/_content/doc/mvs/replace.svg
@@ -0,0 +1,261 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xl="http://www.w3.org/1999/xlink" version="1.1" xmlns:dc="http://purl.org/dc/elements/1.1/" viewBox="-1 -5 528 276" width="528" height="276">
+ <defs>
+ <font-face font-family="Roboto" font-size="16" panose-1="2 0 0 0 0 0 0 0 0 0" units-per-em="1000" underline-position="-73.24219" underline-thickness="48.828125" slope="0" x-height="528.3203" cap-height="710.9375" ascent="927.7344" descent="-244.14062" font-weight="700">
+ <font-face-src>
+ <font-face-name name="Roboto-Bold"/>
+ </font-face-src>
+ </font-face>
+ <font-face font-family="Roboto" font-size="16" panose-1="2 0 0 0 0 0 0 0 0 0" units-per-em="1000" underline-position="-73.24219" underline-thickness="48.828125" slope="0" x-height="528.3203" cap-height="710.9375" ascent="927.7344" descent="-244.14062" font-weight="400">
+ <font-face-src>
+ <font-face-name name="Roboto-Regular"/>
+ </font-face-src>
+ </font-face>
+ <marker orient="auto" overflow="visible" markerUnits="strokeWidth" id="FilledArrow_Marker" stroke-linejoin="miter" stroke-miterlimit="10" viewBox="-1 -4 10 8" markerWidth="10" markerHeight="8" color="black">
+ <g>
+ <path d="M 8 0 L 0 -3 L 0 3 Z" fill="currentColor" stroke="currentColor" stroke-width="1"/>
+ </g>
+ </marker>
+ <marker orient="auto" overflow="visible" markerUnits="strokeWidth" id="FilledArrow_Marker_2" stroke-linejoin="miter" stroke-miterlimit="10" viewBox="-1 -4 10 8" markerWidth="10" markerHeight="8" color="#444">
+ <g>
+ <path d="M 8 0 L 0 -3 L 0 3 Z" fill="currentColor" stroke="currentColor" stroke-width="1"/>
+ </g>
+ </marker>
+ <marker orient="auto" overflow="visible" markerUnits="strokeWidth" id="Arrow_Marker" stroke-linejoin="miter" stroke-miterlimit="10" viewBox="-1 -4 10 8" markerWidth="10" markerHeight="8" color="black">
+ <g>
+ <path d="M 8 0 L 0 -3 L 0 3 Z" fill="none" stroke="currentColor" stroke-width="1"/>
+ </g>
+ </marker>
+ <font-face font-family="Helvetica Neue" font-size="14" panose-1="2 0 5 3 0 0 0 2 0 4" units-per-em="1000" underline-position="-100" underline-thickness="50" slope="0" x-height="517" cap-height="714" ascent="951.9958" descent="-212.99744" font-weight="400">
+ <font-face-src>
+ <font-face-name name="HelveticaNeue"/>
+ </font-face-src>
+ </font-face>
+ </defs>
+ <metadata> Produced by OmniGraffle 7.16
+ <dc:date>2020-06-16 22:17:46 +0000</dc:date>
+ </metadata>
+ <g id="Canvas_1" stroke-opacity="1" stroke-dasharray="none" stroke="none" fill-opacity="1" fill="none">
+ <title>Canvas 1</title>
+ <g id="Canvas_1: Layer 1">
+ <title>Layer 1</title>
+ <g id="Graphic_2">
+ <rect x="130" y="0" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="130" y="0" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(135 5.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="2.1015625" y="15">Main</tspan>
+ </text>
+ </g>
+ <g id="Graphic_3">
+ <rect x="180" y="60" width="190" height="50" fill="white"/>
+ <path d="M 180 60 L 370 60 L 370 110 L 180 110 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_4">
+ <rect x="190" y="70" width="50" height="30" fill="white"/>
+ <rect x="190" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(195 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.9492188" y="15">B 1.1</tspan>
+ </text>
+ </g>
+ <g id="Graphic_10">
+ <rect x="250" y="70" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="250" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(255 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="1.3984375" y="15">B 1.2</tspan>
+ </text>
+ </g>
+ <g id="Graphic_11">
+ <rect x="310" y="70" width="50" height="30" fill="white"/>
+ <rect x="310" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(315 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.9492188" y="15">B 1.3</tspan>
+ </text>
+ </g>
+ <g id="Graphic_17">
+ <rect x="0" y="60" width="130" height="50" fill="white"/>
+ <path d="M 0 60 L 130 60 L 130 110 L 0 110 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_16">
+ <rect x="10" y="70" width="50" height="30" fill="white"/>
+ <rect x="10" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(15 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.7109375" y="15">A 1.1</tspan>
+ </text>
+ </g>
+ <g id="Graphic_15">
+ <rect x="70" y="70" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="70" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(75 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="1.1210938" y="15">A 1.2</tspan>
+ </text>
+ </g>
+ <g id="Line_27">
+ <line x1="141.07143" y1="31.25" x2="115.3714" y2="61.23336" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_28">
+ <line x1="181.25" y1="30.3125" x2="240.1986" y2="64.69918" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Graphic_32">
+ <rect x="0" y="140" width="250" height="50" fill="white"/>
+ <path d="M 0 140 L 250 140 L 250 190 L 0 190 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_31">
+ <rect x="10" y="150" width="50" height="30" fill="white"/>
+ <rect x="10" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(15 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.7226562" y="15">C 1.1</tspan>
+ </text>
+ </g>
+ <g id="Graphic_30">
+ <rect x="70" y="150" width="50" height="30" fill="white"/>
+ <rect x="70" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(75 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.7226562" y="15">C 1.2</tspan>
+ </text>
+ </g>
+ <g id="Graphic_33">
+ <rect x="130" y="150" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="130" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(135 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.7226562" y="15">C 1.3</tspan>
+ </text>
+ </g>
+ <g id="Graphic_34">
+ <rect x="190" y="150" width="50" height="30" fill="white"/>
+ <rect x="190" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(195 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.7226562" y="15">C 1.4</tspan>
+ </text>
+ </g>
+ <g id="Graphic_40">
+ <rect x="60" y="220" width="190" height="50" fill="white"/>
+ <path d="M 60 220 L 250 220 L 250 270 L 60 270 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_39">
+ <rect x="69" y="230" width="50" height="30" fill="white"/>
+ <rect x="69" y="230" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(74 235.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.6835938" y="15">D 1.1</tspan>
+ </text>
+ </g>
+ <g id="Graphic_38">
+ <rect x="129" y="230" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="129" y="230" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(134 235.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.6835938" y="15">D 1.2</tspan>
+ </text>
+ </g>
+ <g id="Graphic_37">
+ <rect x="189" y="230" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="189" y="230" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(194 235.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="1.3046875" y="15">D 1.3</tspan>
+ </text>
+ </g>
+ <g id="Group_45">
+ <g id="Graphic_44">
+ <rect x="420" y="140" width="70" height="50" fill="white"/>
+ <path d="M 420 140 L 490 140 L 490 190 L 420 190 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_43">
+ <rect x="430" y="150" width="50" height="30" fill="white"/>
+ <rect x="430" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(435 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="2.3828125" y="15">E 1.1</tspan>
+ </text>
+ </g>
+ </g>
+ <g id="Group_46">
+ <g id="Graphic_48">
+ <rect x="420" y="220" width="70" height="50" fill="white"/>
+ <path d="M 420 220 L 490 220 L 490 270 L 420 270 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_47">
+ <rect x="430" y="230" width="50" height="30" fill="white"/>
+ <rect x="430" y="230" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(435 235.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="2.5078125" y="15">F 1.1</tspan>
+ </text>
+ </g>
+ </g>
+ <g id="Line_50">
+ <line x1="107.1875" y1="101.25" x2="137.81" y2="142.08" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_51">
+ <line x1="262.8125" y1="101.25" x2="232.19" y2="142.08" marker-end="url(#FilledArrow_Marker_2)" stroke="#444" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="1.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Line_52">
+ <line x1="35" y1="100" x2="35" y2="140.1" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_53">
+ <line x1="46.0625" y1="180" x2="77.06143" y2="222.03245" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_54">
+ <line x1="94.8125" y1="180" x2="94.31124" y2="220.10077" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_55">
+ <line x1="154.8125" y1="180" x2="154.31124" y2="220.10077" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_56">
+ <line x1="203.5625" y1="180" x2="171.4403" y2="222.12749" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_57">
+ <line x1="357.5" y1="100" x2="424.2627" y2="144.50847" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_58">
+ <path d="M 450.8284 180 C 449.32873 187.07273 448 196.12552 448 206 C 448 211.10463 448.3551 215.88823 448.9053 220.23645" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_59">
+ <path d="M 461.33417 230 C 463.3183 223.5244 465 215.29436 465 206 C 465 200.16788 464.33784 194.6224 463.3543 189.60223" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Graphic_62">
+ <rect x="300" y="140" width="70" height="50" fill="white"/>
+ <path d="M 300 140 L 370 140 L 370 190 L 300 190 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_61">
+ <rect x="310" y="150" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="310" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(315 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="14.894531" y="15">R</tspan>
+ </text>
+ </g>
+ <g id="Line_63">
+ <line x1="287.1875" y1="101.25" x2="316.8725" y2="140.83" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_65">
+ <line x1="310.42188" y1="181.25" x2="246.83636" y2="223.29" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_67">
+ <line x1="240" y1="165" x2="298.85" y2="165" marker-end="url(#Arrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="1.0,5.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_73">
+ <rect x="390" y="0" width="16" height="16" fill="#e0ebf5"/>
+ <rect x="390" y="0" width="16" height="16" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ </g>
+ <g id="Graphic_72">
+ <text transform="translate(417 0)" fill="black">
+ <tspan font-family="Helvetica Neue" font-size="14" font-weight="400" fill="black" x="0" y="13">Selected version</tspan>
+ </text>
+ </g>
+ <g id="Graphic_71">
+ <rect x="390" y="26" width="16" height="16" fill="#e0ebf5"/>
+ <rect x="390" y="26" width="16" height="16" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Graphic_70">
+ <text transform="translate(417 26)" fill="black">
+ <tspan font-family="Helvetica Neue" font-size="14" font-weight="400" fill="black" x="0" y="13">go.mod loaded</tspan>
+ </text>
+ </g>
+ <g id="Graphic_69">
+ <rect x="390" y="52" width="16" height="16" fill="white"/>
+ <rect x="390" y="52" width="16" height="16" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Graphic_68">
+ <text transform="translate(417 52)" fill="black">
+ <tspan font-family="Helvetica Neue" font-size="14" font-weight="400" fill="black" x="0" y="13">Available version</tspan>
+ </text>
+ </g>
+ </g>
+ </g>
+</svg>
diff --git a/_content/doc/mvs/upgrade.svg b/_content/doc/mvs/upgrade.svg
new file mode 100644
index 0000000..53118fb
--- /dev/null
+++ b/_content/doc/mvs/upgrade.svg
@@ -0,0 +1,241 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xl="http://www.w3.org/1999/xlink" version="1.1" xmlns:dc="http://purl.org/dc/elements/1.1/" viewBox="-1 -5 528 276" width="528" height="276">
+ <defs>
+ <font-face font-family="Roboto" font-size="16" panose-1="2 0 0 0 0 0 0 0 0 0" units-per-em="1000" underline-position="-73.24219" underline-thickness="48.828125" slope="0" x-height="528.3203" cap-height="710.9375" ascent="927.7344" descent="-244.14062" font-weight="700">
+ <font-face-src>
+ <font-face-name name="Roboto-Bold"/>
+ </font-face-src>
+ </font-face>
+ <font-face font-family="Roboto" font-size="16" panose-1="2 0 0 0 0 0 0 0 0 0" units-per-em="1000" underline-position="-73.24219" underline-thickness="48.828125" slope="0" x-height="528.3203" cap-height="710.9375" ascent="927.7344" descent="-244.14062" font-weight="400">
+ <font-face-src>
+ <font-face-name name="Roboto-Regular"/>
+ </font-face-src>
+ </font-face>
+ <marker orient="auto" overflow="visible" markerUnits="strokeWidth" id="FilledArrow_Marker" stroke-linejoin="miter" stroke-miterlimit="10" viewBox="-1 -4 10 8" markerWidth="10" markerHeight="8" color="black">
+ <g>
+ <path d="M 8 0 L 0 -3 L 0 3 Z" fill="currentColor" stroke="currentColor" stroke-width="1"/>
+ </g>
+ </marker>
+ <marker orient="auto" overflow="visible" markerUnits="strokeWidth" id="FilledArrow_Marker_2" stroke-linejoin="miter" stroke-miterlimit="10" viewBox="-1 -3 6 6" markerWidth="6" markerHeight="6" color="black">
+ <g>
+ <path d="M 4 0 L 0 -1.5 L 0 1.5 Z" fill="currentColor" stroke="currentColor" stroke-width="1"/>
+ </g>
+ </marker>
+ <font-face font-family="Helvetica Neue" font-size="14" panose-1="2 0 5 3 0 0 0 2 0 4" units-per-em="1000" underline-position="-100" underline-thickness="50" slope="0" x-height="517" cap-height="714" ascent="951.9958" descent="-212.99744" font-weight="400">
+ <font-face-src>
+ <font-face-name name="HelveticaNeue"/>
+ </font-face-src>
+ </font-face>
+ </defs>
+ <metadata> Produced by OmniGraffle 7.16
+ <dc:date>2020-06-16 22:22:02 +0000</dc:date>
+ </metadata>
+ <g id="Canvas_1" stroke-opacity="1" stroke-dasharray="none" stroke="none" fill-opacity="1" fill="none">
+ <title>Canvas 1</title>
+ <g id="Canvas_1: Layer 1">
+ <title>Layer 1</title>
+ <g id="Graphic_2">
+ <rect x="130" y="0" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="130" y="0" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(135 5.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="2.1015625" y="15">Main</tspan>
+ </text>
+ </g>
+ <g id="Graphic_3">
+ <rect x="180" y="60" width="190" height="50" fill="white"/>
+ <path d="M 180 60 L 370 60 L 370 110 L 180 110 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_4">
+ <rect x="190" y="70" width="50" height="30" fill="white"/>
+ <rect x="190" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(195 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.9492188" y="15">B 1.1</tspan>
+ </text>
+ </g>
+ <g id="Graphic_10">
+ <rect x="250" y="70" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="250" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(255 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.9492188" y="15">B 1.2</tspan>
+ </text>
+ </g>
+ <g id="Graphic_11">
+ <rect x="310" y="70" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="310" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(315 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="1.3984375" y="15">B 1.3</tspan>
+ </text>
+ </g>
+ <g id="Graphic_17">
+ <rect x="0" y="60" width="130" height="50" fill="white"/>
+ <path d="M 0 60 L 130 60 L 130 110 L 0 110 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_16">
+ <rect x="10" y="70" width="50" height="30" fill="white"/>
+ <rect x="10" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(15 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.7109375" y="15">A 1.1</tspan>
+ </text>
+ </g>
+ <g id="Graphic_15">
+ <rect x="70" y="70" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="70" y="70" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(75 75.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="1.1210938" y="15">A 1.2</tspan>
+ </text>
+ </g>
+ <g id="Line_27">
+ <line x1="141.07143" y1="31.25" x2="115.3714" y2="61.23336" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_28">
+ <line x1="181.25" y1="30.3125" x2="241.4486" y2="65.42834" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Graphic_32">
+ <rect x="0" y="140" width="250" height="50" fill="white"/>
+ <path d="M 0 140 L 250 140 L 250 190 L 0 190 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_31">
+ <rect x="10" y="150" width="50" height="30" fill="white"/>
+ <rect x="10" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(15 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.7226562" y="15">C 1.1</tspan>
+ </text>
+ </g>
+ <g id="Graphic_30">
+ <rect x="70" y="150" width="50" height="30" fill="white"/>
+ <rect x="70" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(75 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.7226562" y="15">C 1.2</tspan>
+ </text>
+ </g>
+ <g id="Graphic_33">
+ <rect x="130" y="150" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="130" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(135 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.7226562" y="15">C 1.3</tspan>
+ </text>
+ </g>
+ <g id="Graphic_34">
+ <rect x="190" y="150" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="190" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(195 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="1.2695312" y="15">C 1.4</tspan>
+ </text>
+ </g>
+ <g id="Graphic_40">
+ <rect x="60" y="220" width="190" height="50" fill="white"/>
+ <path d="M 60 220 L 250 220 L 250 270 L 60 270 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_39">
+ <rect x="69" y="230" width="50" height="30" fill="white"/>
+ <rect x="69" y="230" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(74 235.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.6835938" y="15">D 1.1</tspan>
+ </text>
+ </g>
+ <g id="Graphic_38">
+ <rect x="129" y="230" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="129" y="230" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ <text transform="translate(134 235.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="400" fill="black" x="1.6835938" y="15">D 1.2</tspan>
+ </text>
+ </g>
+ <g id="Graphic_37">
+ <rect x="189" y="230" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="189" y="230" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(194 235.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="1.3046875" y="15">D 1.3</tspan>
+ </text>
+ </g>
+ <g id="Graphic_44">
+ <rect x="300" y="140" width="70" height="50" fill="white"/>
+ <path d="M 300 140 L 370 140 L 370 190 L 300 190 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_43">
+ <rect x="310" y="150" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="310" y="150" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(315 155.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="2.0039062" y="15">E 1.1</tspan>
+ </text>
+ </g>
+ <g id="Graphic_48">
+ <rect x="300" y="220" width="70" height="50" fill="white"/>
+ <path d="M 300 220 L 370 220 L 370 270 L 300 270 Z" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="4.0,4.0" stroke-width="1"/>
+ </g>
+ <g id="Graphic_47">
+ <rect x="310" y="230" width="50" height="30" fill="#e0ebf5"/>
+ <rect x="310" y="230" width="50" height="30" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ <text transform="translate(315 235.5)" fill="black">
+ <tspan font-family="Roboto" font-size="16" font-weight="700" fill="black" x="2.1210938" y="15">F 1.1</tspan>
+ </text>
+ </g>
+ <g id="Line_50">
+ <line x1="107.1875" y1="101.25" x2="137.81" y2="142.08" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_51">
+ <line x1="263.75" y1="100" x2="233.1275" y2="140.83" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_52">
+ <line x1="35" y1="100" x2="35" y2="140.1" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_53">
+ <line x1="46.0625" y1="180" x2="77.06143" y2="222.03245" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_54">
+ <line x1="94.8125" y1="180" x2="94.31124" y2="220.10077" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_55">
+ <line x1="154.8125" y1="180" x2="154.31124" y2="220.10077" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_56">
+ <line x1="202.60938" y1="181.25" x2="171.4403" y2="222.12749" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_57">
+ <line x1="335" y1="101.25" x2="335" y2="138.85" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_58">
+ <path d="M 330.5695 181.25 C 329.1791 188.12527 328 196.69805 328 206 C 328 210.61503 328.29024 214.96764 328.75252 218.97336" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_59">
+ <path d="M 341.7068 228.75 C 343.52436 222.47873 345 214.70632 345 206 C 345 200.66228 344.44535 195.56466 343.5973 190.8901" marker-end="url(#FilledArrow_Marker)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_60">
+ <line x1="300" y1="85" x2="302.85" y2="85" marker-end="url(#FilledArrow_Marker_2)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_61">
+ <line x1="180" y1="165" x2="182.85" y2="165" marker-end="url(#FilledArrow_Marker_2)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Line_62">
+ <line x1="179" y1="245" x2="181.85" y2="245" marker-end="url(#FilledArrow_Marker_2)" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Graphic_68">
+ <rect x="390" y="0" width="16" height="16" fill="#e0ebf5"/>
+ <rect x="390" y="0" width="16" height="16" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5"/>
+ </g>
+ <g id="Graphic_67">
+ <text transform="translate(417 0)" fill="black">
+ <tspan font-family="Helvetica Neue" font-size="14" font-weight="400" fill="black" x="0" y="13">Selected version</tspan>
+ </text>
+ </g>
+ <g id="Graphic_66">
+ <rect x="390" y="26" width="16" height="16" fill="#e0ebf5"/>
+ <rect x="390" y="26" width="16" height="16" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Graphic_65">
+ <text transform="translate(417 26)" fill="black">
+ <tspan font-family="Helvetica Neue" font-size="14" font-weight="400" fill="black" x="0" y="13">go.mod loaded</tspan>
+ </text>
+ </g>
+ <g id="Graphic_64">
+ <rect x="390" y="52" width="16" height="16" fill="white"/>
+ <rect x="390" y="52" width="16" height="16" stroke="black" stroke-linecap="round" stroke-linejoin="round" stroke-width="1"/>
+ </g>
+ <g id="Graphic_63">
+ <text transform="translate(417 52)" fill="black">
+ <tspan font-family="Helvetica Neue" font-size="14" font-weight="400" fill="black" x="0" y="13">Available version</tspan>
+ </text>
+ </g>
+ </g>
+ </g>
+</svg>
diff --git a/_content/doc/play/fib.go b/_content/doc/play/fib.go
new file mode 100644
index 0000000..19e4721
--- /dev/null
+++ b/_content/doc/play/fib.go
@@ -0,0 +1,19 @@
+package main
+
+import "fmt"
+
+// fib returns a function that returns
+// successive Fibonacci numbers.
+func fib() func() int {
+ a, b := 0, 1
+ return func() int {
+ a, b = b, a+b
+ return a
+ }
+}
+
+func main() {
+ f := fib()
+ // Function calls are evaluated left-to-right.
+ fmt.Println(f(), f(), f(), f(), f())
+}
diff --git a/_content/doc/play/hello.go b/_content/doc/play/hello.go
new file mode 100644
index 0000000..3badf12
--- /dev/null
+++ b/_content/doc/play/hello.go
@@ -0,0 +1,9 @@
+// You can edit this code!
+// Click here and start typing.
+package main
+
+import "fmt"
+
+func main() {
+ fmt.Println("Hello, 世界")
+}
diff --git a/_content/doc/play/life.go b/_content/doc/play/life.go
new file mode 100644
index 0000000..51afb61
--- /dev/null
+++ b/_content/doc/play/life.go
@@ -0,0 +1,113 @@
+// An implementation of Conway's Game of Life.
+package main
+
+import (
+ "bytes"
+ "fmt"
+ "math/rand"
+ "time"
+)
+
+// Field represents a two-dimensional field of cells.
+type Field struct {
+ s [][]bool
+ w, h int
+}
+
+// NewField returns an empty field of the specified width and height.
+func NewField(w, h int) *Field {
+ s := make([][]bool, h)
+ for i := range s {
+ s[i] = make([]bool, w)
+ }
+ return &Field{s: s, w: w, h: h}
+}
+
+// Set sets the state of the specified cell to the given value.
+func (f *Field) Set(x, y int, b bool) {
+ f.s[y][x] = b
+}
+
+// Alive reports whether the specified cell is alive.
+// If the x or y coordinates are outside the field boundaries they are wrapped
+// toroidally. For instance, an x value of -1 is treated as width-1.
+func (f *Field) Alive(x, y int) bool {
+ x += f.w
+ x %= f.w
+ y += f.h
+ y %= f.h
+ return f.s[y][x]
+}
+
+// Next returns the state of the specified cell at the next time step.
+func (f *Field) Next(x, y int) bool {
+ // Count the adjacent cells that are alive.
+ alive := 0
+ for i := -1; i <= 1; i++ {
+ for j := -1; j <= 1; j++ {
+ if (j != 0 || i != 0) && f.Alive(x+i, y+j) {
+ alive++
+ }
+ }
+ }
+ // Return next state according to the game rules:
+ // exactly 3 neighbors: on,
+ // exactly 2 neighbors: maintain current state,
+ // otherwise: off.
+ return alive == 3 || alive == 2 && f.Alive(x, y)
+}
+
+// Life stores the state of a round of Conway's Game of Life.
+type Life struct {
+ a, b *Field
+ w, h int
+}
+
+// NewLife returns a new Life game state with a random initial state.
+func NewLife(w, h int) *Life {
+ a := NewField(w, h)
+ for i := 0; i < (w * h / 4); i++ {
+ a.Set(rand.Intn(w), rand.Intn(h), true)
+ }
+ return &Life{
+ a: a, b: NewField(w, h),
+ w: w, h: h,
+ }
+}
+
+// Step advances the game by one instant, recomputing and updating all cells.
+func (l *Life) Step() {
+ // Update the state of the next field (b) from the current field (a).
+ for y := 0; y < l.h; y++ {
+ for x := 0; x < l.w; x++ {
+ l.b.Set(x, y, l.a.Next(x, y))
+ }
+ }
+ // Swap fields a and b.
+ l.a, l.b = l.b, l.a
+}
+
+// String returns the game board as a string.
+func (l *Life) String() string {
+ var buf bytes.Buffer
+ for y := 0; y < l.h; y++ {
+ for x := 0; x < l.w; x++ {
+ b := byte(' ')
+ if l.a.Alive(x, y) {
+ b = '*'
+ }
+ buf.WriteByte(b)
+ }
+ buf.WriteByte('\n')
+ }
+ return buf.String()
+}
+
+func main() {
+ l := NewLife(40, 15)
+ for i := 0; i < 300; i++ {
+ l.Step()
+ fmt.Print("\x0c", l) // Clear screen and print field.
+ time.Sleep(time.Second / 30)
+ }
+}
diff --git a/_content/doc/play/peano.go b/_content/doc/play/peano.go
new file mode 100644
index 0000000..214fe1b
--- /dev/null
+++ b/_content/doc/play/peano.go
@@ -0,0 +1,88 @@
+// Peano integers are represented by a linked
+// list whose nodes contain no data
+// (the nodes are the data).
+// http://en.wikipedia.org/wiki/Peano_axioms
+
+// This program demonstrates that Go's automatic
+// stack management can handle heavily recursive
+// computations.
+
+package main
+
+import "fmt"
+
+// Number is a pointer to a Number
+type Number *Number
+
+// The arithmetic value of a Number is the
+// count of the nodes comprising the list.
+// (See the count function below.)
+
+// -------------------------------------
+// Peano primitives
+
+func zero() *Number {
+ return nil
+}
+
+func isZero(x *Number) bool {
+ return x == nil
+}
+
+func add1(x *Number) *Number {
+ e := new(Number)
+ *e = x
+ return e
+}
+
+func sub1(x *Number) *Number {
+ return *x
+}
+
+func add(x, y *Number) *Number {
+ if isZero(y) {
+ return x
+ }
+ return add(add1(x), sub1(y))
+}
+
+func mul(x, y *Number) *Number {
+ if isZero(x) || isZero(y) {
+ return zero()
+ }
+ return add(mul(x, sub1(y)), x)
+}
+
+func fact(n *Number) *Number {
+ if isZero(n) {
+ return add1(zero())
+ }
+ return mul(fact(sub1(n)), n)
+}
+
+// -------------------------------------
+// Helpers to generate/count Peano integers
+
+func gen(n int) *Number {
+ if n > 0 {
+ return add1(gen(n - 1))
+ }
+ return zero()
+}
+
+func count(x *Number) int {
+ if isZero(x) {
+ return 0
+ }
+ return count(sub1(x)) + 1
+}
+
+// -------------------------------------
+// Print i! for i in [0,9]
+
+func main() {
+ for i := 0; i <= 9; i++ {
+ f := count(fact(gen(i)))
+ fmt.Println(i, "! =", f)
+ }
+}
diff --git a/_content/doc/play/pi.go b/_content/doc/play/pi.go
new file mode 100644
index 0000000..f61884e
--- /dev/null
+++ b/_content/doc/play/pi.go
@@ -0,0 +1,34 @@
+// Concurrent computation of pi.
+// See https://goo.gl/la6Kli.
+//
+// This demonstrates Go's ability to handle
+// large numbers of concurrent processes.
+// It is an unreasonable way to calculate pi.
+package main
+
+import (
+ "fmt"
+ "math"
+)
+
+func main() {
+ fmt.Println(pi(5000))
+}
+
+// pi launches n goroutines to compute an
+// approximation of pi.
+func pi(n int) float64 {
+ ch := make(chan float64)
+ for k := 0; k <= n; k++ {
+ go term(ch, float64(k))
+ }
+ f := 0.0
+ for k := 0; k <= n; k++ {
+ f += <-ch
+ }
+ return f
+}
+
+func term(ch chan float64, k float64) {
+ ch <- 4 * math.Pow(-1, k) / (2*k + 1)
+}
diff --git a/_content/doc/play/sieve.go b/_content/doc/play/sieve.go
new file mode 100644
index 0000000..5190934
--- /dev/null
+++ b/_content/doc/play/sieve.go
@@ -0,0 +1,36 @@
+// A concurrent prime sieve
+
+package main
+
+import "fmt"
+
+// Send the sequence 2, 3, 4, ... to channel 'ch'.
+func Generate(ch chan<- int) {
+ for i := 2; ; i++ {
+ ch <- i // Send 'i' to channel 'ch'.
+ }
+}
+
+// Copy the values from channel 'in' to channel 'out',
+// removing those divisible by 'prime'.
+func Filter(in <-chan int, out chan<- int, prime int) {
+ for {
+ i := <-in // Receive value from 'in'.
+ if i%prime != 0 {
+ out <- i // Send 'i' to 'out'.
+ }
+ }
+}
+
+// The prime sieve: Daisy-chain Filter processes.
+func main() {
+ ch := make(chan int) // Create a new channel.
+ go Generate(ch) // Launch Generate goroutine.
+ for i := 0; i < 10; i++ {
+ prime := <-ch
+ fmt.Println(prime)
+ ch1 := make(chan int)
+ go Filter(ch, ch1, prime)
+ ch = ch1
+ }
+}
diff --git a/_content/doc/play/solitaire.go b/_content/doc/play/solitaire.go
new file mode 100644
index 0000000..15022aa
--- /dev/null
+++ b/_content/doc/play/solitaire.go
@@ -0,0 +1,117 @@
+// This program solves the (English) peg
+// solitaire board game.
+// http://en.wikipedia.org/wiki/Peg_solitaire
+
+package main
+
+import "fmt"
+
+const N = 11 + 1 // length of a row (+1 for \n)
+
+// The board must be surrounded by 2 illegal
+// fields in each direction so that move()
+// doesn't need to check the board boundaries.
+// Periods represent illegal fields,
+// ● are pegs, and ○ are holes.
+
+var board = []rune(
+ `...........
+...........
+....●●●....
+....●●●....
+..●●●●●●●..
+..●●●○●●●..
+..●●●●●●●..
+....●●●....
+....●●●....
+...........
+...........
+`)
+
+// center is the position of the center hole if
+// there is a single one; otherwise it is -1.
+var center int
+
+func init() {
+ n := 0
+ for pos, field := range board {
+ if field == '○' {
+ center = pos
+ n++
+ }
+ }
+ if n != 1 {
+ center = -1 // no single hole
+ }
+}
+
+var moves int // number of times move is called
+
+// move tests if there is a peg at position pos that
+// can jump over another peg in direction dir. If the
+// move is valid, it is executed and move returns true.
+// Otherwise, move returns false.
+func move(pos, dir int) bool {
+ moves++
+ if board[pos] == '●' && board[pos+dir] == '●' && board[pos+2*dir] == '○' {
+ board[pos] = '○'
+ board[pos+dir] = '○'
+ board[pos+2*dir] = '●'
+ return true
+ }
+ return false
+}
+
+// unmove reverts a previously executed valid move.
+func unmove(pos, dir int) {
+ board[pos] = '●'
+ board[pos+dir] = '●'
+ board[pos+2*dir] = '○'
+}
+
+// solve tries to find a sequence of moves such that
+// there is only one peg left at the end; if center is
+// >= 0, that last peg must be in the center position.
+// If a solution is found, solve prints the board after
+// each move in a backward fashion (i.e., the last
+// board position is printed first, all the way back to
+// the starting board position).
+func solve() bool {
+ var last, n int
+ for pos, field := range board {
+ // try each board position
+ if field == '●' {
+ // found a peg
+ for _, dir := range [...]int{-1, -N, +1, +N} {
+ // try each direction
+ if move(pos, dir) {
+ // a valid move was found and executed,
+ // see if this new board has a solution
+ if solve() {
+ unmove(pos, dir)
+ fmt.Println(string(board))
+ return true
+ }
+ unmove(pos, dir)
+ }
+ }
+ last = pos
+ n++
+ }
+ }
+ // tried each possible move
+ if n == 1 && (center < 0 || last == center) {
+ // there's only one peg left
+ fmt.Println(string(board))
+ return true
+ }
+ // no solution found for this board
+ return false
+}
+
+func main() {
+ if !solve() {
+ fmt.Println("no solution found")
+ }
+ fmt.Println(moves, "moves tried")
+}
diff --git a/_content/doc/play/tree.go b/_content/doc/play/tree.go
new file mode 100644
index 0000000..3790e6c
--- /dev/null
+++ b/_content/doc/play/tree.go
@@ -0,0 +1,100 @@
+// Go's concurrency primitives make it easy to
+// express concurrent concepts, such as
+// this binary tree comparison.
+//
+// Trees may be of different shapes,
+// but have the same contents. For example:
+//
+// 4 6
+// 2 6 4 7
+// 1 3 5 7 2 5
+// 1 3
+//
+// This program compares a pair of trees by
+// walking each in its own goroutine,
+// sending their contents through a channel
+// to a third goroutine that compares them.
+
+package main
+
+import (
+ "fmt"
+ "math/rand"
+)
+
+// A Tree is a binary tree with integer values.
+type Tree struct {
+ Left *Tree
+ Value int
+ Right *Tree
+}
+
+// Walk traverses a tree depth-first,
+// sending each Value on a channel.
+func Walk(t *Tree, ch chan int) {
+ if t == nil {
+ return
+ }
+ Walk(t.Left, ch)
+ ch <- t.Value
+ Walk(t.Right, ch)
+}
+
+// Walker launches Walk in a new goroutine,
+// and returns a read-only channel of values.
+func Walker(t *Tree) <-chan int {
+ ch := make(chan int)
+ go func() {
+ Walk(t, ch)
+ close(ch)
+ }()
+ return ch
+}
+
+// Compare reads values from two Walkers
+// that run simultaneously, and returns true
+// if t1 and t2 have the same contents.
+func Compare(t1, t2 *Tree) bool {
+ c1, c2 := Walker(t1), Walker(t2)
+ for {
+ v1, ok1 := <-c1
+ v2, ok2 := <-c2
+ if !ok1 || !ok2 {
+ return ok1 == ok2
+ }
+ if v1 != v2 {
+ break
+ }
+ }
+ return false
+}
+
+// New returns a new, random binary tree
+// holding the values 1k, 2k, ..., nk.
+func New(n, k int) *Tree {
+ var t *Tree
+ for _, v := range rand.Perm(n) {
+ t = insert(t, (1+v)*k)
+ }
+ return t
+}
+
+func insert(t *Tree, v int) *Tree {
+ if t == nil {
+ return &Tree{nil, v, nil}
+ }
+ if v < t.Value {
+ t.Left = insert(t.Left, v)
+ return t
+ }
+ t.Right = insert(t.Right, v)
+ return t
+}
+
+func main() {
+ t1 := New(100, 1)
+ fmt.Println(Compare(t1, New(100, 1)), "Same Contents")
+ fmt.Println(Compare(t1, New(99, 1)), "Differing Sizes")
+ fmt.Println(Compare(t1, New(100, 2)), "Differing Values")
+ fmt.Println(Compare(t1, New(101, 2)), "Dissimilar")
+}
diff --git a/_content/doc/progs/cgo1.go b/_content/doc/progs/cgo1.go
new file mode 100644
index 0000000..d559e13
--- /dev/null
+++ b/_content/doc/progs/cgo1.go
@@ -0,0 +1,22 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package rand
+
+/*
+#include <stdlib.h>
+*/
+import "C"
+
+// STOP OMIT
+func Random() int {
+ return int(C.rand())
+}
+
+// STOP OMIT
+func Seed(i int) {
+ C.srand(C.uint(i))
+}
+
+// END OMIT
diff --git a/_content/doc/progs/cgo2.go b/_content/doc/progs/cgo2.go
new file mode 100644
index 0000000..da07aa4
--- /dev/null
+++ b/_content/doc/progs/cgo2.go
@@ -0,0 +1,22 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package rand2
+
+/*
+#include <stdlib.h>
+*/
+import "C"
+
+func Random() int {
+ var r C.int = C.rand()
+ return int(r)
+}
+
+// STOP OMIT
+func Seed(i int) {
+ C.srand(C.uint(i))
+}
+
+// END OMIT
diff --git a/_content/doc/progs/cgo3.go b/_content/doc/progs/cgo3.go
new file mode 100644
index 0000000..d5cedf4
--- /dev/null
+++ b/_content/doc/progs/cgo3.go
@@ -0,0 +1,18 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package print
+
+// #include <stdio.h>
+// #include <stdlib.h>
+import "C"
+import "unsafe"
+
+func Print(s string) {
+ cs := C.CString(s)
+ C.fputs(cs, (*C.FILE)(C.stdout))
+ C.free(unsafe.Pointer(cs))
+}
+
+// END OMIT
diff --git a/_content/doc/progs/cgo4.go b/_content/doc/progs/cgo4.go
new file mode 100644
index 0000000..dbb07e8
--- /dev/null
+++ b/_content/doc/progs/cgo4.go
@@ -0,0 +1,18 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package print
+
+// #include <stdio.h>
+// #include <stdlib.h>
+import "C"
+import "unsafe"
+
+func Print(s string) {
+ cs := C.CString(s)
+ defer C.free(unsafe.Pointer(cs))
+ C.fputs(cs, (*C.FILE)(C.stdout))
+}
+
+// END OMIT
diff --git a/_content/doc/progs/defer.go b/_content/doc/progs/defer.go
new file mode 100644
index 0000000..2e11020
--- /dev/null
+++ b/_content/doc/progs/defer.go
@@ -0,0 +1,64 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file contains the code snippets included in "Defer, Panic, and Recover."
+
+package main
+
+import (
+ "fmt"
+ "io"
+ "os"
+)
+
+func a() {
+ i := 0
+ defer fmt.Println(i)
+ i++
+ return
+}
+
+// STOP OMIT
+
+func b() {
+ for i := 0; i < 4; i++ {
+ defer fmt.Print(i)
+ }
+}
+
+// STOP OMIT
+
+func c() (i int) {
+ defer func() { i++ }()
+ return 1
+}
+
+// STOP OMIT
+
+// Initial version.
+func CopyFile(dstName, srcName string) (written int64, err error) {
+ src, err := os.Open(srcName)
+ if err != nil {
+ return
+ }
+
+ dst, err := os.Create(dstName)
+ if err != nil {
+ return
+ }
+
+ written, err = io.Copy(dst, src)
+ dst.Close()
+ src.Close()
+ return
+}
+
+// STOP OMIT
+
+func main() {
+ a()
+ b()
+ fmt.Println()
+ fmt.Println(c())
+}
diff --git a/_content/doc/progs/defer2.go b/_content/doc/progs/defer2.go
new file mode 100644
index 0000000..cad66b0
--- /dev/null
+++ b/_content/doc/progs/defer2.go
@@ -0,0 +1,58 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file contains the code snippets included in "Defer, Panic, and Recover."
+
+package main
+
+import "fmt"
+import "io" // OMIT
+import "os" // OMIT
+
+func main() {
+ f()
+ fmt.Println("Returned normally from f.")
+}
+
+func f() {
+ defer func() {
+ if r := recover(); r != nil {
+ fmt.Println("Recovered in f", r)
+ }
+ }()
+ fmt.Println("Calling g.")
+ g(0)
+ fmt.Println("Returned normally from g.")
+}
+
+func g(i int) {
+ if i > 3 {
+ fmt.Println("Panicking!")
+ panic(fmt.Sprintf("%v", i))
+ }
+ defer fmt.Println("Defer in g", i)
+ fmt.Println("Printing in g", i)
+ g(i + 1)
+}
+
+// STOP OMIT
+
+// Revised version.
+func CopyFile(dstName, srcName string) (written int64, err error) {
+ src, err := os.Open(srcName)
+ if err != nil {
+ return
+ }
+ defer src.Close()
+
+ dst, err := os.Create(dstName)
+ if err != nil {
+ return
+ }
+ defer dst.Close()
+
+ return io.Copy(dst, src)
+}
+
+// STOP OMIT
diff --git a/_content/doc/progs/eff_bytesize.go b/_content/doc/progs/eff_bytesize.go
new file mode 100644
index 0000000..b459611
--- /dev/null
+++ b/_content/doc/progs/eff_bytesize.go
@@ -0,0 +1,47 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import "fmt"
+
+type ByteSize float64
+
+const (
+ _ = iota // ignore first value by assigning to blank identifier
+ KB ByteSize = 1 << (10 * iota)
+ MB
+ GB
+ TB
+ PB
+ EB
+ ZB
+ YB
+)
+
+func (b ByteSize) String() string {
+ switch {
+ case b >= YB:
+ return fmt.Sprintf("%.2fYB", b/YB)
+ case b >= ZB:
+ return fmt.Sprintf("%.2fZB", b/ZB)
+ case b >= EB:
+ return fmt.Sprintf("%.2fEB", b/EB)
+ case b >= PB:
+ return fmt.Sprintf("%.2fPB", b/PB)
+ case b >= TB:
+ return fmt.Sprintf("%.2fTB", b/TB)
+ case b >= GB:
+ return fmt.Sprintf("%.2fGB", b/GB)
+ case b >= MB:
+ return fmt.Sprintf("%.2fMB", b/MB)
+ case b >= KB:
+ return fmt.Sprintf("%.2fKB", b/KB)
+ }
+ return fmt.Sprintf("%.2fB", b)
+}
+
+func main() {
+ fmt.Println(YB, ByteSize(1e13))
+}
diff --git a/_content/doc/progs/eff_qr.go b/_content/doc/progs/eff_qr.go
new file mode 100644
index 0000000..f2055f0
--- /dev/null
+++ b/_content/doc/progs/eff_qr.go
@@ -0,0 +1,50 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "flag"
+ "html/template"
+ "log"
+ "net/http"
+)
+
+var addr = flag.String("addr", ":1718", "http service address") // Q=17, R=18
+
+var templ = template.Must(template.New("qr").Parse(templateStr))
+
+func main() {
+ flag.Parse()
+ http.Handle("/", http.HandlerFunc(QR))
+ err := http.ListenAndServe(*addr, nil)
+ if err != nil {
+ log.Fatal("ListenAndServe:", err)
+ }
+}
+
+func QR(w http.ResponseWriter, req *http.Request) {
+ templ.Execute(w, req.FormValue("s"))
+}
+
+const templateStr = `
+<html>
+<head>
+<title>QR Link Generator</title>
+</head>
+<body>
+{{if .}}
+<img src="http://chart.apis.google.com/chart?chs=300x300&cht=qr&choe=UTF-8&chl={{.}}" />
+<br>
+{{.}}
+<br>
+<br>
+{{end}}
+<form action="/" name=f method="GET">
+ <input maxLength=1024 size=70 name=s value="" title="Text to QR Encode">
+ <input type=submit value="Show QR" name=qr>
+</form>
+</body>
+</html>
+`
diff --git a/_content/doc/progs/eff_sequence.go b/_content/doc/progs/eff_sequence.go
new file mode 100644
index 0000000..ab1826b
--- /dev/null
+++ b/_content/doc/progs/eff_sequence.go
@@ -0,0 +1,49 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "fmt"
+ "sort"
+)
+
+func main() {
+ seq := Sequence{6, 2, -1, 44, 16}
+ sort.Sort(seq)
+ fmt.Println(seq)
+}
+
+type Sequence []int
+
+// Methods required by sort.Interface.
+func (s Sequence) Len() int {
+ return len(s)
+}
+func (s Sequence) Less(i, j int) bool {
+ return s[i] < s[j]
+}
+func (s Sequence) Swap(i, j int) {
+ s[i], s[j] = s[j], s[i]
+}
+
+// Copy returns a copy of the Sequence.
+func (s Sequence) Copy() Sequence {
+ copy := make(Sequence, 0, len(s))
+ return append(copy, s...)
+}
+
+// Method for printing - sorts the elements before printing.
+func (s Sequence) String() string {
+ s = s.Copy() // Make a copy; don't overwrite argument.
+ sort.Sort(s)
+ str := "["
+ for i, elem := range s { // Loop is O(N²); will fix that in next example.
+ if i > 0 {
+ str += " "
+ }
+ str += fmt.Sprint(elem)
+ }
+ return str + "]"
+}
diff --git a/_content/doc/progs/eff_unused1.go b/_content/doc/progs/eff_unused1.go
new file mode 100644
index 0000000..285d55e
--- /dev/null
+++ b/_content/doc/progs/eff_unused1.go
@@ -0,0 +1,16 @@
+package main
+
+import (
+ "fmt"
+ "io"
+ "log"
+ "os"
+)
+
+func main() {
+ fd, err := os.Open("test.go")
+ if err != nil {
+ log.Fatal(err)
+ }
+ // TODO: use fd.
+}
diff --git a/_content/doc/progs/eff_unused2.go b/_content/doc/progs/eff_unused2.go
new file mode 100644
index 0000000..92eb74e
--- /dev/null
+++ b/_content/doc/progs/eff_unused2.go
@@ -0,0 +1,20 @@
+package main
+
+import (
+ "fmt"
+ "io"
+ "log"
+ "os"
+)
+
+var _ = fmt.Printf // For debugging; delete when done.
+var _ io.Reader // For debugging; delete when done.
+
+func main() {
+ fd, err := os.Open("test.go")
+ if err != nil {
+ log.Fatal(err)
+ }
+ // TODO: use fd.
+ _ = fd
+}
diff --git a/_content/doc/progs/error.go b/_content/doc/progs/error.go
new file mode 100644
index 0000000..e776cdb
--- /dev/null
+++ b/_content/doc/progs/error.go
@@ -0,0 +1,127 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file contains the code snippets included in "Error Handling and Go."
+
+package main
+
+import (
+ "encoding/json"
+ "errors"
+ "fmt"
+ "log"
+ "net"
+ "os"
+ "time"
+)
+
+type File struct{}
+
+func Open(name string) (file *File, err error) {
+ // OMIT
+ panic(1)
+ // STOP OMIT
+}
+
+func openFile() { // OMIT
+ f, err := os.Open("filename.ext")
+ if err != nil {
+ log.Fatal(err)
+ }
+ // do something with the open *File f
+ // STOP OMIT
+ _ = f
+}
+
+// errorString is a trivial implementation of error.
+type errorString struct {
+ s string
+}
+
+func (e *errorString) Error() string {
+ return e.s
+}
+
+// STOP OMIT
+
+// New returns an error that formats as the given text.
+func New(text string) error {
+ return &errorString{text}
+}
+
+// STOP OMIT
+
+func Sqrt(f float64) (float64, error) {
+ if f < 0 {
+ return 0, errors.New("math: square root of negative number")
+ }
+ // implementation
+ return 0, nil // OMIT
+}
+
+// STOP OMIT
+
+func printErr() (int, error) { // OMIT
+ f, err := Sqrt(-1)
+ if err != nil {
+ fmt.Println(err)
+ }
+ // STOP OMIT
+ // fmtError OMIT
+ if f < 0 {
+ return 0, fmt.Errorf("math: square root of negative number %g", f)
+ }
+ // STOP OMIT
+ return 0, nil
+}
+
+type NegativeSqrtError float64
+
+func (f NegativeSqrtError) Error() string {
+ return fmt.Sprintf("math: square root of negative number %g", float64(f))
+}
+
+// STOP OMIT
+
+type SyntaxError struct {
+ msg string // description of error
+ Offset int64 // error occurred after reading Offset bytes
+}
+
+func (e *SyntaxError) Error() string { return e.msg }
+
+// STOP OMIT
+
+func decodeError(dec *json.Decoder, val struct{}) error { // OMIT
+ var f os.FileInfo // OMIT
+ if err := dec.Decode(&val); err != nil {
+ if serr, ok := err.(*json.SyntaxError); ok {
+ line, col := findLine(f, serr.Offset)
+ return fmt.Errorf("%s:%d:%d: %v", f.Name(), line, col, err)
+ }
+ return err
+ }
+ // STOP OMIT
+ return nil
+}
+
+func findLine(os.FileInfo, int64) (int, int) {
+ // place holder; no need to run
+ return 0, 0
+}
+
+func netError(err error) { // OMIT
+ for { // OMIT
+ if nerr, ok := err.(net.Error); ok && nerr.Temporary() {
+ time.Sleep(1e9)
+ continue
+ }
+ if err != nil {
+ log.Fatal(err)
+ }
+ // STOP OMIT
+ }
+}
+
+func main() {}
diff --git a/_content/doc/progs/error2.go b/_content/doc/progs/error2.go
new file mode 100644
index 0000000..086b671
--- /dev/null
+++ b/_content/doc/progs/error2.go
@@ -0,0 +1,54 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file contains the code snippets included in "Error Handling and Go."
+
+package main
+
+import (
+ "net/http"
+ "text/template"
+)
+
+func init() {
+ http.HandleFunc("/view", viewRecord)
+}
+
+func viewRecord(w http.ResponseWriter, r *http.Request) {
+ c := appengine.NewContext(r)
+ key := datastore.NewKey(c, "Record", r.FormValue("id"), 0, nil)
+ record := new(Record)
+ if err := datastore.Get(c, key, record); err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ return
+ }
+ if err := viewTemplate.Execute(w, record); err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ }
+}
+
+// STOP OMIT
+
+type ap struct{}
+
+func (ap) NewContext(*http.Request) *ctx { return nil }
+
+type ctx struct{}
+
+func (*ctx) Errorf(string, ...interface{}) {}
+
+var appengine ap
+
+type ds struct{}
+
+func (ds) NewKey(*ctx, string, string, int, *int) string { return "" }
+func (ds) Get(*ctx, string, *Record) error { return nil }
+
+var datastore ds
+
+type Record struct{}
+
+var viewTemplate *template.Template
+
+func main() {}
diff --git a/_content/doc/progs/error3.go b/_content/doc/progs/error3.go
new file mode 100644
index 0000000..d9e56b5
--- /dev/null
+++ b/_content/doc/progs/error3.go
@@ -0,0 +1,63 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file contains the code snippets included in "Error Handling and Go."
+
+package main
+
+import (
+ "net/http"
+ "text/template"
+)
+
+func init() {
+ http.Handle("/view", appHandler(viewRecord))
+}
+
+// STOP OMIT
+
+func viewRecord(w http.ResponseWriter, r *http.Request) error {
+ c := appengine.NewContext(r)
+ key := datastore.NewKey(c, "Record", r.FormValue("id"), 0, nil)
+ record := new(Record)
+ if err := datastore.Get(c, key, record); err != nil {
+ return err
+ }
+ return viewTemplate.Execute(w, record)
+}
+
+// STOP OMIT
+
+type appHandler func(http.ResponseWriter, *http.Request) error
+
+func (fn appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+ if err := fn(w, r); err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ }
+}
+
+// STOP OMIT
+
+type ap struct{}
+
+func (ap) NewContext(*http.Request) *ctx { return nil }
+
+type ctx struct{}
+
+func (*ctx) Errorf(string, ...interface{}) {}
+
+var appengine ap
+
+type ds struct{}
+
+func (ds) NewKey(*ctx, string, string, int, *int) string { return "" }
+func (ds) Get(*ctx, string, *Record) error { return nil }
+
+var datastore ds
+
+type Record struct{}
+
+var viewTemplate *template.Template
+
+func main() {}
diff --git a/_content/doc/progs/error4.go b/_content/doc/progs/error4.go
new file mode 100644
index 0000000..8b2f304
--- /dev/null
+++ b/_content/doc/progs/error4.go
@@ -0,0 +1,74 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file contains the code snippets included in "Error Handling and Go."
+
+package main
+
+import (
+ "net/http"
+ "text/template"
+)
+
+type appError struct {
+ Error error
+ Message string
+ Code int
+}
+
+// STOP OMIT
+
+type appHandler func(http.ResponseWriter, *http.Request) *appError
+
+func (fn appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+ if e := fn(w, r); e != nil { // e is *appError, not error.
+ c := appengine.NewContext(r)
+ c.Errorf("%v", e.Error)
+ http.Error(w, e.Message, e.Code)
+ }
+}
+
+// STOP OMIT
+
+func viewRecord(w http.ResponseWriter, r *http.Request) *appError {
+ c := appengine.NewContext(r)
+ key := datastore.NewKey(c, "Record", r.FormValue("id"), 0, nil)
+ record := new(Record)
+ if err := datastore.Get(c, key, record); err != nil {
+ return &appError{err, "Record not found", 404}
+ }
+ if err := viewTemplate.Execute(w, record); err != nil {
+ return &appError{err, "Can't display record", 500}
+ }
+ return nil
+}
+
+// STOP OMIT
+
+func init() {
+ http.Handle("/view", appHandler(viewRecord))
+}
+
+type ap struct{}
+
+func (ap) NewContext(*http.Request) *ctx { return nil }
+
+type ctx struct{}
+
+func (*ctx) Errorf(string, ...interface{}) {}
+
+var appengine ap
+
+type ds struct{}
+
+func (ds) NewKey(*ctx, string, string, int, *int) string { return "" }
+func (ds) Get(*ctx, string, *Record) error { return nil }
+
+var datastore ds
+
+type Record struct{}
+
+var viewTemplate *template.Template
+
+func main() {}
diff --git a/_content/doc/progs/go1.go b/_content/doc/progs/go1.go
new file mode 100644
index 0000000..50fd934
--- /dev/null
+++ b/_content/doc/progs/go1.go
@@ -0,0 +1,245 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file contains examples to embed in the Go 1 release notes document.
+
+package main
+
+import (
+ "errors"
+ "flag"
+ "fmt"
+ "log"
+ "os"
+ "path/filepath"
+ "testing"
+ "time"
+ "unicode"
+)
+
+func main() {
+ flag.Parse()
+ stringAppend()
+ mapDelete()
+ mapIteration()
+ multipleAssignment()
+ structEquality()
+ compositeLiterals()
+ runeType()
+ errorExample()
+ timePackage()
+ walkExample()
+ osIsExist()
+}
+
+var timeout = flag.Duration("timeout", 30*time.Second, "how long to wait for completion")
+
+func init() {
+ // canonicalize the logging
+ log.SetFlags(0)
+}
+
+func mapDelete() {
+ m := map[string]int{"7": 7, "23": 23}
+ k := "7"
+ delete(m, k)
+ if m["7"] != 0 || m["23"] != 23 {
+ log.Fatal("mapDelete:", m)
+ }
+}
+
+func stringAppend() {
+ greeting := []byte{}
+ greeting = append(greeting, []byte("hello ")...)
+ greeting = append(greeting, "world"...)
+ if string(greeting) != "hello world" {
+ log.Fatal("stringAppend: ", string(greeting))
+ }
+}
+
+func mapIteration() {
+ m := map[string]int{"Sunday": 0, "Monday": 1}
+ for name, value := range m {
+ // This loop should not assume Sunday will be visited first.
+ f(name, value)
+ }
+}
+
+func f(string, int) {
+}
+
+func assert(t bool) {
+ if !t {
+ log.Panic("assertion fail")
+ }
+}
+
+func multipleAssignment() {
+ sa := []int{1, 2, 3}
+ i := 0
+ i, sa[i] = 1, 2 // sets i = 1, sa[0] = 2
+
+ sb := []int{1, 2, 3}
+ j := 0
+ sb[j], j = 2, 1 // sets sb[0] = 2, j = 1
+
+ sc := []int{1, 2, 3}
+ sc[0], sc[0] = 1, 2 // sets sc[0] = 1, then sc[0] = 2 (so sc[0] = 2 at end)
+
+ assert(i == 1 && sa[0] == 2)
+ assert(j == 1 && sb[0] == 2)
+ assert(sc[0] == 2)
+}
+
+func structEquality() {
+ type Day struct {
+ long string
+ short string
+ }
+ Christmas := Day{"Christmas", "XMas"}
+ Thanksgiving := Day{"Thanksgiving", "Turkey"}
+ holiday := map[Day]bool{
+ Christmas: true,
+ Thanksgiving: true,
+ }
+ fmt.Printf("Christmas is a holiday: %t\n", holiday[Christmas])
+}
+
+func compositeLiterals() {
+ type Date struct {
+ month string
+ day int
+ }
+ // Struct values, fully qualified; always legal.
+ holiday1 := []Date{
+ Date{"Feb", 14},
+ Date{"Nov", 11},
+ Date{"Dec", 25},
+ }
+ // Struct values, type name elided; always legal.
+ holiday2 := []Date{
+ {"Feb", 14},
+ {"Nov", 11},
+ {"Dec", 25},
+ }
+ // Pointers, fully qualified, always legal.
+ holiday3 := []*Date{
+ &Date{"Feb", 14},
+ &Date{"Nov", 11},
+ &Date{"Dec", 25},
+ }
+ // Pointers, type name elided; legal in Go 1.
+ holiday4 := []*Date{
+ {"Feb", 14},
+ {"Nov", 11},
+ {"Dec", 25},
+ }
+ // STOP OMIT
+ _, _, _, _ = holiday1, holiday2, holiday3, holiday4
+}
+
+func runeType() {
+ // STARTRUNE OMIT
+ delta := 'δ' // delta has type rune.
+ var DELTA rune
+ DELTA = unicode.ToUpper(delta)
+ epsilon := unicode.ToLower(DELTA + 1)
+ if epsilon != 'δ'+1 {
+ log.Fatal("inconsistent casing for Greek")
+ }
+ // ENDRUNE OMIT
+}
+
+// START ERROR EXAMPLE OMIT
+type SyntaxError struct {
+ File string
+ Line int
+ Message string
+}
+
+func (se *SyntaxError) Error() string {
+ return fmt.Sprintf("%s:%d: %s", se.File, se.Line, se.Message)
+}
+
+// END ERROR EXAMPLE OMIT
+
+func errorExample() {
+ var ErrSyntax = errors.New("syntax error")
+ _ = ErrSyntax
+ se := &SyntaxError{"file", 7, "error"}
+ got := fmt.Sprint(se)
+ const expect = "file:7: error"
+ if got != expect {
+ log.Fatalf("errorsPackage: expected %q got %q", expect, got)
+ }
+}
+
+// sleepUntil sleeps until the specified time. It returns immediately if it's too late.
+func sleepUntil(wakeup time.Time) {
+ now := time.Now() // A Time.
+ if !wakeup.After(now) {
+ return
+ }
+ delta := wakeup.Sub(now) // A Duration.
+ fmt.Printf("Sleeping for %.3fs\n", delta.Seconds())
+ time.Sleep(delta)
+}
+
+func timePackage() {
+ sleepUntil(time.Now().Add(123 * time.Millisecond))
+}
+
+func walkExample() {
+ // STARTWALK OMIT
+ markFn := func(path string, info os.FileInfo, err error) error {
+ if path == "pictures" { // Will skip walking of directory pictures and its contents.
+ return filepath.SkipDir
+ }
+ if err != nil {
+ return err
+ }
+ log.Println(path)
+ return nil
+ }
+ err := filepath.Walk(".", markFn)
+ if err != nil {
+ log.Fatal(err)
+ }
+ // ENDWALK OMIT
+}
+
+func initializationFunction(c chan int) {
+ c <- 1
+}
+
+var PackageGlobal int
+
+func init() {
+ c := make(chan int)
+ go initializationFunction(c)
+ PackageGlobal = <-c
+}
+
+func BenchmarkSprintf(b *testing.B) {
+ // Verify correctness before running benchmark.
+ b.StopTimer()
+ got := fmt.Sprintf("%x", 23)
+ const expect = "17"
+ if expect != got {
+ b.Fatalf("expected %q; got %q", expect, got)
+ }
+ b.StartTimer()
+ for i := 0; i < b.N; i++ {
+ fmt.Sprintf("%x", 23)
+ }
+}
+
+func osIsExist() {
+ name := "go1.go"
+ f, err := os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0600)
+ if os.IsExist(err) {
+ log.Printf("%s already exists", name)
+ }
+ _ = f
+}
diff --git a/_content/doc/progs/gobs1.go b/_content/doc/progs/gobs1.go
new file mode 100644
index 0000000..7077ca1
--- /dev/null
+++ b/_content/doc/progs/gobs1.go
@@ -0,0 +1,22 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package gobs1
+
+type T struct{ X, Y, Z int } // Only exported fields are encoded and decoded.
+var t = T{X: 7, Y: 0, Z: 8}
+
+// STOP OMIT
+
+type U struct{ X, Y *int8 } // Note: pointers to int8s
+var u U
+
+// STOP OMIT
+
+type Node struct {
+ Value int
+ Left, Right *Node
+}
+
+// STOP OMIT
diff --git a/_content/doc/progs/gobs2.go b/_content/doc/progs/gobs2.go
new file mode 100644
index 0000000..85bb41c
--- /dev/null
+++ b/_content/doc/progs/gobs2.go
@@ -0,0 +1,43 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "bytes"
+ "encoding/gob"
+ "fmt"
+ "log"
+)
+
+type P struct {
+ X, Y, Z int
+ Name string
+}
+
+type Q struct {
+ X, Y *int32
+ Name string
+}
+
+func main() {
+ // Initialize the encoder and decoder. Normally enc and dec would be
+ // bound to network connections and the encoder and decoder would
+ // run in different processes.
+ var network bytes.Buffer // Stand-in for a network connection
+ enc := gob.NewEncoder(&network) // Will write to network.
+ dec := gob.NewDecoder(&network) // Will read from network.
+ // Encode (send) the value.
+ err := enc.Encode(P{3, 4, 5, "Pythagoras"})
+ if err != nil {
+ log.Fatal("encode error:", err)
+ }
+ // Decode (receive) the value.
+ var q Q
+ err = dec.Decode(&q)
+ if err != nil {
+ log.Fatal("decode error:", err)
+ }
+ fmt.Printf("%q: {%d,%d}\n", q.Name, *q.X, *q.Y)
+}
diff --git a/_content/doc/progs/image_draw.go b/_content/doc/progs/image_draw.go
new file mode 100644
index 0000000..bb73c8a
--- /dev/null
+++ b/_content/doc/progs/image_draw.go
@@ -0,0 +1,142 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file contains the code snippets included in "The Go image/draw package."
+
+package main
+
+import (
+ "image"
+ "image/color"
+ "image/draw"
+)
+
+func main() {
+ Color()
+ Rect()
+ RectAndScroll()
+ ConvAndCircle()
+ Glyph()
+}
+
+func Color() {
+ c := color.RGBA{255, 0, 255, 255}
+ r := image.Rect(0, 0, 640, 480)
+ dst := image.NewRGBA(r)
+
+ // ZERO OMIT
+ // image.ZP is the zero point -- the origin.
+ draw.Draw(dst, r, &image.Uniform{c}, image.ZP, draw.Src)
+ // STOP OMIT
+
+ // BLUE OMIT
+ m := image.NewRGBA(image.Rect(0, 0, 640, 480))
+ blue := color.RGBA{0, 0, 255, 255}
+ draw.Draw(m, m.Bounds(), &image.Uniform{blue}, image.ZP, draw.Src)
+ // STOP OMIT
+
+ // RESET OMIT
+ draw.Draw(m, m.Bounds(), image.Transparent, image.ZP, draw.Src)
+ // STOP OMIT
+}
+
+func Rect() {
+ dst := image.NewRGBA(image.Rect(0, 0, 640, 480))
+ sr := image.Rect(0, 0, 200, 200)
+ src := image.Black
+ dp := image.Point{100, 100}
+
+ // RECT OMIT
+ r := image.Rectangle{dp, dp.Add(sr.Size())}
+ draw.Draw(dst, r, src, sr.Min, draw.Src)
+ // STOP OMIT
+}
+
+func RectAndScroll() {
+ dst := image.NewRGBA(image.Rect(0, 0, 640, 480))
+ sr := image.Rect(0, 0, 200, 200)
+ src := image.Black
+ dp := image.Point{100, 100}
+
+ // RECT2 OMIT
+ r := sr.Sub(sr.Min).Add(dp)
+ draw.Draw(dst, r, src, sr.Min, draw.Src)
+ // STOP OMIT
+
+ m := dst
+
+ // SCROLL OMIT
+ b := m.Bounds()
+ p := image.Pt(0, 20)
+ // Note that even though the second argument is b,
+ // the effective rectangle is smaller due to clipping.
+ draw.Draw(m, b, m, b.Min.Add(p), draw.Src)
+ dirtyRect := b.Intersect(image.Rect(b.Min.X, b.Max.Y-20, b.Max.X, b.Max.Y))
+ // STOP OMIT
+
+ _ = dirtyRect // noop
+}
+
+func ConvAndCircle() {
+ src := image.NewRGBA(image.Rect(0, 0, 640, 480))
+ dst := image.NewRGBA(image.Rect(0, 0, 640, 480))
+
+ // CONV OMIT
+ b := src.Bounds()
+ m := image.NewRGBA(b)
+ draw.Draw(m, b, src, b.Min, draw.Src)
+ // STOP OMIT
+
+ p := image.Point{100, 100}
+ r := 50
+
+ // CIRCLE2 OMIT
+ draw.DrawMask(dst, dst.Bounds(), src, image.ZP, &circle{p, r}, image.ZP, draw.Over)
+ // STOP OMIT
+}
+
+func theGlyphImageForAFont() image.Image {
+ return image.NewRGBA(image.Rect(0, 0, 640, 480))
+}
+
+func theBoundsFor(index int) image.Rectangle {
+ return image.Rect(0, 0, 32, 32)
+}
+
+func Glyph() {
+ p := image.Point{100, 100}
+ dst := image.NewRGBA(image.Rect(0, 0, 640, 480))
+ glyphIndex := 42
+
+ // GLYPH OMIT
+ src := &image.Uniform{color.RGBA{0, 0, 255, 255}}
+ mask := theGlyphImageForAFont()
+ mr := theBoundsFor(glyphIndex)
+ draw.DrawMask(dst, mr.Sub(mr.Min).Add(p), src, image.ZP, mask, mr.Min, draw.Over)
+ // STOP OMIT
+}
+
+//CIRCLESTRUCT OMIT
+type circle struct {
+ p image.Point
+ r int
+}
+
+func (c *circle) ColorModel() color.Model {
+ return color.AlphaModel
+}
+
+func (c *circle) Bounds() image.Rectangle {
+ return image.Rect(c.p.X-c.r, c.p.Y-c.r, c.p.X+c.r, c.p.Y+c.r)
+}
+
+func (c *circle) At(x, y int) color.Color {
+ xx, yy, rr := float64(x-c.p.X)+0.5, float64(y-c.p.Y)+0.5, float64(c.r)
+ if xx*xx+yy*yy < rr*rr {
+ return color.Alpha{255}
+ }
+ return color.Alpha{0}
+}
+
+//STOP OMIT
diff --git a/_content/doc/progs/image_package1.go b/_content/doc/progs/image_package1.go
new file mode 100644
index 0000000..c4c401e
--- /dev/null
+++ b/_content/doc/progs/image_package1.go
@@ -0,0 +1,15 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "fmt"
+ "image"
+)
+
+func main() {
+ p := image.Point{2, 1}
+ fmt.Println("X is", p.X, "Y is", p.Y)
+}
diff --git a/_content/doc/progs/image_package2.go b/_content/doc/progs/image_package2.go
new file mode 100644
index 0000000..fcb5d9f
--- /dev/null
+++ b/_content/doc/progs/image_package2.go
@@ -0,0 +1,16 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "fmt"
+ "image"
+)
+
+func main() {
+ r := image.Rect(2, 1, 5, 5)
+ // Dx and Dy return a rectangle's width and height.
+ fmt.Println(r.Dx(), r.Dy(), image.Pt(0, 0).In(r)) // prints 3 4 false
+}
diff --git a/_content/doc/progs/image_package3.go b/_content/doc/progs/image_package3.go
new file mode 100644
index 0000000..13d0f08
--- /dev/null
+++ b/_content/doc/progs/image_package3.go
@@ -0,0 +1,15 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "fmt"
+ "image"
+)
+
+func main() {
+ r := image.Rect(2, 1, 5, 5).Add(image.Pt(-4, -2))
+ fmt.Println(r.Dx(), r.Dy(), image.Pt(0, 0).In(r)) // prints 3 4 true
+}
diff --git a/_content/doc/progs/image_package4.go b/_content/doc/progs/image_package4.go
new file mode 100644
index 0000000..c46fddf
--- /dev/null
+++ b/_content/doc/progs/image_package4.go
@@ -0,0 +1,16 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "fmt"
+ "image"
+)
+
+func main() {
+ r := image.Rect(0, 0, 4, 3).Intersect(image.Rect(2, 2, 5, 5))
+ // Size returns a rectangle's width and height, as a Point.
+ fmt.Printf("%#v\n", r.Size()) // prints image.Point{X:2, Y:1}
+}
diff --git a/_content/doc/progs/image_package5.go b/_content/doc/progs/image_package5.go
new file mode 100644
index 0000000..0bb5c76
--- /dev/null
+++ b/_content/doc/progs/image_package5.go
@@ -0,0 +1,17 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "fmt"
+ "image"
+ "image/color"
+)
+
+func main() {
+ m := image.NewRGBA(image.Rect(0, 0, 640, 480))
+ m.Set(5, 5, color.RGBA{255, 0, 0, 255})
+ fmt.Println(m.At(5, 5))
+}
diff --git a/_content/doc/progs/image_package6.go b/_content/doc/progs/image_package6.go
new file mode 100644
index 0000000..62eeecd
--- /dev/null
+++ b/_content/doc/progs/image_package6.go
@@ -0,0 +1,17 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "fmt"
+ "image"
+)
+
+func main() {
+ m0 := image.NewRGBA(image.Rect(0, 0, 8, 5))
+ m1 := m0.SubImage(image.Rect(1, 2, 5, 5)).(*image.RGBA)
+ fmt.Println(m0.Bounds().Dx(), m1.Bounds().Dx()) // prints 8, 4
+ fmt.Println(m0.Stride == m1.Stride) // prints true
+}
diff --git a/_content/doc/progs/interface.go b/_content/doc/progs/interface.go
new file mode 100644
index 0000000..c2925d5
--- /dev/null
+++ b/_content/doc/progs/interface.go
@@ -0,0 +1,62 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file contains the code snippets included in "The Laws of Reflection."
+
+package main
+
+import (
+ "bufio"
+ "bytes"
+ "io"
+ "os"
+)
+
+type MyInt int
+
+var i int
+var j MyInt
+
+// STOP OMIT
+
+// Reader is the interface that wraps the basic Read method.
+type Reader interface {
+ Read(p []byte) (n int, err error)
+}
+
+// Writer is the interface that wraps the basic Write method.
+type Writer interface {
+ Write(p []byte) (n int, err error)
+}
+
+// STOP OMIT
+
+func readers() { // OMIT
+ var r io.Reader
+ r = os.Stdin
+ r = bufio.NewReader(r)
+ r = new(bytes.Buffer)
+ // and so on
+ // STOP OMIT
+}
+
+func typeAssertions() (interface{}, error) { // OMIT
+ var r io.Reader
+ tty, err := os.OpenFile("/dev/tty", os.O_RDWR, 0)
+ if err != nil {
+ return nil, err
+ }
+ r = tty
+ // STOP OMIT
+ var w io.Writer
+ w = r.(io.Writer)
+ // STOP OMIT
+ var empty interface{}
+ empty = w
+ // STOP OMIT
+ return empty, err
+}
+
+func main() {
+}
diff --git a/_content/doc/progs/interface2.go b/_content/doc/progs/interface2.go
new file mode 100644
index 0000000..a541d94
--- /dev/null
+++ b/_content/doc/progs/interface2.go
@@ -0,0 +1,132 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file contains the code snippets included in "The Laws of Reflection."
+
+package main
+
+import (
+ "fmt"
+ "reflect"
+)
+
+func main() {
+ var x float64 = 3.4
+ fmt.Println("type:", reflect.TypeOf(x))
+ // STOP OMIT
+ // TODO(proppy): test output OMIT
+}
+
+// STOP main OMIT
+
+func f1() {
+ // START f1 OMIT
+ var x float64 = 3.4
+ v := reflect.ValueOf(x)
+ fmt.Println("type:", v.Type())
+ fmt.Println("kind is float64:", v.Kind() == reflect.Float64)
+ fmt.Println("value:", v.Float())
+ // STOP OMIT
+}
+
+func f2() {
+ // START f2 OMIT
+ var x uint8 = 'x'
+ v := reflect.ValueOf(x)
+ fmt.Println("type:", v.Type()) // uint8.
+ fmt.Println("kind is uint8: ", v.Kind() == reflect.Uint8) // true.
+ x = uint8(v.Uint()) // v.Uint returns a uint64.
+ // STOP OMIT
+}
+
+func f3() {
+ // START f3 OMIT
+ type MyInt int
+ var x MyInt = 7
+ v := reflect.ValueOf(x)
+ // STOP OMIT
+ // START f3b OMIT
+ y := v.Interface().(float64) // y will have type float64.
+ fmt.Println(y)
+ // STOP OMIT
+ // START f3c OMIT
+ fmt.Println(v.Interface())
+ // STOP OMIT
+ // START f3d OMIT
+ fmt.Printf("value is %7.1e\n", v.Interface())
+ // STOP OMIT
+}
+
+func f4() {
+ // START f4 OMIT
+ var x float64 = 3.4
+ v := reflect.ValueOf(x)
+ v.SetFloat(7.1) // Error: will panic.
+ // STOP OMIT
+}
+
+func f5() {
+ // START f5 OMIT
+ var x float64 = 3.4
+ v := reflect.ValueOf(x)
+ fmt.Println("settability of v:", v.CanSet())
+ // STOP OMIT
+}
+
+func f6() {
+ // START f6 OMIT
+ var x float64 = 3.4
+ v := reflect.ValueOf(x)
+ // STOP OMIT
+ // START f6b OMIT
+ v.SetFloat(7.1)
+ // STOP OMIT
+}
+
+func f7() {
+ // START f7 OMIT
+ var x float64 = 3.4
+ p := reflect.ValueOf(&x) // Note: take the address of x.
+ fmt.Println("type of p:", p.Type())
+ fmt.Println("settability of p:", p.CanSet())
+ // STOP OMIT
+ // START f7b OMIT
+ v := p.Elem()
+ fmt.Println("settability of v:", v.CanSet())
+ // STOP OMIT
+ // START f7c OMIT
+ v.SetFloat(7.1)
+ fmt.Println(v.Interface())
+ fmt.Println(x)
+ // STOP OMIT
+}
+
+func f8() {
+ // START f8 OMIT
+ type T struct {
+ A int
+ B string
+ }
+ t := T{23, "skidoo"}
+ s := reflect.ValueOf(&t).Elem()
+ typeOfT := s.Type()
+ for i := 0; i < s.NumField(); i++ {
+ f := s.Field(i)
+ fmt.Printf("%d: %s %s = %v\n", i,
+ typeOfT.Field(i).Name, f.Type(), f.Interface())
+ }
+ // STOP OMIT
+ // START f8b OMIT
+ s.Field(0).SetInt(77)
+ s.Field(1).SetString("Sunset Strip")
+ fmt.Println("t is now", t)
+ // STOP OMIT
+}
+
+func f9() {
+ // START f9 OMIT
+ var x float64 = 3.4
+ fmt.Println("value:", reflect.ValueOf(x))
+ // STOP OMIT
+}
diff --git a/_content/doc/progs/json1.go b/_content/doc/progs/json1.go
new file mode 100644
index 0000000..9804efb
--- /dev/null
+++ b/_content/doc/progs/json1.go
@@ -0,0 +1,88 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "encoding/json"
+ "log"
+ "reflect"
+)
+
+type Message struct {
+ Name string
+ Body string
+ Time int64
+}
+
+// STOP OMIT
+
+func Encode() {
+ m := Message{"Alice", "Hello", 1294706395881547000}
+ b, err := json.Marshal(m)
+
+ if err != nil {
+ panic(err)
+ }
+
+ expected := []byte(`{"Name":"Alice","Body":"Hello","Time":1294706395881547000}`)
+ if !reflect.DeepEqual(b, expected) {
+ log.Panicf("Error marshaling %q, expected %q, got %q.", m, expected, b)
+ }
+
+}
+
+func Decode() {
+ b := []byte(`{"Name":"Alice","Body":"Hello","Time":1294706395881547000}`)
+ var m Message
+ err := json.Unmarshal(b, &m)
+
+ if err != nil {
+ panic(err)
+ }
+
+ expected := Message{
+ Name: "Alice",
+ Body: "Hello",
+ Time: 1294706395881547000,
+ }
+
+ if !reflect.DeepEqual(m, expected) {
+ log.Panicf("Error unmarshaling %q, expected %q, got %q.", b, expected, m)
+ }
+
+ m = Message{
+ Name: "Alice",
+ Body: "Hello",
+ Time: 1294706395881547000,
+ }
+
+ // STOP OMIT
+}
+
+func PartialDecode() {
+ b := []byte(`{"Name":"Bob","Food":"Pickle"}`)
+ var m Message
+ err := json.Unmarshal(b, &m)
+
+ // STOP OMIT
+
+ if err != nil {
+ panic(err)
+ }
+
+ expected := Message{
+ Name: "Bob",
+ }
+
+ if !reflect.DeepEqual(expected, m) {
+ log.Panicf("Error unmarshaling %q, expected %q, got %q.", b, expected, m)
+ }
+}
+
+func main() {
+ Encode()
+ Decode()
+ PartialDecode()
+}
diff --git a/_content/doc/progs/json2.go b/_content/doc/progs/json2.go
new file mode 100644
index 0000000..6089ae6
--- /dev/null
+++ b/_content/doc/progs/json2.go
@@ -0,0 +1,42 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "fmt"
+ "math"
+)
+
+func InterfaceExample() {
+ var i interface{}
+ i = "a string"
+ i = 2011
+ i = 2.777
+
+ // STOP OMIT
+
+ r := i.(float64)
+ fmt.Println("the circle's area", math.Pi*r*r)
+
+ // STOP OMIT
+
+ switch v := i.(type) {
+ case int:
+ fmt.Println("twice i is", v*2)
+ case float64:
+ fmt.Println("the reciprocal of i is", 1/v)
+ case string:
+ h := len(v) / 2
+ fmt.Println("i swapped by halves is", v[h:]+v[:h])
+ default:
+ // i isn't one of the types above
+ }
+
+ // STOP OMIT
+}
+
+func main() {
+ InterfaceExample()
+}
diff --git a/_content/doc/progs/json3.go b/_content/doc/progs/json3.go
new file mode 100644
index 0000000..442c155
--- /dev/null
+++ b/_content/doc/progs/json3.go
@@ -0,0 +1,73 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "encoding/json"
+ "fmt"
+ "log"
+ "reflect"
+)
+
+func Decode() {
+ b := []byte(`{"Name":"Wednesday","Age":6,"Parents":["Gomez","Morticia"]}`)
+
+ var f interface{}
+ err := json.Unmarshal(b, &f)
+
+ // STOP OMIT
+
+ if err != nil {
+ panic(err)
+ }
+
+ expected := map[string]interface{}{
+ "Name": "Wednesday",
+ "Age": float64(6),
+ "Parents": []interface{}{
+ "Gomez",
+ "Morticia",
+ },
+ }
+
+ if !reflect.DeepEqual(f, expected) {
+ log.Panicf("Error unmarshaling %q, expected %q, got %q", b, expected, f)
+ }
+
+ f = map[string]interface{}{
+ "Name": "Wednesday",
+ "Age": 6,
+ "Parents": []interface{}{
+ "Gomez",
+ "Morticia",
+ },
+ }
+
+ // STOP OMIT
+
+ m := f.(map[string]interface{})
+
+ for k, v := range m {
+ switch vv := v.(type) {
+ case string:
+ fmt.Println(k, "is string", vv)
+ case int:
+ fmt.Println(k, "is int", vv)
+ case []interface{}:
+ fmt.Println(k, "is an array:")
+ for i, u := range vv {
+ fmt.Println(i, u)
+ }
+ default:
+ fmt.Println(k, "is of a type I don't know how to handle")
+ }
+ }
+
+ // STOP OMIT
+}
+
+func main() {
+ Decode()
+}
diff --git a/_content/doc/progs/json4.go b/_content/doc/progs/json4.go
new file mode 100644
index 0000000..1c7e5b4
--- /dev/null
+++ b/_content/doc/progs/json4.go
@@ -0,0 +1,45 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "encoding/json"
+ "log"
+ "reflect"
+)
+
+type FamilyMember struct {
+ Name string
+ Age int
+ Parents []string
+}
+
+// STOP OMIT
+
+func Decode() {
+ b := []byte(`{"Name":"Bob","Age":20,"Parents":["Morticia", "Gomez"]}`)
+ var m FamilyMember
+ err := json.Unmarshal(b, &m)
+
+ // STOP OMIT
+
+ if err != nil {
+ panic(err)
+ }
+
+ expected := FamilyMember{
+ Name: "Bob",
+ Age: 20,
+ Parents: []string{"Morticia", "Gomez"},
+ }
+
+ if !reflect.DeepEqual(expected, m) {
+ log.Panicf("Error unmarshaling %q, expected %q, got %q", b, expected, m)
+ }
+}
+
+func main() {
+ Decode()
+}
diff --git a/_content/doc/progs/json5.go b/_content/doc/progs/json5.go
new file mode 100644
index 0000000..6d7a4ca
--- /dev/null
+++ b/_content/doc/progs/json5.go
@@ -0,0 +1,31 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "encoding/json"
+ "log"
+ "os"
+)
+
+func main() {
+ dec := json.NewDecoder(os.Stdin)
+ enc := json.NewEncoder(os.Stdout)
+ for {
+ var v map[string]interface{}
+ if err := dec.Decode(&v); err != nil {
+ log.Println(err)
+ return
+ }
+ for k := range v {
+ if k != "Name" {
+ delete(v, k)
+ }
+ }
+ if err := enc.Encode(&v); err != nil {
+ log.Println(err)
+ }
+ }
+}
diff --git a/_content/doc/progs/run.go b/_content/doc/progs/run.go
new file mode 100644
index 0000000..8ac75cd
--- /dev/null
+++ b/_content/doc/progs/run.go
@@ -0,0 +1,229 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// run runs the docs tests found in this directory.
+package main
+
+import (
+ "bytes"
+ "flag"
+ "fmt"
+ "io/ioutil"
+ "os"
+ "os/exec"
+ "path/filepath"
+ "regexp"
+ "runtime"
+ "strings"
+ "time"
+)
+
+const usage = `go run run.go [tests]
+
+run.go runs the docs tests in this directory.
+If no tests are provided, it runs all tests.
+Tests may be specified without their .go suffix.
+`
+
+func main() {
+ start := time.Now()
+
+ flag.Usage = func() {
+ fmt.Fprintf(os.Stderr, usage)
+ flag.PrintDefaults()
+ os.Exit(2)
+ }
+
+ flag.Parse()
+ if flag.NArg() == 0 {
+ // run all tests
+ fixcgo()
+ } else {
+ // run specified tests
+ onlyTest(flag.Args()...)
+ }
+
+ tmpdir, err := ioutil.TempDir("", "go-progs")
+ if err != nil {
+ fmt.Fprintln(os.Stderr, err)
+ os.Exit(1)
+ }
+
+ // ratec limits the number of tests running concurrently.
+ // None of the tests are intensive, so don't bother
+ // trying to manually adjust for slow builders.
+ ratec := make(chan bool, runtime.NumCPU())
+ errc := make(chan error, len(tests))
+
+ for _, tt := range tests {
+ tt := tt
+ ratec <- true
+ go func() {
+ errc <- test(tmpdir, tt.file, tt.want)
+ <-ratec
+ }()
+ }
+
+ var rc int
+ for range tests {
+ if err := <-errc; err != nil {
+ fmt.Fprintln(os.Stderr, err)
+ rc = 1
+ }
+ }
+ os.Remove(tmpdir)
+ if rc == 0 {
+ fmt.Printf("ok\t%s\t%s\n", filepath.Base(os.Args[0]), time.Since(start).Round(time.Millisecond))
+ }
+ os.Exit(rc)
+}
+
+// test builds the test in the given file.
+// If want is non-empty, test also runs the test
+// and checks that the output matches the regexp want.
+func test(tmpdir, file, want string) error {
+ // Build the program.
+ prog := filepath.Join(tmpdir, file+".exe")
+ cmd := exec.Command("go", "build", "-o", prog, file+".go")
+ out, err := cmd.CombinedOutput()
+ if err != nil {
+ return fmt.Errorf("go build %s.go failed: %v\nOutput:\n%s", file, err, out)
+ }
+ defer os.Remove(prog)
+
+ // Only run the test if we have output to check.
+ if want == "" {
+ return nil
+ }
+
+ cmd = exec.Command(prog)
+ out, err = cmd.CombinedOutput()
+ if err != nil {
+ return fmt.Errorf("%s failed: %v\nOutput:\n%s", file, err, out)
+ }
+
+ // Canonicalize output.
+ out = bytes.TrimRight(out, "\n")
+ out = bytes.ReplaceAll(out, []byte{'\n'}, []byte{' '})
+
+ // Check the result.
+ match, err := regexp.Match(want, out)
+ if err != nil {
+ return fmt.Errorf("failed to parse regexp %q: %v", want, err)
+ }
+ if !match {
+ return fmt.Errorf("%s.go:\n%q\ndoes not match %s", file, out, want)
+ }
+
+ return nil
+}
+
+type testcase struct {
+ file string
+ want string
+}
+
+var tests = []testcase{
+ // defer_panic_recover
+ {"defer", `^0 3210 2$`},
+ {"defer2", `^Calling g. Printing in g 0 Printing in g 1 Printing in g 2 Printing in g 3 Panicking! Defer in g 3 Defer in g 2 Defer in g 1 Defer in g 0 Recovered in f 4 Returned normally from f.$`},
+
+ // effective_go
+ {"eff_bytesize", `^1.00YB 9.09TB$`},
+ {"eff_qr", ""},
+ {"eff_sequence", `^\[-1 2 6 16 44\]$`},
+ {"eff_unused2", ""},
+
+ // error_handling
+ {"error", ""},
+ {"error2", ""},
+ {"error3", ""},
+ {"error4", ""},
+
+ // law_of_reflection
+ {"interface", ""},
+ {"interface2", `^type: float64$`},
+
+ // c_go_cgo
+ {"cgo1", ""},
+ {"cgo2", ""},
+ {"cgo3", ""},
+ {"cgo4", ""},
+
+ // timeout
+ {"timeout1", ""},
+ {"timeout2", ""},
+
+ // gobs
+ {"gobs1", ""},
+ {"gobs2", ""},
+
+ // json
+ {"json1", `^$`},
+ {"json2", `the reciprocal of i is`},
+ {"json3", `Age is int 6`},
+ {"json4", `^$`},
+ {"json5", ""},
+
+ // image_package
+ {"image_package1", `^X is 2 Y is 1$`},
+ {"image_package2", `^3 4 false$`},
+ {"image_package3", `^3 4 true$`},
+ {"image_package4", `^image.Point{X:2, Y:1}$`},
+ {"image_package5", `^{255 0 0 255}$`},
+ {"image_package6", `^8 4 true$`},
+
+ // other
+ {"go1", `^Christmas is a holiday: true .*go1.go already exists$`},
+ {"slices", ""},
+}
+
+func onlyTest(files ...string) {
+ var new []testcase
+NextFile:
+ for _, file := range files {
+ file = strings.TrimSuffix(file, ".go")
+ for _, tt := range tests {
+ if tt.file == file {
+ new = append(new, tt)
+ continue NextFile
+ }
+ }
+ fmt.Fprintf(os.Stderr, "test %s.go not found\n", file)
+ os.Exit(1)
+ }
+ tests = new
+}
+
+func skipTest(file string) {
+ for i, tt := range tests {
+ if tt.file == file {
+ copy(tests[i:], tests[i+1:])
+ tests = tests[:len(tests)-1]
+ return
+ }
+ }
+ panic("delete(" + file + "): not found")
+}
+
+func fixcgo() {
+ if os.Getenv("CGO_ENABLED") != "1" {
+ skipTest("cgo1")
+ skipTest("cgo2")
+ skipTest("cgo3")
+ skipTest("cgo4")
+ return
+ }
+
+ switch runtime.GOOS {
+ case "freebsd":
+ // cgo1 and cgo2 don't run on freebsd, srandom has a different signature
+ skipTest("cgo1")
+ skipTest("cgo2")
+ case "netbsd":
+ // cgo1 and cgo2 don't run on netbsd, srandom has a different signature
+ skipTest("cgo1")
+ skipTest("cgo2")
+ }
+}
diff --git a/_content/doc/progs/slices.go b/_content/doc/progs/slices.go
new file mode 100644
index 0000000..967a3e7
--- /dev/null
+++ b/_content/doc/progs/slices.go
@@ -0,0 +1,63 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+ "io/ioutil"
+ "regexp"
+)
+
+func AppendByte(slice []byte, data ...byte) []byte {
+ m := len(slice)
+ n := m + len(data)
+ if n > cap(slice) { // if necessary, reallocate
+ // allocate double what's needed, for future growth.
+ newSlice := make([]byte, (n+1)*2)
+ copy(newSlice, slice)
+ slice = newSlice
+ }
+ slice = slice[0:n]
+ copy(slice[m:n], data)
+ return slice
+}
+
+// STOP OMIT
+
+// Filter returns a new slice holding only
+// the elements of s that satisfy fn.
+func Filter(s []int, fn func(int) bool) []int {
+ var p []int // == nil
+ for _, i := range s {
+ if fn(i) {
+ p = append(p, i)
+ }
+ }
+ return p
+}
+
+// STOP OMIT
+
+var digitRegexp = regexp.MustCompile("[0-9]+")
+
+func FindDigits(filename string) []byte {
+ b, _ := ioutil.ReadFile(filename)
+ return digitRegexp.Find(b)
+}
+
+// STOP OMIT
+
+func CopyDigits(filename string) []byte {
+ b, _ := ioutil.ReadFile(filename)
+ b = digitRegexp.Find(b)
+ c := make([]byte, len(b))
+ copy(c, b)
+ return c
+}
+
+// STOP OMIT
+
+func main() {
+ // place holder; no need to run
+}
diff --git a/_content/doc/progs/timeout1.go b/_content/doc/progs/timeout1.go
new file mode 100644
index 0000000..353ba69
--- /dev/null
+++ b/_content/doc/progs/timeout1.go
@@ -0,0 +1,29 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package timeout
+
+import (
+ "time"
+)
+
+func Timeout() {
+ ch := make(chan bool, 1)
+ timeout := make(chan bool, 1)
+ go func() {
+ time.Sleep(1 * time.Second)
+ timeout <- true
+ }()
+
+ // STOP OMIT
+
+ select {
+ case <-ch:
+ // a read from ch has occurred
+ case <-timeout:
+ // the read from ch has timed out
+ }
+
+ // STOP OMIT
+}
diff --git a/_content/doc/progs/timeout2.go b/_content/doc/progs/timeout2.go
new file mode 100644
index 0000000..b0d34ea
--- /dev/null
+++ b/_content/doc/progs/timeout2.go
@@ -0,0 +1,28 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package query
+
+type Conn string
+
+func (c Conn) DoQuery(query string) Result {
+ return Result("result")
+}
+
+type Result string
+
+func Query(conns []Conn, query string) Result {
+ ch := make(chan Result, 1)
+ for _, conn := range conns {
+ go func(c Conn) {
+ select {
+ case ch <- c.DoQuery(query):
+ default:
+ }
+ }(conn)
+ }
+ return <-ch
+}
+
+// STOP OMIT
diff --git a/_content/doc/root.html b/_content/doc/root.html
new file mode 100644
index 0000000..92be7ec
--- /dev/null
+++ b/_content/doc/root.html
@@ -0,0 +1,181 @@
+<!--{
+ "Path": "/",
+ "Template": true
+}-->
+
+<div class="HomeContainer">
+ <section class="HomeSection Hero">
+ <h1 class="Hero-header">
+ Go is an open source programming language that makes it easy to build
+ <strong>simple</strong>, <strong>reliable</strong>, and <strong>efficient</strong> software.
+ </h1>
+ <i class="Hero-gopher"></i>
+ <a href="/dl/" class="Button Button--big HeroDownloadButton">
+ <img class="HeroDownloadButton-image" src="/lib/godoc/images/cloud-download.svg" alt="">
+ Download Go
+ </a>
+ <p class="Hero-description">
+ Binary distributions available for<br>
+ Linux, macOS, Windows, and more.
+ </p>
+ </section>
+
+ <section class="HomeSection Playground">
+ <div class="Playground-headerContainer">
+ <h2 class="HomeSection-header">Try Go</h2>
+ {{if not $.GoogleCN}}
+ <a class="Playground-popout js-playgroundShareEl">Open in Playground</a>
+ {{end}}
+ </div>
+ <div class="Playground-inputContainer">
+ <textarea class="Playground-input js-playgroundCodeEl" spellcheck="false" aria-label="Try Go">// You can edit this code!
+// Click here and start typing.
+package main
+
+import "fmt"
+
+func main() {
+ fmt.Println("Hello, 世界")
+}
+</textarea>
+ </div>
+ <div class="Playground-outputContainer js-playgroundOutputEl">
+ <pre class="Playground-output"><noscript>Hello, 世界</noscript></pre>
+ </div>
+ <div class="Playground-controls">
+ <select class="Playground-selectExample js-playgroundToysEl" aria-label="Code examples">
+ <option value="hello.go">Hello, World!</option>
+ <option value="life.go">Conway's Game of Life</option>
+ <option value="fib.go">Fibonacci Closure</option>
+ <option value="peano.go">Peano Integers</option>
+ <option value="pi.go">Concurrent pi</option>
+ <option value="sieve.go">Concurrent Prime Sieve</option>
+ <option value="solitaire.go">Peg Solitaire Solver</option>
+ <option value="tree.go">Tree Comparison</option>
+ </select>
+ <div class="Playground-buttons">
+ <button class="Button Button--primary js-playgroundRunEl" title="Run this code [shift-enter]">Run</button>
+ <div class="Playground-secondaryButtons">
+ {{if not $.GoogleCN}}
+ <button class="Button js-playgroundShareEl" title="Share this code">Share</button>
+ <a class="Button tour" href="https://tour.golang.org/" title="Playground Go from your browser">Tour</a>
+ {{end}}
+ </div>
+ </div>
+ </div>
+ </section>
+
+ {{if not $.GoogleCN}}
+ <section class="HomeSection Blog js-blogContainerEl">
+ <h2 class="HomeSection-header">Featured articles</h2>
+ <div class="Blog-footer js-blogFooterEl"><a class="Button Button--primary" href="https://blog.golang.org/">Read more ></a></div>
+ </section>
+
+ <section class="HomeSection">
+ <h2 class="HomeSection-header">Featured video</h2>
+ <div class="js-videoContainer" style="--aspect-ratio-padding: 58.07%;">
+ <iframe width="415" height="241" src="https://www.youtube.com/embed/rFejpH_tAHM" frameborder="0" allowfullscreen></iframe>
+ </div>
+ </section>
+ {{end}}
+</div>
+<script>
+(function() {
+ 'use strict';
+
+ window.initFuncs.push(function() {
+ // Set up playground if enabled.
+ if (window.playground) {
+ window.playground({
+ "codeEl": ".js-playgroundCodeEl",
+ "outputEl": ".js-playgroundOutputEl",
+ "runEl": ".js-playgroundRunEl",
+ "shareEl": ".js-playgroundShareEl",
+ "shareRedirect": "//play.golang.org/p/",
+ "toysEl": ".js-playgroundToysEl"
+ });
+
+ // The pre matched below is added by the code above. Style it appropriately.
+ document.querySelector(".js-playgroundOutputEl pre").classList.add("Playground-output");
+ } else {
+ $(".Playground").hide();
+ }
+ });
+
+ {{if not $.GoogleCN}}
+ function readableTime(t) {
+ var m = ["January", "February", "March", "April", "May", "June", "July",
+ "August", "September", "October", "November", "December"];
+ var p = t.substring(0, t.indexOf("T")).split("-");
+ var d = new Date(p[0], p[1]-1, p[2]);
+ return d.getDate() + " " + m[d.getMonth()] + " " + d.getFullYear();
+ }
+
+ window.feedLoaded = function(result) {
+ var read = document.querySelector(".js-blogFooterEl");
+ for (var i = 0; i < result.length && i < 2; i++) {
+ var entry = result[i];
+ var header = document.createElement("h3");
+ header.className = "Blog-title";
+ var titleLink = document.createElement("a");
+ titleLink.href = entry.Link;
+ titleLink.rel = "noopener";
+ titleLink.textContent = entry.Title;
+ header.appendChild(titleLink);
+ read.parentNode.insertBefore(header, read);
+ var extract = document.createElement("div");
+ extract.className = "Blog-extract";
+ extract.innerHTML = entry.Summary;
+ // Ensure any cross-origin links have rel=noopener set.
+ var links = extract.querySelectorAll("a");
+ for (var j = 0; j < links.length; j++) {
+ links[j].rel = "noopener";
+ links[j].classList.add("Blog-link");
+ }
+ read.parentNode.insertBefore(extract, read);
+ var when = document.createElement("div");
+ when.className = "Blog-when";
+ when.textContent = "Published " + readableTime(entry.Time);
+ read.parentNode.insertBefore(when, read);
+ }
+ }
+
+ window.initFuncs.push(function() {
+ // Load blog feed.
+ $("<script/>")
+ .attr("src", "//blog.golang.org/.json?jsonp=feedLoaded")
+ .appendTo("body");
+
+ // Set the video at random.
+ var videos = [
+ {
+ s: "https://www.youtube.com/embed/rFejpH_tAHM",
+ title: "dotGo 2015 - Rob Pike - Simplicity is Complicated",
+ },
+ {
+ s: "https://www.youtube.com/embed/0ReKdcpNyQg",
+ title: "GopherCon 2015: Robert Griesemer - The Evolution of Go",
+ },
+ {
+ s: "https://www.youtube.com/embed/sX8r6zATHGU",
+ title: "Steve Francia - Go: building on the shoulders of giants and stepping on a few toes",
+ },
+ {
+ s: "https://www.youtube.com/embed/rWJHbh6qO_Y",
+ title: "Brad Fitzpatrick Go 1.11 and beyond",
+ },
+ {
+ s: "https://www.youtube.com/embed/bmZNaUcwBt4",
+ title: "The Why of Go",
+ },
+ {
+ s: "https://www.youtube.com/embed/0Zbh_vmAKvk",
+ title: "GopherCon 2017: Russ Cox - The Future of Go",
+ },
+ ];
+ var v = videos[Math.floor(Math.random()*videos.length)];
+ $(".js-videoContainer iframe").attr("src", v.s).attr("title", v.title);
+ });
+ {{end}} {{/* if not .GoogleCN */}}
+})();
+</script>
diff --git a/_content/doc/security.html b/_content/doc/security.html
new file mode 100644
index 0000000..5fc1412
--- /dev/null
+++ b/_content/doc/security.html
@@ -0,0 +1,182 @@
+<!--{
+ "Title": "Go Security Policy",
+ "Path": "/security"
+}-->
+
+<h2>Implementation</h2>
+
+<h3>Reporting a Security Bug</h3>
+
+<p>
+Please report to us any issues you find.
+This document explains how to do that and what to expect in return.
+</p>
+
+<p>
+All security bugs in the Go distribution should be reported by email to
+<a href="mailto:security@golang.org">security@golang.org</a>.
+This mail is delivered to a small security team.
+Your email will be acknowledged within 24 hours, and you'll receive a more
+detailed response to your email within 72 hours indicating the next steps in
+handling your report.
+</p>
+
+<p>
+To ensure your report is not marked as spam, please include the word "vulnerability"
+anywhere in your email. Please use a descriptive subject line for your report email.
+</p>
+
+<p>
+After the initial reply to your report, the security team will endeavor to keep
+you informed of the progress being made towards a fix and full announcement.
+These updates will be sent at least every five days.
+In reality, this is more likely to be every 24-48 hours.
+</p>
+
+<p>
+If you have not received a reply to your email within 48 hours or you have not
+heard from the security team for the past five days please contact the Go
+security team directly:
+</p>
+
+<ul>
+<li>Primary security coordinator: <a href="mailto:filippo@golang.org">Filippo Valsorda</a>.</li>
+<li>Secondary coordinator: <a href="mailto:agl@golang.org">Adam Langley</a>.</li>
+<li>If you receive no response, mail <a href="mailto:golang-dev@googlegroups.com">golang-dev@googlegroups.com</a> or use the <a href="https://groups.google.com/forum/#!forum/golang-dev">golang-dev web interface</a>.</li>
+</ul>
+
+<p>
+Please note that golang-dev is a public discussion forum.
+When escalating on this list, please do not disclose the details of the issue.
+Simply state that you're trying to reach a member of the security team.
+</p>
+
+<h3>Flagging Existing Issues as Security-related</h3>
+
+<p>
+If you believe that an <a href="https://golang.org/issue">existing issue</a>
+is security-related, we ask that you send an email to
+<a href="mailto:security@golang.org">security@golang.org</a>.
+The email should include the issue ID and a short description of why it should
+be handled according to this security policy.
+</p>
+
+<h3>Disclosure Process</h3>
+
+<p>The Go project uses the following disclosure process:</p>
+
+<ol>
+<li>Once the security report is received it is assigned a primary handler.
+This person coordinates the fix and release process.</li>
+<li>The issue is confirmed and a list of affected software is determined.</li>
+<li>Code is audited to find any potential similar problems.</li>
+<li>If it is determined, in consultation with the submitter, that a CVE-ID is
+required, the primary handler obtains one via email to
+<a href="https://oss-security.openwall.org/wiki/mailing-lists/distros">oss-distros</a>.</li>
+<li>Fixes are prepared for the two most recent major releases and the head/master
+revision. These fixes are not yet committed to the public repository.</li>
+<li>A notification is sent to the
+<a href="https://groups.google.com/group/golang-announce">golang-announce</a>
+mailing list to give users time to prepare their systems for the update.</li>
+<li>Three working days following this notification, the fixes are applied to
+the <a href="https://go.googlesource.com/go">public repository</a> and a new
+Go release is issued.</li>
+<li>On the date that the fixes are applied, announcements are sent to
+<a href="https://groups.google.com/group/golang-announce">golang-announce</a>,
+<a href="https://groups.google.com/group/golang-dev">golang-dev</a>, and
+<a href="https://groups.google.com/group/golang-nuts">golang-nuts</a>.
+</ol>
+
+<p>
+This process can take some time, especially when coordination is required with
+maintainers of other projects. Every effort will be made to handle the bug in
+as timely a manner as possible, however it's important that we follow the
+process described above to ensure that disclosures are handled consistently.
+</p>
+
+<p>
+For security issues that include the assignment of a CVE-ID,
+the issue is listed publicly under the
+<a href="https://www.cvedetails.com/vulnerability-list/vendor_id-14185/Golang.html">"Golang" product on the CVEDetails website</a>
+as well as the
+<a href="https://web.nvd.nist.gov/view/vuln/search">National Vulnerability Disclosure site</a>.
+</p>
+
+<h3>Receiving Security Updates</h3>
+
+<p>
+The best way to receive security announcements is to subscribe to the
+<a href="https://groups.google.com/forum/#!forum/golang-announce">golang-announce</a>
+mailing list. Any messages pertaining to a security issue will be prefixed
+with <code>[security]</code>.
+</p>
+
+<h3>Comments on This Policy</h3>
+
+<p>
+If you have any suggestions to improve this policy, please send an email to
+<a href="mailto:golang-dev@golang.org">golang-dev@golang.org</a> for discussion.
+</p>
+
+<h3>PGP Key for <a href="mailto:security@golang.org">security@golang.org</a></h3>
+
+<p>
+We accept PGP-encrypted email, but the majority of the security team
+are not regular PGP users so it's somewhat inconvenient. Please only
+use PGP for critical security reports.
+</p>
+
+<pre>
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+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+=Nx85
+-----END PGP PUBLIC KEY BLOCK-----
+</pre>
diff --git a/_content/doc/share.png b/_content/doc/share.png
new file mode 100644
index 0000000..c04f0c7
--- /dev/null
+++ b/_content/doc/share.png
Binary files differ
diff --git a/_content/doc/tos.html b/_content/doc/tos.html
new file mode 100644
index 0000000..fff4642
--- /dev/null
+++ b/_content/doc/tos.html
@@ -0,0 +1,11 @@
+<!--{
+ "Title": "Terms of service"
+}-->
+
+<p>
+The Go website (the "Website") is hosted by Google.
+By using and/or visiting the Website, you consent to be bound by Google's general
+<a href="//www.google.com/intl/en/policies/terms/">Terms of Service</a>
+and Google's general
+<a href="//www.google.com/intl/en/privacy/privacy-policy.html">Privacy Policy</a>.
+</p>
diff --git a/_content/doc/tutorial/add-a-test.html b/_content/doc/tutorial/add-a-test.html
new file mode 100644
index 0000000..7dc5d80
--- /dev/null
+++ b/_content/doc/tutorial/add-a-test.html
@@ -0,0 +1,210 @@
+<!--{
+ "Title": "Add a test"
+}-->
+
+<p>
+ Now that you've gotten your code to a stable place (nicely done, by the way),
+ add a test. Testing your code during development can expose bugs that find
+ their way in as you make changes. In this topic, you add a test for the
+ <code>Hello</code> function.
+</p>
+
+<aside class="Note">
+ <strong>Note:</strong> This topic is part of a multi-part tutorial that begins
+ with <a href="/doc/tutorial/create-module.html">Create a Go module</a>.
+</aside>
+
+<p>
+ Go's built-in support for unit testing makes it easier to test as you go.
+ Specifically, using naming conventions, Go's <code>testing</code> package, and
+ the <code>go test</code> command, you can quickly write and execute tests.
+</p>
+
+<ol>
+ <li>
+ In the greetings directory, create a file called greetings_test.go.
+
+ <p>
+ Ending a file's name with _test.go tells the <code>go test</code> command
+ that this file contains test functions.
+ </p>
+ </li>
+
+ <li>
+ In greetings_test.go, paste the following code and save the file.
+
+ <pre>
+package greetings
+
+import (
+ "testing"
+ "regexp"
+)
+
+// TestHelloName calls greetings.Hello with a name, checking
+// for a valid return value.
+func TestHelloName(t *testing.T) {
+ name := "Gladys"
+ want := regexp.MustCompile(`\b`+name+`\b`)
+ msg, err := Hello("Gladys")
+ if !want.MatchString(msg) || err != nil {
+ t.Fatalf(`Hello("Gladys") = %q, %v, want match for %#q, nil`, msg, err, want)
+ }
+}
+
+// TestHelloEmpty calls greetings.Hello with an empty string,
+// checking for an error.
+func TestHelloEmpty(t *testing.T) {
+ msg, err := Hello("")
+ if msg != "" || err == nil {
+ t.Fatalf(`Hello("") = %q, %v, want "", error`, msg, err)
+ }
+}
+</pre
+ >
+
+ <p>
+ In this code, you:
+ </p>
+
+ <ul>
+ <li>
+ Implement test functions in the same package as the code you're testing.
+ </li>
+ <li>
+ Create two test functions to test the <code>greetings.Hello</code>
+ function. Test function names have the form <code>Test<em>Name</em></code>,
+ where <em>Name</em> says something about the specific test. Also, test
+ functions take a pointer to the <code>testing</code> package's
+ <a href="https://pkg.go.dev/testing/#T"><code>testing.T</code>
+ type</a> as a parameter. You use this parameter's methods for reporting
+ and logging from your test.
+ </li>
+ <li>
+ Implement two tests:
+
+ <ul>
+ <li>
+ <code>TestHelloName</code> calls the <code>Hello</code> function,
+ passing a <code>name</code> value with which the function should be
+ able to return a valid response message. If the call returns an
+ error or an unexpected response message (one that doesn't include
+ the name you passed in), you use the <code>t</code> parameter's
+ <a href="https://pkg.go.dev/testing/#T.Fatalf">
+ <code>Fatalf</code> method</a> to print a message to the console
+ and end execution.
+ </li>
+ <li>
+ <code>TestHelloEmpty</code> calls the <code>Hello</code> function
+ with an empty string. This test is designed to confirm that your
+ error handling works. If the call returns a non-empty string or no
+ error, you use the <code>t</code> parameter's <code>Fatalf</code>
+ method to print a message to the console and end execution.
+ </li>
+ </ul>
+ </li>
+ </ul>
+ </li>
+
+ <li>
+ At the command line in the greetings directory, run the
+ <a href="/cmd/go/#hdr-Test_packages"
+ ><code>go test</code> command</a
+ >
+ to execute the test.
+
+ <p>
+ The <code>go test</code> command executes test functions (whose names
+ begin with <code>Test</code>) in test files (whose names end with
+ _test.go). You can add the <code>-v</code> flag to get verbose output that
+ lists all of the tests and their results.
+ </p>
+
+ <p>
+ The tests should pass.
+ </p>
+
+ <pre>
+$ go test
+PASS
+ok example.com/greetings 0.364s
+
+$ go test -v
+=== RUN TestHelloName
+--- PASS: TestHelloName (0.00s)
+=== RUN TestHelloEmpty
+--- PASS: TestHelloEmpty (0.00s)
+PASS
+ok example.com/greetings 0.372s
+</pre
+ >
+ </li>
+
+ <li>
+ Break the <code>greetings.Hello</code> function to view a failing test.
+
+ <p>
+ The <code>TestHelloName</code> test function checks the return value for
+ the name you specified as a <code>Hello</code> function parameter. To view
+ a failing test result, change the <code>greetings.Hello</code> function so
+ that it no longer includes the name.
+ </p>
+
+ <p>
+ In greetings/greetings.go, paste the following code in place of the
+ <code>Hello</code> function. Note that the highlighted lines change the
+ value that the function returns, as if the <code>name</code> argument had
+ been accidentally removed.
+ </p>
+
+ <pre>
+// Hello returns a greeting for the named person.
+func Hello(name string) (string, error) {
+ // If no name was given, return an error with a message.
+ if name == "" {
+ return name, errors.New("empty name")
+ }
+ // Create a message using a random format.
+ <ins>// message := fmt.Sprintf(randomFormat(), name)
+ message := fmt.Sprint(randomFormat())</ins>
+ return message, nil
+}
+</pre>
+ </li>
+
+ <li>
+ At the command line in the greetings directory, run <code>go test</code> to
+ execute the test.
+
+ <p>
+ This time, run <code>go test</code> without the <code>-v</code> flag. The
+ output will include results for only the tests that failed, which can be
+ useful when you have a lot of tests. The <code>TestHelloName</code> test
+ should fail -- <code>TestHelloEmpty</code> still passes.
+ </p>
+
+ <pre>
+$ go test
+--- FAIL: TestHelloName (0.00s)
+ greetings_test.go:15: Hello("Gladys") = "Hail, %v! Well met!", <nil>, want match for `\bGladys\b`, nil
+FAIL
+exit status 1
+FAIL example.com/greetings 0.182s
+</pre
+ >
+ </li>
+</ol>
+
+<p>
+ In the next (and last) topic, you'll see how to compile and install your code
+ to run it locally.
+</p>
+
+<p class="Navigation">
+ <a class="Navigation-prev" href="/doc/tutorial/greetings-multiple-people.html"
+ >< Return greetings for multiple people</a
+ >
+ <a class="Navigation-next" href="/doc/tutorial/compile-install.html"
+ >Compile and install the application ></a
+ >
+</p>
diff --git a/_content/doc/tutorial/call-module-code.html b/_content/doc/tutorial/call-module-code.html
new file mode 100644
index 0000000..1a63d8c
--- /dev/null
+++ b/_content/doc/tutorial/call-module-code.html
@@ -0,0 +1,240 @@
+<!--{
+ "Title": "Call your code from another module"
+}-->
+
+<p>
+ In the <a href="/doc/tutorial/create-module.html">previous section</a>, you created a
+ <code>greetings</code> module. In this section, you'll write code to make
+ calls to the <code>Hello</code> function in the module you just wrote. You'll
+ write code you can execute as an application, and which calls code in the
+ <code>greetings</code> module.
+</p>
+
+<aside class="Note">
+ <strong>Note:</strong> This topic is part of a multi-part tutorial that begins
+ with <a href="/doc/tutorial/create-module.html">Create a Go module</a>.
+</aside>
+
+<ol>
+ <li>
+ Create a <code>hello</code> directory for your Go module source code. This
+ is where you'll write your caller.
+
+ <p>
+ After you create this directory, you should have both a hello and a
+ greetings directory at the same level in the hierarchy, like so:
+ </p>
+ <pre><home>/
+ |-- greetings/
+ |-- hello/</pre>
+
+ <p>
+ For example, if your command prompt is in the greetings directory, you
+ could use the following commands:
+ </p>
+
+ <pre>
+cd ..
+mkdir hello
+cd hello
+</pre
+ >
+ </li>
+
+ <li>
+ Enable dependency tracking for the code you're about to write.
+
+ <p>
+ To enable dependency tracking for your code, run the
+ <a
+ href="/ref/mod#go-mod-init"
+ ><code>go mod init</code> command</a>, giving it the name of the module
+ your code will be in.</p>
+
+ <p>
+ For the purposes of this tutorial, use <code>example.com/hello</code>
+ for the module path.
+ </p>
+
+ <pre>
+$ go mod init example.com/hello
+go: creating new go.mod: module example.com/hello
+</pre>
+ </li>
+
+ <li>
+ In your text editor, in the hello directory, create a file in which to
+ write your code and call it hello.go.
+ </li>
+
+ <li>
+ Write code to call the <code>Hello</code> function, then print the
+ function's return value.
+
+ <p>
+ To do that, paste the following code into hello.go.
+ </p>
+
+ <pre>
+package main
+
+import (
+ "fmt"
+
+ "example.com/greetings"
+)
+
+func main() {
+ // Get a greeting message and print it.
+ message := greetings.Hello("Gladys")
+ fmt.Println(message)
+}
+</pre>
+
+ <p>
+ In this code, you:
+ </p>
+
+ <ul>
+ <li>
+ Declare a <code>main</code> package. In Go, code executed as an
+ application must be in a <code>main</code> package.
+ </li>
+ <li>
+ Import two packages: <code>example.com/greetings</code> and
+ the <a href="https://pkg.go.dev/fmt/"><code>fmt</code> package</a>. This
+ gives your code access to functions in those packages. Importing
+ <code>example.com/greetings</code> (the package contained in the module
+ you created earlier) gives you access to the <code>Hello</code>
+ function. You also import <code>fmt</code>, with functions for handling
+ input and output text (such as printing text to the console).
+ </li>
+ <li>
+ Get a greeting by calling the <code>greetings</code> package’s
+ <code>Hello</code> function.
+ </li>
+ </ul>
+ </li>
+
+ <li>
+ Edit the <code>example.com/hello</code> module to use your local
+ <code>example.com/greetings</code> module.
+
+ <p>
+ For production use, you’d publish the <code>example.com/greetings</code>
+ module from its repository (with a module path that reflected its published
+ location), where Go tools could find it to download it.
+ For now, because you haven't published the module yet, you need to adapt
+ the <code>example.com/hello</code> module so it can find the
+ <code>example.com/greetings</code> code on your local file system.
+ </p>
+
+ <p>
+ To do that, use the
+ <a href="/ref/mod#go-mod-edit"><code>go
+ mod edit</code> command</a> to edit the <code>example.com/hello</code>
+ module to redirect Go tools from its module path (where the module isn't)
+ to the local directory (where it is).
+ </p>
+
+ <ol>
+ <li>
+ From the command prompt in the hello directory, run the following
+ command:
+
+ <pre>
+$ go mod edit -replace=example.com/greetings=../greetings
+</pre>
+
+ <p>
+ The command specifies that <code>example.com/greetings</code> should be
+ replaced with <code>../greetings</code> for the purpose of locating the
+ dependency. After you run the command, the go.mod file in the hello
+ directory should include a <a href="/doc/modules/gomod-ref#replace">
+ <code>replace</code> directive</a>:
+ </p>
+
+ <pre>
+module example.com/hello
+
+go 1.16
+
+<ins>replace example.com/greetings => ../greetings</ins>
+</pre>
+ </li>
+
+ <li>
+ From the command prompt in the hello directory, run the
+ <a href="/ref/mod#go-mod-tidy">
+ <code>go mod tidy</code> command</a> to synchronize the
+ <code>example.com/hello</code> module's dependencies, adding those
+ required by the code, but not yet tracked in the module.
+
+ <pre>$ go mod tidy
+go: found example.com/greetings in example.com/greetings v0.0.0-00010101000000-000000000000
+</pre>
+ <p>
+ After the command completes, the <code>example.com/hello</code>
+ module's go.mod file should look like this:
+ </p>
+
+ <pre>module example.com/hello
+
+go 1.16
+
+replace example.com/greetings => ../greetings
+
+<ins>require example.com/greetings v0.0.0-00010101000000-000000000000</ins></pre>
+
+ <p>
+ The command found the local code in the greetings directory, then
+ added a <a href="/doc/modules/gomod-ref#require"><code>require</code>
+ directive</a> to specify that <code>example.com/hello</code>
+ requires <code>example.com/greetings</code>. You created this
+ dependency when you imported the <code>greetings</code> package in
+ hello.go.
+ </p>
+ <p>
+ The number following the module path is a <em>pseudo-version number</em>
+ -- a generated number used in place of a semantic version number (which
+ the module doesn't have yet).
+ </p>
+ <p>
+ To reference a <em>published</em> module, a go.mod file would
+ typically omit the <code>replace</code> directive and use a
+ <code>require</code> directive with a tagged version number at the end.
+ </p>
+
+ <pre>require example.com/greetings v1.1.0</pre>
+
+ <p>For more on version numbers, see
+ <a href="/doc/modules/version-numbers">Module version numbering</a>.</p>
+ </li>
+ </ol>
+ <li>
+ At the command prompt in the <code>hello</code> directory, run your code to
+ confirm that it works.
+
+ <pre>
+$ go run .
+Hi, Gladys. Welcome!
+</pre>
+ </li>
+</ol>
+
+<p>
+ Congrats! You've written two functioning modules.
+</p>
+
+<p>
+ In the next topic, you'll add some error handling.
+</p>
+
+<p class="Navigation">
+ <a class="Navigation-prev" href="/doc/tutorial/create-module.html"
+ >< Create a Go module</a
+ >
+ <a class="Navigation-next" href="/doc/tutorial/handle-errors.html"
+ >Return and handle an error ></a
+ >
+</p>
diff --git a/_content/doc/tutorial/compile-install.html b/_content/doc/tutorial/compile-install.html
new file mode 100644
index 0000000..330f645
--- /dev/null
+++ b/_content/doc/tutorial/compile-install.html
@@ -0,0 +1,179 @@
+<!--{
+ "Title": "Compile and install the application"
+}-->
+
+<p>
+ In this last topic, you'll learn a couple new <code>go</code> commands. While
+ the <code>go run</code> command is a useful shortcut for compiling and running
+ a program when you're making frequent changes, it doesn't generate a binary
+ executable.</p>
+
+<p>
+ This topic introduces two additional commands for building code:
+</p>
+
+<ul>
+ <li>
+ The <a href="/cmd/go/#hdr-Compile_packages_and_dependencies"><code>go
+ build</code> command</a> compiles the packages, along with their dependencies,
+ but it doesn't install the results.
+ </li>
+ <li>
+ The <a href="/ref/mod#go-install"><code>go
+ install</code> command</a> compiles and installs the packages.
+ </li>
+</ul>
+
+<aside class="Note">
+ <strong>Note:</strong> This topic is part of a multi-part tutorial that begins
+ with <a href="create-module.html">Create a Go module</a>.
+</aside>
+
+<ol>
+ <li>
+ From the command line in the hello directory, run the <code>go build</code>
+ command to compile the code into an executable.
+
+ <pre>$ go build</pre>
+ </li>
+
+ <li>
+ From the command line in the hello directory, run the new <code>hello</code>
+ executable to confirm that the code works.
+
+ <p>
+ Note that your result might differ depending on whether you changed
+ your greetings.go code after testing it.
+ </p>
+
+ <ul>
+ <li>
+ On Linux or Mac:
+
+ <pre>
+$ ./hello
+map[Darrin:Great to see you, Darrin! Gladys:Hail, Gladys! Well met! Samantha:Hail, Samantha! Well met!]
+</pre>
+ </li>
+
+ <li>
+ On Windows:
+
+ <pre>
+$ hello.exe
+map[Darrin:Great to see you, Darrin! Gladys:Hail, Gladys! Well met! Samantha:Hail, Samantha! Well met!]
+</pre>
+ </li>
+ </ul>
+ <p>
+ You've compiled the application into an executable so you can run it.
+ But to run it currently, your prompt needs either to be in the executable's
+ directory, or to specify the executable's path.
+ </p>
+ <p>
+ Next, you'll install the executable so you can run it without specifying
+ its path.
+ </p>
+ </li>
+
+ <li>
+ Discover the Go install path, where the <code>go</code> command will install
+ the current package.
+
+ <p>
+ You can discover the install path by running the
+ <a href="/cmd/go/#hdr-List_packages_or_modules">
+ <code>go list</code> command</a>, as in the following example:
+ </p>
+
+ <pre>
+$ go list -f '{{.Target}}'
+</pre>
+
+ <p>
+ For example, the command's output might say <code>/home/gopher/bin/hello</code>,
+ meaning that binaries are installed to /home/gopher/bin. You'll need this
+ install directory in the next step.
+ </p>
+ </li>
+
+ <li>
+ Add the Go install directory to your system's shell path.
+
+ <p>
+ That way, you'll be able to run your program's executable without
+ specifying where the executable is.
+ </p>
+
+ <ul>
+ <li>
+ On Linux or Mac, run the following command:
+
+ <pre>
+$ export PATH=$PATH:/path/to/your/install/directory
+</pre
+ >
+ </li>
+
+ <li>
+ On Windows, run the following command:
+
+ <pre>
+$ set PATH=%PATH%;C:\path\to\your\install\directory
+</pre
+ >
+ </li>
+ </ul>
+
+ <p>
+ As an alternative, if you already have a directory like
+ <code>$HOME/bin</code> in your shell path and you'd like to install your
+ Go programs there, you can change the install target by setting the
+ <code>GOBIN</code> variable using the
+ <a href="/cmd/go/#hdr-Print_Go_environment_information">
+ <code>go env</code> command</a>:
+ </p>
+
+ <pre>
+$ go env -w GOBIN=/path/to/your/bin
+</pre>
+
+ <p>
+ or
+ </p>
+
+ <pre>
+$ go env -w GOBIN=C:\path\to\your\bin
+</pre
+ >
+ </li>
+
+ <li>
+ Once you've updated the shell path, run the <code>go install</code> command
+ to compile and install the package.
+
+ <pre>$ go install</pre>
+ </li>
+
+ <li>
+ Run your application by simply typing its name. To make this interesting,
+ open a new command prompt and run the <code>hello</code> executable name
+ in some other directory.
+
+ <pre>
+$ hello
+map[Darrin:Hail, Darrin! Well met! Gladys:Great to see you, Gladys! Samantha:Hail, Samantha! Well met!]
+</pre
+ >
+ </li>
+</ol>
+
+<p>
+ That wraps up this Go tutorial!
+</p>
+
+<p class="Navigation">
+ <a class="Navigation-prev" href="add-a-test.html">< Add a test</a>
+ <a class="Navigation-next" href="module-conclusion.html">Conclusion and links
+ to more information ></a>
+</p>
diff --git a/_content/doc/tutorial/create-module.html b/_content/doc/tutorial/create-module.html
new file mode 100644
index 0000000..e9df336
--- /dev/null
+++ b/_content/doc/tutorial/create-module.html
@@ -0,0 +1,257 @@
+<!--{
+ "Title": "Tutorial: Create a Go module"
+}-->
+
+<p>
+ This is the first part of a tutorial that introduces a few fundamental
+ features of the Go language. If you're just getting started with Go, be sure
+ to take a look at
+ <a href="/doc/tutorial/getting-started.html">Tutorial: Get started with Go</a>, which introduces
+ the <code>go</code> command, Go modules, and very simple Go code.
+</p>
+
+<p>
+ In this tutorial you'll create two modules. The first is a library which is
+ intended to be imported by other libraries or applications. The second is a
+ caller application which will use the first.
+</p>
+
+<p>
+ This tutorial's sequence includes seven brief topics that each illustrate a
+ different part of the language.
+</p>
+
+<ol>
+ <li>
+ Create a module -- Write a small module with functions you can call from
+ another module.
+ </li>
+ <li>
+ <a href="/doc/tutorial/call-module-code.html">Call your code from another module</a> --
+ Import and use your new module.
+ </li>
+ <li>
+ <a href="/doc/tutorial/handle-errors.html">Return and handle an error</a> -- Add simple
+ error handling.
+ </li>
+ <li>
+ <a href="/doc/tutorial/random-greeting.html">Return a random greeting</a> -- Handle data
+ in slices (Go's dynamically-sized arrays).
+ </li>
+ <li>
+ <a href="/doc/tutorial/greetings-multiple-people.html"
+ >Return greetings for multiple people</a
+ >
+ -- Store key/value pairs in a map.
+ </li>
+ <li>
+ <a href="/doc/tutorial/add-a-test.html">Add a test</a> -- Use Go's built-in unit testing
+ features to test your code.
+ </li>
+ <li>
+ <a href="/doc/tutorial/compile-install.html">Compile and install the application</a> --
+ Compile and install your code locally.
+ </li>
+</ol>
+
+<aside class="Note">
+ <strong>Note:</strong> For other tutorials, see
+ <a href="/doc/tutorial/index.html">Tutorials</a>.
+</aside>
+
+<h2 id="prerequisites">Prerequisites</h2>
+
+<ul>
+ <li>
+ <strong>Some programming experience.</strong> The code here is pretty
+ simple, but it helps to know something about functions, loops, and arrays.
+ </li>
+ <li>
+ <strong>A tool to edit your code.</strong> Any text editor you have will
+ work fine. Most text editors have good support for Go. The most popular are
+ VSCode (free), GoLand (paid), and Vim (free).
+ </li>
+ <li>
+ <strong>A command terminal.</strong> Go works well using any terminal on
+ Linux and Mac, and on PowerShell or cmd in Windows.
+ </li>
+</ul>
+
+<h2 id="start">Start a module that others can use</h2>
+
+<p>
+ Start by creating a Go module. In a
+ module, you collect one or more related packages for a discrete and useful set
+ of functions. For example, you might create a module with packages that have
+ functions for doing financial analysis so that others writing financial
+ applications can use your work. For more about developing modules, see
+ <a href="/doc/modules/developing">Developing and publishing modules</a>.
+</p>
+
+<p>
+ Go code is grouped into packages, and packages are grouped into modules. Your
+ module specifies dependencies needed to run your code, including the Go
+ version and the set of other modules it requires.
+</p>
+
+<p>
+ As you add or improve functionality in your module, you publish new versions
+ of the module. Developers writing code that calls functions in your module can
+ import the module's updated packages and test with the new version before
+ putting it into production use.
+</p>
+
+<ol>
+ <li>
+ Open a command prompt and <code>cd</code> to your home directory.
+
+ <p>
+ On Linux or Mac:
+ </p>
+
+ <pre>
+cd
+</pre
+ >
+
+ <p>
+ On Windows:
+ </p>
+
+ <pre>
+cd %HOMEPATH%
+</pre
+ >
+ </li>
+
+ <li>
+ Create a <code>greetings</code> directory for your Go module source code.
+
+ <p>
+ For example, from your home directory use the following commands:
+ </p>
+
+ <pre>
+mkdir greetings
+cd greetings
+</pre
+ >
+ </li>
+
+ <li>
+ Start your module using the
+ <a
+ href="/ref/mod#go-mod-init"
+ ><code>go mod init</code> command</a
+ >.
+
+ <p>
+ Run the <code>go mod init</code> command, giving it your module path --
+ here, use <code>example.com/greetings</code>. If you publish a module,
+ this <em>must</em> be a path from which your module can be downloaded by
+ Go tools. That would be your code's repository.
+ </p>
+
+ <pre>
+$ go mod init example.com/greetings
+go: creating new go.mod: module example.com/greetings
+</pre
+ >
+
+ <p>
+ The <code>go mod init</code> command creates a go.mod file to track your
+ code's dependencies. So far, the file includes only the name of your
+ module and the Go version your code supports. But as you add dependencies,
+ the go.mod file will list the versions your code depends on. This keeps
+ builds reproducible and gives you direct control over which module
+ versions to use.
+ </p>
+ </li>
+
+ <li>
+ In your text editor, create a file in which to write your code and call it
+ greetings.go.
+ </li>
+
+ <li>
+ Paste the following code into your greetings.go file and save the file.
+
+ <pre>
+package greetings
+
+import "fmt"
+
+// Hello returns a greeting for the named person.
+func Hello(name string) string {
+ // Return a greeting that embeds the name in a message.
+ message := fmt.Sprintf("Hi, %v. Welcome!", name)
+ return message
+}
+</pre
+ >
+
+ <p>
+ This is the first code for your module. It returns a greeting to any
+ caller that asks for one. You'll write code that calls this function in
+ the next step.
+ </p>
+
+ <p>
+ In this code, you:
+ </p>
+
+ <ul>
+ <li>
+ Declare a <code>greetings</code> package to collect related functions.
+ </li>
+ <li>
+ Implement a <code>Hello</code> function to return the greeting.
+ <p>
+ This function takes a <code>name</code> parameter whose type is
+ <code>string</code>. The function also returns a <code>string</code>.
+ In Go, a function whose name starts with a capital letter can be
+ called by a function not in the same package. This is known in Go as
+ an exported name. For more about exported names, see
+ <a href="https://tour.golang.org/basics/3">Exported names</a> in the
+ Go tour.
+ </p>
+ <img src="images/function-syntax.png" width="300px" />
+ </li>
+
+ <li>
+ Declare a <code>message</code> variable to hold your greeting.
+ <p>
+ In Go, the <code>:=</code> operator is a shortcut for declaring and
+ initializing a variable in one line (Go uses the value on the right to
+ determine the variable's type). Taking the long way, you might have
+ written this as:
+ </p>
+ <pre>
+var message string
+message = fmt.Sprintf("Hi, %v. Welcome!", name)
+</pre
+ >
+ </li>
+
+ <li>
+ Use the <code>fmt</code> package's <a href="https://pkg.go.dev/fmt/#Sprintf">
+ <code>Sprintf</code> function</a> to create a greeting message. The
+ first argument is a format string, and <code>Sprintf</code> substitutes
+ the <code>name</code> parameter's value for the <code>%v</code> format
+ verb. Inserting the value of the <code>name</code> parameter completes
+ the greeting text.
+ </li>
+ <li>Return the formatted greeting text to the caller.</li>
+ </ul>
+ </li>
+</ol>
+
+<p>
+ In the next step, you'll call this function from another module.
+</p>
+
+<p class="Navigation">
+ <a class="Navigation-next" href="/doc/tutorial/call-module-code.html"
+ >Call your code from another module ></a
+ >
+</p>
diff --git a/_content/doc/tutorial/getting-started.html b/_content/doc/tutorial/getting-started.html
new file mode 100644
index 0000000..43e23d9
--- /dev/null
+++ b/_content/doc/tutorial/getting-started.html
@@ -0,0 +1,304 @@
+<!--{
+ "Title": "Tutorial: Get started with Go"
+}-->
+
+<p>
+ In this tutorial, you'll get a brief introduction to Go programming. Along the
+ way, you will:
+</p>
+
+<ul>
+ <li>Install Go (if you haven't already).</li>
+ <li>Write some simple "Hello, world" code.</li>
+ <li>Use the <code>go</code> command to run your code.</li>
+ <li>
+ Use the Go package discovery tool to find packages you can use in your own
+ code.
+ </li>
+ <li>Call functions of an external module.</li>
+</ul>
+
+<aside class="Note">
+ <strong>Note:</strong> For other tutorials, see
+ <a href="/doc/tutorial/index.html">Tutorials</a>.
+</aside>
+
+<h2 id="prerequisites">Prerequisites</h2>
+
+<ul>
+ <li>
+ <strong>Some programming experience.</strong> The code here is pretty
+ simple, but it helps to know something about functions.
+ </li>
+ <li>
+ <strong>A tool to edit your code.</strong> Any text editor you have will
+ work fine. Most text editors have good support for Go. The most popular are
+ VSCode (free), GoLand (paid), and Vim (free).
+ </li>
+ <li>
+ <strong>A command terminal.</strong> Go works well using any terminal on
+ Linux and Mac, and on PowerShell or cmd in Windows.
+ </li>
+</ul>
+
+<h2 id="install">Install Go</h2>
+
+<p>Just use the <a href="/doc/install">Download and install</a> steps.</p>
+
+<h2 id="code">Write some code</h2>
+
+<p>
+ Get started with Hello, World.
+</p>
+
+<ol>
+ <li>
+ Open a command prompt and cd to your home directory.
+
+ <p>
+ On Linux or Mac:
+ </p>
+
+ <pre>
+cd
+</pre
+ >
+
+ <p>
+ On Windows:
+ </p>
+
+ <pre>
+cd %HOMEPATH%
+</pre
+ >
+ </li>
+
+ <li>
+ Create a hello directory for your first Go source code.
+
+ <p>
+ For example, use the following commands:
+ </p>
+
+ <pre>
+mkdir hello
+cd hello
+</pre
+ >
+ </li>
+
+ <li>
+ Enable dependency tracking for your code.
+
+ <p>
+ When your code imports packages contained in other modules, you manage
+ those dependencies through your code's own module. That module is defined
+ by a go.mod file that tracks the modules that provide those packages. That
+ go.mod file stays with your code, including in your source code
+ repository.
+ </p>
+
+ <p>
+ To enable dependency tracking for your code by creating a go.mod file, run
+ the
+ <a href="/ref/mod#go-mod-init"><code>go mod init</code> command</a>,
+ giving it the name of the module your code will be in. The name is the
+ module's module path. In most cases, this will be the repository
+ location where your source code will be kept, such as
+ <code>github.com/mymodule</code>. If you plan to publish your module
+ for others to use, the module path <em>must</em> be a location from
+ which Go tools can download your module.
+ </p>
+
+ <p>For the purposes of this tutorial, just use
+ <code>example.com/hello</code>.
+ </p>
+
+ <pre>
+$ go mod init example.com/hello
+go: creating new go.mod: module example.com/hello
+</pre
+ >
+ </li>
+
+ <li>
+ In your text editor, create a file hello.go in which to write your code.
+ </li>
+
+ <li>
+ Paste the following code into your hello.go file and save the file.
+
+ <pre>
+package main
+
+import "fmt"
+
+func main() {
+ fmt.Println("Hello, World!")
+}
+</pre
+ >
+
+ <p>
+ This is your Go code. In this code, you:
+ </p>
+
+ <ul>
+ <li>
+ Declare a <code>main</code> package (a package is a way to group
+ functions, and it's made up of all the files in the same directory).
+ </li>
+ <li>
+ Import the popular
+ <a href="https://pkg.go.dev/fmt/"><code>fmt</code> package</a>,
+ which contains functions for formatting text, including printing to the
+ console. This package is one of the
+ <a href="https://pkg.go.dev/std">standard library</a> packages you got
+ when you installed Go.
+ </li>
+ <li>
+ Implement a <code>main</code> function to print a message to the
+ console. A <code>main</code> function executes by default when you run
+ the <code>main</code> package.
+ </li>
+ </ul>
+ </li>
+
+ <li>
+ Run your code to see the greeting.
+
+ <pre>
+$ go run .
+Hello, World!
+</pre
+ >
+
+ <p>
+ The
+ <a href="/cmd/go/#hdr-Compile_and_run_Go_program"
+ ><code>go run</code> command</a
+ >
+ is one of many <code>go</code> commands you'll use to get things done with
+ Go. Use the following command to get a list of the others:
+ </p>
+
+ <pre>
+$ go help
+</pre
+ >
+ </li>
+</ol>
+
+<h2 id="call">Call code in an external package</h2>
+
+<p>
+ When you need your code to do something that might have been implemented by
+ someone else, you can look for a package that has functions you can use in
+ your code.
+</p>
+
+<ol>
+ <li>
+ Make your printed message a little more interesting with a function from an
+ external module.
+
+ <ol>
+ <li>
+ Visit pkg.go.dev and
+ <a href="https://pkg.go.dev/search?q=quote"
+ >search for a "quote" package</a
+ >.
+ </li>
+ <li>
+ Locate and click the <code>rsc.io/quote</code> package in search results
+ (if you see <code>rsc.io/quote/v3</code>, ignore it for now).
+ </li>
+ <li>
+ In the <strong>Documentation</strong> section, under <strong>Index</strong>, note the
+ list of functions you can call from your code. You'll use the
+ <code>Go</code> function.
+ </li>
+ <li>
+ At the top of this page, note that package <code>quote</code> is
+ included in the <code>rsc.io/quote</code> module.
+ </li>
+ </ol>
+
+ <p>
+ You can use the pkg.go.dev site to find published modules whose packages
+ have functions you can use in your own code. Packages are published in
+ modules -- like <code>rsc.io/quote</code> -- where others can use them.
+ Modules are improved with new versions over time, and you can upgrade your
+ code to use the improved versions.
+ </p>
+ </li>
+
+ <li>
+ In your Go code, import the <code>rsc.io/quote</code> package and add a call
+ to its <code>Go</code> function.
+
+ <p>
+ After adding the highlighted lines, your code should include the
+ following:
+ </p>
+
+ <pre>
+package main
+
+import "fmt"
+
+<ins>import "rsc.io/quote"</ins>
+
+func main() {
+ <ins>fmt.Println(quote.Go())</ins>
+}
+</pre>
+ </li>
+
+ <li>
+ Add new module requirements and sums.
+
+ <p>
+ Go will add the <code>quote</code> module as a requirement, as well as a
+ go.sum file for use in authenticating the module. For more, see
+ <a href="/ref/mod#authenticating">Authenticating modules</a> in the Go
+ Modules Reference.
+ </p>
+ <pre>
+$ go mod tidy
+go: finding module for package rsc.io/quote
+go: found rsc.io/quote in rsc.io/quote v1.5.2
+</pre
+ >
+ </li>
+
+ <li>
+ Run your code to see the message generated by the function you're calling.
+
+ <pre>
+$ go run .
+Don't communicate by sharing memory, share memory by communicating.
+</pre
+ >
+
+ <p>
+ Notice that your code calls the <code>Go</code> function, printing a
+ clever message about communication.
+ </p>
+
+ <p>
+ When you ran <code>go mod tidy</code>, it located and downloaded the
+ <code>rsc.io/quote</code> module that contains the package you imported.
+ By default, it downloaded the latest version -- v1.5.2.
+ </p>
+ </li>
+</ol>
+
+<h2 id="write-more">Write more code</h2>
+
+<p>
+ With this quick introduction, you got Go installed and learned some of the
+ basics. To write some more code with another tutorial, take a look at
+ <a href="/doc/tutorial/create-module.html">Create a Go module</a>.
+</p>
diff --git a/_content/doc/tutorial/greetings-multiple-people.html b/_content/doc/tutorial/greetings-multiple-people.html
new file mode 100644
index 0000000..52d7f73
--- /dev/null
+++ b/_content/doc/tutorial/greetings-multiple-people.html
@@ -0,0 +1,221 @@
+<!--{
+ "Title": "Return greetings for multiple people"
+}-->
+
+<p>
+ In the last changes you'll make to your module's code, you'll add support for
+ getting greetings for multiple people in one request. In other words, you'll
+ handle a multiple-value input, then pair values in that input with a
+ multiple-value output. To do this, you'll need to pass a set of names to a
+ function that can return a greeting for each of them.
+</p>
+
+<aside class="Note">
+ <strong>Note:</strong> This topic is part of a multi-part tutorial that begins
+ with <a href="/doc/tutorial/create-module.html">Create a Go module</a>.
+</aside>
+
+<p>
+ But there's a hitch. Changing the <code>Hello</code> function's
+ parameter from a single name to a set of names would change the function's
+ signature. If you had already published the <code>example.com/greetings</code>
+ module and users had already written code calling <code>Hello</code>, that
+ change would break their programs.</p>
+
+<p>
+ In this situation, a better choice is to write a new function with a different
+ name. The new function will take multiple parameters. That preserves the old
+ function for backward compatibility.
+</p>
+
+<ol>
+ <li>
+ In greetings/greetings.go, change your code so it looks like the following.
+
+ <pre>
+package greetings
+
+import (
+ "errors"
+ "fmt"
+ "math/rand"
+ "time"
+)
+
+// Hello returns a greeting for the named person.
+func Hello(name string) (string, error) {
+ // If no name was given, return an error with a message.
+ if name == "" {
+ return name, errors.New("empty name")
+ }
+ // Create a message using a random format.
+ message := fmt.Sprintf(randomFormat(), name)
+ return message, nil
+}
+
+<ins>// Hellos returns a map that associates each of the named people
+// with a greeting message.
+func Hellos(names []string) (map[string]string, error) {
+ // A map to associate names with messages.
+ messages := make(map[string]string)
+ // Loop through the received slice of names, calling
+ // the Hello function to get a message for each name.
+ for _, name := range names {
+ message, err := Hello(name)
+ if err != nil {
+ return nil, err
+ }
+ // In the map, associate the retrieved message with
+ // the name.
+ messages[name] = message
+ }
+ return messages, nil
+}</ins>
+
+// Init sets initial values for variables used in the function.
+func init() {
+ rand.Seed(time.Now().UnixNano())
+}
+
+// randomFormat returns one of a set of greeting messages. The returned
+// message is selected at random.
+func randomFormat() string {
+ // A slice of message formats.
+ formats := []string{
+ "Hi, %v. Welcome!",
+ "Great to see you, %v!",
+ "Hail, %v! Well met!",
+ }
+
+ // Return one of the message formats selected at random.
+ return formats[rand.Intn(len(formats))]
+}
+</pre>
+
+ <p>
+ In this code, you:
+ </p>
+
+ <ul>
+ <li>
+ Add a <code>Hellos</code> function whose parameter is a slice of names
+ rather than a single name. Also, you change one of its return types from
+ a <code>string</code> to a <code>map</code> so you can return names
+ mapped to greeting messages.
+ </li>
+ <li>
+ Have the new <code>Hellos</code> function call the existing
+ <code>Hello</code> function. This helps reduce duplication while also
+ leaving both functions in place.
+ </li>
+ <li>
+ Create a <code>messages</code> map to associate each of the
+ received names (as a key) with a generated message (as a value). In Go,
+ you initialize a map with the following syntax:
+ <code>make(map[<em>key-type</em>]<em>value-type</em>)</code>. You have
+ the <code>Hellos</code> function return this map to the caller. For more
+ about maps, see <a href="https://blog.golang.org/maps">Go maps in
+ action</a> on the Go blog.
+ </li>
+ <li>
+ Loop through the names your function received, checking that each has a
+ non-empty value, then associate a message with each. In this
+ <code>for</code> loop, <code>range</code> returns two values: the index
+ of the current item in the loop and a copy of the item's value. You
+ don't need the index, so you use the Go blank identifier (an underscore)
+ to ignore it. For more, see
+ <a href="/doc/effective_go.html#blank">The blank
+ identifier</a> in Effective Go.
+ </li>
+ </ul>
+ </li>
+
+ <li>
+ In your hello/hello.go calling code, pass a slice of names, then print the
+ contents of the names/messages map you get back.
+
+ <p>
+ In hello.go, change your code so it looks like the following.
+ </p>
+
+ <pre>
+package main
+
+import (
+ "fmt"
+ "log"
+
+ "example.com/greetings"
+)
+
+func main() {
+ // Set properties of the predefined Logger, including
+ // the log entry prefix and a flag to disable printing
+ // the time, source file, and line number.
+ log.SetPrefix("greetings: ")
+ log.SetFlags(0)
+
+ <ins>// A slice of names.
+ names := []string{"Gladys", "Samantha", "Darrin"}</ins>
+
+ // Request greeting messages for the names.
+ messages, err := greetings.Hellos(names)
+ if err != nil {
+ log.Fatal(err)
+ }
+ // If no error was returned, print the returned map of
+ // messages to the console.
+ fmt.Println(messages)
+}
+</pre>
+
+ <p>
+ With these changes, you:
+ </p>
+
+ <ul>
+ <li>
+ Create a <code>names</code> variable as a slice type holding three
+ names.
+ </li>
+ <li>
+ Pass the <code>names</code> variable as the argument to the
+ <code>Hellos</code> function.
+ </li>
+ </ul>
+ </li>
+
+ <li>
+ At the command line, change to the directory that contains hello/hello.go,
+ then use <code>go run</code> to confirm that the code works.
+
+ <p>
+ The output should be a string representation of the map associating names
+ with messages, something like the following:
+ </p>
+
+ <pre>
+$ go run .
+map[Darrin:Hail, Darrin! Well met! Gladys:Hi, Gladys. Welcome! Samantha:Hail, Samantha! Well met!]
+</pre
+ >
+ </li>
+</ol>
+
+<p>
+ This topic introduced maps for representing name/value pairs. It also
+ introduced the idea of preserving backward compatibility
+ by implementing a new function for new or changed functionality in a module.
+ For more about backward compatibility, see
+ <a href="https://blog.golang.org/module-compatibility">Keeping your modules
+ compatible</a>.
+</p>
+
+<p>Next, you'll use built-in Go features to create a unit test for your code.</p>
+
+<p class="Navigation">
+ <a class="Navigation-prev" href="/doc/tutorial/random-greeting.html"
+ >< Return a random greeting</a
+ >
+ <a class="Navigation-next" href="/doc/tutorial/add-a-test.html">Add a test ></a>
+</p>
diff --git a/_content/doc/tutorial/handle-errors.html b/_content/doc/tutorial/handle-errors.html
new file mode 100644
index 0000000..41a0aad
--- /dev/null
+++ b/_content/doc/tutorial/handle-errors.html
@@ -0,0 +1,188 @@
+<!--{
+ "Title": "Return and handle an error"
+}-->
+
+<p>
+ Handling errors is an essential feature of solid code. In this section, you'll
+ add a bit of code to return an error from the greetings module, then handle it
+ in the caller.
+</p>
+
+<aside class="Note">
+ <strong>Note:</strong> This topic is part of a multi-part tutorial that begins
+ with <a href="/doc/tutorial/create-module.html">Create a Go module</a>.
+</aside>
+
+<ol>
+ <li>
+ In greetings/greetings.go, add the code highlighted below.
+
+ <p>
+ There's no sense sending a greeting back if you don't know who to greet.
+ Return an error to the caller if the name is empty. Copy the following
+ code into greetings.go and save the file.
+ </p>
+
+ <pre>
+package greetings
+
+import (
+ <ins>"errors"</ins>
+ "fmt"
+)
+
+// Hello returns a greeting for the named person.
+func Hello(name string) <ins>(</ins>string<ins>, error)</ins> {
+ <ins>// If no name was given, return an error with a message.
+ if name == "" {
+ return "", errors.New("empty name")
+ }</ins>
+
+ // If a name was received, return a value that embeds the name
+ // in a greeting message.
+ message := fmt.Sprintf("Hi, %v. Welcome!", name)
+ return message<ins>, nil</ins>
+}
+</pre>
+
+ <p>
+ In this code, you:
+ </p>
+
+ <ul>
+ <li>
+ Change the function so that it returns two values: a
+ <code>string</code> and an <code>error</code>. Your caller will check
+ the second value to see if an error occurred. (Any Go function can
+ return multiple values. For more, see
+ <a href="/doc/effective_go.html#multiple-returns">Effective Go</a>.)
+ </li>
+ <li>
+ Import the Go standard library <code>errors</code> package so you can
+ use its
+ <a href="https://pkg.go.dev/errors/#example-New"
+ ><code>errors.New</code> function</a
+ >.
+ </li>
+ <li>
+ Add an <code>if</code> statement to check for an invalid request (an
+ empty string where the name should be) and return an error if the
+ request is invalid. The <code>errors.New</code> function returns an
+ <code>error</code> with your message inside.
+ </li>
+ <li>
+ Add <code>nil</code> (meaning no error) as a second value in the
+ successful return. That way, the caller can see that the function
+ succeeded.
+ </li>
+ </ul>
+ </li>
+
+ <li>
+ In your hello/hello.go file, handle the error now returned by the
+ <code>Hello</code> function, along with the non-error value.
+
+ <p>
+ Paste the following code into hello.go.
+ </p>
+
+ <pre>
+package main
+
+import (
+ "fmt"
+ <ins>"log"</ins>
+
+ "example.com/greetings"
+)
+
+func main() {
+ <ins>// Set properties of the predefined Logger, including
+ // the log entry prefix and a flag to disable printing
+ // the time, source file, and line number.
+ log.SetPrefix("greetings: ")
+ log.SetFlags(0)</ins>
+
+ // Request a greeting message.
+ <ins>message, err := greetings.Hello("")</ins>
+ <ins>// If an error was returned, print it to the console and
+ // exit the program.
+ if err != nil {
+ log.Fatal(err)
+ }
+
+ // If no error was returned, print the returned message
+ // to the console.</ins>
+ fmt.Println(message)
+}
+</pre>
+
+ <p>
+ In this code, you:
+ </p>
+
+ <ul>
+ <li>
+ Configure the
+ <a href="https://pkg.go.dev/log/"><code>log</code> package</a> to
+ print the command name ("greetings: ") at the start of its log messages,
+ without a time stamp or source file information.
+ </li>
+ <li>
+ Assign both of the <code>Hello</code> return values, including the
+ <code>error</code>, to variables.
+ </li>
+ <li>
+ Change the <code>Hello</code> argument from Gladys’s name to an empty
+ string, so you can try out your error-handling code.
+ </li>
+ <li>
+ Look for a non-nil <code>error</code> value. There's no sense continuing
+ in this case.
+ </li>
+ <li>
+ Use the functions in the standard library's <code>log package</code> to
+ output error information. If you get an error, you use the
+ <code>log</code> package's
+ <a href="https://pkg.go.dev/log?tab=doc#Fatal"
+ ><code>Fatal</code> function</a
+ >
+ to print the error and stop the program.
+ </li>
+ </ul>
+ </li>
+
+ <li>
+ At the command line in the <code>hello</code> directory, run hello.go to
+ confirm that the code works.
+
+ <p>
+ Now that you're passing in an empty name, you'll get an error.
+ </p>
+
+ <pre>
+$ go run .
+greetings: empty name
+exit status 1
+</pre
+ >
+ </li>
+</ol>
+
+<p>
+ That's common error handling in Go: Return an error as a value so the caller
+ can check for it.
+</p>
+
+<p>
+ Next, you'll use a Go slice to return a randomly-selected greeting.
+</p>
+
+<p class="Navigation">
+ <a class="Navigation-prev" href="/doc/tutorial/call-module-code.html"
+ >< Call your code from another module</a
+ >
+ <a class="Navigation-next" href="/doc/tutorial/random-greeting.html"
+ >Return a random greeting ></a
+ >
+</p>
diff --git a/_content/doc/tutorial/images/function-syntax.graffle b/_content/doc/tutorial/images/function-syntax.graffle
new file mode 100644
index 0000000..dd2fcdd
--- /dev/null
+++ b/_content/doc/tutorial/images/function-syntax.graffle
Binary files differ
diff --git a/_content/doc/tutorial/images/function-syntax.png b/_content/doc/tutorial/images/function-syntax.png
new file mode 100644
index 0000000..63d29b6
--- /dev/null
+++ b/_content/doc/tutorial/images/function-syntax.png
Binary files differ
diff --git a/_content/doc/tutorial/index.html b/_content/doc/tutorial/index.html
new file mode 100644
index 0000000..c6bae81
--- /dev/null
+++ b/_content/doc/tutorial/index.html
@@ -0,0 +1,45 @@
+<!--{
+ "Title": "Tutorials"
+}-->
+
+<p>If you're new to a part of Go, take a look at the tutorials linked below.</p>
+
+<p>
+ If you haven't installed Go yet, see
+ <a href="/doc/install">Download and install</a>.
+</p>
+
+<table id="tutorials-list" class="DocTable">
+ <thead>
+ <tr class="DocTable-head">
+ <th class="DocTable-cell" width="20%">Tutorial</th>
+ <th class="DocTable-cell">Description</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr class="DocTable-row">
+ <td class="DocTable-cell">
+ <a href="/doc/tutorial/getting-started.html">Getting started</a>
+ </td>
+ <td class="DocTable-cell">Say Hello, World with Go.</td>
+ </tr>
+ <tr class="DocTable-row">
+ <td class="DocTable-cell">
+ <a href="/doc/tutorial/create-module.html">Create a module</a>
+ </td>
+ <td class="DocTable-cell">
+ A multi-part tutorial that introduces common programming language
+ features from the Go perspective.
+ </td>
+ </tr>
+ <tr class="DocTable-row">
+ <td class="DocTable-cell">
+ <a href="https://tour.golang.org/welcome/1">A Tour of Go</a>
+ </td>
+ <td class="DocTable-cell">
+ An interactive introduction to Go: basic syntax and data structures;
+ methods and interfaces; and Go's concurrency primitives.
+ </td>
+ </tr>
+ </tbody>
+</table>
diff --git a/_content/doc/tutorial/module-conclusion.html b/_content/doc/tutorial/module-conclusion.html
new file mode 100644
index 0000000..f86af3a
--- /dev/null
+++ b/_content/doc/tutorial/module-conclusion.html
@@ -0,0 +1,31 @@
+<!--{
+ "Title": "Conclusion",
+ "Path": "/doc/tutorial/module-conclusion"
+}-->
+
+<p>
+ In this tutorial, you wrote functions that you packaged into two modules: one
+ with logic for sending greetings; the other as a consumer for the first.
+</p>
+
+<aside class="Note">
+ <strong>Note:</strong> This topic is part of a multi-part tutorial that begins
+ with <a href="/doc/tutorial/create-module.html">Create a Go module</a>.
+</aside>
+
+<p>
+ For more on managing dependencies in your code, see
+ <a href="/doc/modules/managing-dependencies">Managing dependencies</a>. For
+ more about developing modules for others to use, see
+ <a href="/doc/modules/developing">Developing and publishing modules</a>.
+</p>
+
+<p>For many more features of the Go language, check out the
+ <a href="https://tour.golang.org/welcome/1">Tour of Go</a>.
+</p>
+
+<p class="Navigation">
+ <a class="Navigation-prev" href="/doc/tutorial/compile-install.html"
+ >< Compile and install the application</a
+ >
+</p>
diff --git a/_content/doc/tutorial/random-greeting.html b/_content/doc/tutorial/random-greeting.html
new file mode 100644
index 0000000..ad74681
--- /dev/null
+++ b/_content/doc/tutorial/random-greeting.html
@@ -0,0 +1,180 @@
+<!--{
+ "Title": "Return a random greeting"
+}-->
+
+<p>
+ In this section, you'll change your code so that instead of returning a single
+ greeting every time, it returns one of several predefined greeting messages.
+</p>
+
+<aside class="Note">
+ <strong>Note:</strong> This topic is part of a multi-part tutorial that begins
+ with <a href="/doc/tutorial/create-module.html">Create a Go module</a>.
+</aside>
+
+<p>
+ To do this, you'll use a Go slice. A slice is like an array, except that its
+ size changes dynamically as you add and remove items. The slice is one of Go's
+ most useful types.
+</p>
+
+<p>
+ You'll add a small slice to contain three greeting messages, then have your
+ code return one of the messages randomly. For more on slices,
+ see <a href="https://blog.golang.org/slices-intro">Go slices</a> in the Go
+ blog.
+</p>
+
+<ol>
+ <li>
+ In greetings/greetings.go, change your code so it looks like the following.
+
+ <pre>
+package greetings
+
+import (
+ "errors"
+ "fmt"
+ <ins>"math/rand"
+ "time"</ins>
+)
+
+// Hello returns a greeting for the named person.
+func Hello(name string) (string, error) {
+ // If no name was given, return an error with a message.
+ if name == "" {
+ return name, errors.New("empty name")
+ }
+ // Create a message using a random format.
+ message := fmt.Sprintf(<ins>randomFormat()</ins>, name)
+ return message, nil
+}
+
+<ins>// init sets initial values for variables used in the function.
+func init() {
+ rand.Seed(time.Now().UnixNano())
+}
+
+// randomFormat returns one of a set of greeting messages. The returned
+// message is selected at random.
+func randomFormat() string {
+ // A slice of message formats.
+ formats := []string{
+ "Hi, %v. Welcome!",
+ "Great to see you, %v!",
+ "Hail, %v! Well met!",
+ }
+
+ // Return a randomly selected message format by specifying
+ // a random index for the slice of formats.
+ return formats[rand.Intn(len(formats))]
+}</ins>
+</pre>
+
+ <p>
+ In this code, you:
+ </p>
+
+ <ul>
+ <li>
+ Add a <code>randomFormat</code> function that returns a randomly
+ selected format for a greeting message. Note that
+ <code>randomFormat</code> starts with a lowercase letter, making it
+ accessible only to code in its own package (in other words, it's not
+ exported).
+ </li>
+ <li>
+ In <code>randomFormat</code>, declare a <code>formats</code> slice with
+ three message formats. When declaring a slice, you omit its size in the
+ brackets, like this: <code>[]string</code>. This tells Go that the size
+ of the array underlying the slice can be dynamically changed.
+ </li>
+ <li>
+ Use the
+ <a href="https://pkg.go.dev/math/rand/"
+ ><code>math/rand</code> package</a
+ >
+ to generate a random number for selecting an item from the slice.
+ </li>
+ <li>
+ Add an <code>init</code> function to seed the <code>rand</code> package
+ with the current time. Go executes <code>init</code> functions
+ automatically at program startup, after global variables have been
+ initialized. For more about <code>init</code> functions, see
+ <a href="/doc/effective_go.html#init">Effective Go</a>.
+ </li>
+ <li>
+ In <code>Hello</code>, call the <code>randomFormat</code> function to
+ get a format for the message you'll return, then use the format and
+ <code>name</code> value together to create the message.
+ </li>
+ <li>Return the message (or an error) as you did before.</li>
+ </ul>
+
+ </li>
+
+ <li>
+ In hello/hello.go, change your code so it looks like the following.
+
+ <p>You're just adding Gladys's name (or a different name, if you like)
+ as an argument to the <code>Hello</code> function call in hello.go.</p>
+
+ <pre>package main
+
+import (
+ "fmt"
+ "log"
+
+ "example.com/greetings"
+)
+
+func main() {
+ // Set properties of the predefined Logger, including
+ // the log entry prefix and a flag to disable printing
+ // the time, source file, and line number.
+ log.SetPrefix("greetings: ")
+ log.SetFlags(0)
+
+ // Request a greeting message.
+ <ins>message, err := greetings.Hello("Gladys")</ins>
+ // If an error was returned, print it to the console and
+ // exit the program.
+ if err != nil {
+ log.Fatal(err)
+ }
+
+ // If no error was returned, print the returned message
+ // to the console.
+ fmt.Println(message)
+}</pre>
+ </li>
+
+ <li>
+ At the command line, in the hello directory, run hello.go to confirm that
+ the code works. Run it multiple times, noticing that the greeting changes.
+
+ <pre>
+$ go run .
+Great to see you, Gladys!
+
+$ go run .
+Hi, Gladys. Welcome!
+
+$ go run .
+Hail, Gladys! Well met!
+</pre>
+ </li>
+</ol>
+
+<p>
+ Next, you'll use a slice to greet multiple people.
+</p>
+
+<p class="Navigation">
+ <a class="Navigation-prev" href="/doc/tutorial/handle-errors.html"
+ >< Return and handle an error</a
+ >
+ <a class="Navigation-next" href="/doc/tutorial/greetings-multiple-people.html"
+ >Return greetings for multiple people ></a
+ >
+</p>
diff --git a/_content/favicon.ico b/_content/favicon.ico
new file mode 100644
index 0000000..8d22584
--- /dev/null
+++ b/_content/favicon.ico
Binary files differ
diff --git a/_content/lib/godoc/analysis/call-eg.png b/_content/lib/godoc/analysis/call-eg.png
new file mode 100644
index 0000000..c48bf4d
--- /dev/null
+++ b/_content/lib/godoc/analysis/call-eg.png
Binary files differ
diff --git a/_content/lib/godoc/analysis/call3.png b/_content/lib/godoc/analysis/call3.png
new file mode 100644
index 0000000..387a38c
--- /dev/null
+++ b/_content/lib/godoc/analysis/call3.png
Binary files differ
diff --git a/_content/lib/godoc/analysis/callers1.png b/_content/lib/godoc/analysis/callers1.png
new file mode 100644
index 0000000..80fbc62
--- /dev/null
+++ b/_content/lib/godoc/analysis/callers1.png
Binary files differ
diff --git a/_content/lib/godoc/analysis/callers2.png b/_content/lib/godoc/analysis/callers2.png
new file mode 100644
index 0000000..59a84ed
--- /dev/null
+++ b/_content/lib/godoc/analysis/callers2.png
Binary files differ
diff --git a/_content/lib/godoc/analysis/chan1.png b/_content/lib/godoc/analysis/chan1.png
new file mode 100644
index 0000000..5eb2811
--- /dev/null
+++ b/_content/lib/godoc/analysis/chan1.png
Binary files differ
diff --git a/_content/lib/godoc/analysis/chan2a.png b/_content/lib/godoc/analysis/chan2a.png
new file mode 100644
index 0000000..b757504
--- /dev/null
+++ b/_content/lib/godoc/analysis/chan2a.png
Binary files differ
diff --git a/_content/lib/godoc/analysis/chan2b.png b/_content/lib/godoc/analysis/chan2b.png
new file mode 100644
index 0000000..d197862
--- /dev/null
+++ b/_content/lib/godoc/analysis/chan2b.png
Binary files differ
diff --git a/_content/lib/godoc/analysis/error1.png b/_content/lib/godoc/analysis/error1.png
new file mode 100644
index 0000000..69550b9
--- /dev/null
+++ b/_content/lib/godoc/analysis/error1.png
Binary files differ
diff --git a/_content/lib/godoc/analysis/help.html b/_content/lib/godoc/analysis/help.html
new file mode 100644
index 0000000..023c07d
--- /dev/null
+++ b/_content/lib/godoc/analysis/help.html
@@ -0,0 +1,254 @@
+<!--{
+ "Title": "Static analysis features of godoc"
+}-->
+
+<style>
+ span.err { 'font-size:120%; color:darkred; background-color: yellow; }
+ img.ss { margin-left: 1in; } /* screenshot */
+ img.dotted { border: thin dotted; }
+</style>
+
+<!-- Images were grabbed from Chrome/Linux at 150% zoom, and are
+ displayed at 66% of natural size. This allows users to zoom a
+ little before seeing pixels. -->
+
+<p>
+ When invoked with the <code>-analysis</code> flag, godoc performs
+ static analysis on the Go packages it indexes and displays the
+ results in the source and package views. This document provides a
+ brief tour of these features.
+</p>
+
+<h2>Type analysis features</h2>
+<p>
+ <code>godoc -analysis=type</code> performs static checking similar
+ to that done by a compiler: it detects ill-formed programs, resolves
+ each identifier to the entity it denotes, computes the type of each
+ expression and the method set of each type, and determines which
+ types are assignable to each interface type.
+
+ <b>Type analysis</b> is relatively quick, requiring about 10 seconds for
+ the >200 packages of the standard library, for example.
+</p>
+
+<h3>Compiler errors</h3>
+<p>
+ If any source file contains a compilation error, the source view
+ will highlight the errant location in red. Hovering over it
+ displays the error message.
+</p>
+<img class="ss" width='811' src='error1.png'><br/>
+
+<h3>Identifier resolution</h3>
+<p>
+ In the source view, every referring identifier is annotated with
+ information about the language entity it refers to: a package,
+ constant, variable, type, function or statement label.
+
+ Hovering over the identifier reveals the entity's kind and type
+ (e.g. <code>var x int</code> or <code>func f
+ func(int) string</code>).
+</p>
+<img class="ss" width='652' src='ident-field.png'><br/>
+<br/>
+<img class="ss" width='652' src='ident-func.png'>
+<p>
+ Clicking the link takes you to the entity's definition.
+</p>
+<img class="ss" width='652' src='ident-def.png'><br/>
+
+<h3>Type information: size/alignment, method set, interfaces</h3>
+<p>
+ Clicking on the identifier that defines a named type causes a panel
+ to appear, displaying information about the named type, including
+ its size and alignment in bytes, its
+ <a href='http://golang.org/ref/spec#Method_sets'>method set</a>, and its
+ <i>implements</i> relation: the set of types T that are assignable to
+ or from this type U where at least one of T or U is an interface.
+
+ This example shows information about <code>net/rpc.methodType</code>.
+</p>
+<img class="ss" width='470' src='typeinfo-src.png'>
+<p>
+ The method set includes not only the declared methods of the type,
+ but also any methods "promoted" from anonymous fields of structs,
+ such as <code>sync.Mutex</code> in this example.
+
+ In addition, the receiver type is displayed as <code>*T</code> or
+ <code>T</code> depending on whether it requires the address or just
+ a copy of the receiver value.
+</p>
+<p>
+ The method set and <i>implements</i> relation are also available
+ via the package view.
+</p>
+<img class="ss dotted" width='716' src='typeinfo-pkg.png'>
+
+<h2>Pointer analysis features</h2>
+<p>
+ <code>godoc -analysis=pointer</code> additionally performs a precise
+ whole-program <b>pointer analysis</b>. In other words, it
+ approximates the set of memory locations to which each
+ reference—not just vars of kind <code>*T</code>, but also
+ <code>[]T</code>, <code>func</code>, <code>map</code>,
+ <code>chan</code>, and <code>interface</code>—may refer. This
+ information reveals the possible destinations of each dynamic call
+ (via a <code>func</code> variable or interface method), and the
+ relationship between send and receive operations on the same
+ channel.
+</p>
+<p>
+ Compared to type analysis, pointer analysis requires more time and
+ memory, and is impractical for code bases exceeding a million lines.
+</p>
+
+<h3>Call graph navigation</h3>
+<p>
+ When pointer analysis is complete, the source view annotates the
+ code with <b>callers</b> and <b>callees</b> information: callers
+ information is associated with the <code>func</code> keyword that
+ declares a function, and callees information is associated with the
+ open paren '<span style="color: dark-blue"><code>(</code></span>' of
+ a function call.
+</p>
+<p>
+ In this example, hovering over the declaration of the
+ <code>rot13</code> function (defined in strings/strings_test.go)
+ reveals that it is called in exactly one place.
+</p>
+<img class="ss" width='612' src='callers1.png'>
+<p>
+ Clicking the link navigates to the sole caller. (If there were
+ multiple callers, a list of choices would be displayed first.)
+</p>
+<img class="ss" width='680' src='callers2.png'>
+<p>
+ Notice that hovering over this call reveals that there are 19
+ possible callees at this site, of which our <code>rot13</code>
+ function was just one: this is a dynamic call through a variable of
+ type <code>func(rune) rune</code>.
+
+ Clicking on the call brings up the list of all 19 potential callees,
+ shown truncated. Many of them are anonymous functions.
+</p>
+<img class="ss" width='564' src='call3.png'>
+<p>
+ Pointer analysis gives a very precise approximation of the call
+ graph compared to type-based techniques.
+
+ As a case in point, the next example shows the dynamic call inside
+ the <code>testing</code> package responsible for calling all
+ user-defined functions named <code>Example<i>XYZ</i></code>.
+</p>
+<img class="ss" width='361' src='call-eg.png'>
+<p>
+ Recall that all such functions have type <code>func()</code>,
+ i.e. no arguments and no results. A type-based approximation could
+ only conclude that this call might dispatch to any function matching
+ that type—and these are very numerous in most
+ programs—but pointer analysis can track the flow of specific
+ <code>func</code> values through the testing package.
+
+ As an indication of its precision, the result contains only
+ functions whose name starts with <code>Example</code>.
+</p>
+
+<h3>Intra-package call graph</h3>
+<p>
+ The same call graph information is presented in a very different way
+ in the package view. For each package, an interactive tree view
+ allows exploration of the call graph as it relates to just that
+ package; all functions from other packages are elided.
+
+ The roots of the tree are the external entry points of the package:
+ not only its exported functions, but also any unexported or
+ anonymous functions that are called (dynamically) from outside the
+ package.
+</p>
+<p>
+ This example shows the entry points of the
+ <code>path/filepath</code> package, with the call graph for
+ <code>Glob</code> expanded several levels
+</p>
+<img class="ss dotted" width='501' src='ipcg-pkg.png'>
+<p>
+ Notice that the nodes for Glob and Join appear multiple times: the
+ tree is a partial unrolling of a cyclic graph; the full unrolling
+ is in general infinite.
+</p>
+<p>
+ For each function documented in the package view, another
+ interactive tree view allows exploration of the same graph starting
+ at that function.
+
+ This is a portion of the internal graph of
+ <code>net/http.ListenAndServe</code>.
+</p>
+<img class="ss dotted" width='455' src='ipcg-func.png'>
+
+<h3>Channel peers (send ↔ receive)</h3>
+<p>
+ Because concurrent Go programs use channels to pass not just values
+ but also control between different goroutines, it is natural when
+ reading Go code to want to navigate from a channel send to the
+ corresponding receive so as to understand the sequence of events.
+</p>
+<p>
+ Godoc annotates every channel operation—make, send, range,
+ receive, close—with a link to a panel displaying information
+ about other operations that might alias the same channel.
+</p>
+<p>
+ This example, from the tests of <code>net/http</code>, shows a send
+ operation on a <code>chan bool</code>.
+</p>
+<img class="ss" width='811' src='chan1.png'>
+<p>
+ Clicking on the <code><-</code> send operator reveals that this
+ channel is made at a unique location (line 332) and that there are
+ three receive operations that might read this value.
+
+ It hardly needs pointing out that some channel element types are
+ very widely used (e.g. struct{}, bool, int, interface{}) and that a
+ typical Go program might contain dozens of receive operations on a
+ value of type <code>chan bool</code>; yet the pointer analysis is
+ able to distinguish operations on channels at a much finer precision
+ than based on their type alone.
+</p>
+<p>
+ Notice also that the send occurs in a different (anonymous) function
+ from the outer one containing the <code>make</code> and the receive
+ operations.
+</p>
+<p>
+ Here's another example of send on a different <code>chan
+ bool</code>, also in package <code>net/http</code>:
+</p>
+<img class="ss" width='774' src='chan2a.png'>
+<p>
+ The analysis finds just one receive operation that might receive
+ from this channel, in the test for this feature.
+</p>
+<img class="ss" width='737' src='chan2b.png'>
+
+<h2>Known issues</h2>
+<p>
+ All analysis results pertain to exactly
+ one configuration (e.g. amd64 linux). Files that are conditionally
+ compiled based on different platforms or build tags are not visible
+ to the analysis.
+</p>
+<p>
+ Files that <code>import "C"</code> require
+ preprocessing by the cgo tool. The file offsets after preprocessing
+ do not align with the unpreprocessed file, so markup is misaligned.
+</p>
+<p>
+ Files are not periodically re-analyzed.
+ If the files change underneath the running server, the displayed
+ markup is misaligned.
+</p>
+<p>
+ Additional issues are listed at
+ <a href='https://go.googlesource.com/tools/+/master/godoc/analysis/README'>tools/godoc/analysis/README</a>.
+</p>
diff --git a/_content/lib/godoc/analysis/ident-def.png b/_content/lib/godoc/analysis/ident-def.png
new file mode 100644
index 0000000..b0d9e55
--- /dev/null
+++ b/_content/lib/godoc/analysis/ident-def.png
Binary files differ
diff --git a/_content/lib/godoc/analysis/ident-field.png b/_content/lib/godoc/analysis/ident-field.png
new file mode 100644
index 0000000..76cbe5a
--- /dev/null
+++ b/_content/lib/godoc/analysis/ident-field.png
Binary files differ
diff --git a/_content/lib/godoc/analysis/ident-func.png b/_content/lib/godoc/analysis/ident-func.png
new file mode 100644
index 0000000..69670fa
--- /dev/null
+++ b/_content/lib/godoc/analysis/ident-func.png
Binary files differ
diff --git a/_content/lib/godoc/analysis/ipcg-func.png b/_content/lib/godoc/analysis/ipcg-func.png
new file mode 100644
index 0000000..523318d
--- /dev/null
+++ b/_content/lib/godoc/analysis/ipcg-func.png
Binary files differ
diff --git a/_content/lib/godoc/analysis/ipcg-pkg.png b/_content/lib/godoc/analysis/ipcg-pkg.png
new file mode 100644
index 0000000..e029068
--- /dev/null
+++ b/_content/lib/godoc/analysis/ipcg-pkg.png
Binary files differ
diff --git a/_content/lib/godoc/analysis/typeinfo-pkg.png b/_content/lib/godoc/analysis/typeinfo-pkg.png
new file mode 100644
index 0000000..91bd5f7
--- /dev/null
+++ b/_content/lib/godoc/analysis/typeinfo-pkg.png
Binary files differ
diff --git a/_content/lib/godoc/analysis/typeinfo-src.png b/_content/lib/godoc/analysis/typeinfo-src.png
new file mode 100644
index 0000000..6e5b147
--- /dev/null
+++ b/_content/lib/godoc/analysis/typeinfo-src.png
Binary files differ
diff --git a/_content/lib/godoc/codewalk.html b/_content/lib/godoc/codewalk.html
new file mode 100644
index 0000000..0f3d22a
--- /dev/null
+++ b/_content/lib/godoc/codewalk.html
@@ -0,0 +1,56 @@
+<!--
+ Copyright 2010 The Go Authors. All rights reserved.
+ Use of this source code is governed by a BSD-style
+ license that can be found in the LICENSE file.
+-->
+
+<style type='text/css'>@import "/doc/codewalk/codewalk.css";</style>
+<script type="text/javascript" src="/doc/codewalk/codewalk.js"></script>
+
+<div id="codewalk-main">
+ <div class="left" id="code-column">
+ <div id='sizer'></div>
+ <div id="code-area">
+ <div id="code-header" align="center">
+ <a id="code-popout-link" href="" target="_blank">
+ <img title="View code in new window" alt="Pop Out Code" src="/doc/codewalk/popout.png" style="display: block; float: right;"/>
+ </a>
+ <select id="code-selector">
+ {{range .File}}
+ <option value="/doc/codewalk/?fileprint=/{{urlquery .}}">{{html .}}</option>
+ {{end}}
+ </select>
+ </div>
+ <div id="code">
+ <iframe class="code-display" name="code-display" id="code-display"></iframe>
+ </div>
+ </div>
+ <div id="code-options" class="setting">
+ <span>code on <a id="set-code-left" class="selected" href="#">left</a> • <a id="set-code-right" href="#">right</a></span>
+ <span>code width <span id="code-column-width">70%</span></span>
+ <span>filepaths <a id="show-filepaths" class="selected" href="#">shown</a> • <a id="hide-filepaths" href="#">hidden</a></span>
+ </div>
+ </div>
+ <div class="right" id="comment-column">
+ <div id="comment-area">
+ {{range .Step}}
+ <div class="comment first last">
+ <a class="comment-link" href="/doc/codewalk/?fileprint=/{{urlquery .File}}&lo={{urlquery .Lo}}&hi={{urlquery .Hi}}#mark" target="code-display"></a>
+ <div class="comment-title">{{html .Title}}</div>
+ <div class="comment-text">
+ {{with .Err}}
+ ERROR LOADING FILE: {{html .}}<br/><br/>
+ {{end}}
+ {{.XML}}
+ </div>
+ <div class="comment-text file-name"><span class="path-file">{{html .}}</span></div>
+ </div>
+ {{end}}
+ </div>
+ <div id="comment-options" class="setting">
+ <a id="prev-comment" href="#"><span class="hotkey">p</span>revious step</a>
+ •
+ <a id="next-comment" href="#"><span class="hotkey">n</span>ext step</a>
+ </div>
+ </div>
+</div>
diff --git a/_content/lib/godoc/codewalkdir.html b/_content/lib/godoc/codewalkdir.html
new file mode 100644
index 0000000..b7674c6
--- /dev/null
+++ b/_content/lib/godoc/codewalkdir.html
@@ -0,0 +1,16 @@
+<!--
+ Copyright 2010 The Go Authors. All rights reserved.
+ Use of this source code is governed by a BSD-style
+ license that can be found in the LICENSE file.
+-->
+
+<table class="layout">
+{{range .}}
+<tr>
+ {{$name_html := html .Name}}
+ <td><a href="{{$name_html}}">{{$name_html}}</a></td>
+ <td width="25"> </td>
+ <td>{{html .Title}}</td>
+</tr>
+{{end}}
+</table>
diff --git a/_content/lib/godoc/dirlist.html b/_content/lib/godoc/dirlist.html
new file mode 100644
index 0000000..78530e6
--- /dev/null
+++ b/_content/lib/godoc/dirlist.html
@@ -0,0 +1,25 @@
+<!--
+ Copyright 2009 The Go Authors. All rights reserved.
+ Use of this source code is governed by a BSD-style
+ license that can be found in the LICENSE file.
+-->
+
+<p>
+<table class="layout">
+<tr>
+ <th align="left">File</th>
+ <td width="25"> </td>
+ <th align="right">Bytes</th>
+</tr>
+<tr>
+ <td><a href="../">../</a></td>
+</tr>
+{{range .}}{{if .IsDir}}
+ <tr><td align="left"><a href="{{html .Name}}/">{{html .Name}}/</a><td></tr>
+{{end}}{{end}}
+{{range .}}{{if not .IsDir}}
+ <tr><td align="left"><a href="{{html .Name}}">{{html .Name}}</a><td align="right">{{html .Size}}</tr>
+{{end}}{{end}}
+
+</table>
+</p>
diff --git a/_content/lib/godoc/error.html b/_content/lib/godoc/error.html
new file mode 100644
index 0000000..7573aa2
--- /dev/null
+++ b/_content/lib/godoc/error.html
@@ -0,0 +1,9 @@
+<!--
+ Copyright 2009 The Go Authors. All rights reserved.
+ Use of this source code is governed by a BSD-style
+ license that can be found in the LICENSE file.
+-->
+
+<p>
+<span class="alert" style="font-size:120%">{{html .}}</span>
+</p>
diff --git a/_content/lib/godoc/example.html b/_content/lib/godoc/example.html
new file mode 100644
index 0000000..bde02c6
--- /dev/null
+++ b/_content/lib/godoc/example.html
@@ -0,0 +1,30 @@
+<div id="example_{{.Name}}" class="toggle">
+ <div class="collapsed">
+ <p class="exampleHeading toggleButton">▹ <span class="text">Example{{example_suffix .Name}}</span></p>
+ </div>
+ <div class="expanded">
+ <p class="exampleHeading toggleButton">▾ <span class="text">Example{{example_suffix .Name}}</span></p>
+ {{with .Doc}}<p>{{html .}}</p>{{end}}
+ {{$output := .Output}}
+ {{with .Play}}
+ <div class="play">
+ <div class="input"><textarea class="code" spellcheck="false">{{html .}}</textarea></div>
+ <div class="output"><pre>{{html $output}}</pre></div>
+ <div class="buttons">
+ <button class="Button Button--primary run" title="Run this code [shift-enter]">Run</button>
+ <button class="Button fmt" title="Format this code">Format</button>
+ {{if not $.GoogleCN}}
+ <button class="Button share" title="Share this code">Share</button>
+ {{end}}
+ </div>
+ </div>
+ {{else}}
+ <p>Code:</p>
+ <pre class="code">{{.Code}}</pre>
+ {{with .Output}}
+ <p>Output:</p>
+ <pre class="output">{{html .}}</pre>
+ {{end}}
+ {{end}}
+ </div>
+</div>
diff --git a/_content/lib/godoc/godoc.html b/_content/lib/godoc/godoc.html
new file mode 100644
index 0000000..f1d14e4
--- /dev/null
+++ b/_content/lib/godoc/godoc.html
@@ -0,0 +1,111 @@
+<!DOCTYPE html>
+<html lang="en">
+<meta charset="utf-8">
+<meta name="description" content="Go is an open source programming language that makes it easy to build simple, reliable, and efficient software.">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="theme-color" content="#00ADD8">
+{{with .Tabtitle}}
+ <title>{{html .}} - The Go Programming Language</title>
+{{else}}
+ <title>The Go Programming Language</title>
+{{end}}
+<link href="https://fonts.googleapis.com/css?family=Work+Sans:600|Roboto:400,700" rel="stylesheet">
+<link href="https://fonts.googleapis.com/css?family=Product+Sans&text=Supported%20by%20Google&display=swap" rel="stylesheet">
+<link type="text/css" rel="stylesheet" href="/lib/godoc/style.css">
+<script>window.initFuncs = [];</script>
+{{with .GoogleAnalytics}}
+<script>
+var _gaq = _gaq || [];
+_gaq.push(["_setAccount", "{{.}}"]);
+window.trackPageview = function() {
+ _gaq.push(["_trackPageview", location.pathname+location.hash]);
+};
+window.trackPageview();
+window.trackEvent = function(category, action, opt_label, opt_value, opt_noninteraction) {
+ _gaq.push(["_trackEvent", category, action, opt_label, opt_value, opt_noninteraction]);
+};
+</script>
+{{end}}
+<script src="/lib/godoc/jquery.js" defer></script>
+
+<script src="/lib/godoc/playground.js" defer></script>
+{{with .Version}}<script>var goVersion = {{printf "%q" .}};</script>{{end}}
+<script src="/lib/godoc/godocs.js" defer></script>
+
+<body class="Site">
+<header class="Header js-header">
+ <div class="Header-banner">
+ Black Lives Matter.
+ <a href="https://support.eji.org/give/153413/#!/donation/checkout"
+ target="_blank"
+ rel="noopener">Support the Equal Justice Initiative.</a>
+ </div>
+ <nav class="Header-nav {{if .Title}}Header-nav--wide{{end}}">
+ <a href="/"><img class="Header-logo" src="/lib/godoc/images/go-logo-blue.svg" alt="Go"></a>
+ <button class="Header-menuButton js-headerMenuButton" aria-label="Main menu" aria-expanded="false">
+ <div class="Header-menuButtonInner"></div>
+ </button>
+ <ul class="Header-menu">
+ <li class="Header-menuItem"><a href="/doc/">Documents</a></li>
+ <li class="Header-menuItem"><a href="/pkg/">Packages</a></li>
+ <li class="Header-menuItem"><a href="/project/">The Project</a></li>
+ <li class="Header-menuItem"><a href="/help/">Help</a></li>
+ {{if not .GoogleCN}}
+ <li class="Header-menuItem"><a href="/blog/">Blog</a></li>
+ <li class="Header-menuItem"><a href="https://play.golang.org/">Play</a></li>
+ {{end}}
+ </ul>
+ </nav>
+</header>
+
+<main id="page" class="Site-content{{if .Title}} wide{{end}}">
+<div class="container">
+
+{{if or .Title .SrcPath}}
+ <h1>
+ {{html .Title}}
+ {{html .SrcPath | srcBreadcrumb}}
+ </h1>
+{{end}}
+
+{{with .Subtitle}}
+ <h2>{{html .}}</h2>
+{{end}}
+
+{{with .SrcPath}}
+ <h2>
+ Documentation: {{html . | srcToPkgLink}}
+ </h2>
+{{end}}
+
+{{/* The Table of Contents is automatically inserted in this <div>.
+ Do not delete this <div>. */}}
+<div id="nav"></div>
+
+{{/* Body is HTML-escaped elsewhere */}}
+{{printf "%s" .Body}}
+
+</div><!-- .container -->
+</main><!-- #page -->
+<footer>
+ <div class="Footer {{if .Title}}Footer--wide{{end}}">
+ <img class="Footer-gopher" src="/lib/godoc/images/footer-gopher.jpg" alt="The Go Gopher">
+ <ul class="Footer-links">
+ <li class="Footer-link"><a href="/doc/copyright.html">Copyright</a></li>
+ <li class="Footer-link"><a href="/doc/tos.html">Terms of Service</a></li>
+ <li class="Footer-link"><a href="http://www.google.com/intl/en/policies/privacy/">Privacy Policy</a></li>
+ <li class="Footer-link"><a href="http://golang.org/issues/new?title=x/website:" target="_blank" rel="noopener">Report a website issue</a></li>
+ </ul>
+ <a class="Footer-supportedBy" href="https://google.com">Supported by Google</a>
+ </div>
+</footer>
+{{if .GoogleAnalytics}}
+<script>
+(function() {
+ var ga = document.createElement("script"); ga.type = "text/javascript"; ga.async = true;
+ ga.src = ("https:" == document.location.protocol ? "https://ssl" : "http://www") + ".google-analytics.com/ga.js";
+ var s = document.getElementsByTagName("script")[0]; s.parentNode.insertBefore(ga, s);
+})();
+</script>
+{{end}}
+
diff --git a/_content/lib/godoc/godocs.js b/_content/lib/godoc/godocs.js
new file mode 100644
index 0000000..68e2a89
--- /dev/null
+++ b/_content/lib/godoc/godocs.js
@@ -0,0 +1,381 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/* A little code to ease navigation of these documents.
+ *
+ * On window load we:
+ * + Generate a table of contents (generateTOC)
+ * + Bind foldable sections (bindToggles)
+ * + Bind links to foldable sections (bindToggleLinks)
+ */
+
+(function() {
+ 'use strict';
+
+ var headerEl = document.querySelector('.js-header');
+ var menuButtonEl = document.querySelector('.js-headerMenuButton');
+ menuButtonEl.addEventListener('click', function(e) {
+ e.preventDefault();
+ headerEl.classList.toggle('is-active');
+ menuButtonEl.setAttribute(
+ 'aria-expanded',
+ headerEl.classList.contains('is-active')
+ );
+ });
+
+ /* Generates a table of contents: looks for h2 and h3 elements and generates
+ * links. "Decorates" the element with id=="nav" with this table of contents.
+ */
+ function generateTOC() {
+ if ($('#manual-nav').length > 0) {
+ return;
+ }
+
+ // For search, we send the toc precomputed from server-side.
+ // TODO: Ideally, this should always be precomputed for all pages, but then
+ // we need to do HTML parsing on the server-side.
+ if (location.pathname === '/search') {
+ return;
+ }
+
+ var nav = $('#nav');
+ if (nav.length === 0) {
+ return;
+ }
+
+ var toc_items = [];
+ $(nav)
+ .nextAll('h2, h3')
+ .each(function() {
+ var node = this;
+ if (node.id == '') node.id = 'tmp_' + toc_items.length;
+ var link = $('<a/>')
+ .attr('href', '#' + node.id)
+ .text($(node).text());
+ var item;
+ if ($(node).is('h2')) {
+ item = $('<dt/>');
+ } else {
+ // h3
+ item = $('<dd class="indent"/>');
+ }
+ item.append(link);
+ toc_items.push(item);
+ });
+ if (toc_items.length <= 1) {
+ return;
+ }
+ var dl1 = $('<dl/>');
+ var dl2 = $('<dl/>');
+
+ var split_index = toc_items.length / 2 + 1;
+ if (split_index < 8) {
+ split_index = toc_items.length;
+ }
+ for (var i = 0; i < split_index; i++) {
+ dl1.append(toc_items[i]);
+ }
+ for (; /* keep using i */ i < toc_items.length; i++) {
+ dl2.append(toc_items[i]);
+ }
+
+ var tocTable = $('<table class="unruled"/>').appendTo(nav);
+ var tocBody = $('<tbody/>').appendTo(tocTable);
+ var tocRow = $('<tr/>').appendTo(tocBody);
+
+ // 1st column
+ $('<td class="first"/>')
+ .appendTo(tocRow)
+ .append(dl1);
+ // 2nd column
+ $('<td/>')
+ .appendTo(tocRow)
+ .append(dl2);
+ }
+
+ function bindToggle(el) {
+ $('.toggleButton', el).click(function() {
+ if ($(this).closest('.toggle, .toggleVisible')[0] != el) {
+ // Only trigger the closest toggle header.
+ return;
+ }
+
+ if ($(el).is('.toggle')) {
+ $(el)
+ .addClass('toggleVisible')
+ .removeClass('toggle');
+ } else {
+ $(el)
+ .addClass('toggle')
+ .removeClass('toggleVisible');
+ }
+ });
+ }
+
+ function bindToggles(selector) {
+ $(selector).each(function(i, el) {
+ bindToggle(el);
+ });
+ }
+
+ function bindToggleLink(el, prefix) {
+ $(el).click(function() {
+ var href = $(el).attr('href');
+ var i = href.indexOf('#' + prefix);
+ if (i < 0) {
+ return;
+ }
+ var id = '#' + prefix + href.slice(i + 1 + prefix.length);
+ if ($(id).is('.toggle')) {
+ $(id)
+ .find('.toggleButton')
+ .first()
+ .click();
+ }
+ });
+ }
+ function bindToggleLinks(selector, prefix) {
+ $(selector).each(function(i, el) {
+ bindToggleLink(el, prefix);
+ });
+ }
+
+ function setupInlinePlayground() {
+ 'use strict';
+ // Set up playground when each element is toggled.
+ $('div.play').each(function(i, el) {
+ // Set up playground for this example.
+ var setup = function() {
+ var code = $('.code', el);
+ playground({
+ codeEl: code,
+ outputEl: $('.output', el),
+ runEl: $('.run', el),
+ fmtEl: $('.fmt', el),
+ shareEl: $('.share', el),
+ shareRedirect: '//play.golang.org/p/',
+ });
+
+ // Make the code textarea resize to fit content.
+ var resize = function() {
+ code.height(0);
+ var h = code[0].scrollHeight;
+ code.height(h + 20); // minimize bouncing.
+ code.closest('.input').height(h);
+ };
+ code.on('keydown', resize);
+ code.on('keyup', resize);
+ code.keyup(); // resize now.
+ };
+
+ // If example already visible, set up playground now.
+ if ($(el).is(':visible')) {
+ setup();
+ return;
+ }
+
+ // Otherwise, set up playground when example is expanded.
+ var built = false;
+ $(el)
+ .closest('.toggle')
+ .click(function() {
+ // Only set up once.
+ if (!built) {
+ setup();
+ built = true;
+ }
+ });
+ });
+ }
+
+ // fixFocus tries to put focus to #page so that keyboard navigation works.
+ function fixFocus() {
+ var page = $('#page');
+ var topbar = $('div#topbar');
+ page.css('outline', 0); // disable outline when focused
+ page.attr('tabindex', -1); // and set tabindex so that it is focusable
+ $(window)
+ .resize(function(evt) {
+ // only focus page when the topbar is at fixed position (that is, it's in
+ // front of page, and keyboard event will go to the former by default.)
+ // by focusing page, keyboard event will go to page so that up/down arrow,
+ // space, etc. will work as expected.
+ if (topbar.css('position') == 'fixed') page.focus();
+ })
+ .resize();
+ }
+
+ function toggleHash() {
+ var id = window.location.hash.substring(1);
+ // Open all of the toggles for a particular hash.
+ var els = $(
+ document.getElementById(id),
+ $('a[name]').filter(function() {
+ return $(this).attr('name') == id;
+ })
+ );
+
+ while (els.length) {
+ for (var i = 0; i < els.length; i++) {
+ var el = $(els[i]);
+ if (el.is('.toggle')) {
+ el.find('.toggleButton')
+ .first()
+ .click();
+ }
+ }
+ els = el.parent();
+ }
+ }
+
+ function personalizeInstallInstructions() {
+ var prefix = '?download=';
+ var s = window.location.search;
+ if (s.indexOf(prefix) != 0) {
+ // No 'download' query string; detect "test" instructions from User Agent.
+ if (navigator.platform.indexOf('Win') != -1) {
+ $('.testUnix').hide();
+ $('.testWindows').show();
+ } else {
+ $('.testUnix').show();
+ $('.testWindows').hide();
+ }
+ return;
+ }
+
+ var filename = s.substr(prefix.length);
+ var filenameRE = /^go1\.\d+(\.\d+)?([a-z0-9]+)?\.([a-z0-9]+)(-[a-z0-9]+)?(-osx10\.[68])?\.([a-z.]+)$/;
+ var m = filenameRE.exec(filename);
+ if (!m) {
+ // Can't interpret file name; bail.
+ return;
+ }
+ $('.downloadFilename').text(filename);
+ $('.hideFromDownload').hide();
+
+ var os = m[3];
+ var ext = m[6];
+ if (ext != 'tar.gz') {
+ $('#tarballInstructions').hide();
+ }
+ if (os != 'darwin' || ext != 'pkg') {
+ $('#darwinPackageInstructions').hide();
+ }
+ if (os != 'windows') {
+ $('#windowsInstructions').hide();
+ $('.testUnix').show();
+ $('.testWindows').hide();
+ } else {
+ if (ext != 'msi') {
+ $('#windowsInstallerInstructions').hide();
+ }
+ if (ext != 'zip') {
+ $('#windowsZipInstructions').hide();
+ }
+ $('.testUnix').hide();
+ $('.testWindows').show();
+ }
+
+ var download = '/dl/' + filename;
+
+ var message = $(
+ '<p class="downloading">' +
+ 'Your download should begin shortly. ' +
+ 'If it does not, click <a>this link</a>.</p>'
+ );
+ message.find('a').attr('href', download);
+ message.insertAfter('#nav');
+
+ window.location = download;
+ }
+
+ function updateVersionTags() {
+ var v = window.goVersion;
+ if (/^go[0-9.]+$/.test(v)) {
+ $('.versionTag')
+ .empty()
+ .text(v);
+ $('.whereTag').hide();
+ }
+ }
+
+ function addPermalinks() {
+ function addPermalink(source, parent) {
+ var id = source.attr('id');
+ if (id == '' || id.indexOf('tmp_') === 0) {
+ // Auto-generated permalink.
+ return;
+ }
+ if (parent.find('> .permalink').length) {
+ // Already attached.
+ return;
+ }
+ parent
+ .append(' ')
+ .append($("<a class='permalink'>¶</a>").attr('href', '#' + id));
+ }
+
+ $('#page .container')
+ .find('h2[id], h3[id]')
+ .each(function() {
+ var el = $(this);
+ addPermalink(el, el);
+ });
+
+ $('#page .container')
+ .find('dl[id]')
+ .each(function() {
+ var el = $(this);
+ // Add the anchor to the "dt" element.
+ addPermalink(el, el.find('> dt').first());
+ });
+ }
+
+ $('.js-expandAll').click(function() {
+ if ($(this).hasClass('collapsed')) {
+ toggleExamples('toggle');
+ $(this).text('(Collapse All)');
+ } else {
+ toggleExamples('toggleVisible');
+ $(this).text('(Expand All)');
+ }
+ $(this).toggleClass('collapsed');
+ });
+
+ function toggleExamples(className) {
+ // We need to explicitly iterate through divs starting with "example_"
+ // to avoid toggling Overview and Index collapsibles.
+ $("[id^='example_']").each(function() {
+ // Check for state and click it only if required.
+ if ($(this).hasClass(className)) {
+ $(this)
+ .find('.toggleButton')
+ .first()
+ .click();
+ }
+ });
+ }
+
+ $(document).ready(function() {
+ generateTOC();
+ addPermalinks();
+ bindToggles('.toggle');
+ bindToggles('.toggleVisible');
+ bindToggleLinks('.exampleLink', 'example_');
+ bindToggleLinks('.overviewLink', '');
+ bindToggleLinks('.examplesLink', '');
+ bindToggleLinks('.indexLink', '');
+ setupInlinePlayground();
+ fixFocus();
+ toggleHash();
+ personalizeInstallInstructions();
+ updateVersionTags();
+
+ // godoc.html defines window.initFuncs in the <head> tag, and root.html and
+ // codewalk.js push their on-page-ready functions to the list.
+ // We execute those functions here, to avoid loading jQuery until the page
+ // content is loaded.
+ for (var i = 0; i < window.initFuncs.length; i++) window.initFuncs[i]();
+ });
+})();
diff --git a/_content/lib/godoc/images/cloud-download.svg b/_content/lib/godoc/images/cloud-download.svg
new file mode 100644
index 0000000..c6a367d
--- /dev/null
+++ b/_content/lib/godoc/images/cloud-download.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24"><path fill="none" d="M0 0h24v24H0V0z"/><path fill="#202224" d="M19.35 10.04C18.67 6.59 15.64 4 12 4 9.11 4 6.6 5.64 5.35 8.04 2.34 8.36 0 10.91 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5 0-2.64-2.05-4.78-4.65-4.96zM19 18H6c-2.21 0-4-1.79-4-4 0-2.05 1.53-3.76 3.56-3.97l1.07-.11.5-.95C8.08 7.14 9.94 6 12 6c2.62 0 4.88 1.86 5.39 4.43l.3 1.5 1.53.11c1.56.1 2.78 1.41 2.78 2.96 0 1.65-1.35 3-3 3zm-5.55-8h-2.9v3H8l4 4 4-4h-2.55z"/></svg>
diff --git a/_content/lib/godoc/images/footer-gopher.jpg b/_content/lib/godoc/images/footer-gopher.jpg
new file mode 100644
index 0000000..498fb5d
--- /dev/null
+++ b/_content/lib/godoc/images/footer-gopher.jpg
Binary files differ
diff --git a/_content/lib/godoc/images/go-logo-blue.svg b/_content/lib/godoc/images/go-logo-blue.svg
new file mode 100644
index 0000000..da6ea83
--- /dev/null
+++ b/_content/lib/godoc/images/go-logo-blue.svg
@@ -0,0 +1 @@
+<svg height="78" viewBox="0 0 207 78" width="207" xmlns="http://www.w3.org/2000/svg"><g fill="#00acd7" fill-rule="evenodd"><path d="m16.2 24.1c-.4 0-.5-.2-.3-.5l2.1-2.7c.2-.3.7-.5 1.1-.5h35.7c.4 0 .5.3.3.6l-1.7 2.6c-.2.3-.7.6-1 .6z"/><path d="m1.1 33.3c-.4 0-.5-.2-.3-.5l2.1-2.7c.2-.3.7-.5 1.1-.5h45.6c.4 0 .6.3.5.6l-.8 2.4c-.1.4-.5.6-.9.6z"/><path d="m25.3 42.5c-.4 0-.5-.3-.3-.6l1.4-2.5c.2-.3.6-.6 1-.6h20c.4 0 .6.3.6.7l-.2 2.4c0 .4-.4.7-.7.7z"/><g transform="translate(55)"><path d="m74.1 22.3c-6.3 1.6-10.6 2.8-16.8 4.4-1.5.4-1.6.5-2.9-1-1.5-1.7-2.6-2.8-4.7-3.8-6.3-3.1-12.4-2.2-18.1 1.5-6.8 4.4-10.3 10.9-10.2 19 .1 8 5.6 14.6 13.5 15.7 6.8.9 12.5-1.5 17-6.6.9-1.1 1.7-2.3 2.7-3.7-3.6 0-8.1 0-19.3 0-2.1 0-2.6-1.3-1.9-3 1.3-3.1 3.7-8.3 5.1-10.9.3-.6 1-1.6 2.5-1.6h36.4c-.2 2.7-.2 5.4-.6 8.1-1.1 7.2-3.8 13.8-8.2 19.6-7.2 9.5-16.6 15.4-28.5 17-9.8 1.3-18.9-.6-26.9-6.6-7.4-5.6-11.6-13-12.7-22.2-1.3-10.9 1.9-20.7 8.5-29.3 7.1-9.3 16.5-15.2 28-17.3 9.4-1.7 18.4-.6 26.5 4.9 5.3 3.5 9.1 8.3 11.6 14.1.6.9.2 1.4-1 1.7z"/><path d="m107.2 77.6c-9.1-.2-17.4-2.8-24.4-8.8-5.9-5.1-9.6-11.6-10.8-19.3-1.8-11.3 1.3-21.3 8.1-30.2 7.3-9.6 16.1-14.6 28-16.7 10.2-1.8 19.8-.8 28.5 5.1 7.9 5.4 12.8 12.7 14.1 22.3 1.7 13.5-2.2 24.5-11.5 33.9-6.6 6.7-14.7 10.9-24 12.8-2.7.5-5.4.6-8 .9zm23.8-40.4c-.1-1.3-.1-2.3-.3-3.3-1.8-9.9-10.9-15.5-20.4-13.3-9.3 2.1-15.3 8-17.5 17.4-1.8 7.8 2 15.7 9.2 18.9 5.5 2.4 11 2.1 16.3-.6 7.9-4.1 12.2-10.5 12.7-19.1z" fill-rule="nonzero"/></g></g></svg>
\ No newline at end of file
diff --git a/_content/lib/godoc/images/home-gopher.png b/_content/lib/godoc/images/home-gopher.png
new file mode 100644
index 0000000..85a5d2e
--- /dev/null
+++ b/_content/lib/godoc/images/home-gopher.png
Binary files differ
diff --git a/_content/lib/godoc/images/minus.gif b/_content/lib/godoc/images/minus.gif
new file mode 100644
index 0000000..47fb7b7
--- /dev/null
+++ b/_content/lib/godoc/images/minus.gif
Binary files differ
diff --git a/_content/lib/godoc/images/play-link.svg b/_content/lib/godoc/images/play-link.svg
new file mode 100644
index 0000000..30beeaa
--- /dev/null
+++ b/_content/lib/godoc/images/play-link.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24"><path fill="none" d="M0 0h24v24H0V0z"/><path fill="#00758d" d="M9 5v2h6.59L4 18.59 5.41 20 17 8.41V15h2V5H9z"/></svg>
diff --git a/_content/lib/godoc/images/plus.gif b/_content/lib/godoc/images/plus.gif
new file mode 100644
index 0000000..6906621
--- /dev/null
+++ b/_content/lib/godoc/images/plus.gif
Binary files differ
diff --git a/_content/lib/godoc/images/treeview-black-line.gif b/_content/lib/godoc/images/treeview-black-line.gif
new file mode 100644
index 0000000..e549687
--- /dev/null
+++ b/_content/lib/godoc/images/treeview-black-line.gif
Binary files differ
diff --git a/_content/lib/godoc/images/treeview-black.gif b/_content/lib/godoc/images/treeview-black.gif
new file mode 100644
index 0000000..b718d17
--- /dev/null
+++ b/_content/lib/godoc/images/treeview-black.gif
Binary files differ
diff --git a/_content/lib/godoc/images/treeview-default-line.gif b/_content/lib/godoc/images/treeview-default-line.gif
new file mode 100644
index 0000000..37114d3
--- /dev/null
+++ b/_content/lib/godoc/images/treeview-default-line.gif
Binary files differ
diff --git a/_content/lib/godoc/images/treeview-default.gif b/_content/lib/godoc/images/treeview-default.gif
new file mode 100644
index 0000000..76eee60
--- /dev/null
+++ b/_content/lib/godoc/images/treeview-default.gif
Binary files differ
diff --git a/_content/lib/godoc/images/treeview-gray-line.gif b/_content/lib/godoc/images/treeview-gray-line.gif
new file mode 100644
index 0000000..3760044
--- /dev/null
+++ b/_content/lib/godoc/images/treeview-gray-line.gif
Binary files differ
diff --git a/_content/lib/godoc/images/treeview-gray.gif b/_content/lib/godoc/images/treeview-gray.gif
new file mode 100644
index 0000000..cfdf1ab
--- /dev/null
+++ b/_content/lib/godoc/images/treeview-gray.gif
Binary files differ
diff --git a/_content/lib/godoc/jquery.js b/_content/lib/godoc/jquery.js
new file mode 100644
index 0000000..bc3fbc8
--- /dev/null
+++ b/_content/lib/godoc/jquery.js
@@ -0,0 +1,2 @@
+/*! jQuery v1.8.2 jquery.com | jquery.org/license */
+(function(a,b){function G(a){var b=F[a]={};return p.each(a.split(s),function(a,c){b[c]=!0}),b}function J(a,c,d){if(d===b&&a.nodeType===1){var e="data-"+c.replace(I,"-$1").toLowerCase();d=a.getAttribute(e);if(typeof d=="string"){try{d=d==="true"?!0:d==="false"?!1:d==="null"?null:+d+""===d?+d:H.test(d)?p.parseJSON(d):d}catch(f){}p.data(a,c,d)}else d=b}return d}function K(a){var b;for(b in a){if(b==="data"&&p.isEmptyObject(a[b]))continue;if(b!=="toJSON")return!1}return!0}function ba(){return!1}function bb(){return!0}function bh(a){return!a||!a.parentNode||a.parentNode.nodeType===11}function bi(a,b){do a=a[b];while(a&&a.nodeType!==1);return a}function bj(a,b,c){b=b||0;if(p.isFunction(b))return p.grep(a,function(a,d){var e=!!b.call(a,d,a);return e===c});if(b.nodeType)return p.grep(a,function(a,d){return a===b===c});if(typeof b=="string"){var d=p.grep(a,function(a){return a.nodeType===1});if(be.test(b))return p.filter(b,d,!c);b=p.filter(b,d)}return p.grep(a,function(a,d){return p.inArray(a,b)>=0===c})}function bk(a){var b=bl.split("|"),c=a.createDocumentFragment();if(c.createElement)while(b.length)c.createElement(b.pop());return c}function bC(a,b){return a.getElementsByTagName(b)[0]||a.appendChild(a.ownerDocument.createElement(b))}function bD(a,b){if(b.nodeType!==1||!p.hasData(a))return;var c,d,e,f=p._data(a),g=p._data(b,f),h=f.events;if(h){delete g.handle,g.events={};for(c in h)for(d=0,e=h[c].length;d<e;d++)p.event.add(b,c,h[c][d])}g.data&&(g.data=p.extend({},g.data))}function bE(a,b){var c;if(b.nodeType!==1)return;b.clearAttributes&&b.clearAttributes(),b.mergeAttributes&&b.mergeAttributes(a),c=b.nodeName.toLowerCase(),c==="object"?(b.parentNode&&(b.outerHTML=a.outerHTML),p.support.html5Clone&&a.innerHTML&&!p.trim(b.innerHTML)&&(b.innerHTML=a.innerHTML)):c==="input"&&bv.test(a.type)?(b.defaultChecked=b.checked=a.checked,b.value!==a.value&&(b.value=a.value)):c==="option"?b.selected=a.defaultSelected:c==="input"||c==="textarea"?b.defaultValue=a.defaultValue:c==="script"&&b.text!==a.text&&(b.text=a.text),b.removeAttribute(p.expando)}function bF(a){return typeof a.getElementsByTagName!="undefined"?a.getElementsByTagName("*"):typeof a.querySelectorAll!="undefined"?a.querySelectorAll("*"):[]}function bG(a){bv.test(a.type)&&(a.defaultChecked=a.checked)}function bY(a,b){if(b in a)return b;var c=b.charAt(0).toUpperCase()+b.slice(1),d=b,e=bW.length;while(e--){b=bW[e]+c;if(b in a)return b}return d}function bZ(a,b){return a=b||a,p.css(a,"display")==="none"||!p.contains(a.ownerDocument,a)}function b$(a,b){var c,d,e=[],f=0,g=a.length;for(;f<g;f++){c=a[f];if(!c.style)continue;e[f]=p._data(c,"olddisplay"),b?(!e[f]&&c.style.display==="none"&&(c.style.display=""),c.style.display===""&&bZ(c)&&(e[f]=p._data(c,"olddisplay",cc(c.nodeName)))):(d=bH(c,"display"),!e[f]&&d!=="none"&&p._data(c,"olddisplay",d))}for(f=0;f<g;f++){c=a[f];if(!c.style)continue;if(!b||c.style.display==="none"||c.style.display==="")c.style.display=b?e[f]||"":"none"}return a}function b_(a,b,c){var d=bP.exec(b);return d?Math.max(0,d[1]-(c||0))+(d[2]||"px"):b}function ca(a,b,c,d){var e=c===(d?"border":"content")?4:b==="width"?1:0,f=0;for(;e<4;e+=2)c==="margin"&&(f+=p.css(a,c+bV[e],!0)),d?(c==="content"&&(f-=parseFloat(bH(a,"padding"+bV[e]))||0),c!=="margin"&&(f-=parseFloat(bH(a,"border"+bV[e]+"Width"))||0)):(f+=parseFloat(bH(a,"padding"+bV[e]))||0,c!=="padding"&&(f+=parseFloat(bH(a,"border"+bV[e]+"Width"))||0));return f}function cb(a,b,c){var d=b==="width"?a.offsetWidth:a.offsetHeight,e=!0,f=p.support.boxSizing&&p.css(a,"boxSizing")==="border-box";if(d<=0||d==null){d=bH(a,b);if(d<0||d==null)d=a.style[b];if(bQ.test(d))return d;e=f&&(p.support.boxSizingReliable||d===a.style[b]),d=parseFloat(d)||0}return d+ca(a,b,c||(f?"border":"content"),e)+"px"}function cc(a){if(bS[a])return bS[a];var b=p("<"+a+">").appendTo(e.body),c=b.css("display");b.remove();if(c==="none"||c===""){bI=e.body.appendChild(bI||p.extend(e.createElement("iframe"),{frameBorder:0,width:0,height:0}));if(!bJ||!bI.createElement)bJ=(bI.contentWindow||bI.contentDocument).document,bJ.write("<!doctype html><html><body>"),bJ.close();b=bJ.body.appendChild(bJ.createElement(a)),c=bH(b,"display"),e.body.removeChild(bI)}return bS[a]=c,c}function ci(a,b,c,d){var e;if(p.isArray(b))p.each(b,function(b,e){c||ce.test(a)?d(a,e):ci(a+"["+(typeof e=="object"?b:"")+"]",e,c,d)});else if(!c&&p.type(b)==="object")for(e in b)ci(a+"["+e+"]",b[e],c,d);else d(a,b)}function cz(a){return function(b,c){typeof b!="string"&&(c=b,b="*");var d,e,f,g=b.toLowerCase().split(s),h=0,i=g.length;if(p.isFunction(c))for(;h<i;h++)d=g[h],f=/^\+/.test(d),f&&(d=d.substr(1)||"*"),e=a[d]=a[d]||[],e[f?"unshift":"push"](c)}}function cA(a,c,d,e,f,g){f=f||c.dataTypes[0],g=g||{},g[f]=!0;var h,i=a[f],j=0,k=i?i.length:0,l=a===cv;for(;j<k&&(l||!h);j++)h=i[j](c,d,e),typeof h=="string"&&(!l||g[h]?h=b:(c.dataTypes.unshift(h),h=cA(a,c,d,e,h,g)));return(l||!h)&&!g["*"]&&(h=cA(a,c,d,e,"*",g)),h}function cB(a,c){var d,e,f=p.ajaxSettings.flatOptions||{};for(d in c)c[d]!==b&&((f[d]?a:e||(e={}))[d]=c[d]);e&&p.extend(!0,a,e)}function cC(a,c,d){var e,f,g,h,i=a.contents,j=a.dataTypes,k=a.responseFields;for(f in k)f in d&&(c[k[f]]=d[f]);while(j[0]==="*")j.shift(),e===b&&(e=a.mimeType||c.getResponseHeader("content-type"));if(e)for(f in i)if(i[f]&&i[f].test(e)){j.unshift(f);break}if(j[0]in d)g=j[0];else{for(f in d){if(!j[0]||a.converters[f+" "+j[0]]){g=f;break}h||(h=f)}g=g||h}if(g)return g!==j[0]&&j.unshift(g),d[g]}function cD(a,b){var c,d,e,f,g=a.dataTypes.slice(),h=g[0],i={},j=0;a.dataFilter&&(b=a.dataFilter(b,a.dataType));if(g[1])for(c in a.converters)i[c.toLowerCase()]=a.converters[c];for(;e=g[++j];)if(e!=="*"){if(h!=="*"&&h!==e){c=i[h+" "+e]||i["* "+e];if(!c)for(d in i){f=d.split(" ");if(f[1]===e){c=i[h+" "+f[0]]||i["* "+f[0]];if(c){c===!0?c=i[d]:i[d]!==!0&&(e=f[0],g.splice(j--,0,e));break}}}if(c!==!0)if(c&&a["throws"])b=c(b);else try{b=c(b)}catch(k){return{state:"parsererror",error:c?k:"No conversion from "+h+" to "+e}}}h=e}return{state:"success",data:b}}function cL(){try{return new a.XMLHttpRequest}catch(b){}}function cM(){try{return new a.ActiveXObject("Microsoft.XMLHTTP")}catch(b){}}function cU(){return setTimeout(function(){cN=b},0),cN=p.now()}function cV(a,b){p.each(b,function(b,c){var d=(cT[b]||[]).concat(cT["*"]),e=0,f=d.length;for(;e<f;e++)if(d[e].call(a,b,c))return})}function cW(a,b,c){var d,e=0,f=0,g=cS.length,h=p.Deferred().always(function(){delete i.elem}),i=function(){var b=cN||cU(),c=Math.max(0,j.startTime+j.duration-b),d=1-(c/j.duration||0),e=0,f=j.tweens.length;for(;e<f;e++)j.tweens[e].run(d);return h.notifyWith(a,[j,d,c]),d<1&&f?c:(h.resolveWith(a,[j]),!1)},j=h.promise({elem:a,props:p.extend({},b),opts:p.extend(!0,{specialEasing:{}},c),originalProperties:b,originalOptions:c,startTime:cN||cU(),duration:c.duration,tweens:[],createTween:function(b,c,d){var e=p.Tween(a,j.opts,b,c,j.opts.specialEasing[b]||j.opts.easing);return j.tweens.push(e),e},stop:function(b){var c=0,d=b?j.tweens.length:0;for(;c<d;c++)j.tweens[c].run(1);return b?h.resolveWith(a,[j,b]):h.rejectWith(a,[j,b]),this}}),k=j.props;cX(k,j.opts.specialEasing);for(;e<g;e++){d=cS[e].call(j,a,k,j.opts);if(d)return d}return cV(j,k),p.isFunction(j.opts.start)&&j.opts.start.call(a,j),p.fx.timer(p.extend(i,{anim:j,queue:j.opts.queue,elem:a})),j.progress(j.opts.progress).done(j.opts.done,j.opts.complete).fail(j.opts.fail).always(j.opts.always)}function cX(a,b){var c,d,e,f,g;for(c in a){d=p.camelCase(c),e=b[d],f=a[c],p.isArray(f)&&(e=f[1],f=a[c]=f[0]),c!==d&&(a[d]=f,delete a[c]),g=p.cssHooks[d];if(g&&"expand"in g){f=g.expand(f),delete a[d];for(c in f)c in a||(a[c]=f[c],b[c]=e)}else b[d]=e}}function cY(a,b,c){var d,e,f,g,h,i,j,k,l=this,m=a.style,n={},o=[],q=a.nodeType&&bZ(a);c.queue||(j=p._queueHooks(a,"fx"),j.unqueued==null&&(j.unqueued=0,k=j.empty.fire,j.empty.fire=function(){j.unqueued||k()}),j.unqueued++,l.always(function(){l.always(function(){j.unqueued--,p.queue(a,"fx").length||j.empty.fire()})})),a.nodeType===1&&("height"in b||"width"in b)&&(c.overflow=[m.overflow,m.overflowX,m.overflowY],p.css(a,"display")==="inline"&&p.css(a,"float")==="none"&&(!p.support.inlineBlockNeedsLayout||cc(a.nodeName)==="inline"?m.display="inline-block":m.zoom=1)),c.overflow&&(m.overflow="hidden",p.support.shrinkWrapBlocks||l.done(function(){m.overflow=c.overflow[0],m.overflowX=c.overflow[1],m.overflowY=c.overflow[2]}));for(d in b){f=b[d];if(cP.exec(f)){delete b[d];if(f===(q?"hide":"show"))continue;o.push(d)}}g=o.length;if(g){h=p._data(a,"fxshow")||p._data(a,"fxshow",{}),q?p(a).show():l.done(function(){p(a).hide()}),l.done(function(){var b;p.removeData(a,"fxshow",!0);for(b in n)p.style(a,b,n[b])});for(d=0;d<g;d++)e=o[d],i=l.createTween(e,q?h[e]:0),n[e]=h[e]||p.style(a,e),e in h||(h[e]=i.start,q&&(i.end=i.start,i.start=e==="width"||e==="height"?1:0))}}function cZ(a,b,c,d,e){return new cZ.prototype.init(a,b,c,d,e)}function c$(a,b){var c,d={height:a},e=0;b=b?1:0;for(;e<4;e+=2-b)c=bV[e],d["margin"+c]=d["padding"+c]=a;return b&&(d.opacity=d.width=a),d}function da(a){return p.isWindow(a)?a:a.nodeType===9?a.defaultView||a.parentWindow:!1}var c,d,e=a.document,f=a.location,g=a.navigator,h=a.jQuery,i=a.$,j=Array.prototype.push,k=Array.prototype.slice,l=Array.prototype.indexOf,m=Object.prototype.toString,n=Object.prototype.hasOwnProperty,o=String.prototype.trim,p=function(a,b){return new p.fn.init(a,b,c)},q=/[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source,r=/\S/,s=/\s+/,t=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,u=/^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,v=/^<(\w+)\s*\/?>(?:<\/\1>|)$/,w=/^[\],:{}\s]*$/,x=/(?:^|:|,)(?:\s*\[)+/g,y=/\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,z=/"[^"\\\r\n]*"|true|false|null|-?(?:\d\d*\.|)\d+(?:[eE][\-+]?\d+|)/g,A=/^-ms-/,B=/-([\da-z])/gi,C=function(a,b){return(b+"").toUpperCase()},D=function(){e.addEventListener?(e.removeEventListener("DOMContentLoaded",D,!1),p.ready()):e.readyState==="complete"&&(e.detachEvent("onreadystatechange",D),p.ready())},E={};p.fn=p.prototype={constructor:p,init:function(a,c,d){var f,g,h,i;if(!a)return this;if(a.nodeType)return this.context=this[0]=a,this.length=1,this;if(typeof a=="string"){a.charAt(0)==="<"&&a.charAt(a.length-1)===">"&&a.length>=3?f=[null,a,null]:f=u.exec(a);if(f&&(f[1]||!c)){if(f[1])return c=c instanceof p?c[0]:c,i=c&&c.nodeType?c.ownerDocument||c:e,a=p.parseHTML(f[1],i,!0),v.test(f[1])&&p.isPlainObject(c)&&this.attr.call(a,c,!0),p.merge(this,a);g=e.getElementById(f[2]);if(g&&g.parentNode){if(g.id!==f[2])return d.find(a);this.length=1,this[0]=g}return this.context=e,this.selector=a,this}return!c||c.jquery?(c||d).find(a):this.constructor(c).find(a)}return p.isFunction(a)?d.ready(a):(a.selector!==b&&(this.selector=a.selector,this.context=a.context),p.makeArray(a,this))},selector:"",jquery:"1.8.2",length:0,size:function(){return this.length},toArray:function(){return k.call(this)},get:function(a){return a==null?this.toArray():a<0?this[this.length+a]:this[a]},pushStack:function(a,b,c){var d=p.merge(this.constructor(),a);return d.prevObject=this,d.context=this.context,b==="find"?d.selector=this.selector+(this.selector?" ":"")+c:b&&(d.selector=this.selector+"."+b+"("+c+")"),d},each:function(a,b){return p.each(this,a,b)},ready:function(a){return p.ready.promise().done(a),this},eq:function(a){return a=+a,a===-1?this.slice(a):this.slice(a,a+1)},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},slice:function(){return this.pushStack(k.apply(this,arguments),"slice",k.call(arguments).join(","))},map:function(a){return this.pushStack(p.map(this,function(b,c){return a.call(b,c,b)}))},end:function(){return this.prevObject||this.constructor(null)},push:j,sort:[].sort,splice:[].splice},p.fn.init.prototype=p.fn,p.extend=p.fn.extend=function(){var a,c,d,e,f,g,h=arguments[0]||{},i=1,j=arguments.length,k=!1;typeof h=="boolean"&&(k=h,h=arguments[1]||{},i=2),typeof h!="object"&&!p.isFunction(h)&&(h={}),j===i&&(h=this,--i);for(;i<j;i++)if((a=arguments[i])!=null)for(c in a){d=h[c],e=a[c];if(h===e)continue;k&&e&&(p.isPlainObject(e)||(f=p.isArray(e)))?(f?(f=!1,g=d&&p.isArray(d)?d:[]):g=d&&p.isPlainObject(d)?d:{},h[c]=p.extend(k,g,e)):e!==b&&(h[c]=e)}return h},p.extend({noConflict:function(b){return a.$===p&&(a.$=i),b&&a.jQuery===p&&(a.jQuery=h),p},isReady:!1,readyWait:1,holdReady:function(a){a?p.readyWait++:p.ready(!0)},ready:function(a){if(a===!0?--p.readyWait:p.isReady)return;if(!e.body)return setTimeout(p.ready,1);p.isReady=!0;if(a!==!0&&--p.readyWait>0)return;d.resolveWith(e,[p]),p.fn.trigger&&p(e).trigger("ready").off("ready")},isFunction:function(a){return p.type(a)==="function"},isArray:Array.isArray||function(a){return p.type(a)==="array"},isWindow:function(a){return a!=null&&a==a.window},isNumeric:function(a){return!isNaN(parseFloat(a))&&isFinite(a)},type:function(a){return a==null?String(a):E[m.call(a)]||"object"},isPlainObject:function(a){if(!a||p.type(a)!=="object"||a.nodeType||p.isWindow(a))return!1;try{if(a.constructor&&!n.call(a,"constructor")&&!n.call(a.constructor.prototype,"isPrototypeOf"))return!1}catch(c){return!1}var d;for(d in a);return d===b||n.call(a,d)},isEmptyObject:function(a){var b;for(b in a)return!1;return!0},error:function(a){throw new Error(a)},parseHTML:function(a,b,c){var d;return!a||typeof a!="string"?null:(typeof b=="boolean"&&(c=b,b=0),b=b||e,(d=v.exec(a))?[b.createElement(d[1])]:(d=p.buildFragment([a],b,c?null:[]),p.merge([],(d.cacheable?p.clone(d.fragment):d.fragment).childNodes)))},parseJSON:function(b){if(!b||typeof b!="string")return null;b=p.trim(b);if(a.JSON&&a.JSON.parse)return a.JSON.parse(b);if(w.test(b.replace(y,"@").replace(z,"]").replace(x,"")))return(new Function("return "+b))();p.error("Invalid JSON: "+b)},parseXML:function(c){var d,e;if(!c||typeof c!="string")return null;try{a.DOMParser?(e=new DOMParser,d=e.parseFromString(c,"text/xml")):(d=new ActiveXObject("Microsoft.XMLDOM"),d.async="false",d.loadXML(c))}catch(f){d=b}return(!d||!d.documentElement||d.getElementsByTagName("parsererror").length)&&p.error("Invalid XML: "+c),d},noop:function(){},globalEval:function(b){b&&r.test(b)&&(a.execScript||function(b){a.eval.call(a,b)})(b)},camelCase:function(a){return a.replace(A,"ms-").replace(B,C)},nodeName:function(a,b){return a.nodeName&&a.nodeName.toLowerCase()===b.toLowerCase()},each:function(a,c,d){var e,f=0,g=a.length,h=g===b||p.isFunction(a);if(d){if(h){for(e in a)if(c.apply(a[e],d)===!1)break}else for(;f<g;)if(c.apply(a[f++],d)===!1)break}else if(h){for(e in a)if(c.call(a[e],e,a[e])===!1)break}else for(;f<g;)if(c.call(a[f],f,a[f++])===!1)break;return a},trim:o&&!o.call(" ")?function(a){return a==null?"":o.call(a)}:function(a){return a==null?"":(a+"").replace(t,"")},makeArray:function(a,b){var c,d=b||[];return a!=null&&(c=p.type(a),a.length==null||c==="string"||c==="function"||c==="regexp"||p.isWindow(a)?j.call(d,a):p.merge(d,a)),d},inArray:function(a,b,c){var d;if(b){if(l)return l.call(b,a,c);d=b.length,c=c?c<0?Math.max(0,d+c):c:0;for(;c<d;c++)if(c in b&&b[c]===a)return c}return-1},merge:function(a,c){var d=c.length,e=a.length,f=0;if(typeof d=="number")for(;f<d;f++)a[e++]=c[f];else while(c[f]!==b)a[e++]=c[f++];return a.length=e,a},grep:function(a,b,c){var d,e=[],f=0,g=a.length;c=!!c;for(;f<g;f++)d=!!b(a[f],f),c!==d&&e.push(a[f]);return e},map:function(a,c,d){var e,f,g=[],h=0,i=a.length,j=a instanceof p||i!==b&&typeof i=="number"&&(i>0&&a[0]&&a[i-1]||i===0||p.isArray(a));if(j)for(;h<i;h++)e=c(a[h],h,d),e!=null&&(g[g.length]=e);else for(f in a)e=c(a[f],f,d),e!=null&&(g[g.length]=e);return g.concat.apply([],g)},guid:1,proxy:function(a,c){var d,e,f;return typeof c=="string"&&(d=a[c],c=a,a=d),p.isFunction(a)?(e=k.call(arguments,2),f=function(){return a.apply(c,e.concat(k.call(arguments)))},f.guid=a.guid=a.guid||p.guid++,f):b},access:function(a,c,d,e,f,g,h){var i,j=d==null,k=0,l=a.length;if(d&&typeof d=="object"){for(k in d)p.access(a,c,k,d[k],1,g,e);f=1}else if(e!==b){i=h===b&&p.isFunction(e),j&&(i?(i=c,c=function(a,b,c){return i.call(p(a),c)}):(c.call(a,e),c=null));if(c)for(;k<l;k++)c(a[k],d,i?e.call(a[k],k,c(a[k],d)):e,h);f=1}return f?a:j?c.call(a):l?c(a[0],d):g},now:function(){return(new Date).getTime()}}),p.ready.promise=function(b){if(!d){d=p.Deferred();if(e.readyState==="complete")setTimeout(p.ready,1);else if(e.addEventListener)e.addEventListener("DOMContentLoaded",D,!1),a.addEventListener("load",p.ready,!1);else{e.attachEvent("onreadystatechange",D),a.attachEvent("onload",p.ready);var c=!1;try{c=a.frameElement==null&&e.documentElement}catch(f){}c&&c.doScroll&&function g(){if(!p.isReady){try{c.doScroll("left")}catch(a){return setTimeout(g,50)}p.ready()}}()}}return d.promise(b)},p.each("Boolean Number String Function Array Date RegExp Object".split(" "),function(a,b){E["[object "+b+"]"]=b.toLowerCase()}),c=p(e);var F={};p.Callbacks=function(a){a=typeof a=="string"?F[a]||G(a):p.extend({},a);var c,d,e,f,g,h,i=[],j=!a.once&&[],k=function(b){c=a.memory&&b,d=!0,h=f||0,f=0,g=i.length,e=!0;for(;i&&h<g;h++)if(i[h].apply(b[0],b[1])===!1&&a.stopOnFalse){c=!1;break}e=!1,i&&(j?j.length&&k(j.shift()):c?i=[]:l.disable())},l={add:function(){if(i){var b=i.length;(function d(b){p.each(b,function(b,c){var e=p.type(c);e==="function"&&(!a.unique||!l.has(c))?i.push(c):c&&c.length&&e!=="string"&&d(c)})})(arguments),e?g=i.length:c&&(f=b,k(c))}return this},remove:function(){return i&&p.each(arguments,function(a,b){var c;while((c=p.inArray(b,i,c))>-1)i.splice(c,1),e&&(c<=g&&g--,c<=h&&h--)}),this},has:function(a){return p.inArray(a,i)>-1},empty:function(){return i=[],this},disable:function(){return i=j=c=b,this},disabled:function(){return!i},lock:function(){return j=b,c||l.disable(),this},locked:function(){return!j},fireWith:function(a,b){return b=b||[],b=[a,b.slice?b.slice():b],i&&(!d||j)&&(e?j.push(b):k(b)),this},fire:function(){return l.fireWith(this,arguments),this},fired:function(){return!!d}};return l},p.extend({Deferred:function(a){var b=[["resolve","done",p.Callbacks("once memory"),"resolved"],["reject","fail",p.Callbacks("once memory"),"rejected"],["notify","progress",p.Callbacks("memory")]],c="pending",d={state:function(){return c},always:function(){return e.done(arguments).fail(arguments),this},then:function(){var a=arguments;return p.Deferred(function(c){p.each(b,function(b,d){var f=d[0],g=a[b];e[d[1]](p.isFunction(g)?function(){var a=g.apply(this,arguments);a&&p.isFunction(a.promise)?a.promise().done(c.resolve).fail(c.reject).progress(c.notify):c[f+"With"](this===e?c:this,[a])}:c[f])}),a=null}).promise()},promise:function(a){return a!=null?p.extend(a,d):d}},e={};return d.pipe=d.then,p.each(b,function(a,f){var g=f[2],h=f[3];d[f[1]]=g.add,h&&g.add(function(){c=h},b[a^1][2].disable,b[2][2].lock),e[f[0]]=g.fire,e[f[0]+"With"]=g.fireWith}),d.promise(e),a&&a.call(e,e),e},when:function(a){var b=0,c=k.call(arguments),d=c.length,e=d!==1||a&&p.isFunction(a.promise)?d:0,f=e===1?a:p.Deferred(),g=function(a,b,c){return function(d){b[a]=this,c[a]=arguments.length>1?k.call(arguments):d,c===h?f.notifyWith(b,c):--e||f.resolveWith(b,c)}},h,i,j;if(d>1){h=new Array(d),i=new Array(d),j=new Array(d);for(;b<d;b++)c[b]&&p.isFunction(c[b].promise)?c[b].promise().done(g(b,j,c)).fail(f.reject).progress(g(b,i,h)):--e}return e||f.resolveWith(j,c),f.promise()}}),p.support=function(){var b,c,d,f,g,h,i,j,k,l,m,n=e.createElement("div");n.setAttribute("className","t"),n.innerHTML=" <link/><table></table><a href='/a'>a</a><input type='checkbox'/>",c=n.getElementsByTagName("*"),d=n.getElementsByTagName("a")[0],d.style.cssText="top:1px;float:left;opacity:.5";if(!c||!c.length)return{};f=e.createElement("select"),g=f.appendChild(e.createElement("option")),h=n.getElementsByTagName("input")[0],b={leadingWhitespace:n.firstChild.nodeType===3,tbody:!n.getElementsByTagName("tbody").length,htmlSerialize:!!n.getElementsByTagName("link").length,style:/top/.test(d.getAttribute("style")),hrefNormalized:d.getAttribute("href")==="/a",opacity:/^0.5/.test(d.style.opacity),cssFloat:!!d.style.cssFloat,checkOn:h.value==="on",optSelected:g.selected,getSetAttribute:n.className!=="t",enctype:!!e.createElement("form").enctype,html5Clone:e.createElement("nav").cloneNode(!0).outerHTML!=="<:nav></:nav>",boxModel:e.compatMode==="CSS1Compat",submitBubbles:!0,changeBubbles:!0,focusinBubbles:!1,deleteExpando:!0,noCloneEvent:!0,inlineBlockNeedsLayout:!1,shrinkWrapBlocks:!1,reliableMarginRight:!0,boxSizingReliable:!0,pixelPosition:!1},h.checked=!0,b.noCloneChecked=h.cloneNode(!0).checked,f.disabled=!0,b.optDisabled=!g.disabled;try{delete n.test}catch(o){b.deleteExpando=!1}!n.addEventListener&&n.attachEvent&&n.fireEvent&&(n.attachEvent("onclick",m=function(){b.noCloneEvent=!1}),n.cloneNode(!0).fireEvent("onclick"),n.detachEvent("onclick",m)),h=e.createElement("input"),h.value="t",h.setAttribute("type","radio"),b.radioValue=h.value==="t",h.setAttribute("checked","checked"),h.setAttribute("name","t"),n.appendChild(h),i=e.createDocumentFragment(),i.appendChild(n.lastChild),b.checkClone=i.cloneNode(!0).cloneNode(!0).lastChild.checked,b.appendChecked=h.checked,i.removeChild(h),i.appendChild(n);if(n.attachEvent)for(k in{submit:!0,change:!0,focusin:!0})j="on"+k,l=j in n,l||(n.setAttribute(j,"return;"),l=typeof n[j]=="function"),b[k+"Bubbles"]=l;return p(function(){var c,d,f,g,h="padding:0;margin:0;border:0;display:block;overflow:hidden;",i=e.getElementsByTagName("body")[0];if(!i)return;c=e.createElement("div"),c.style.cssText="visibility:hidden;border:0;width:0;height:0;position:static;top:0;margin-top:1px",i.insertBefore(c,i.firstChild),d=e.createElement("div"),c.appendChild(d),d.innerHTML="<table><tr><td></td><td>t</td></tr></table>",f=d.getElementsByTagName("td"),f[0].style.cssText="padding:0;margin:0;border:0;display:none",l=f[0].offsetHeight===0,f[0].style.display="",f[1].style.display="none",b.reliableHiddenOffsets=l&&f[0].offsetHeight===0,d.innerHTML="",d.style.cssText="box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;",b.boxSizing=d.offsetWidth===4,b.doesNotIncludeMarginInBodyOffset=i.offsetTop!==1,a.getComputedStyle&&(b.pixelPosition=(a.getComputedStyle(d,null)||{}).top!=="1%",b.boxSizingReliable=(a.getComputedStyle(d,null)||{width:"4px"}).width==="4px",g=e.createElement("div"),g.style.cssText=d.style.cssText=h,g.style.marginRight=g.style.width="0",d.style.width="1px",d.appendChild(g),b.reliableMarginRight=!parseFloat((a.getComputedStyle(g,null)||{}).marginRight)),typeof d.style.zoom!="undefined"&&(d.innerHTML="",d.style.cssText=h+"width:1px;padding:1px;display:inline;zoom:1",b.inlineBlockNeedsLayout=d.offsetWidth===3,d.style.display="block",d.style.overflow="visible",d.innerHTML="<div></div>",d.firstChild.style.width="5px",b.shrinkWrapBlocks=d.offsetWidth!==3,c.style.zoom=1),i.removeChild(c),c=d=f=g=null}),i.removeChild(n),c=d=f=g=h=i=n=null,b}();var H=/(?:\{[\s\S]*\}|\[[\s\S]*\])$/,I=/([A-Z])/g;p.extend({cache:{},deletedIds:[],uuid:0,expando:"jQuery"+(p.fn.jquery+Math.random()).replace(/\D/g,""),noData:{embed:!0,object:"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",applet:!0},hasData:function(a){return a=a.nodeType?p.cache[a[p.expando]]:a[p.expando],!!a&&!K(a)},data:function(a,c,d,e){if(!p.acceptData(a))return;var f,g,h=p.expando,i=typeof c=="string",j=a.nodeType,k=j?p.cache:a,l=j?a[h]:a[h]&&h;if((!l||!k[l]||!e&&!k[l].data)&&i&&d===b)return;l||(j?a[h]=l=p.deletedIds.pop()||p.guid++:l=h),k[l]||(k[l]={},j||(k[l].toJSON=p.noop));if(typeof c=="object"||typeof c=="function")e?k[l]=p.extend(k[l],c):k[l].data=p.extend(k[l].data,c);return f=k[l],e||(f.data||(f.data={}),f=f.data),d!==b&&(f[p.camelCase(c)]=d),i?(g=f[c],g==null&&(g=f[p.camelCase(c)])):g=f,g},removeData:function(a,b,c){if(!p.acceptData(a))return;var d,e,f,g=a.nodeType,h=g?p.cache:a,i=g?a[p.expando]:p.expando;if(!h[i])return;if(b){d=c?h[i]:h[i].data;if(d){p.isArray(b)||(b in d?b=[b]:(b=p.camelCase(b),b in d?b=[b]:b=b.split(" ")));for(e=0,f=b.length;e<f;e++)delete d[b[e]];if(!(c?K:p.isEmptyObject)(d))return}}if(!c){delete h[i].data;if(!K(h[i]))return}g?p.cleanData([a],!0):p.support.deleteExpando||h!=h.window?delete h[i]:h[i]=null},_data:function(a,b,c){return p.data(a,b,c,!0)},acceptData:function(a){var b=a.nodeName&&p.noData[a.nodeName.toLowerCase()];return!b||b!==!0&&a.getAttribute("classid")===b}}),p.fn.extend({data:function(a,c){var d,e,f,g,h,i=this[0],j=0,k=null;if(a===b){if(this.length){k=p.data(i);if(i.nodeType===1&&!p._data(i,"parsedAttrs")){f=i.attributes;for(h=f.length;j<h;j++)g=f[j].name,g.indexOf("data-")||(g=p.camelCase(g.substring(5)),J(i,g,k[g]));p._data(i,"parsedAttrs",!0)}}return k}return typeof a=="object"?this.each(function(){p.data(this,a)}):(d=a.split(".",2),d[1]=d[1]?"."+d[1]:"",e=d[1]+"!",p.access(this,function(c){if(c===b)return k=this.triggerHandler("getData"+e,[d[0]]),k===b&&i&&(k=p.data(i,a),k=J(i,a,k)),k===b&&d[1]?this.data(d[0]):k;d[1]=c,this.each(function(){var b=p(this);b.triggerHandler("setData"+e,d),p.data(this,a,c),b.triggerHandler("changeData"+e,d)})},null,c,arguments.length>1,null,!1))},removeData:function(a){return this.each(function(){p.removeData(this,a)})}}),p.extend({queue:function(a,b,c){var d;if(a)return b=(b||"fx")+"queue",d=p._data(a,b),c&&(!d||p.isArray(c)?d=p._data(a,b,p.makeArray(c)):d.push(c)),d||[]},dequeue:function(a,b){b=b||"fx";var c=p.queue(a,b),d=c.length,e=c.shift(),f=p._queueHooks(a,b),g=function(){p.dequeue(a,b)};e==="inprogress"&&(e=c.shift(),d--),e&&(b==="fx"&&c.unshift("inprogress"),delete f.stop,e.call(a,g,f)),!d&&f&&f.empty.fire()},_queueHooks:function(a,b){var c=b+"queueHooks";return p._data(a,c)||p._data(a,c,{empty:p.Callbacks("once memory").add(function(){p.removeData(a,b+"queue",!0),p.removeData(a,c,!0)})})}}),p.fn.extend({queue:function(a,c){var d=2;return typeof a!="string"&&(c=a,a="fx",d--),arguments.length<d?p.queue(this[0],a):c===b?this:this.each(function(){var b=p.queue(this,a,c);p._queueHooks(this,a),a==="fx"&&b[0]!=="inprogress"&&p.dequeue(this,a)})},dequeue:function(a){return this.each(function(){p.dequeue(this,a)})},delay:function(a,b){return a=p.fx?p.fx.speeds[a]||a:a,b=b||"fx",this.queue(b,function(b,c){var d=setTimeout(b,a);c.stop=function(){clearTimeout(d)}})},clearQueue:function(a){return this.queue(a||"fx",[])},promise:function(a,c){var d,e=1,f=p.Deferred(),g=this,h=this.length,i=function(){--e||f.resolveWith(g,[g])};typeof a!="string"&&(c=a,a=b),a=a||"fx";while(h--)d=p._data(g[h],a+"queueHooks"),d&&d.empty&&(e++,d.empty.add(i));return i(),f.promise(c)}});var L,M,N,O=/[\t\r\n]/g,P=/\r/g,Q=/^(?:button|input)$/i,R=/^(?:button|input|object|select|textarea)$/i,S=/^a(?:rea|)$/i,T=/^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,U=p.support.getSetAttribute;p.fn.extend({attr:function(a,b){return p.access(this,p.attr,a,b,arguments.length>1)},removeAttr:function(a){return this.each(function(){p.removeAttr(this,a)})},prop:function(a,b){return p.access(this,p.prop,a,b,arguments.length>1)},removeProp:function(a){return a=p.propFix[a]||a,this.each(function(){try{this[a]=b,delete this[a]}catch(c){}})},addClass:function(a){var b,c,d,e,f,g,h;if(p.isFunction(a))return this.each(function(b){p(this).addClass(a.call(this,b,this.className))});if(a&&typeof a=="string"){b=a.split(s);for(c=0,d=this.length;c<d;c++){e=this[c];if(e.nodeType===1)if(!e.className&&b.length===1)e.className=a;else{f=" "+e.className+" ";for(g=0,h=b.length;g<h;g++)f.indexOf(" "+b[g]+" ")<0&&(f+=b[g]+" ");e.className=p.trim(f)}}}return this},removeClass:function(a){var c,d,e,f,g,h,i;if(p.isFunction(a))return this.each(function(b){p(this).removeClass(a.call(this,b,this.className))});if(a&&typeof a=="string"||a===b){c=(a||"").split(s);for(h=0,i=this.length;h<i;h++){e=this[h];if(e.nodeType===1&&e.className){d=(" "+e.className+" ").replace(O," ");for(f=0,g=c.length;f<g;f++)while(d.indexOf(" "+c[f]+" ")>=0)d=d.replace(" "+c[f]+" "," ");e.className=a?p.trim(d):""}}}return this},toggleClass:function(a,b){var c=typeof a,d=typeof b=="boolean";return p.isFunction(a)?this.each(function(c){p(this).toggleClass(a.call(this,c,this.className,b),b)}):this.each(function(){if(c==="string"){var e,f=0,g=p(this),h=b,i=a.split(s);while(e=i[f++])h=d?h:!g.hasClass(e),g[h?"addClass":"removeClass"](e)}else if(c==="undefined"||c==="boolean")this.className&&p._data(this,"__className__",this.className),this.className=this.className||a===!1?"":p._data(this,"__className__")||""})},hasClass:function(a){var b=" "+a+" ",c=0,d=this.length;for(;c<d;c++)if(this[c].nodeType===1&&(" "+this[c].className+" ").replace(O," ").indexOf(b)>=0)return!0;return!1},val:function(a){var c,d,e,f=this[0];if(!arguments.length){if(f)return c=p.valHooks[f.type]||p.valHooks[f.nodeName.toLowerCase()],c&&"get"in c&&(d=c.get(f,"value"))!==b?d:(d=f.value,typeof d=="string"?d.replace(P,""):d==null?"":d);return}return e=p.isFunction(a),this.each(function(d){var f,g=p(this);if(this.nodeType!==1)return;e?f=a.call(this,d,g.val()):f=a,f==null?f="":typeof f=="number"?f+="":p.isArray(f)&&(f=p.map(f,function(a){return a==null?"":a+""})),c=p.valHooks[this.type]||p.valHooks[this.nodeName.toLowerCase()];if(!c||!("set"in c)||c.set(this,f,"value")===b)this.value=f})}}),p.extend({valHooks:{option:{get:function(a){var b=a.attributes.value;return!b||b.specified?a.value:a.text}},select:{get:function(a){var b,c,d,e,f=a.selectedIndex,g=[],h=a.options,i=a.type==="select-one";if(f<0)return null;c=i?f:0,d=i?f+1:h.length;for(;c<d;c++){e=h[c];if(e.selected&&(p.support.optDisabled?!e.disabled:e.getAttribute("disabled")===null)&&(!e.parentNode.disabled||!p.nodeName(e.parentNode,"optgroup"))){b=p(e).val();if(i)return b;g.push(b)}}return i&&!g.length&&h.length?p(h[f]).val():g},set:function(a,b){var c=p.makeArray(b);return p(a).find("option").each(function(){this.selected=p.inArray(p(this).val(),c)>=0}),c.length||(a.selectedIndex=-1),c}}},attrFn:{},attr:function(a,c,d,e){var f,g,h,i=a.nodeType;if(!a||i===3||i===8||i===2)return;if(e&&p.isFunction(p.fn[c]))return p(a)[c](d);if(typeof a.getAttribute=="undefined")return p.prop(a,c,d);h=i!==1||!p.isXMLDoc(a),h&&(c=c.toLowerCase(),g=p.attrHooks[c]||(T.test(c)?M:L));if(d!==b){if(d===null){p.removeAttr(a,c);return}return g&&"set"in g&&h&&(f=g.set(a,d,c))!==b?f:(a.setAttribute(c,d+""),d)}return g&&"get"in g&&h&&(f=g.get(a,c))!==null?f:(f=a.getAttribute(c),f===null?b:f)},removeAttr:function(a,b){var c,d,e,f,g=0;if(b&&a.nodeType===1){d=b.split(s);for(;g<d.length;g++)e=d[g],e&&(c=p.propFix[e]||e,f=T.test(e),f||p.attr(a,e,""),a.removeAttribute(U?e:c),f&&c in a&&(a[c]=!1))}},attrHooks:{type:{set:function(a,b){if(Q.test(a.nodeName)&&a.parentNode)p.error("type property can't be changed");else if(!p.support.radioValue&&b==="radio"&&p.nodeName(a,"input")){var c=a.value;return a.setAttribute("type",b),c&&(a.value=c),b}}},value:{get:function(a,b){return L&&p.nodeName(a,"button")?L.get(a,b):b in a?a.value:null},set:function(a,b,c){if(L&&p.nodeName(a,"button"))return L.set(a,b,c);a.value=b}}},propFix:{tabindex:"tabIndex",readonly:"readOnly","for":"htmlFor","class":"className",maxlength:"maxLength",cellspacing:"cellSpacing",cellpadding:"cellPadding",rowspan:"rowSpan",colspan:"colSpan",usemap:"useMap",frameborder:"frameBorder",contenteditable:"contentEditable"},prop:function(a,c,d){var e,f,g,h=a.nodeType;if(!a||h===3||h===8||h===2)return;return g=h!==1||!p.isXMLDoc(a),g&&(c=p.propFix[c]||c,f=p.propHooks[c]),d!==b?f&&"set"in f&&(e=f.set(a,d,c))!==b?e:a[c]=d:f&&"get"in f&&(e=f.get(a,c))!==null?e:a[c]},propHooks:{tabIndex:{get:function(a){var c=a.getAttributeNode("tabindex");return c&&c.specified?parseInt(c.value,10):R.test(a.nodeName)||S.test(a.nodeName)&&a.href?0:b}}}}),M={get:function(a,c){var d,e=p.prop(a,c);return e===!0||typeof e!="boolean"&&(d=a.getAttributeNode(c))&&d.nodeValue!==!1?c.toLowerCase():b},set:function(a,b,c){var d;return b===!1?p.removeAttr(a,c):(d=p.propFix[c]||c,d in a&&(a[d]=!0),a.setAttribute(c,c.toLowerCase())),c}},U||(N={name:!0,id:!0,coords:!0},L=p.valHooks.button={get:function(a,c){var d;return d=a.getAttributeNode(c),d&&(N[c]?d.value!=="":d.specified)?d.value:b},set:function(a,b,c){var d=a.getAttributeNode(c);return d||(d=e.createAttribute(c),a.setAttributeNode(d)),d.value=b+""}},p.each(["width","height"],function(a,b){p.attrHooks[b]=p.extend(p.attrHooks[b],{set:function(a,c){if(c==="")return a.setAttribute(b,"auto"),c}})}),p.attrHooks.contenteditable={get:L.get,set:function(a,b,c){b===""&&(b="false"),L.set(a,b,c)}}),p.support.hrefNormalized||p.each(["href","src","width","height"],function(a,c){p.attrHooks[c]=p.extend(p.attrHooks[c],{get:function(a){var d=a.getAttribute(c,2);return d===null?b:d}})}),p.support.style||(p.attrHooks.style={get:function(a){return a.style.cssText.toLowerCase()||b},set:function(a,b){return a.style.cssText=b+""}}),p.support.optSelected||(p.propHooks.selected=p.extend(p.propHooks.selected,{get:function(a){var b=a.parentNode;return b&&(b.selectedIndex,b.parentNode&&b.parentNode.selectedIndex),null}})),p.support.enctype||(p.propFix.enctype="encoding"),p.support.checkOn||p.each(["radio","checkbox"],function(){p.valHooks[this]={get:function(a){return a.getAttribute("value")===null?"on":a.value}}}),p.each(["radio","checkbox"],function(){p.valHooks[this]=p.extend(p.valHooks[this],{set:function(a,b){if(p.isArray(b))return a.checked=p.inArray(p(a).val(),b)>=0}})});var V=/^(?:textarea|input|select)$/i,W=/^([^\.]*|)(?:\.(.+)|)$/,X=/(?:^|\s)hover(\.\S+|)\b/,Y=/^key/,Z=/^(?:mouse|contextmenu)|click/,$=/^(?:focusinfocus|focusoutblur)$/,_=function(a){return p.event.special.hover?a:a.replace(X,"mouseenter$1 mouseleave$1")};p.event={add:function(a,c,d,e,f){var g,h,i,j,k,l,m,n,o,q,r;if(a.nodeType===3||a.nodeType===8||!c||!d||!(g=p._data(a)))return;d.handler&&(o=d,d=o.handler,f=o.selector),d.guid||(d.guid=p.guid++),i=g.events,i||(g.events=i={}),h=g.handle,h||(g.handle=h=function(a){return typeof p!="undefined"&&(!a||p.event.triggered!==a.type)?p.event.dispatch.apply(h.elem,arguments):b},h.elem=a),c=p.trim(_(c)).split(" ");for(j=0;j<c.length;j++){k=W.exec(c[j])||[],l=k[1],m=(k[2]||"").split(".").sort(),r=p.event.special[l]||{},l=(f?r.delegateType:r.bindType)||l,r=p.event.special[l]||{},n=p.extend({type:l,origType:k[1],data:e,handler:d,guid:d.guid,selector:f,needsContext:f&&p.expr.match.needsContext.test(f),namespace:m.join(".")},o),q=i[l];if(!q){q=i[l]=[],q.delegateCount=0;if(!r.setup||r.setup.call(a,e,m,h)===!1)a.addEventListener?a.addEventListener(l,h,!1):a.attachEvent&&a.attachEvent("on"+l,h)}r.add&&(r.add.call(a,n),n.handler.guid||(n.handler.guid=d.guid)),f?q.splice(q.delegateCount++,0,n):q.push(n),p.event.global[l]=!0}a=null},global:{},remove:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,n,o,q,r=p.hasData(a)&&p._data(a);if(!r||!(m=r.events))return;b=p.trim(_(b||"")).split(" ");for(f=0;f<b.length;f++){g=W.exec(b[f])||[],h=i=g[1],j=g[2];if(!h){for(h in m)p.event.remove(a,h+b[f],c,d,!0);continue}n=p.event.special[h]||{},h=(d?n.delegateType:n.bindType)||h,o=m[h]||[],k=o.length,j=j?new RegExp("(^|\\.)"+j.split(".").sort().join("\\.(?:.*\\.|)")+"(\\.|$)"):null;for(l=0;l<o.length;l++)q=o[l],(e||i===q.origType)&&(!c||c.guid===q.guid)&&(!j||j.test(q.namespace))&&(!d||d===q.selector||d==="**"&&q.selector)&&(o.splice(l--,1),q.selector&&o.delegateCount--,n.remove&&n.remove.call(a,q));o.length===0&&k!==o.length&&((!n.teardown||n.teardown.call(a,j,r.handle)===!1)&&p.removeEvent(a,h,r.handle),delete m[h])}p.isEmptyObject(m)&&(delete r.handle,p.removeData(a,"events",!0))},customEvent:{getData:!0,setData:!0,changeData:!0},trigger:function(c,d,f,g){if(!f||f.nodeType!==3&&f.nodeType!==8){var h,i,j,k,l,m,n,o,q,r,s=c.type||c,t=[];if($.test(s+p.event.triggered))return;s.indexOf("!")>=0&&(s=s.slice(0,-1),i=!0),s.indexOf(".")>=0&&(t=s.split("."),s=t.shift(),t.sort());if((!f||p.event.customEvent[s])&&!p.event.global[s])return;c=typeof c=="object"?c[p.expando]?c:new p.Event(s,c):new p.Event(s),c.type=s,c.isTrigger=!0,c.exclusive=i,c.namespace=t.join("."),c.namespace_re=c.namespace?new RegExp("(^|\\.)"+t.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,m=s.indexOf(":")<0?"on"+s:"";if(!f){h=p.cache;for(j in h)h[j].events&&h[j].events[s]&&p.event.trigger(c,d,h[j].handle.elem,!0);return}c.result=b,c.target||(c.target=f),d=d!=null?p.makeArray(d):[],d.unshift(c),n=p.event.special[s]||{};if(n.trigger&&n.trigger.apply(f,d)===!1)return;q=[[f,n.bindType||s]];if(!g&&!n.noBubble&&!p.isWindow(f)){r=n.delegateType||s,k=$.test(r+s)?f:f.parentNode;for(l=f;k;k=k.parentNode)q.push([k,r]),l=k;l===(f.ownerDocument||e)&&q.push([l.defaultView||l.parentWindow||a,r])}for(j=0;j<q.length&&!c.isPropagationStopped();j++)k=q[j][0],c.type=q[j][1],o=(p._data(k,"events")||{})[c.type]&&p._data(k,"handle"),o&&o.apply(k,d),o=m&&k[m],o&&p.acceptData(k)&&o.apply&&o.apply(k,d)===!1&&c.preventDefault();return c.type=s,!g&&!c.isDefaultPrevented()&&(!n._default||n._default.apply(f.ownerDocument,d)===!1)&&(s!=="click"||!p.nodeName(f,"a"))&&p.acceptData(f)&&m&&f[s]&&(s!=="focus"&&s!=="blur"||c.target.offsetWidth!==0)&&!p.isWindow(f)&&(l=f[m],l&&(f[m]=null),p.event.triggered=s,f[s](),p.event.triggered=b,l&&(f[m]=l)),c.result}return},dispatch:function(c){c=p.event.fix(c||a.event);var d,e,f,g,h,i,j,l,m,n,o=(p._data(this,"events")||{})[c.type]||[],q=o.delegateCount,r=k.call(arguments),s=!c.exclusive&&!c.namespace,t=p.event.special[c.type]||{},u=[];r[0]=c,c.delegateTarget=this;if(t.preDispatch&&t.preDispatch.call(this,c)===!1)return;if(q&&(!c.button||c.type!=="click"))for(f=c.target;f!=this;f=f.parentNode||this)if(f.disabled!==!0||c.type!=="click"){h={},j=[];for(d=0;d<q;d++)l=o[d],m=l.selector,h[m]===b&&(h[m]=l.needsContext?p(m,this).index(f)>=0:p.find(m,this,null,[f]).length),h[m]&&j.push(l);j.length&&u.push({elem:f,matches:j})}o.length>q&&u.push({elem:this,matches:o.slice(q)});for(d=0;d<u.length&&!c.isPropagationStopped();d++){i=u[d],c.currentTarget=i.elem;for(e=0;e<i.matches.length&&!c.isImmediatePropagationStopped();e++){l=i.matches[e];if(s||!c.namespace&&!l.namespace||c.namespace_re&&c.namespace_re.test(l.namespace))c.data=l.data,c.handleObj=l,g=((p.event.special[l.origType]||{}).handle||l.handler).apply(i.elem,r),g!==b&&(c.result=g,g===!1&&(c.preventDefault(),c.stopPropagation()))}}return t.postDispatch&&t.postDispatch.call(this,c),c.result},props:"attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),fixHooks:{},keyHooks:{props:"char charCode key keyCode".split(" "),filter:function(a,b){return a.which==null&&(a.which=b.charCode!=null?b.charCode:b.keyCode),a}},mouseHooks:{props:"button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),filter:function(a,c){var d,f,g,h=c.button,i=c.fromElement;return a.pageX==null&&c.clientX!=null&&(d=a.target.ownerDocument||e,f=d.documentElement,g=d.body,a.pageX=c.clientX+(f&&f.scrollLeft||g&&g.scrollLeft||0)-(f&&f.clientLeft||g&&g.clientLeft||0),a.pageY=c.clientY+(f&&f.scrollTop||g&&g.scrollTop||0)-(f&&f.clientTop||g&&g.clientTop||0)),!a.relatedTarget&&i&&(a.relatedTarget=i===a.target?c.toElement:i),!a.which&&h!==b&&(a.which=h&1?1:h&2?3:h&4?2:0),a}},fix:function(a){if(a[p.expando])return a;var b,c,d=a,f=p.event.fixHooks[a.type]||{},g=f.props?this.props.concat(f.props):this.props;a=p.Event(d);for(b=g.length;b;)c=g[--b],a[c]=d[c];return a.target||(a.target=d.srcElement||e),a.target.nodeType===3&&(a.target=a.target.parentNode),a.metaKey=!!a.metaKey,f.filter?f.filter(a,d):a},special:{load:{noBubble:!0},focus:{delegateType:"focusin"},blur:{delegateType:"focusout"},beforeunload:{setup:function(a,b,c){p.isWindow(this)&&(this.onbeforeunload=c)},teardown:function(a,b){this.onbeforeunload===b&&(this.onbeforeunload=null)}}},simulate:function(a,b,c,d){var e=p.extend(new p.Event,c,{type:a,isSimulated:!0,originalEvent:{}});d?p.event.trigger(e,null,b):p.event.dispatch.call(b,e),e.isDefaultPrevented()&&c.preventDefault()}},p.event.handle=p.event.dispatch,p.removeEvent=e.removeEventListener?function(a,b,c){a.removeEventListener&&a.removeEventListener(b,c,!1)}:function(a,b,c){var d="on"+b;a.detachEvent&&(typeof a[d]=="undefined"&&(a[d]=null),a.detachEvent(d,c))},p.Event=function(a,b){if(this instanceof p.Event)a&&a.type?(this.originalEvent=a,this.type=a.type,this.isDefaultPrevented=a.defaultPrevented||a.returnValue===!1||a.getPreventDefault&&a.getPreventDefault()?bb:ba):this.type=a,b&&p.extend(this,b),this.timeStamp=a&&a.timeStamp||p.now(),this[p.expando]=!0;else return new p.Event(a,b)},p.Event.prototype={preventDefault:function(){this.isDefaultPrevented=bb;var a=this.originalEvent;if(!a)return;a.preventDefault?a.preventDefault():a.returnValue=!1},stopPropagation:function(){this.isPropagationStopped=bb;var a=this.originalEvent;if(!a)return;a.stopPropagation&&a.stopPropagation(),a.cancelBubble=!0},stopImmediatePropagation:function(){this.isImmediatePropagationStopped=bb,this.stopPropagation()},isDefaultPrevented:ba,isPropagationStopped:ba,isImmediatePropagationStopped:ba},p.each({mouseenter:"mouseover",mouseleave:"mouseout"},function(a,b){p.event.special[a]={delegateType:b,bindType:b,handle:function(a){var c,d=this,e=a.relatedTarget,f=a.handleObj,g=f.selector;if(!e||e!==d&&!p.contains(d,e))a.type=f.origType,c=f.handler.apply(this,arguments),a.type=b;return c}}}),p.support.submitBubbles||(p.event.special.submit={setup:function(){if(p.nodeName(this,"form"))return!1;p.event.add(this,"click._submit keypress._submit",function(a){var c=a.target,d=p.nodeName(c,"input")||p.nodeName(c,"button")?c.form:b;d&&!p._data(d,"_submit_attached")&&(p.event.add(d,"submit._submit",function(a){a._submit_bubble=!0}),p._data(d,"_submit_attached",!0))})},postDispatch:function(a){a._submit_bubble&&(delete a._submit_bubble,this.parentNode&&!a.isTrigger&&p.event.simulate("submit",this.parentNode,a,!0))},teardown:function(){if(p.nodeName(this,"form"))return!1;p.event.remove(this,"._submit")}}),p.support.changeBubbles||(p.event.special.change={setup:function(){if(V.test(this.nodeName)){if(this.type==="checkbox"||this.type==="radio")p.event.add(this,"propertychange._change",function(a){a.originalEvent.propertyName==="checked"&&(this._just_changed=!0)}),p.event.add(this,"click._change",function(a){this._just_changed&&!a.isTrigger&&(this._just_changed=!1),p.event.simulate("change",this,a,!0)});return!1}p.event.add(this,"beforeactivate._change",function(a){var b=a.target;V.test(b.nodeName)&&!p._data(b,"_change_attached")&&(p.event.add(b,"change._change",function(a){this.parentNode&&!a.isSimulated&&!a.isTrigger&&p.event.simulate("change",this.parentNode,a,!0)}),p._data(b,"_change_attached",!0))})},handle:function(a){var b=a.target;if(this!==b||a.isSimulated||a.isTrigger||b.type!=="radio"&&b.type!=="checkbox")return a.handleObj.handler.apply(this,arguments)},teardown:function(){return p.event.remove(this,"._change"),!V.test(this.nodeName)}}),p.support.focusinBubbles||p.each({focus:"focusin",blur:"focusout"},function(a,b){var c=0,d=function(a){p.event.simulate(b,a.target,p.event.fix(a),!0)};p.event.special[b]={setup:function(){c++===0&&e.addEventListener(a,d,!0)},teardown:function(){--c===0&&e.removeEventListener(a,d,!0)}}}),p.fn.extend({on:function(a,c,d,e,f){var g,h;if(typeof a=="object"){typeof c!="string"&&(d=d||c,c=b);for(h in a)this.on(h,c,d,a[h],f);return this}d==null&&e==null?(e=c,d=c=b):e==null&&(typeof c=="string"?(e=d,d=b):(e=d,d=c,c=b));if(e===!1)e=ba;else if(!e)return this;return f===1&&(g=e,e=function(a){return p().off(a),g.apply(this,arguments)},e.guid=g.guid||(g.guid=p.guid++)),this.each(function(){p.event.add(this,a,e,d,c)})},one:function(a,b,c,d){return this.on(a,b,c,d,1)},off:function(a,c,d){var e,f;if(a&&a.preventDefault&&a.handleObj)return e=a.handleObj,p(a.delegateTarget).off(e.namespace?e.origType+"."+e.namespace:e.origType,e.selector,e.handler),this;if(typeof a=="object"){for(f in a)this.off(f,c,a[f]);return this}if(c===!1||typeof c=="function")d=c,c=b;return d===!1&&(d=ba),this.each(function(){p.event.remove(this,a,d,c)})},bind:function(a,b,c){return this.on(a,null,b,c)},unbind:function(a,b){return this.off(a,null,b)},live:function(a,b,c){return p(this.context).on(a,this.selector,b,c),this},die:function(a,b){return p(this.context).off(a,this.selector||"**",b),this},delegate:function(a,b,c,d){return this.on(b,a,c,d)},undelegate:function(a,b,c){return arguments.length===1?this.off(a,"**"):this.off(b,a||"**",c)},trigger:function(a,b){return this.each(function(){p.event.trigger(a,b,this)})},triggerHandler:function(a,b){if(this[0])return p.event.trigger(a,b,this[0],!0)},toggle:function(a){var b=arguments,c=a.guid||p.guid++,d=0,e=function(c){var e=(p._data(this,"lastToggle"+a.guid)||0)%d;return p._data(this,"lastToggle"+a.guid,e+1),c.preventDefault(),b[e].apply(this,arguments)||!1};e.guid=c;while(d<b.length)b[d++].guid=c;return this.click(e)},hover:function(a,b){return this.mouseenter(a).mouseleave(b||a)}}),p.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error contextmenu".split(" "),function(a,b){p.fn[b]=function(a,c){return c==null&&(c=a,a=null),arguments.length>0?this.on(b,null,a,c):this.trigger(b)},Y.test(b)&&(p.event.fixHooks[b]=p.event.keyHooks),Z.test(b)&&(p.event.fixHooks[b]=p.event.mouseHooks)}),function(a,b){function bc(a,b,c,d){c=c||[],b=b||r;var e,f,i,j,k=b.nodeType;if(!a||typeof a!="string")return c;if(k!==1&&k!==9)return[];i=g(b);if(!i&&!d)if(e=P.exec(a))if(j=e[1]){if(k===9){f=b.getElementById(j);if(!f||!f.parentNode)return c;if(f.id===j)return c.push(f),c}else if(b.ownerDocument&&(f=b.ownerDocument.getElementById(j))&&h(b,f)&&f.id===j)return c.push(f),c}else{if(e[2])return w.apply(c,x.call(b.getElementsByTagName(a),0)),c;if((j=e[3])&&_&&b.getElementsByClassName)return w.apply(c,x.call(b.getElementsByClassName(j),0)),c}return bp(a.replace(L,"$1"),b,c,d,i)}function bd(a){return function(b){var c=b.nodeName.toLowerCase();return c==="input"&&b.type===a}}function be(a){return function(b){var c=b.nodeName.toLowerCase();return(c==="input"||c==="button")&&b.type===a}}function bf(a){return z(function(b){return b=+b,z(function(c,d){var e,f=a([],c.length,b),g=f.length;while(g--)c[e=f[g]]&&(c[e]=!(d[e]=c[e]))})})}function bg(a,b,c){if(a===b)return c;var d=a.nextSibling;while(d){if(d===b)return-1;d=d.nextSibling}return 1}function bh(a,b){var c,d,f,g,h,i,j,k=C[o][a];if(k)return b?0:k.slice(0);h=a,i=[],j=e.preFilter;while(h){if(!c||(d=M.exec(h)))d&&(h=h.slice(d[0].length)),i.push(f=[]);c=!1;if(d=N.exec(h))f.push(c=new q(d.shift())),h=h.slice(c.length),c.type=d[0].replace(L," ");for(g in e.filter)(d=W[g].exec(h))&&(!j[g]||(d=j[g](d,r,!0)))&&(f.push(c=new q(d.shift())),h=h.slice(c.length),c.type=g,c.matches=d);if(!c)break}return b?h.length:h?bc.error(a):C(a,i).slice(0)}function bi(a,b,d){var e=b.dir,f=d&&b.dir==="parentNode",g=u++;return b.first?function(b,c,d){while(b=b[e])if(f||b.nodeType===1)return a(b,c,d)}:function(b,d,h){if(!h){var i,j=t+" "+g+" ",k=j+c;while(b=b[e])if(f||b.nodeType===1){if((i=b[o])===k)return b.sizset;if(typeof i=="string"&&i.indexOf(j)===0){if(b.sizset)return b}else{b[o]=k;if(a(b,d,h))return b.sizset=!0,b;b.sizset=!1}}}else while(b=b[e])if(f||b.nodeType===1)if(a(b,d,h))return b}}function bj(a){return a.length>1?function(b,c,d){var e=a.length;while(e--)if(!a[e](b,c,d))return!1;return!0}:a[0]}function bk(a,b,c,d,e){var f,g=[],h=0,i=a.length,j=b!=null;for(;h<i;h++)if(f=a[h])if(!c||c(f,d,e))g.push(f),j&&b.push(h);return g}function bl(a,b,c,d,e,f){return d&&!d[o]&&(d=bl(d)),e&&!e[o]&&(e=bl(e,f)),z(function(f,g,h,i){if(f&&e)return;var j,k,l,m=[],n=[],o=g.length,p=f||bo(b||"*",h.nodeType?[h]:h,[],f),q=a&&(f||!b)?bk(p,m,a,h,i):p,r=c?e||(f?a:o||d)?[]:g:q;c&&c(q,r,h,i);if(d){l=bk(r,n),d(l,[],h,i),j=l.length;while(j--)if(k=l[j])r[n[j]]=!(q[n[j]]=k)}if(f){j=a&&r.length;while(j--)if(k=r[j])f[m[j]]=!(g[m[j]]=k)}else r=bk(r===g?r.splice(o,r.length):r),e?e(null,g,r,i):w.apply(g,r)})}function bm(a){var b,c,d,f=a.length,g=e.relative[a[0].type],h=g||e.relative[" "],i=g?1:0,j=bi(function(a){return a===b},h,!0),k=bi(function(a){return y.call(b,a)>-1},h,!0),m=[function(a,c,d){return!g&&(d||c!==l)||((b=c).nodeType?j(a,c,d):k(a,c,d))}];for(;i<f;i++)if(c=e.relative[a[i].type])m=[bi(bj(m),c)];else{c=e.filter[a[i].type].apply(null,a[i].matches);if(c[o]){d=++i;for(;d<f;d++)if(e.relative[a[d].type])break;return bl(i>1&&bj(m),i>1&&a.slice(0,i-1).join("").replace(L,"$1"),c,i<d&&bm(a.slice(i,d)),d<f&&bm(a=a.slice(d)),d<f&&a.join(""))}m.push(c)}return bj(m)}function bn(a,b){var d=b.length>0,f=a.length>0,g=function(h,i,j,k,m){var n,o,p,q=[],s=0,u="0",x=h&&[],y=m!=null,z=l,A=h||f&&e.find.TAG("*",m&&i.parentNode||i),B=t+=z==null?1:Math.E;y&&(l=i!==r&&i,c=g.el);for(;(n=A[u])!=null;u++){if(f&&n){for(o=0;p=a[o];o++)if(p(n,i,j)){k.push(n);break}y&&(t=B,c=++g.el)}d&&((n=!p&&n)&&s--,h&&x.push(n))}s+=u;if(d&&u!==s){for(o=0;p=b[o];o++)p(x,q,i,j);if(h){if(s>0)while(u--)!x[u]&&!q[u]&&(q[u]=v.call(k));q=bk(q)}w.apply(k,q),y&&!h&&q.length>0&&s+b.length>1&&bc.uniqueSort(k)}return y&&(t=B,l=z),x};return g.el=0,d?z(g):g}function bo(a,b,c,d){var e=0,f=b.length;for(;e<f;e++)bc(a,b[e],c,d);return c}function bp(a,b,c,d,f){var g,h,j,k,l,m=bh(a),n=m.length;if(!d&&m.length===1){h=m[0]=m[0].slice(0);if(h.length>2&&(j=h[0]).type==="ID"&&b.nodeType===9&&!f&&e.relative[h[1].type]){b=e.find.ID(j.matches[0].replace(V,""),b,f)[0];if(!b)return c;a=a.slice(h.shift().length)}for(g=W.POS.test(a)?-1:h.length-1;g>=0;g--){j=h[g];if(e.relative[k=j.type])break;if(l=e.find[k])if(d=l(j.matches[0].replace(V,""),R.test(h[0].type)&&b.parentNode||b,f)){h.splice(g,1),a=d.length&&h.join("");if(!a)return w.apply(c,x.call(d,0)),c;break}}}return i(a,m)(d,b,f,c,R.test(a)),c}function bq(){}var c,d,e,f,g,h,i,j,k,l,m=!0,n="undefined",o=("sizcache"+Math.random()).replace(".",""),q=String,r=a.document,s=r.documentElement,t=0,u=0,v=[].pop,w=[].push,x=[].slice,y=[].indexOf||function(a){var b=0,c=this.length;for(;b<c;b++)if(this[b]===a)return b;return-1},z=function(a,b){return a[o]=b==null||b,a},A=function(){var a={},b=[];return z(function(c,d){return b.push(c)>e.cacheLength&&delete a[b.shift()],a[c]=d},a)},B=A(),C=A(),D=A(),E="[\\x20\\t\\r\\n\\f]",F="(?:\\\\.|[-\\w]|[^\\x00-\\xa0])+",G=F.replace("w","w#"),H="([*^$|!~]?=)",I="\\["+E+"*("+F+")"+E+"*(?:"+H+E+"*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|("+G+")|)|)"+E+"*\\]",J=":("+F+")(?:\\((?:(['\"])((?:\\\\.|[^\\\\])*?)\\2|([^()[\\]]*|(?:(?:"+I+")|[^:]|\\\\.)*|.*))\\)|)",K=":(even|odd|eq|gt|lt|nth|first|last)(?:\\("+E+"*((?:-\\d)?\\d*)"+E+"*\\)|)(?=[^-]|$)",L=new RegExp("^"+E+"+|((?:^|[^\\\\])(?:\\\\.)*)"+E+"+$","g"),M=new RegExp("^"+E+"*,"+E+"*"),N=new RegExp("^"+E+"*([\\x20\\t\\r\\n\\f>+~])"+E+"*"),O=new RegExp(J),P=/^(?:#([\w\-]+)|(\w+)|\.([\w\-]+))$/,Q=/^:not/,R=/[\x20\t\r\n\f]*[+~]/,S=/:not\($/,T=/h\d/i,U=/input|select|textarea|button/i,V=/\\(?!\\)/g,W={ID:new RegExp("^#("+F+")"),CLASS:new RegExp("^\\.("+F+")"),NAME:new RegExp("^\\[name=['\"]?("+F+")['\"]?\\]"),TAG:new RegExp("^("+F.replace("w","w*")+")"),ATTR:new RegExp("^"+I),PSEUDO:new RegExp("^"+J),POS:new RegExp(K,"i"),CHILD:new RegExp("^:(only|nth|first|last)-child(?:\\("+E+"*(even|odd|(([+-]|)(\\d*)n|)"+E+"*(?:([+-]|)"+E+"*(\\d+)|))"+E+"*\\)|)","i"),needsContext:new RegExp("^"+E+"*[>+~]|"+K,"i")},X=function(a){var b=r.createElement("div");try{return a(b)}catch(c){return!1}finally{b=null}},Y=X(function(a){return a.appendChild(r.createComment("")),!a.getElementsByTagName("*").length}),Z=X(function(a){return a.innerHTML="<a href='#'></a>",a.firstChild&&typeof a.firstChild.getAttribute!==n&&a.firstChild.getAttribute("href")==="#"}),$=X(function(a){a.innerHTML="<select></select>";var b=typeof a.lastChild.getAttribute("multiple");return b!=="boolean"&&b!=="string"}),_=X(function(a){return a.innerHTML="<div class='hidden e'></div><div class='hidden'></div>",!a.getElementsByClassName||!a.getElementsByClassName("e").length?!1:(a.lastChild.className="e",a.getElementsByClassName("e").length===2)}),ba=X(function(a){a.id=o+0,a.innerHTML="<a name='"+o+"'></a><div name='"+o+"'></div>",s.insertBefore(a,s.firstChild);var b=r.getElementsByName&&r.getElementsByName(o).length===2+r.getElementsByName(o+0).length;return d=!r.getElementById(o),s.removeChild(a),b});try{x.call(s.childNodes,0)[0].nodeType}catch(bb){x=function(a){var b,c=[];for(;b=this[a];a++)c.push(b);return c}}bc.matches=function(a,b){return bc(a,null,null,b)},bc.matchesSelector=function(a,b){return bc(b,null,null,[a]).length>0},f=bc.getText=function(a){var b,c="",d=0,e=a.nodeType;if(e){if(e===1||e===9||e===11){if(typeof a.textContent=="string")return a.textContent;for(a=a.firstChild;a;a=a.nextSibling)c+=f(a)}else if(e===3||e===4)return a.nodeValue}else for(;b=a[d];d++)c+=f(b);return c},g=bc.isXML=function(a){var b=a&&(a.ownerDocument||a).documentElement;return b?b.nodeName!=="HTML":!1},h=bc.contains=s.contains?function(a,b){var c=a.nodeType===9?a.documentElement:a,d=b&&b.parentNode;return a===d||!!(d&&d.nodeType===1&&c.contains&&c.contains(d))}:s.compareDocumentPosition?function(a,b){return b&&!!(a.compareDocumentPosition(b)&16)}:function(a,b){while(b=b.parentNode)if(b===a)return!0;return!1},bc.attr=function(a,b){var c,d=g(a);return d||(b=b.toLowerCase()),(c=e.attrHandle[b])?c(a):d||$?a.getAttribute(b):(c=a.getAttributeNode(b),c?typeof a[b]=="boolean"?a[b]?b:null:c.specified?c.value:null:null)},e=bc.selectors={cacheLength:50,createPseudo:z,match:W,attrHandle:Z?{}:{href:function(a){return a.getAttribute("href",2)},type:function(a){return a.getAttribute("type")}},find:{ID:d?function(a,b,c){if(typeof b.getElementById!==n&&!c){var d=b.getElementById(a);return d&&d.parentNode?[d]:[]}}:function(a,c,d){if(typeof c.getElementById!==n&&!d){var e=c.getElementById(a);return e?e.id===a||typeof e.getAttributeNode!==n&&e.getAttributeNode("id").value===a?[e]:b:[]}},TAG:Y?function(a,b){if(typeof b.getElementsByTagName!==n)return b.getElementsByTagName(a)}:function(a,b){var c=b.getElementsByTagName(a);if(a==="*"){var d,e=[],f=0;for(;d=c[f];f++)d.nodeType===1&&e.push(d);return e}return c},NAME:ba&&function(a,b){if(typeof b.getElementsByName!==n)return b.getElementsByName(name)},CLASS:_&&function(a,b,c){if(typeof b.getElementsByClassName!==n&&!c)return b.getElementsByClassName(a)}},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(a){return a[1]=a[1].replace(V,""),a[3]=(a[4]||a[5]||"").replace(V,""),a[2]==="~="&&(a[3]=" "+a[3]+" "),a.slice(0,4)},CHILD:function(a){return a[1]=a[1].toLowerCase(),a[1]==="nth"?(a[2]||bc.error(a[0]),a[3]=+(a[3]?a[4]+(a[5]||1):2*(a[2]==="even"||a[2]==="odd")),a[4]=+(a[6]+a[7]||a[2]==="odd")):a[2]&&bc.error(a[0]),a},PSEUDO:function(a){var b,c;if(W.CHILD.test(a[0]))return null;if(a[3])a[2]=a[3];else if(b=a[4])O.test(b)&&(c=bh(b,!0))&&(c=b.indexOf(")",b.length-c)-b.length)&&(b=b.slice(0,c),a[0]=a[0].slice(0,c)),a[2]=b;return a.slice(0,3)}},filter:{ID:d?function(a){return a=a.replace(V,""),function(b){return b.getAttribute("id")===a}}:function(a){return a=a.replace(V,""),function(b){var c=typeof b.getAttributeNode!==n&&b.getAttributeNode("id");return c&&c.value===a}},TAG:function(a){return a==="*"?function(){return!0}:(a=a.replace(V,"").toLowerCase(),function(b){return b.nodeName&&b.nodeName.toLowerCase()===a})},CLASS:function(a){var b=B[o][a];return b||(b=B(a,new RegExp("(^|"+E+")"+a+"("+E+"|$)"))),function(a){return b.test(a.className||typeof a.getAttribute!==n&&a.getAttribute("class")||"")}},ATTR:function(a,b,c){return function(d,e){var f=bc.attr(d,a);return f==null?b==="!=":b?(f+="",b==="="?f===c:b==="!="?f!==c:b==="^="?c&&f.indexOf(c)===0:b==="*="?c&&f.indexOf(c)>-1:b==="$="?c&&f.substr(f.length-c.length)===c:b==="~="?(" "+f+" ").indexOf(c)>-1:b==="|="?f===c||f.substr(0,c.length+1)===c+"-":!1):!0}},CHILD:function(a,b,c,d){return a==="nth"?function(a){var b,e,f=a.parentNode;if(c===1&&d===0)return!0;if(f){e=0;for(b=f.firstChild;b;b=b.nextSibling)if(b.nodeType===1){e++;if(a===b)break}}return e-=d,e===c||e%c===0&&e/c>=0}:function(b){var c=b;switch(a){case"only":case"first":while(c=c.previousSibling)if(c.nodeType===1)return!1;if(a==="first")return!0;c=b;case"last":while(c=c.nextSibling)if(c.nodeType===1)return!1;return!0}}},PSEUDO:function(a,b){var c,d=e.pseudos[a]||e.setFilters[a.toLowerCase()]||bc.error("unsupported pseudo: "+a);return d[o]?d(b):d.length>1?(c=[a,a,"",b],e.setFilters.hasOwnProperty(a.toLowerCase())?z(function(a,c){var e,f=d(a,b),g=f.length;while(g--)e=y.call(a,f[g]),a[e]=!(c[e]=f[g])}):function(a){return d(a,0,c)}):d}},pseudos:{not:z(function(a){var b=[],c=[],d=i(a.replace(L,"$1"));return d[o]?z(function(a,b,c,e){var f,g=d(a,null,e,[]),h=a.length;while(h--)if(f=g[h])a[h]=!(b[h]=f)}):function(a,e,f){return b[0]=a,d(b,null,f,c),!c.pop()}}),has:z(function(a){return function(b){return bc(a,b).length>0}}),contains:z(function(a){return function(b){return(b.textContent||b.innerText||f(b)).indexOf(a)>-1}}),enabled:function(a){return a.disabled===!1},disabled:function(a){return a.disabled===!0},checked:function(a){var b=a.nodeName.toLowerCase();return b==="input"&&!!a.checked||b==="option"&&!!a.selected},selected:function(a){return a.parentNode&&a.parentNode.selectedIndex,a.selected===!0},parent:function(a){return!e.pseudos.empty(a)},empty:function(a){var b;a=a.firstChild;while(a){if(a.nodeName>"@"||(b=a.nodeType)===3||b===4)return!1;a=a.nextSibling}return!0},header:function(a){return T.test(a.nodeName)},text:function(a){var b,c;return a.nodeName.toLowerCase()==="input"&&(b=a.type)==="text"&&((c=a.getAttribute("type"))==null||c.toLowerCase()===b)},radio:bd("radio"),checkbox:bd("checkbox"),file:bd("file"),password:bd("password"),image:bd("image"),submit:be("submit"),reset:be("reset"),button:function(a){var b=a.nodeName.toLowerCase();return b==="input"&&a.type==="button"||b==="button"},input:function(a){return U.test(a.nodeName)},focus:function(a){var b=a.ownerDocument;return a===b.activeElement&&(!b.hasFocus||b.hasFocus())&&(!!a.type||!!a.href)},active:function(a){return a===a.ownerDocument.activeElement},first:bf(function(a,b,c){return[0]}),last:bf(function(a,b,c){return[b-1]}),eq:bf(function(a,b,c){return[c<0?c+b:c]}),even:bf(function(a,b,c){for(var d=0;d<b;d+=2)a.push(d);return a}),odd:bf(function(a,b,c){for(var d=1;d<b;d+=2)a.push(d);return a}),lt:bf(function(a,b,c){for(var d=c<0?c+b:c;--d>=0;)a.push(d);return a}),gt:bf(function(a,b,c){for(var d=c<0?c+b:c;++d<b;)a.push(d);return a})}},j=s.compareDocumentPosition?function(a,b){return a===b?(k=!0,0):(!a.compareDocumentPosition||!b.compareDocumentPosition?a.compareDocumentPosition:a.compareDocumentPosition(b)&4)?-1:1}:function(a,b){if(a===b)return k=!0,0;if(a.sourceIndex&&b.sourceIndex)return a.sourceIndex-b.sourceIndex;var c,d,e=[],f=[],g=a.parentNode,h=b.parentNode,i=g;if(g===h)return bg(a,b);if(!g)return-1;if(!h)return 1;while(i)e.unshift(i),i=i.parentNode;i=h;while(i)f.unshift(i),i=i.parentNode;c=e.length,d=f.length;for(var j=0;j<c&&j<d;j++)if(e[j]!==f[j])return bg(e[j],f[j]);return j===c?bg(a,f[j],-1):bg(e[j],b,1)},[0,0].sort(j),m=!k,bc.uniqueSort=function(a){var b,c=1;k=m,a.sort(j);if(k)for(;b=a[c];c++)b===a[c-1]&&a.splice(c--,1);return a},bc.error=function(a){throw new Error("Syntax error, unrecognized expression: "+a)},i=bc.compile=function(a,b){var c,d=[],e=[],f=D[o][a];if(!f){b||(b=bh(a)),c=b.length;while(c--)f=bm(b[c]),f[o]?d.push(f):e.push(f);f=D(a,bn(e,d))}return f},r.querySelectorAll&&function(){var a,b=bp,c=/'|\\/g,d=/\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g,e=[":focus"],f=[":active",":focus"],h=s.matchesSelector||s.mozMatchesSelector||s.webkitMatchesSelector||s.oMatchesSelector||s.msMatchesSelector;X(function(a){a.innerHTML="<select><option selected=''></option></select>",a.querySelectorAll("[selected]").length||e.push("\\["+E+"*(?:checked|disabled|ismap|multiple|readonly|selected|value)"),a.querySelectorAll(":checked").length||e.push(":checked")}),X(function(a){a.innerHTML="<p test=''></p>",a.querySelectorAll("[test^='']").length&&e.push("[*^$]="+E+"*(?:\"\"|'')"),a.innerHTML="<input type='hidden'/>",a.querySelectorAll(":enabled").length||e.push(":enabled",":disabled")}),e=new RegExp(e.join("|")),bp=function(a,d,f,g,h){if(!g&&!h&&(!e||!e.test(a))){var i,j,k=!0,l=o,m=d,n=d.nodeType===9&&a;if(d.nodeType===1&&d.nodeName.toLowerCase()!=="object"){i=bh(a),(k=d.getAttribute("id"))?l=k.replace(c,"\\$&"):d.setAttribute("id",l),l="[id='"+l+"'] ",j=i.length;while(j--)i[j]=l+i[j].join("");m=R.test(a)&&d.parentNode||d,n=i.join(",")}if(n)try{return w.apply(f,x.call(m.querySelectorAll(n),0)),f}catch(p){}finally{k||d.removeAttribute("id")}}return b(a,d,f,g,h)},h&&(X(function(b){a=h.call(b,"div");try{h.call(b,"[test!='']:sizzle"),f.push("!=",J)}catch(c){}}),f=new RegExp(f.join("|")),bc.matchesSelector=function(b,c){c=c.replace(d,"='$1']");if(!g(b)&&!f.test(c)&&(!e||!e.test(c)))try{var i=h.call(b,c);if(i||a||b.document&&b.document.nodeType!==11)return i}catch(j){}return bc(c,null,null,[b]).length>0})}(),e.pseudos.nth=e.pseudos.eq,e.filters=bq.prototype=e.pseudos,e.setFilters=new bq,bc.attr=p.attr,p.find=bc,p.expr=bc.selectors,p.expr[":"]=p.expr.pseudos,p.unique=bc.uniqueSort,p.text=bc.getText,p.isXMLDoc=bc.isXML,p.contains=bc.contains}(a);var bc=/Until$/,bd=/^(?:parents|prev(?:Until|All))/,be=/^.[^:#\[\.,]*$/,bf=p.expr.match.needsContext,bg={children:!0,contents:!0,next:!0,prev:!0};p.fn.extend({find:function(a){var b,c,d,e,f,g,h=this;if(typeof a!="string")return p(a).filter(function(){for(b=0,c=h.length;b<c;b++)if(p.contains(h[b],this))return!0});g=this.pushStack("","find",a);for(b=0,c=this.length;b<c;b++){d=g.length,p.find(a,this[b],g);if(b>0)for(e=d;e<g.length;e++)for(f=0;f<d;f++)if(g[f]===g[e]){g.splice(e--,1);break}}return g},has:function(a){var b,c=p(a,this),d=c.length;return this.filter(function(){for(b=0;b<d;b++)if(p.contains(this,c[b]))return!0})},not:function(a){return this.pushStack(bj(this,a,!1),"not",a)},filter:function(a){return this.pushStack(bj(this,a,!0),"filter",a)},is:function(a){return!!a&&(typeof a=="string"?bf.test(a)?p(a,this.context).index(this[0])>=0:p.filter(a,this).length>0:this.filter(a).length>0)},closest:function(a,b){var c,d=0,e=this.length,f=[],g=bf.test(a)||typeof a!="string"?p(a,b||this.context):0;for(;d<e;d++){c=this[d];while(c&&c.ownerDocument&&c!==b&&c.nodeType!==11){if(g?g.index(c)>-1:p.find.matchesSelector(c,a)){f.push(c);break}c=c.parentNode}}return f=f.length>1?p.unique(f):f,this.pushStack(f,"closest",a)},index:function(a){return a?typeof a=="string"?p.inArray(this[0],p(a)):p.inArray(a.jquery?a[0]:a,this):this[0]&&this[0].parentNode?this.prevAll().length:-1},add:function(a,b){var c=typeof a=="string"?p(a,b):p.makeArray(a&&a.nodeType?[a]:a),d=p.merge(this.get(),c);return this.pushStack(bh(c[0])||bh(d[0])?d:p.unique(d))},addBack:function(a){return this.add(a==null?this.prevObject:this.prevObject.filter(a))}}),p.fn.andSelf=p.fn.addBack,p.each({parent:function(a){var b=a.parentNode;return b&&b.nodeType!==11?b:null},parents:function(a){return p.dir(a,"parentNode")},parentsUntil:function(a,b,c){return p.dir(a,"parentNode",c)},next:function(a){return bi(a,"nextSibling")},prev:function(a){return bi(a,"previousSibling")},nextAll:function(a){return p.dir(a,"nextSibling")},prevAll:function(a){return p.dir(a,"previousSibling")},nextUntil:function(a,b,c){return p.dir(a,"nextSibling",c)},prevUntil:function(a,b,c){return p.dir(a,"previousSibling",c)},siblings:function(a){return p.sibling((a.parentNode||{}).firstChild,a)},children:function(a){return p.sibling(a.firstChild)},contents:function(a){return p.nodeName(a,"iframe")?a.contentDocument||a.contentWindow.document:p.merge([],a.childNodes)}},function(a,b){p.fn[a]=function(c,d){var e=p.map(this,b,c);return bc.test(a)||(d=c),d&&typeof d=="string"&&(e=p.filter(d,e)),e=this.length>1&&!bg[a]?p.unique(e):e,this.length>1&&bd.test(a)&&(e=e.reverse()),this.pushStack(e,a,k.call(arguments).join(","))}}),p.extend({filter:function(a,b,c){return c&&(a=":not("+a+")"),b.length===1?p.find.matchesSelector(b[0],a)?[b[0]]:[]:p.find.matches(a,b)},dir:function(a,c,d){var e=[],f=a[c];while(f&&f.nodeType!==9&&(d===b||f.nodeType!==1||!p(f).is(d)))f.nodeType===1&&e.push(f),f=f[c];return e},sibling:function(a,b){var c=[];for(;a;a=a.nextSibling)a.nodeType===1&&a!==b&&c.push(a);return c}});var bl="abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",bm=/ jQuery\d+="(?:null|\d+)"/g,bn=/^\s+/,bo=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,bp=/<([\w:]+)/,bq=/<tbody/i,br=/<|&#?\w+;/,bs=/<(?:script|style|link)/i,bt=/<(?:script|object|embed|option|style)/i,bu=new RegExp("<(?:"+bl+")[\\s/>]","i"),bv=/^(?:checkbox|radio)$/,bw=/checked\s*(?:[^=]|=\s*.checked.)/i,bx=/\/(java|ecma)script/i,by=/^\s*<!(?:\[CDATA\[|\-\-)|[\]\-]{2}>\s*$/g,bz={option:[1,"<select multiple='multiple'>","</select>"],legend:[1,"<fieldset>","</fieldset>"],thead:[1,"<table>","</table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],col:[2,"<table><tbody></tbody><colgroup>","</colgroup></table>"],area:[1,"<map>","</map>"],_default:[0,"",""]},bA=bk(e),bB=bA.appendChild(e.createElement("div"));bz.optgroup=bz.option,bz.tbody=bz.tfoot=bz.colgroup=bz.caption=bz.thead,bz.th=bz.td,p.support.htmlSerialize||(bz._default=[1,"X<div>","</div>"]),p.fn.extend({text:function(a){return p.access(this,function(a){return a===b?p.text(this):this.empty().append((this[0]&&this[0].ownerDocument||e).createTextNode(a))},null,a,arguments.length)},wrapAll:function(a){if(p.isFunction(a))return this.each(function(b){p(this).wrapAll(a.call(this,b))});if(this[0]){var b=p(a,this[0].ownerDocument).eq(0).clone(!0);this[0].parentNode&&b.insertBefore(this[0]),b.map(function(){var a=this;while(a.firstChild&&a.firstChild.nodeType===1)a=a.firstChild;return a}).append(this)}return this},wrapInner:function(a){return p.isFunction(a)?this.each(function(b){p(this).wrapInner(a.call(this,b))}):this.each(function(){var b=p(this),c=b.contents();c.length?c.wrapAll(a):b.append(a)})},wrap:function(a){var b=p.isFunction(a);return this.each(function(c){p(this).wrapAll(b?a.call(this,c):a)})},unwrap:function(){return this.parent().each(function(){p.nodeName(this,"body")||p(this).replaceWith(this.childNodes)}).end()},append:function(){return this.domManip(arguments,!0,function(a){(this.nodeType===1||this.nodeType===11)&&this.appendChild(a)})},prepend:function(){return this.domManip(arguments,!0,function(a){(this.nodeType===1||this.nodeType===11)&&this.insertBefore(a,this.firstChild)})},before:function(){if(!bh(this[0]))return this.domManip(arguments,!1,function(a){this.parentNode.insertBefore(a,this)});if(arguments.length){var a=p.clean(arguments);return this.pushStack(p.merge(a,this),"before",this.selector)}},after:function(){if(!bh(this[0]))return this.domManip(arguments,!1,function(a){this.parentNode.insertBefore(a,this.nextSibling)});if(arguments.length){var a=p.clean(arguments);return this.pushStack(p.merge(this,a),"after",this.selector)}},remove:function(a,b){var c,d=0;for(;(c=this[d])!=null;d++)if(!a||p.filter(a,[c]).length)!b&&c.nodeType===1&&(p.cleanData(c.getElementsByTagName("*")),p.cleanData([c])),c.parentNode&&c.parentNode.removeChild(c);return this},empty:function(){var a,b=0;for(;(a=this[b])!=null;b++){a.nodeType===1&&p.cleanData(a.getElementsByTagName("*"));while(a.firstChild)a.removeChild(a.firstChild)}return this},clone:function(a,b){return a=a==null?!1:a,b=b==null?a:b,this.map(function(){return p.clone(this,a,b)})},html:function(a){return p.access(this,function(a){var c=this[0]||{},d=0,e=this.length;if(a===b)return c.nodeType===1?c.innerHTML.replace(bm,""):b;if(typeof a=="string"&&!bs.test(a)&&(p.support.htmlSerialize||!bu.test(a))&&(p.support.leadingWhitespace||!bn.test(a))&&!bz[(bp.exec(a)||["",""])[1].toLowerCase()]){a=a.replace(bo,"<$1></$2>");try{for(;d<e;d++)c=this[d]||{},c.nodeType===1&&(p.cleanData(c.getElementsByTagName("*")),c.innerHTML=a);c=0}catch(f){}}c&&this.empty().append(a)},null,a,arguments.length)},replaceWith:function(a){return bh(this[0])?this.length?this.pushStack(p(p.isFunction(a)?a():a),"replaceWith",a):this:p.isFunction(a)?this.each(function(b){var c=p(this),d=c.html();c.replaceWith(a.call(this,b,d))}):(typeof a!="string"&&(a=p(a).detach()),this.each(function(){var b=this.nextSibling,c=this.parentNode;p(this).remove(),b?p(b).before(a):p(c).append(a)}))},detach:function(a){return this.remove(a,!0)},domManip:function(a,c,d){a=[].concat.apply([],a);var e,f,g,h,i=0,j=a[0],k=[],l=this.length;if(!p.support.checkClone&&l>1&&typeof j=="string"&&bw.test(j))return this.each(function(){p(this).domManip(a,c,d)});if(p.isFunction(j))return this.each(function(e){var f=p(this);a[0]=j.call(this,e,c?f.html():b),f.domManip(a,c,d)});if(this[0]){e=p.buildFragment(a,this,k),g=e.fragment,f=g.firstChild,g.childNodes.length===1&&(g=f);if(f){c=c&&p.nodeName(f,"tr");for(h=e.cacheable||l-1;i<l;i++)d.call(c&&p.nodeName(this[i],"table")?bC(this[i],"tbody"):this[i],i===h?g:p.clone(g,!0,!0))}g=f=null,k.length&&p.each(k,function(a,b){b.src?p.ajax?p.ajax({url:b.src,type:"GET",dataType:"script",async:!1,global:!1,"throws":!0}):p.error("no ajax"):p.globalEval((b.text||b.textContent||b.innerHTML||"").replace(by,"")),b.parentNode&&b.parentNode.removeChild(b)})}return this}}),p.buildFragment=function(a,c,d){var f,g,h,i=a[0];return c=c||e,c=!c.nodeType&&c[0]||c,c=c.ownerDocument||c,a.length===1&&typeof i=="string"&&i.length<512&&c===e&&i.charAt(0)==="<"&&!bt.test(i)&&(p.support.checkClone||!bw.test(i))&&(p.support.html5Clone||!bu.test(i))&&(g=!0,f=p.fragments[i],h=f!==b),f||(f=c.createDocumentFragment(),p.clean(a,c,f,d),g&&(p.fragments[i]=h&&f)),{fragment:f,cacheable:g}},p.fragments={},p.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){p.fn[a]=function(c){var d,e=0,f=[],g=p(c),h=g.length,i=this.length===1&&this[0].parentNode;if((i==null||i&&i.nodeType===11&&i.childNodes.length===1)&&h===1)return g[b](this[0]),this;for(;e<h;e++)d=(e>0?this.clone(!0):this).get(),p(g[e])[b](d),f=f.concat(d);return this.pushStack(f,a,g.selector)}}),p.extend({clone:function(a,b,c){var d,e,f,g;p.support.html5Clone||p.isXMLDoc(a)||!bu.test("<"+a.nodeName+">")?g=a.cloneNode(!0):(bB.innerHTML=a.outerHTML,bB.removeChild(g=bB.firstChild));if((!p.support.noCloneEvent||!p.support.noCloneChecked)&&(a.nodeType===1||a.nodeType===11)&&!p.isXMLDoc(a)){bE(a,g),d=bF(a),e=bF(g);for(f=0;d[f];++f)e[f]&&bE(d[f],e[f])}if(b){bD(a,g);if(c){d=bF(a),e=bF(g);for(f=0;d[f];++f)bD(d[f],e[f])}}return d=e=null,g},clean:function(a,b,c,d){var f,g,h,i,j,k,l,m,n,o,q,r,s=b===e&&bA,t=[];if(!b||typeof b.createDocumentFragment=="undefined")b=e;for(f=0;(h=a[f])!=null;f++){typeof h=="number"&&(h+="");if(!h)continue;if(typeof h=="string")if(!br.test(h))h=b.createTextNode(h);else{s=s||bk(b),l=b.createElement("div"),s.appendChild(l),h=h.replace(bo,"<$1></$2>"),i=(bp.exec(h)||["",""])[1].toLowerCase(),j=bz[i]||bz._default,k=j[0],l.innerHTML=j[1]+h+j[2];while(k--)l=l.lastChild;if(!p.support.tbody){m=bq.test(h),n=i==="table"&&!m?l.firstChild&&l.firstChild.childNodes:j[1]==="<table>"&&!m?l.childNodes:[];for(g=n.length-1;g>=0;--g)p.nodeName(n[g],"tbody")&&!n[g].childNodes.length&&n[g].parentNode.removeChild(n[g])}!p.support.leadingWhitespace&&bn.test(h)&&l.insertBefore(b.createTextNode(bn.exec(h)[0]),l.firstChild),h=l.childNodes,l.parentNode.removeChild(l)}h.nodeType?t.push(h):p.merge(t,h)}l&&(h=l=s=null);if(!p.support.appendChecked)for(f=0;(h=t[f])!=null;f++)p.nodeName(h,"input")?bG(h):typeof h.getElementsByTagName!="undefined"&&p.grep(h.getElementsByTagName("input"),bG);if(c){q=function(a){if(!a.type||bx.test(a.type))return d?d.push(a.parentNode?a.parentNode.removeChild(a):a):c.appendChild(a)};for(f=0;(h=t[f])!=null;f++)if(!p.nodeName(h,"script")||!q(h))c.appendChild(h),typeof h.getElementsByTagName!="undefined"&&(r=p.grep(p.merge([],h.getElementsByTagName("script")),q),t.splice.apply(t,[f+1,0].concat(r)),f+=r.length)}return t},cleanData:function(a,b){var c,d,e,f,g=0,h=p.expando,i=p.cache,j=p.support.deleteExpando,k=p.event.special;for(;(e=a[g])!=null;g++)if(b||p.acceptData(e)){d=e[h],c=d&&i[d];if(c){if(c.events)for(f in c.events)k[f]?p.event.remove(e,f):p.removeEvent(e,f,c.handle);i[d]&&(delete i[d],j?delete e[h]:e.removeAttribute?e.removeAttribute(h):e[h]=null,p.deletedIds.push(d))}}}}),function(){var a,b;p.uaMatch=function(a){a=a.toLowerCase();var b=/(chrome)[ \/]([\w.]+)/.exec(a)||/(webkit)[ \/]([\w.]+)/.exec(a)||/(opera)(?:.*version|)[ \/]([\w.]+)/.exec(a)||/(msie) ([\w.]+)/.exec(a)||a.indexOf("compatible")<0&&/(mozilla)(?:.*? rv:([\w.]+)|)/.exec(a)||[];return{browser:b[1]||"",version:b[2]||"0"}},a=p.uaMatch(g.userAgent),b={},a.browser&&(b[a.browser]=!0,b.version=a.version),b.chrome?b.webkit=!0:b.webkit&&(b.safari=!0),p.browser=b,p.sub=function(){function a(b,c){return new a.fn.init(b,c)}p.extend(!0,a,this),a.superclass=this,a.fn=a.prototype=this(),a.fn.constructor=a,a.sub=this.sub,a.fn.init=function c(c,d){return d&&d instanceof p&&!(d instanceof a)&&(d=a(d)),p.fn.init.call(this,c,d,b)},a.fn.init.prototype=a.fn;var b=a(e);return a}}();var bH,bI,bJ,bK=/alpha\([^)]*\)/i,bL=/opacity=([^)]*)/,bM=/^(top|right|bottom|left)$/,bN=/^(none|table(?!-c[ea]).+)/,bO=/^margin/,bP=new RegExp("^("+q+")(.*)$","i"),bQ=new RegExp("^("+q+")(?!px)[a-z%]+$","i"),bR=new RegExp("^([-+])=("+q+")","i"),bS={},bT={position:"absolute",visibility:"hidden",display:"block"},bU={letterSpacing:0,fontWeight:400},bV=["Top","Right","Bottom","Left"],bW=["Webkit","O","Moz","ms"],bX=p.fn.toggle;p.fn.extend({css:function(a,c){return p.access(this,function(a,c,d){return d!==b?p.style(a,c,d):p.css(a,c)},a,c,arguments.length>1)},show:function(){return b$(this,!0)},hide:function(){return b$(this)},toggle:function(a,b){var c=typeof a=="boolean";return p.isFunction(a)&&p.isFunction(b)?bX.apply(this,arguments):this.each(function(){(c?a:bZ(this))?p(this).show():p(this).hide()})}}),p.extend({cssHooks:{opacity:{get:function(a,b){if(b){var c=bH(a,"opacity");return c===""?"1":c}}}},cssNumber:{fillOpacity:!0,fontWeight:!0,lineHeight:!0,opacity:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{"float":p.support.cssFloat?"cssFloat":"styleFloat"},style:function(a,c,d,e){if(!a||a.nodeType===3||a.nodeType===8||!a.style)return;var f,g,h,i=p.camelCase(c),j=a.style;c=p.cssProps[i]||(p.cssProps[i]=bY(j,i)),h=p.cssHooks[c]||p.cssHooks[i];if(d===b)return h&&"get"in h&&(f=h.get(a,!1,e))!==b?f:j[c];g=typeof d,g==="string"&&(f=bR.exec(d))&&(d=(f[1]+1)*f[2]+parseFloat(p.css(a,c)),g="number");if(d==null||g==="number"&&isNaN(d))return;g==="number"&&!p.cssNumber[i]&&(d+="px");if(!h||!("set"in h)||(d=h.set(a,d,e))!==b)try{j[c]=d}catch(k){}},css:function(a,c,d,e){var f,g,h,i=p.camelCase(c);return c=p.cssProps[i]||(p.cssProps[i]=bY(a.style,i)),h=p.cssHooks[c]||p.cssHooks[i],h&&"get"in h&&(f=h.get(a,!0,e)),f===b&&(f=bH(a,c)),f==="normal"&&c in bU&&(f=bU[c]),d||e!==b?(g=parseFloat(f),d||p.isNumeric(g)?g||0:f):f},swap:function(a,b,c){var d,e,f={};for(e in b)f[e]=a.style[e],a.style[e]=b[e];d=c.call(a);for(e in b)a.style[e]=f[e];return d}}),a.getComputedStyle?bH=function(b,c){var d,e,f,g,h=a.getComputedStyle(b,null),i=b.style;return h&&(d=h[c],d===""&&!p.contains(b.ownerDocument,b)&&(d=p.style(b,c)),bQ.test(d)&&bO.test(c)&&(e=i.width,f=i.minWidth,g=i.maxWidth,i.minWidth=i.maxWidth=i.width=d,d=h.width,i.width=e,i.minWidth=f,i.maxWidth=g)),d}:e.documentElement.currentStyle&&(bH=function(a,b){var c,d,e=a.currentStyle&&a.currentStyle[b],f=a.style;return e==null&&f&&f[b]&&(e=f[b]),bQ.test(e)&&!bM.test(b)&&(c=f.left,d=a.runtimeStyle&&a.runtimeStyle.left,d&&(a.runtimeStyle.left=a.currentStyle.left),f.left=b==="fontSize"?"1em":e,e=f.pixelLeft+"px",f.left=c,d&&(a.runtimeStyle.left=d)),e===""?"auto":e}),p.each(["height","width"],function(a,b){p.cssHooks[b]={get:function(a,c,d){if(c)return a.offsetWidth===0&&bN.test(bH(a,"display"))?p.swap(a,bT,function(){return cb(a,b,d)}):cb(a,b,d)},set:function(a,c,d){return b_(a,c,d?ca(a,b,d,p.support.boxSizing&&p.css(a,"boxSizing")==="border-box"):0)}}}),p.support.opacity||(p.cssHooks.opacity={get:function(a,b){return bL.test((b&&a.currentStyle?a.currentStyle.filter:a.style.filter)||"")?.01*parseFloat(RegExp.$1)+"":b?"1":""},set:function(a,b){var c=a.style,d=a.currentStyle,e=p.isNumeric(b)?"alpha(opacity="+b*100+")":"",f=d&&d.filter||c.filter||"";c.zoom=1;if(b>=1&&p.trim(f.replace(bK,""))===""&&c.removeAttribute){c.removeAttribute("filter");if(d&&!d.filter)return}c.filter=bK.test(f)?f.replace(bK,e):f+" "+e}}),p(function(){p.support.reliableMarginRight||(p.cssHooks.marginRight={get:function(a,b){return p.swap(a,{display:"inline-block"},function(){if(b)return bH(a,"marginRight")})}}),!p.support.pixelPosition&&p.fn.position&&p.each(["top","left"],function(a,b){p.cssHooks[b]={get:function(a,c){if(c){var d=bH(a,b);return bQ.test(d)?p(a).position()[b]+"px":d}}}})}),p.expr&&p.expr.filters&&(p.expr.filters.hidden=function(a){return a.offsetWidth===0&&a.offsetHeight===0||!p.support.reliableHiddenOffsets&&(a.style&&a.style.display||bH(a,"display"))==="none"},p.expr.filters.visible=function(a){return!p.expr.filters.hidden(a)}),p.each({margin:"",padding:"",border:"Width"},function(a,b){p.cssHooks[a+b]={expand:function(c){var d,e=typeof c=="string"?c.split(" "):[c],f={};for(d=0;d<4;d++)f[a+bV[d]+b]=e[d]||e[d-2]||e[0];return f}},bO.test(a)||(p.cssHooks[a+b].set=b_)});var cd=/%20/g,ce=/\[\]$/,cf=/\r?\n/g,cg=/^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,ch=/^(?:select|textarea)/i;p.fn.extend({serialize:function(){return p.param(this.serializeArray())},serializeArray:function(){return this.map(function(){return this.elements?p.makeArray(this.elements):this}).filter(function(){return this.name&&!this.disabled&&(this.checked||ch.test(this.nodeName)||cg.test(this.type))}).map(function(a,b){var c=p(this).val();return c==null?null:p.isArray(c)?p.map(c,function(a,c){return{name:b.name,value:a.replace(cf,"\r\n")}}):{name:b.name,value:c.replace(cf,"\r\n")}}).get()}}),p.param=function(a,c){var d,e=[],f=function(a,b){b=p.isFunction(b)?b():b==null?"":b,e[e.length]=encodeURIComponent(a)+"="+encodeURIComponent(b)};c===b&&(c=p.ajaxSettings&&p.ajaxSettings.traditional);if(p.isArray(a)||a.jquery&&!p.isPlainObject(a))p.each(a,function(){f(this.name,this.value)});else for(d in a)ci(d,a[d],c,f);return e.join("&").replace(cd,"+")};var cj,ck,cl=/#.*$/,cm=/^(.*?):[ \t]*([^\r\n]*)\r?$/mg,cn=/^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/,co=/^(?:GET|HEAD)$/,cp=/^\/\//,cq=/\?/,cr=/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,cs=/([?&])_=[^&]*/,ct=/^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+)|)|)/,cu=p.fn.load,cv={},cw={},cx=["*/"]+["*"];try{ck=f.href}catch(cy){ck=e.createElement("a"),ck.href="",ck=ck.href}cj=ct.exec(ck.toLowerCase())||[],p.fn.load=function(a,c,d){if(typeof a!="string"&&cu)return cu.apply(this,arguments);if(!this.length)return this;var e,f,g,h=this,i=a.indexOf(" ");return i>=0&&(e=a.slice(i,a.length),a=a.slice(0,i)),p.isFunction(c)?(d=c,c=b):c&&typeof c=="object"&&(f="POST"),p.ajax({url:a,type:f,dataType:"html",data:c,complete:function(a,b){d&&h.each(d,g||[a.responseText,b,a])}}).done(function(a){g=arguments,h.html(e?p("<div>").append(a.replace(cr,"")).find(e):a)}),this},p.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "),function(a,b){p.fn[b]=function(a){return this.on(b,a)}}),p.each(["get","post"],function(a,c){p[c]=function(a,d,e,f){return p.isFunction(d)&&(f=f||e,e=d,d=b),p.ajax({type:c,url:a,data:d,success:e,dataType:f})}}),p.extend({getScript:function(a,c){return p.get(a,b,c,"script")},getJSON:function(a,b,c){return p.get(a,b,c,"json")},ajaxSetup:function(a,b){return b?cB(a,p.ajaxSettings):(b=a,a=p.ajaxSettings),cB(a,b),a},ajaxSettings:{url:ck,isLocal:cn.test(cj[1]),global:!0,type:"GET",contentType:"application/x-www-form-urlencoded; charset=UTF-8",processData:!0,async:!0,accepts:{xml:"application/xml, text/xml",html:"text/html",text:"text/plain",json:"application/json, text/javascript","*":cx},contents:{xml:/xml/,html:/html/,json:/json/},responseFields:{xml:"responseXML",text:"responseText"},converters:{"* text":a.String,"text html":!0,"text json":p.parseJSON,"text xml":p.parseXML},flatOptions:{context:!0,url:!0}},ajaxPrefilter:cz(cv),ajaxTransport:cz(cw),ajax:function(a,c){function y(a,c,f,i){var k,s,t,u,w,y=c;if(v===2)return;v=2,h&&clearTimeout(h),g=b,e=i||"",x.readyState=a>0?4:0,f&&(u=cC(l,x,f));if(a>=200&&a<300||a===304)l.ifModified&&(w=x.getResponseHeader("Last-Modified"),w&&(p.lastModified[d]=w),w=x.getResponseHeader("Etag"),w&&(p.etag[d]=w)),a===304?(y="notmodified",k=!0):(k=cD(l,u),y=k.state,s=k.data,t=k.error,k=!t);else{t=y;if(!y||a)y="error",a<0&&(a=0)}x.status=a,x.statusText=(c||y)+"",k?o.resolveWith(m,[s,y,x]):o.rejectWith(m,[x,y,t]),x.statusCode(r),r=b,j&&n.trigger("ajax"+(k?"Success":"Error"),[x,l,k?s:t]),q.fireWith(m,[x,y]),j&&(n.trigger("ajaxComplete",[x,l]),--p.active||p.event.trigger("ajaxStop"))}typeof a=="object"&&(c=a,a=b),c=c||{};var d,e,f,g,h,i,j,k,l=p.ajaxSetup({},c),m=l.context||l,n=m!==l&&(m.nodeType||m instanceof p)?p(m):p.event,o=p.Deferred(),q=p.Callbacks("once memory"),r=l.statusCode||{},t={},u={},v=0,w="canceled",x={readyState:0,setRequestHeader:function(a,b){if(!v){var c=a.toLowerCase();a=u[c]=u[c]||a,t[a]=b}return this},getAllResponseHeaders:function(){return v===2?e:null},getResponseHeader:function(a){var c;if(v===2){if(!f){f={};while(c=cm.exec(e))f[c[1].toLowerCase()]=c[2]}c=f[a.toLowerCase()]}return c===b?null:c},overrideMimeType:function(a){return v||(l.mimeType=a),this},abort:function(a){return a=a||w,g&&g.abort(a),y(0,a),this}};o.promise(x),x.success=x.done,x.error=x.fail,x.complete=q.add,x.statusCode=function(a){if(a){var b;if(v<2)for(b in a)r[b]=[r[b],a[b]];else b=a[x.status],x.always(b)}return this},l.url=((a||l.url)+"").replace(cl,"").replace(cp,cj[1]+"//"),l.dataTypes=p.trim(l.dataType||"*").toLowerCase().split(s),l.crossDomain==null&&(i=ct.exec(l.url.toLowerCase())||!1,l.crossDomain=i&&i.join(":")+(i[3]?"":i[1]==="http:"?80:443)!==cj.join(":")+(cj[3]?"":cj[1]==="http:"?80:443)),l.data&&l.processData&&typeof l.data!="string"&&(l.data=p.param(l.data,l.traditional)),cA(cv,l,c,x);if(v===2)return x;j=l.global,l.type=l.type.toUpperCase(),l.hasContent=!co.test(l.type),j&&p.active++===0&&p.event.trigger("ajaxStart");if(!l.hasContent){l.data&&(l.url+=(cq.test(l.url)?"&":"?")+l.data,delete l.data),d=l.url;if(l.cache===!1){var z=p.now(),A=l.url.replace(cs,"$1_="+z);l.url=A+(A===l.url?(cq.test(l.url)?"&":"?")+"_="+z:"")}}(l.data&&l.hasContent&&l.contentType!==!1||c.contentType)&&x.setRequestHeader("Content-Type",l.contentType),l.ifModified&&(d=d||l.url,p.lastModified[d]&&x.setRequestHeader("If-Modified-Since",p.lastModified[d]),p.etag[d]&&x.setRequestHeader("If-None-Match",p.etag[d])),x.setRequestHeader("Accept",l.dataTypes[0]&&l.accepts[l.dataTypes[0]]?l.accepts[l.dataTypes[0]]+(l.dataTypes[0]!=="*"?", "+cx+"; q=0.01":""):l.accepts["*"]);for(k in l.headers)x.setRequestHeader(k,l.headers[k]);if(!l.beforeSend||l.beforeSend.call(m,x,l)!==!1&&v!==2){w="abort";for(k in{success:1,error:1,complete:1})x[k](l[k]);g=cA(cw,l,c,x);if(!g)y(-1,"No Transport");else{x.readyState=1,j&&n.trigger("ajaxSend",[x,l]),l.async&&l.timeout>0&&(h=setTimeout(function(){x.abort("timeout")},l.timeout));try{v=1,g.send(t,y)}catch(B){if(v<2)y(-1,B);else throw B}}return x}return x.abort()},active:0,lastModified:{},etag:{}});var cE=[],cF=/\?/,cG=/(=)\?(?=&|$)|\?\?/,cH=p.now();p.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var a=cE.pop()||p.expando+"_"+cH++;return this[a]=!0,a}}),p.ajaxPrefilter("json jsonp",function(c,d,e){var f,g,h,i=c.data,j=c.url,k=c.jsonp!==!1,l=k&&cG.test(j),m=k&&!l&&typeof i=="string"&&!(c.contentType||"").indexOf("application/x-www-form-urlencoded")&&cG.test(i);if(c.dataTypes[0]==="jsonp"||l||m)return f=c.jsonpCallback=p.isFunction(c.jsonpCallback)?c.jsonpCallback():c.jsonpCallback,g=a[f],l?c.url=j.replace(cG,"$1"+f):m?c.data=i.replace(cG,"$1"+f):k&&(c.url+=(cF.test(j)?"&":"?")+c.jsonp+"="+f),c.converters["script json"]=function(){return h||p.error(f+" was not called"),h[0]},c.dataTypes[0]="json",a[f]=function(){h=arguments},e.always(function(){a[f]=g,c[f]&&(c.jsonpCallback=d.jsonpCallback,cE.push(f)),h&&p.isFunction(g)&&g(h[0]),h=g=b}),"script"}),p.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/javascript|ecmascript/},converters:{"text script":function(a){return p.globalEval(a),a}}}),p.ajaxPrefilter("script",function(a){a.cache===b&&(a.cache=!1),a.crossDomain&&(a.type="GET",a.global=!1)}),p.ajaxTransport("script",function(a){if(a.crossDomain){var c,d=e.head||e.getElementsByTagName("head")[0]||e.documentElement;return{send:function(f,g){c=e.createElement("script"),c.async="async",a.scriptCharset&&(c.charset=a.scriptCharset),c.src=a.url,c.onload=c.onreadystatechange=function(a,e){if(e||!c.readyState||/loaded|complete/.test(c.readyState))c.onload=c.onreadystatechange=null,d&&c.parentNode&&d.removeChild(c),c=b,e||g(200,"success")},d.insertBefore(c,d.firstChild)},abort:function(){c&&c.onload(0,1)}}}});var cI,cJ=a.ActiveXObject?function(){for(var a in cI)cI[a](0,1)}:!1,cK=0;p.ajaxSettings.xhr=a.ActiveXObject?function(){return!this.isLocal&&cL()||cM()}:cL,function(a){p.extend(p.support,{ajax:!!a,cors:!!a&&"withCredentials"in a})}(p.ajaxSettings.xhr()),p.support.ajax&&p.ajaxTransport(function(c){if(!c.crossDomain||p.support.cors){var d;return{send:function(e,f){var g,h,i=c.xhr();c.username?i.open(c.type,c.url,c.async,c.username,c.password):i.open(c.type,c.url,c.async);if(c.xhrFields)for(h in c.xhrFields)i[h]=c.xhrFields[h];c.mimeType&&i.overrideMimeType&&i.overrideMimeType(c.mimeType),!c.crossDomain&&!e["X-Requested-With"]&&(e["X-Requested-With"]="XMLHttpRequest");try{for(h in e)i.setRequestHeader(h,e[h])}catch(j){}i.send(c.hasContent&&c.data||null),d=function(a,e){var h,j,k,l,m;try{if(d&&(e||i.readyState===4)){d=b,g&&(i.onreadystatechange=p.noop,cJ&&delete cI[g]);if(e)i.readyState!==4&&i.abort();else{h=i.status,k=i.getAllResponseHeaders(),l={},m=i.responseXML,m&&m.documentElement&&(l.xml=m);try{l.text=i.responseText}catch(a){}try{j=i.statusText}catch(n){j=""}!h&&c.isLocal&&!c.crossDomain?h=l.text?200:404:h===1223&&(h=204)}}}catch(o){e||f(-1,o)}l&&f(h,j,l,k)},c.async?i.readyState===4?setTimeout(d,0):(g=++cK,cJ&&(cI||(cI={},p(a).unload(cJ)),cI[g]=d),i.onreadystatechange=d):d()},abort:function(){d&&d(0,1)}}}});var cN,cO,cP=/^(?:toggle|show|hide)$/,cQ=new RegExp("^(?:([-+])=|)("+q+")([a-z%]*)$","i"),cR=/queueHooks$/,cS=[cY],cT={"*":[function(a,b){var c,d,e=this.createTween(a,b),f=cQ.exec(b),g=e.cur(),h=+g||0,i=1,j=20;if(f){c=+f[2],d=f[3]||(p.cssNumber[a]?"":"px");if(d!=="px"&&h){h=p.css(e.elem,a,!0)||c||1;do i=i||".5",h=h/i,p.style(e.elem,a,h+d);while(i!==(i=e.cur()/g)&&i!==1&&--j)}e.unit=d,e.start=h,e.end=f[1]?h+(f[1]+1)*c:c}return e}]};p.Animation=p.extend(cW,{tweener:function(a,b){p.isFunction(a)?(b=a,a=["*"]):a=a.split(" ");var c,d=0,e=a.length;for(;d<e;d++)c=a[d],cT[c]=cT[c]||[],cT[c].unshift(b)},prefilter:function(a,b){b?cS.unshift(a):cS.push(a)}}),p.Tween=cZ,cZ.prototype={constructor:cZ,init:function(a,b,c,d,e,f){this.elem=a,this.prop=c,this.easing=e||"swing",this.options=b,this.start=this.now=this.cur(),this.end=d,this.unit=f||(p.cssNumber[c]?"":"px")},cur:function(){var a=cZ.propHooks[this.prop];return a&&a.get?a.get(this):cZ.propHooks._default.get(this)},run:function(a){var b,c=cZ.propHooks[this.prop];return this.options.duration?this.pos=b=p.easing[this.easing](a,this.options.duration*a,0,1,this.options.duration):this.pos=b=a,this.now=(this.end-this.start)*b+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),c&&c.set?c.set(this):cZ.propHooks._default.set(this),this}},cZ.prototype.init.prototype=cZ.prototype,cZ.propHooks={_default:{get:function(a){var b;return a.elem[a.prop]==null||!!a.elem.style&&a.elem.style[a.prop]!=null?(b=p.css(a.elem,a.prop,!1,""),!b||b==="auto"?0:b):a.elem[a.prop]},set:function(a){p.fx.step[a.prop]?p.fx.step[a.prop](a):a.elem.style&&(a.elem.style[p.cssProps[a.prop]]!=null||p.cssHooks[a.prop])?p.style(a.elem,a.prop,a.now+a.unit):a.elem[a.prop]=a.now}}},cZ.propHooks.scrollTop=cZ.propHooks.scrollLeft={set:function(a){a.elem.nodeType&&a.elem.parentNode&&(a.elem[a.prop]=a.now)}},p.each(["toggle","show","hide"],function(a,b){var c=p.fn[b];p.fn[b]=function(d,e,f){return d==null||typeof d=="boolean"||!a&&p.isFunction(d)&&p.isFunction(e)?c.apply(this,arguments):this.animate(c$(b,!0),d,e,f)}}),p.fn.extend({fadeTo:function(a,b,c,d){return this.filter(bZ).css("opacity",0).show().end().animate({opacity:b},a,c,d)},animate:function(a,b,c,d){var e=p.isEmptyObject(a),f=p.speed(b,c,d),g=function(){var b=cW(this,p.extend({},a),f);e&&b.stop(!0)};return e||f.queue===!1?this.each(g):this.queue(f.queue,g)},stop:function(a,c,d){var e=function(a){var b=a.stop;delete a.stop,b(d)};return typeof a!="string"&&(d=c,c=a,a=b),c&&a!==!1&&this.queue(a||"fx",[]),this.each(function(){var b=!0,c=a!=null&&a+"queueHooks",f=p.timers,g=p._data(this);if(c)g[c]&&g[c].stop&&e(g[c]);else for(c in g)g[c]&&g[c].stop&&cR.test(c)&&e(g[c]);for(c=f.length;c--;)f[c].elem===this&&(a==null||f[c].queue===a)&&(f[c].anim.stop(d),b=!1,f.splice(c,1));(b||!d)&&p.dequeue(this,a)})}}),p.each({slideDown:c$("show"),slideUp:c$("hide"),slideToggle:c$("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(a,b){p.fn[a]=function(a,c,d){return this.animate(b,a,c,d)}}),p.speed=function(a,b,c){var d=a&&typeof a=="object"?p.extend({},a):{complete:c||!c&&b||p.isFunction(a)&&a,duration:a,easing:c&&b||b&&!p.isFunction(b)&&b};d.duration=p.fx.off?0:typeof d.duration=="number"?d.duration:d.duration in p.fx.speeds?p.fx.speeds[d.duration]:p.fx.speeds._default;if(d.queue==null||d.queue===!0)d.queue="fx";return d.old=d.complete,d.complete=function(){p.isFunction(d.old)&&d.old.call(this),d.queue&&p.dequeue(this,d.queue)},d},p.easing={linear:function(a){return a},swing:function(a){return.5-Math.cos(a*Math.PI)/2}},p.timers=[],p.fx=cZ.prototype.init,p.fx.tick=function(){var a,b=p.timers,c=0;for(;c<b.length;c++)a=b[c],!a()&&b[c]===a&&b.splice(c--,1);b.length||p.fx.stop()},p.fx.timer=function(a){a()&&p.timers.push(a)&&!cO&&(cO=setInterval(p.fx.tick,p.fx.interval))},p.fx.interval=13,p.fx.stop=function(){clearInterval(cO),cO=null},p.fx.speeds={slow:600,fast:200,_default:400},p.fx.step={},p.expr&&p.expr.filters&&(p.expr.filters.animated=function(a){return p.grep(p.timers,function(b){return a===b.elem}).length});var c_=/^(?:body|html)$/i;p.fn.offset=function(a){if(arguments.length)return a===b?this:this.each(function(b){p.offset.setOffset(this,a,b)});var c,d,e,f,g,h,i,j={top:0,left:0},k=this[0],l=k&&k.ownerDocument;if(!l)return;return(d=l.body)===k?p.offset.bodyOffset(k):(c=l.documentElement,p.contains(c,k)?(typeof k.getBoundingClientRect!="undefined"&&(j=k.getBoundingClientRect()),e=da(l),f=c.clientTop||d.clientTop||0,g=c.clientLeft||d.clientLeft||0,h=e.pageYOffset||c.scrollTop,i=e.pageXOffset||c.scrollLeft,{top:j.top+h-f,left:j.left+i-g}):j)},p.offset={bodyOffset:function(a){var b=a.offsetTop,c=a.offsetLeft;return p.support.doesNotIncludeMarginInBodyOffset&&(b+=parseFloat(p.css(a,"marginTop"))||0,c+=parseFloat(p.css(a,"marginLeft"))||0),{top:b,left:c}},setOffset:function(a,b,c){var d=p.css(a,"position");d==="static"&&(a.style.position="relative");var e=p(a),f=e.offset(),g=p.css(a,"top"),h=p.css(a,"left"),i=(d==="absolute"||d==="fixed")&&p.inArray("auto",[g,h])>-1,j={},k={},l,m;i?(k=e.position(),l=k.top,m=k.left):(l=parseFloat(g)||0,m=parseFloat(h)||0),p.isFunction(b)&&(b=b.call(a,c,f)),b.top!=null&&(j.top=b.top-f.top+l),b.left!=null&&(j.left=b.left-f.left+m),"using"in b?b.using.call(a,j):e.css(j)}},p.fn.extend({position:function(){if(!this[0])return;var a=this[0],b=this.offsetParent(),c=this.offset(),d=c_.test(b[0].nodeName)?{top:0,left:0}:b.offset();return c.top-=parseFloat(p.css(a,"marginTop"))||0,c.left-=parseFloat(p.css(a,"marginLeft"))||0,d.top+=parseFloat(p.css(b[0],"borderTopWidth"))||0,d.left+=parseFloat(p.css(b[0],"borderLeftWidth"))||0,{top:c.top-d.top,left:c.left-d.left}},offsetParent:function(){return this.map(function(){var a=this.offsetParent||e.body;while(a&&!c_.test(a.nodeName)&&p.css(a,"position")==="static")a=a.offsetParent;return a||e.body})}}),p.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(a,c){var d=/Y/.test(c);p.fn[a]=function(e){return p.access(this,function(a,e,f){var g=da(a);if(f===b)return g?c in g?g[c]:g.document.documentElement[e]:a[e];g?g.scrollTo(d?p(g).scrollLeft():f,d?f:p(g).scrollTop()):a[e]=f},a,e,arguments.length,null)}}),p.each({Height:"height",Width:"width"},function(a,c){p.each({padding:"inner"+a,content:c,"":"outer"+a},function(d,e){p.fn[e]=function(e,f){var g=arguments.length&&(d||typeof e!="boolean"),h=d||(e===!0||f===!0?"margin":"border");return p.access(this,function(c,d,e){var f;return p.isWindow(c)?c.document.documentElement["client"+a]:c.nodeType===9?(f=c.documentElement,Math.max(c.body["scroll"+a],f["scroll"+a],c.body["offset"+a],f["offset"+a],f["client"+a])):e===b?p.css(c,d,e,h):p.style(c,d,e,h)},c,g?e:b,g,null)}})}),a.jQuery=a.$=p,typeof define=="function"&&define.amd&&define.amd.jQuery&&define("jquery",[],function(){return p})})(window);
\ No newline at end of file
diff --git a/_content/lib/godoc/package.html b/_content/lib/godoc/package.html
new file mode 100644
index 0000000..1e36fff
--- /dev/null
+++ b/_content/lib/godoc/package.html
@@ -0,0 +1,239 @@
+<!--
+ Copyright 2009 The Go Authors. All rights reserved.
+ Use of this source code is governed by a BSD-style
+ license that can be found in the LICENSE file.
+-->
+<!--
+ Note: Static (i.e., not template-generated) href and id
+ attributes start with "pkg-" to make it impossible for
+ them to conflict with generated attributes (some of which
+ correspond to Go identifiers).
+-->
+{{with .PDoc}}
+ {{if $.IsMain}}
+ {{/* command documentation */}}
+ {{comment_html .Doc}}
+ {{else}}
+ {{/* package documentation */}}
+ <div id="short-nav">
+ <dl>
+ <dd><code>import "{{html .ImportPath}}"</code></dd>
+ </dl>
+ <dl>
+ <dd><a href="#pkg-overview" class="overviewLink">Overview</a></dd>
+ <dd><a href="#pkg-index" class="indexLink">Index</a></dd>
+ {{if $.Examples}}
+ <dd><a href="#pkg-examples" class="examplesLink">Examples</a></dd>
+ {{end}}
+ {{if $.Dirs}}
+ <dd><a href="#pkg-subdirectories">Subdirectories</a></dd>
+ {{end}}
+ </dl>
+ </div>
+ <!-- The package's Name is printed as title by the top-level template -->
+ <div id="pkg-overview" class="toggleVisible">
+ <div class="collapsed">
+ <h2 class="toggleButton" title="Click to show Overview section">Overview ▹</h2>
+ </div>
+ <div class="expanded">
+ <h2 class="toggleButton" title="Click to hide Overview section">Overview ▾</h2>
+ {{comment_html .Doc}}
+ {{example_html $ ""}}
+ </div>
+ </div>
+
+ <div id="pkg-index" class="toggleVisible">
+ <div class="collapsed">
+ <h2 class="toggleButton" title="Click to show Index section">Index ▹</h2>
+ </div>
+ <div class="expanded">
+ <h2 class="toggleButton" title="Click to hide Index section">Index ▾</h2>
+
+ <!-- Table of contents for API; must be named manual-nav to turn off auto nav. -->
+ <div id="manual-nav">
+ <dl>
+ {{if .Consts}}
+ <dd><a href="#pkg-constants">Constants</a></dd>
+ {{end}}
+ {{if .Vars}}
+ <dd><a href="#pkg-variables">Variables</a></dd>
+ {{end}}
+ {{range .Funcs}}
+ {{$name_html := html .Name}}
+ <dd><a href="#{{$name_html}}">{{node_html $ .Decl false | sanitize}}</a></dd>
+ {{end}}
+ {{range .Types}}
+ {{$tname_html := html .Name}}
+ <dd><a href="#{{$tname_html}}">type {{$tname_html}}</a></dd>
+ {{range .Funcs}}
+ {{$name_html := html .Name}}
+ <dd> <a href="#{{$name_html}}">{{node_html $ .Decl false | sanitize}}</a></dd>
+ {{end}}
+ {{range .Methods}}
+ {{$name_html := html .Name}}
+ <dd> <a href="#{{$tname_html}}.{{$name_html}}">{{node_html $ .Decl false | sanitize}}</a></dd>
+ {{end}}
+ {{end}}
+ {{if $.Bugs}}
+ <dd><a href="#pkg-note-BUG">Bugs</a></dd>
+ {{end}}
+ </dl>
+ </div><!-- #manual-nav -->
+
+ {{if $.Examples}}
+ <div id="pkg-examples">
+ <h3>Examples</h3>
+ <div class="js-expandAll expandAll collapsed">(Expand All)</div>
+ <dl>
+ {{range $.Examples}}
+ <dd><a class="exampleLink" href="#example_{{.Name}}">{{example_name .Name}}</a></dd>
+ {{end}}
+ </dl>
+ </div>
+ {{end}}
+
+ {{with .Filenames}}
+ <h3>Package files</h3>
+ <p>
+ <span style="font-size:90%">
+ {{range .}}
+ <a href="{{.|srcLink|html}}">{{.|filename|html}}</a>
+ {{end}}
+ </span>
+ </p>
+ {{end}}
+ </div><!-- .expanded -->
+ </div><!-- #pkg-index -->
+
+ {{with .Consts}}
+ <h2 id="pkg-constants">Constants</h2>
+ {{range .}}
+ {{comment_html .Doc}}
+ <pre>{{node_html $ .Decl true}}</pre>
+ {{end}}
+ {{end}}
+ {{with .Vars}}
+ <h2 id="pkg-variables">Variables</h2>
+ {{range .}}
+ {{comment_html .Doc}}
+ <pre>{{node_html $ .Decl true}}</pre>
+ {{end}}
+ {{end}}
+ {{range .Funcs}}
+ {{/* Name is a string - no need for FSet */}}
+ {{$name_html := html .Name}}
+ <h2 id="{{$name_html}}">func <a href="{{posLink_url $ .Decl}}">{{$name_html}}</a>
+ <a class="permalink" href="#{{$name_html}}">¶</a>
+ {{$since := since "func" "" .Name $.PDoc.ImportPath}}
+ {{if $since}}<span title="Added in Go {{$since}}">{{$since}}</span>{{end}}
+ </h2>
+ <pre>{{node_html $ .Decl true}}</pre>
+ {{comment_html .Doc}}
+ {{example_html $ .Name}}
+
+ {{end}}
+ {{range .Types}}
+ {{$tname := .Name}}
+ {{$tname_html := html .Name}}
+ <h2 id="{{$tname_html}}">type <a href="{{posLink_url $ .Decl}}">{{$tname_html}}</a>
+ <a class="permalink" href="#{{$tname_html}}">¶</a>
+ {{$since := since "type" "" .Name $.PDoc.ImportPath}}
+ {{if $since}}<span title="Added in Go {{$since}}">{{$since}}</span>{{end}}
+ </h2>
+ {{comment_html .Doc}}
+ <pre>{{node_html $ .Decl true}}</pre>
+
+ {{range .Consts}}
+ {{comment_html .Doc}}
+ <pre>{{node_html $ .Decl true}}</pre>
+ {{end}}
+
+ {{range .Vars}}
+ {{comment_html .Doc}}
+ <pre>{{node_html $ .Decl true}}</pre>
+ {{end}}
+
+ {{example_html $ $tname}}
+
+ {{range .Funcs}}
+ {{$name_html := html .Name}}
+ <h3 id="{{$name_html}}">func <a href="{{posLink_url $ .Decl}}">{{$name_html}}</a>
+ <a class="permalink" href="#{{$name_html}}">¶</a>
+ {{$since := since "func" "" .Name $.PDoc.ImportPath}}
+ {{if $since}}<span title="Added in Go {{$since}}">{{$since}}</span>{{end}}
+ </h3>
+ <pre>{{node_html $ .Decl true}}</pre>
+ {{comment_html .Doc}}
+ {{example_html $ .Name}}
+ {{end}}
+
+ {{range .Methods}}
+ {{$name_html := html .Name}}
+ <h3 id="{{$tname_html}}.{{$name_html}}">func ({{html .Recv}}) <a href="{{posLink_url $ .Decl}}">{{$name_html}}</a>
+ <a class="permalink" href="#{{$tname_html}}.{{$name_html}}">¶</a>
+ {{$since := since "method" .Recv .Name $.PDoc.ImportPath}}
+ {{if $since}}<span title="Added in Go {{$since}}">{{$since}}</span>{{end}}
+ </h3>
+ <pre>{{node_html $ .Decl true}}</pre>
+ {{comment_html .Doc}}
+ {{$name := printf "%s_%s" $tname .Name}}
+ {{example_html $ $name}}
+ {{end}}
+ {{end}}
+ {{end}}
+
+ {{with $.Bugs}}
+ <h2 id="pkg-note-BUG">Bugs</h2>
+ <ul style="list-style: none; padding: 0;">
+ {{range .}}
+ <li><a href="{{posLink_url $ .}}" style="float: left;">☞</a> {{comment_html .Body}}</li>
+ {{end}}
+ </ul>
+ {{end}}
+{{end}}
+
+{{with .PAst}}
+ {{range $filename, $ast := .}}
+ <a href="{{$filename|srcLink|html}}">{{$filename|filename|html}}</a>:<pre>{{node_html $ $ast false}}</pre>
+ {{end}}
+{{end}}
+
+{{with .Dirs}}
+ {{/* DirList entries are numbers and strings - no need for FSet */}}
+ {{if $.PDoc}}
+ <h2 id="pkg-subdirectories">Subdirectories</h2>
+ {{end}}
+ <div class="pkg-dir">
+ <table>
+ <tr>
+ <th class="pkg-name">Name</th>
+ <th class="pkg-synopsis">Synopsis</th>
+ </tr>
+
+ {{if not (or (eq $.Dirname "/src/cmd") $.DirFlat)}}
+ <tr>
+ <td colspan="2"><a href="..">..</a></td>
+ </tr>
+ {{end}}
+
+ {{range .List}}
+ <tr>
+ {{if $.DirFlat}}
+ {{if .HasPkg}}
+ <td class="pkg-name">
+ <a href="{{html .Path}}/{{modeQueryString $.Mode | html}}">{{html .Path}}</a>
+ </td>
+ {{end}}
+ {{else}}
+ <td class="pkg-name" style="padding-left: {{multiply .Depth 20}}px;">
+ <a href="{{html .Path}}/{{modeQueryString $.Mode | html}}">{{html .Name}}</a>
+ </td>
+ {{end}}
+ <td class="pkg-synopsis">
+ {{html .Synopsis}}
+ </td>
+ </tr>
+ {{end}}
+ </table>
+ </div>
+{{end}}
diff --git a/_content/lib/godoc/packageroot.html b/_content/lib/godoc/packageroot.html
new file mode 100644
index 0000000..2b5c5e6
--- /dev/null
+++ b/_content/lib/godoc/packageroot.html
@@ -0,0 +1,105 @@
+<!--
+ Copyright 2018 The Go Authors. All rights reserved.
+ Use of this source code is governed by a BSD-style
+ license that can be found in the LICENSE file.
+-->
+<!--
+ Note: Static (i.e., not template-generated) href and id
+ attributes start with "pkg-" to make it impossible for
+ them to conflict with generated attributes (some of which
+ correspond to Go identifiers).
+-->
+{{with .PAst}}
+ {{range $filename, $ast := .}}
+ <a href="{{$filename|srcLink|html}}">{{$filename|filename|html}}</a>:<pre>{{node_html $ $ast false}}</pre>
+ {{end}}
+{{end}}
+
+{{with .Dirs}}
+ {{/* DirList entries are numbers and strings - no need for FSet */}}
+ {{if $.PDoc}}
+ <h2 id="pkg-subdirectories">Subdirectories</h2>
+ {{end}}
+ <div id="manual-nav">
+ <dl>
+ <dt><a href="#stdlib">Standard library</a></dt>
+ <dt><a href="#other">Other packages</a></dt>
+ <dd><a href="#subrepo">Sub-repositories</a></dd>
+ <dd><a href="#community">Community</a></dd>
+ </dl>
+ </div>
+
+ <div id="stdlib" class="toggleVisible">
+ <div class="collapsed">
+ <h2 class="toggleButton" title="Click to show Standard library section">Standard library ▹</h2>
+ </div>
+ <div class="expanded">
+ <h2 class="toggleButton" title="Click to hide Standard library section">Standard library ▾</h2>
+ <img alt="" class="gopher" src="/doc/gopher/pkg.png"/>
+ <div class="pkg-dir">
+ <table>
+ <tr>
+ <th class="pkg-name">Name</th>
+ <th class="pkg-synopsis">Synopsis</th>
+ </tr>
+
+ {{range .List}}
+ <tr>
+ {{if $.DirFlat}}
+ {{if .HasPkg}}
+ <td class="pkg-name">
+ <a href="{{html .Path}}/{{modeQueryString $.Mode | html}}">{{html .Path}}</a>
+ </td>
+ {{end}}
+ {{else}}
+ <td class="pkg-name" style="padding-left: {{multiply .Depth 20}}px;">
+ <a href="{{html .Path}}/{{modeQueryString $.Mode | html}}">{{html .Name}}</a>
+ </td>
+ {{end}}
+ <td class="pkg-synopsis">
+ {{html .Synopsis}}
+ </td>
+ </tr>
+ {{end}}
+ </table>
+ </div> <!-- .pkg-dir -->
+ </div> <!-- .expanded -->
+ </div> <!-- #stdlib .toggleVisible -->
+
+ <h2 id="other">Other packages</h2>
+ <h3 id="subrepo">Sub-repositories</h3>
+ <p>
+ These packages are part of the Go Project but outside the main Go tree.
+ They are developed under looser <a href="/doc/go1compat">compatibility requirements</a> than the Go core.
+ Install them with "<a href="/cmd/go/#hdr-Download_and_install_packages_and_dependencies">go get</a>".
+ </p>
+ <ul>
+ <li><a href="//pkg.go.dev/golang.org/x/benchmarks">benchmarks</a> — benchmarks to measure Go as it is developed.</li>
+ <li><a href="//pkg.go.dev/golang.org/x/blog">blog</a> — <a href="//blog.golang.org">blog.golang.org</a>'s implementation.</li>
+ <li><a href="//pkg.go.dev/golang.org/x/build">build</a> — <a href="//build.golang.org">build.golang.org</a>'s implementation.</li>
+ <li><a href="//pkg.go.dev/golang.org/x/crypto">crypto</a> — additional cryptography packages.</li>
+ <li><a href="//pkg.go.dev/golang.org/x/debug">debug</a> — an experimental debugger for Go.</li>
+ <li><a href="//pkg.go.dev/golang.org/x/image">image</a> — additional imaging packages.</li>
+ <li><a href="//pkg.go.dev/golang.org/x/mobile">mobile</a> — experimental support for Go on mobile platforms.</li>
+ <li><a href="//pkg.go.dev/golang.org/x/net">net</a> — additional networking packages.</li>
+ <li><a href="//pkg.go.dev/golang.org/x/perf">perf</a> — packages and tools for performance measurement, storage, and analysis.</li>
+ <li><a href="//pkg.go.dev/golang.org/x/pkgsite">pkgsite</a> — home of the pkg.go.dev website.</li>
+ <li><a href="//pkg.go.dev/golang.org/x/review">review</a> — a tool for working with Gerrit code reviews.</li>
+ <li><a href="//pkg.go.dev/golang.org/x/sync">sync</a> — additional concurrency primitives.</li>
+ <li><a href="//pkg.go.dev/golang.org/x/sys">sys</a> — packages for making system calls.</li>
+ <li><a href="//pkg.go.dev/golang.org/x/text">text</a> — packages for working with text.</li>
+ <li><a href="//pkg.go.dev/golang.org/x/time">time</a> — additional time packages.</li>
+ <li><a href="//pkg.go.dev/golang.org/x/tools">tools</a> — godoc, goimports, gorename, and other tools.</li>
+ <li><a href="//pkg.go.dev/golang.org/x/tour">tour</a> — <a href="//tour.golang.org">tour.golang.org</a>'s implementation.</li>
+ <li><a href="//pkg.go.dev/golang.org/x/exp">exp</a> — experimental and deprecated packages (handle with care; may change without warning).</li>
+ </ul>
+
+ <h3 id="community">Community</h3>
+ <p>
+ These services can help you find Open Source packages provided by the community.
+ </p>
+ <ul>
+ <li><a href="//pkg.go.dev">Pkg.go.dev</a> - the Go package discovery site.</li>
+ <li><a href="/wiki/Projects">Projects at the Go Wiki</a> - a curated list of Go projects.</li>
+ </ul>
+{{end}}
diff --git a/_content/lib/godoc/play.js b/_content/lib/godoc/play.js
new file mode 100644
index 0000000..0a10165
--- /dev/null
+++ b/_content/lib/godoc/play.js
@@ -0,0 +1,114 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+function initPlayground(transport) {
+ 'use strict';
+
+ function text(node) {
+ var s = '';
+ for (var i = 0; i < node.childNodes.length; i++) {
+ var n = node.childNodes[i];
+ if (n.nodeType === 1) {
+ if (n.tagName === 'BUTTON') continue;
+ if (n.tagName === 'SPAN' && n.className === 'number') continue;
+ if (n.tagName === 'DIV' || n.tagName == 'BR') {
+ s += '\n';
+ }
+ s += text(n);
+ continue;
+ }
+ if (n.nodeType === 3) {
+ s += n.nodeValue;
+ }
+ }
+ return s.replace('\xA0', ' '); // replace non-breaking spaces
+ }
+
+ // When presenter notes are enabled, the index passed
+ // here will identify the playground to be synced
+ function init(code, index) {
+ var output = document.createElement('div');
+ var outpre = document.createElement('pre');
+ var running;
+
+ if ($ && $(output).resizable) {
+ $(output).resizable({
+ handles: 'n,w,nw',
+ minHeight: 27,
+ minWidth: 135,
+ maxHeight: 608,
+ maxWidth: 990,
+ });
+ }
+
+ function onKill() {
+ if (running) running.Kill();
+ if (window.notesEnabled) updatePlayStorage('onKill', index);
+ }
+
+ function onRun(e) {
+ var sk = e.shiftKey || localStorage.getItem('play-shiftKey') === 'true';
+ if (running) running.Kill();
+ output.style.display = 'block';
+ outpre.innerHTML = '';
+ run1.style.display = 'none';
+ var options = { Race: sk };
+ running = transport.Run(text(code), PlaygroundOutput(outpre), options);
+ if (window.notesEnabled) updatePlayStorage('onRun', index, e);
+ }
+
+ function onClose() {
+ if (running) running.Kill();
+ output.style.display = 'none';
+ run1.style.display = 'inline-block';
+ if (window.notesEnabled) updatePlayStorage('onClose', index);
+ }
+
+ if (window.notesEnabled) {
+ playgroundHandlers.onRun.push(onRun);
+ playgroundHandlers.onClose.push(onClose);
+ playgroundHandlers.onKill.push(onKill);
+ }
+
+ var run1 = document.createElement('button');
+ run1.innerHTML = 'Run';
+ run1.className = 'run';
+ run1.addEventListener('click', onRun, false);
+ var run2 = document.createElement('button');
+ run2.className = 'run';
+ run2.innerHTML = 'Run';
+ run2.addEventListener('click', onRun, false);
+ var kill = document.createElement('button');
+ kill.className = 'kill';
+ kill.innerHTML = 'Kill';
+ kill.addEventListener('click', onKill, false);
+ var close = document.createElement('button');
+ close.className = 'close';
+ close.innerHTML = 'Close';
+ close.addEventListener('click', onClose, false);
+
+ var button = document.createElement('div');
+ button.classList.add('buttons');
+ button.appendChild(run1);
+ // Hack to simulate insertAfter
+ code.parentNode.insertBefore(button, code.nextSibling);
+
+ var buttons = document.createElement('div');
+ buttons.classList.add('buttons');
+ buttons.appendChild(run2);
+ buttons.appendChild(kill);
+ buttons.appendChild(close);
+
+ output.classList.add('output');
+ output.appendChild(buttons);
+ output.appendChild(outpre);
+ output.style.display = 'none';
+ code.parentNode.insertBefore(output, button.nextSibling);
+ }
+
+ var play = document.querySelectorAll('div.playground');
+ for (var i = 0; i < play.length; i++) {
+ init(play[i], i);
+ }
+}
diff --git a/_content/lib/godoc/playground.js b/_content/lib/godoc/playground.js
new file mode 100644
index 0000000..97391d1
--- /dev/null
+++ b/_content/lib/godoc/playground.js
@@ -0,0 +1,575 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+In the absence of any formal way to specify interfaces in JavaScript,
+here's a skeleton implementation of a playground transport.
+
+ function Transport() {
+ // Set up any transport state (eg, make a websocket connection).
+ return {
+ Run: function(body, output, options) {
+ // Compile and run the program 'body' with 'options'.
+ // Call the 'output' callback to display program output.
+ return {
+ Kill: function() {
+ // Kill the running program.
+ }
+ };
+ }
+ };
+ }
+
+ // The output callback is called multiple times, and each time it is
+ // passed an object of this form.
+ var write = {
+ Kind: 'string', // 'start', 'stdout', 'stderr', 'end'
+ Body: 'string' // content of write or end status message
+ }
+
+ // The first call must be of Kind 'start' with no body.
+ // Subsequent calls may be of Kind 'stdout' or 'stderr'
+ // and must have a non-null Body string.
+ // The final call should be of Kind 'end' with an optional
+ // Body string, signifying a failure ("killed", for example).
+
+ // The output callback must be of this form.
+ // See PlaygroundOutput (below) for an implementation.
+ function outputCallback(write) {
+ }
+*/
+
+// HTTPTransport is the default transport.
+// enableVet enables running vet if a program was compiled and ran successfully.
+// If vet returned any errors, display them before the output of a program.
+function HTTPTransport(enableVet) {
+ 'use strict';
+
+ function playback(output, data) {
+ // Backwards compatibility: default values do not affect the output.
+ var events = data.Events || [];
+ var errors = data.Errors || '';
+ var status = data.Status || 0;
+ var isTest = data.IsTest || false;
+ var testsFailed = data.TestsFailed || 0;
+
+ var timeout;
+ output({ Kind: 'start' });
+ function next() {
+ if (!events || events.length === 0) {
+ if (isTest) {
+ if (testsFailed > 0) {
+ output({
+ Kind: 'system',
+ Body:
+ '\n' +
+ testsFailed +
+ ' test' +
+ (testsFailed > 1 ? 's' : '') +
+ ' failed.',
+ });
+ } else {
+ output({ Kind: 'system', Body: '\nAll tests passed.' });
+ }
+ } else {
+ if (status > 0) {
+ output({ Kind: 'end', Body: 'status ' + status + '.' });
+ } else {
+ if (errors !== '') {
+ // errors are displayed only in the case of timeout.
+ output({ Kind: 'end', Body: errors + '.' });
+ } else {
+ output({ Kind: 'end' });
+ }
+ }
+ }
+ return;
+ }
+ var e = events.shift();
+ if (e.Delay === 0) {
+ output({ Kind: e.Kind, Body: e.Message });
+ next();
+ return;
+ }
+ timeout = setTimeout(function() {
+ output({ Kind: e.Kind, Body: e.Message });
+ next();
+ }, e.Delay / 1000000);
+ }
+ next();
+ return {
+ Stop: function() {
+ clearTimeout(timeout);
+ },
+ };
+ }
+
+ function error(output, msg) {
+ output({ Kind: 'start' });
+ output({ Kind: 'stderr', Body: msg });
+ output({ Kind: 'end' });
+ }
+
+ function buildFailed(output, msg) {
+ output({ Kind: 'start' });
+ output({ Kind: 'stderr', Body: msg });
+ output({ Kind: 'system', Body: '\nGo build failed.' });
+ }
+
+ var seq = 0;
+ return {
+ Run: function(body, output, options) {
+ seq++;
+ var cur = seq;
+ var playing;
+ $.ajax('/compile', {
+ type: 'POST',
+ data: { version: 2, body: body },
+ dataType: 'json',
+ success: function(data) {
+ if (seq != cur) return;
+ if (!data) return;
+ if (playing != null) playing.Stop();
+ if (data.Errors) {
+ if (data.Errors === 'process took too long') {
+ // Playback the output that was captured before the timeout.
+ playing = playback(output, data);
+ } else {
+ buildFailed(output, data.Errors);
+ }
+ return;
+ }
+
+ if (!enableVet) {
+ playing = playback(output, data);
+ return;
+ }
+
+ $.ajax('/vet', {
+ data: { body: body },
+ type: 'POST',
+ dataType: 'json',
+ success: function(dataVet) {
+ if (dataVet.Errors) {
+ if (!data.Events) {
+ data.Events = [];
+ }
+ // inject errors from the vet as the first events in the output
+ data.Events.unshift({
+ Message: 'Go vet exited.\n\n',
+ Kind: 'system',
+ Delay: 0,
+ });
+ data.Events.unshift({
+ Message: dataVet.Errors,
+ Kind: 'stderr',
+ Delay: 0,
+ });
+ }
+ playing = playback(output, data);
+ },
+ error: function() {
+ playing = playback(output, data);
+ },
+ });
+ },
+ error: function() {
+ error(output, 'Error communicating with remote server.');
+ },
+ });
+ return {
+ Kill: function() {
+ if (playing != null) playing.Stop();
+ output({ Kind: 'end', Body: 'killed' });
+ },
+ };
+ },
+ };
+}
+
+function SocketTransport() {
+ 'use strict';
+
+ var id = 0;
+ var outputs = {};
+ var started = {};
+ var websocket;
+ if (window.location.protocol == 'http:') {
+ websocket = new WebSocket('ws://' + window.location.host + '/socket');
+ } else if (window.location.protocol == 'https:') {
+ websocket = new WebSocket('wss://' + window.location.host + '/socket');
+ }
+
+ websocket.onclose = function() {
+ console.log('websocket connection closed');
+ };
+
+ websocket.onmessage = function(e) {
+ var m = JSON.parse(e.data);
+ var output = outputs[m.Id];
+ if (output === null) return;
+ if (!started[m.Id]) {
+ output({ Kind: 'start' });
+ started[m.Id] = true;
+ }
+ output({ Kind: m.Kind, Body: m.Body });
+ };
+
+ function send(m) {
+ websocket.send(JSON.stringify(m));
+ }
+
+ return {
+ Run: function(body, output, options) {
+ var thisID = id + '';
+ id++;
+ outputs[thisID] = output;
+ send({ Id: thisID, Kind: 'run', Body: body, Options: options });
+ return {
+ Kill: function() {
+ send({ Id: thisID, Kind: 'kill' });
+ },
+ };
+ },
+ };
+}
+
+function PlaygroundOutput(el) {
+ 'use strict';
+
+ return function(write) {
+ if (write.Kind == 'start') {
+ el.innerHTML = '';
+ return;
+ }
+
+ var cl = 'system';
+ if (write.Kind == 'stdout' || write.Kind == 'stderr') cl = write.Kind;
+
+ var m = write.Body;
+ if (write.Kind == 'end') {
+ m = '\nProgram exited' + (m ? ': ' + m : '.');
+ }
+
+ if (m.indexOf('IMAGE:') === 0) {
+ // TODO(adg): buffer all writes before creating image
+ var url = 'data:image/png;base64,' + m.substr(6);
+ var img = document.createElement('img');
+ img.src = url;
+ el.appendChild(img);
+ return;
+ }
+
+ // ^L clears the screen.
+ var s = m.split('\x0c');
+ if (s.length > 1) {
+ el.innerHTML = '';
+ m = s.pop();
+ }
+
+ m = m.replace(/&/g, '&');
+ m = m.replace(/</g, '<');
+ m = m.replace(/>/g, '>');
+
+ var needScroll = el.scrollTop + el.offsetHeight == el.scrollHeight;
+
+ var span = document.createElement('span');
+ span.className = cl;
+ span.innerHTML = m;
+ el.appendChild(span);
+
+ if (needScroll) el.scrollTop = el.scrollHeight - el.offsetHeight;
+ };
+}
+
+(function() {
+ function lineHighlight(error) {
+ var regex = /prog.go:([0-9]+)/g;
+ var r = regex.exec(error);
+ while (r) {
+ $('.lines div')
+ .eq(r[1] - 1)
+ .addClass('lineerror');
+ r = regex.exec(error);
+ }
+ }
+ function highlightOutput(wrappedOutput) {
+ return function(write) {
+ if (write.Body) lineHighlight(write.Body);
+ wrappedOutput(write);
+ };
+ }
+ function lineClear() {
+ $('.lineerror').removeClass('lineerror');
+ }
+
+ // opts is an object with these keys
+ // codeEl - code editor element
+ // outputEl - program output element
+ // runEl - run button element
+ // fmtEl - fmt button element (optional)
+ // fmtImportEl - fmt "imports" checkbox element (optional)
+ // shareEl - share button element (optional)
+ // shareURLEl - share URL text input element (optional)
+ // shareRedirect - base URL to redirect to on share (optional)
+ // toysEl - toys select element (optional)
+ // enableHistory - enable using HTML5 history API (optional)
+ // transport - playground transport to use (default is HTTPTransport)
+ // enableShortcuts - whether to enable shortcuts (Ctrl+S/Cmd+S to save) (default is false)
+ // enableVet - enable running vet and displaying its errors
+ function playground(opts) {
+ var code = $(opts.codeEl);
+ var transport = opts['transport'] || new HTTPTransport(opts['enableVet']);
+ var running;
+
+ // autoindent helpers.
+ function insertTabs(n) {
+ // find the selection start and end
+ var start = code[0].selectionStart;
+ var end = code[0].selectionEnd;
+ // split the textarea content into two, and insert n tabs
+ var v = code[0].value;
+ var u = v.substr(0, start);
+ for (var i = 0; i < n; i++) {
+ u += '\t';
+ }
+ u += v.substr(end);
+ // set revised content
+ code[0].value = u;
+ // reset caret position after inserted tabs
+ code[0].selectionStart = start + n;
+ code[0].selectionEnd = start + n;
+ }
+ function autoindent(el) {
+ var curpos = el.selectionStart;
+ var tabs = 0;
+ while (curpos > 0) {
+ curpos--;
+ if (el.value[curpos] == '\t') {
+ tabs++;
+ } else if (tabs > 0 || el.value[curpos] == '\n') {
+ break;
+ }
+ }
+ setTimeout(function() {
+ insertTabs(tabs);
+ }, 1);
+ }
+
+ // NOTE(cbro): e is a jQuery event, not a DOM event.
+ function handleSaveShortcut(e) {
+ if (e.isDefaultPrevented()) return false;
+ if (!e.metaKey && !e.ctrlKey) return false;
+ if (e.key != 'S' && e.key != 's') return false;
+
+ e.preventDefault();
+
+ // Share and save
+ share(function(url) {
+ window.location.href = url + '.go?download=true';
+ });
+
+ return true;
+ }
+
+ function keyHandler(e) {
+ if (opts.enableShortcuts && handleSaveShortcut(e)) return;
+
+ if (e.keyCode == 9 && !e.ctrlKey) {
+ // tab (but not ctrl-tab)
+ insertTabs(1);
+ e.preventDefault();
+ return false;
+ }
+ if (e.keyCode == 13) {
+ // enter
+ if (e.shiftKey) {
+ // +shift
+ run();
+ e.preventDefault();
+ return false;
+ }
+ if (e.ctrlKey) {
+ // +control
+ fmt();
+ e.preventDefault();
+ } else {
+ autoindent(e.target);
+ }
+ }
+ return true;
+ }
+ code.unbind('keydown').bind('keydown', keyHandler);
+ var outdiv = $(opts.outputEl).empty();
+ var output = $('<pre/>').appendTo(outdiv);
+
+ function body() {
+ return $(opts.codeEl).val();
+ }
+ function setBody(text) {
+ $(opts.codeEl).val(text);
+ }
+ function origin(href) {
+ return ('' + href)
+ .split('/')
+ .slice(0, 3)
+ .join('/');
+ }
+
+ var pushedEmpty = window.location.pathname == '/';
+ function inputChanged() {
+ if (pushedEmpty) {
+ return;
+ }
+ pushedEmpty = true;
+ $(opts.shareURLEl).hide();
+ window.history.pushState(null, '', '/');
+ }
+ function popState(e) {
+ if (e === null) {
+ return;
+ }
+ if (e && e.state && e.state.code) {
+ setBody(e.state.code);
+ }
+ }
+ var rewriteHistory = false;
+ if (
+ window.history &&
+ window.history.pushState &&
+ window.addEventListener &&
+ opts.enableHistory
+ ) {
+ rewriteHistory = true;
+ code[0].addEventListener('input', inputChanged);
+ window.addEventListener('popstate', popState);
+ }
+
+ function setError(error) {
+ if (running) running.Kill();
+ lineClear();
+ lineHighlight(error);
+ output
+ .empty()
+ .addClass('error')
+ .text(error);
+ }
+ function loading() {
+ lineClear();
+ if (running) running.Kill();
+ output.removeClass('error').text('Waiting for remote server...');
+ }
+ function run() {
+ loading();
+ running = transport.Run(
+ body(),
+ highlightOutput(PlaygroundOutput(output[0]))
+ );
+ }
+
+ function fmt() {
+ loading();
+ var data = { body: body() };
+ if ($(opts.fmtImportEl).is(':checked')) {
+ data['imports'] = 'true';
+ }
+ $.ajax('/fmt', {
+ data: data,
+ type: 'POST',
+ dataType: 'json',
+ success: function(data) {
+ if (data.Error) {
+ setError(data.Error);
+ } else {
+ setBody(data.Body);
+ setError('');
+ }
+ },
+ });
+ }
+
+ var shareURL; // jQuery element to show the shared URL.
+ var sharing = false; // true if there is a pending request.
+ var shareCallbacks = [];
+ function share(opt_callback) {
+ if (opt_callback) shareCallbacks.push(opt_callback);
+
+ if (sharing) return;
+ sharing = true;
+
+ var sharingData = body();
+ $.ajax('/share', {
+ processData: false,
+ data: sharingData,
+ type: 'POST',
+ contentType: 'text/plain; charset=utf-8',
+ complete: function(xhr) {
+ sharing = false;
+ if (xhr.status != 200) {
+ alert('Server error; try again.');
+ return;
+ }
+ if (opts.shareRedirect) {
+ window.location = opts.shareRedirect + xhr.responseText;
+ }
+ var path = '/p/' + xhr.responseText;
+ var url = origin(window.location) + path;
+
+ for (var i = 0; i < shareCallbacks.length; i++) {
+ shareCallbacks[i](url);
+ }
+ shareCallbacks = [];
+
+ if (shareURL) {
+ shareURL
+ .show()
+ .val(url)
+ .focus()
+ .select();
+
+ if (rewriteHistory) {
+ var historyData = { code: sharingData };
+ window.history.pushState(historyData, '', path);
+ pushedEmpty = false;
+ }
+ }
+ },
+ });
+ }
+
+ $(opts.runEl).click(run);
+ $(opts.fmtEl).click(fmt);
+
+ if (
+ opts.shareEl !== null &&
+ (opts.shareURLEl !== null || opts.shareRedirect !== null)
+ ) {
+ if (opts.shareURLEl) {
+ shareURL = $(opts.shareURLEl).hide();
+ }
+ $(opts.shareEl).click(function() {
+ share();
+ });
+ }
+
+ if (opts.toysEl !== null) {
+ $(opts.toysEl).bind('change', function() {
+ var toy = $(this).val();
+ $.ajax('/doc/play/' + toy, {
+ processData: false,
+ type: 'GET',
+ complete: function(xhr) {
+ if (xhr.status != 200) {
+ alert('Server error; try again.');
+ return;
+ }
+ setBody(xhr.responseText);
+ },
+ });
+ });
+ }
+ }
+
+ window.playground = playground;
+})();
diff --git a/_content/lib/godoc/style.css b/_content/lib/godoc/style.css
new file mode 100644
index 0000000..7e5008d
--- /dev/null
+++ b/_content/lib/godoc/style.css
@@ -0,0 +1,1073 @@
+body {
+ background-color: #fff;
+ color: #3e4042;
+ font-family: Roboto, Arial, sans-serif;
+ line-height: 1.3;
+ margin: 0;
+ text-align: center;
+}
+.Note {
+ /* For styling "Note" sections. */
+ background-color: rgb(224, 235, 245);
+ font-size: 0.875rem;
+ margin: 1.25rem;
+ max-width: 50rem;
+ padding: 0.5rem 0.5rem 0.5rem 0.625rem;
+}
+/* Tabs */
+.TabSection {
+ background: #fff;
+ border: 0.0625rem solid #dadce0;
+ border-radius: 0.3125rem;
+ box-shadow: none;
+ max-width: 50rem;
+}
+.TabSection-tabList {
+ flex-shrink: 0;
+ position: relative;
+ border-bottom: 0.0625rem solid #dadce0;
+}
+.TabSection-tab {
+ background: #fff;
+ border: none;
+ line-height: 3rem;
+ padding: 0 1.125rem;
+ position: relative;
+}
+.TabSection-tab[aria-selected='true'] {
+ outline: 0;
+ background-color: #e0ebf5;
+}
+.TabSection-tab:focus {
+ outline: 0;
+ background-color: #e0ebf5;
+}
+.TabSection-tabPanel {
+ font-size: 0.875rem;
+}
+/* Tutorial previous and next links */
+.Navigation {
+ font-size: 0.875rem;
+}
+.Navigation-prev {
+ float: left;
+ font-weight: bold;
+}
+.Navigation-next {
+ float: right;
+ font-weight: bold;
+}
+/* Table in doc topics. */
+.DocTable {
+ border-collapse: collapse;
+ font-size: 0.875rem;
+ margin: 1.25rem;
+ max-width: 50rem;
+}
+.DocTable-row {
+ border-bottom: 0.0625rem solid #dadce0;
+ height: 3rem;
+ vertical-align: top;
+}
+.DocTable-head {
+ background: #e8eaed;
+ border-bottom: 0.0625rem solid #dadce0;
+ border-top: 0.0625rem solid #dadce0;
+ height: 3rem;
+}
+.DocTable-cell {
+ padding: 0.4375rem;
+}
+.DocTable-cell pre {
+ font-size: 0.775rem;
+}
+.DocTable-cell p,
+.DocTable-cell pre {
+ margin: 0rem 0rem 0.875rem;
+}
+.DocTable-row--highlighted {
+ background: #f0f0f0;
+ border-bottom: 0.0625rem solid #dadce0;
+ height: 3rem;
+}
+textarea {
+ /* Inherit text color from body avoiding illegible text in the case where the
+ * user has inverted the browsers custom text and background colors. */
+ color: inherit;
+}
+pre,
+code {
+ font-family: Menlo, monospace;
+ font-size: 0.875rem;
+}
+code {
+ /* Reduce spacing between words in code inline with text. Monospace font
+ * spaces tend to be wider than proportional font spaces. */
+ word-spacing: -0.3em;
+}
+pre code {
+ /* Maintain spacing inside preformatted blocks rendered from Markdown.
+ * See golang.org/issue/41507. */
+ word-spacing: 0;
+}
+pre {
+ line-height: 1.4;
+ overflow-x: auto;
+}
+pre .comment {
+ color: #006600;
+}
+pre .highlight,
+pre .highlight-comment,
+pre .selection-highlight,
+pre .selection-highlight-comment {
+ background: #ffff00;
+}
+pre .selection,
+pre .selection-comment {
+ background: #ff9632;
+}
+pre .ln {
+ color: #999;
+ background: #efefef;
+}
+pre ins {
+ /* For styling highlighted code in examples. */
+ color: rgb(0, 125, 156);
+ font-weight: bold;
+ text-decoration: none;
+}
+.ln {
+ user-select: none;
+
+ /* Ensure 8 characters in the document - which due to floating
+ * point rendering issues, might have a width of less than 1 each - are 8
+ * characters wide, so a tab in the 9th position indents properly. See
+ * https://github.com/webcompat/web-bugs/issues/17530#issuecomment-402675091
+ * for more information. */
+ display: inline-block;
+ width: 8ch;
+}
+.search-nav {
+ margin-left: 1.25rem;
+ font-size: 0.875rem;
+ column-gap: 1.25rem;
+ column-fill: auto;
+ column-width: 14rem;
+}
+.search-nav .indent {
+ margin-left: 1.25rem;
+}
+a,
+.exampleHeading .text,
+.expandAll {
+ color: #007d9c;
+ text-decoration: none;
+}
+a:hover,
+.exampleHeading .text:hover,
+.expandAll:hover {
+ text-decoration: underline;
+}
+.article a {
+ text-decoration: underline;
+}
+.article .title a {
+ text-decoration: none;
+}
+.permalink {
+ display: none;
+}
+:hover > .permalink {
+ display: inline;
+}
+p,
+li {
+ max-width: 50rem;
+ word-wrap: break-word;
+}
+p,
+pre,
+ul,
+ol {
+ margin: 1.25rem;
+}
+pre {
+ background: #efefef;
+ padding: 0.625rem;
+ border-radius: 0.3125rem;
+}
+h1,
+h2,
+h3,
+h4 {
+ margin: 1.25rem 0 1.25rem;
+ padding: 0;
+ color: #202224;
+ font-family: 'Work Sans', sans-serif;
+ font-weight: 600;
+}
+h1 {
+ font-size: 1.75rem;
+ line-height: 1;
+}
+h1 .text-muted {
+ color: #777;
+}
+h2 {
+ font-size: 1.25rem;
+ background: #e0ebf5;
+ padding: 0.5rem;
+ line-height: 1.25;
+ font-weight: normal;
+ overflow-wrap: break-word;
+}
+h2 a {
+ font-weight: bold;
+}
+h3 {
+ font-size: 1.25rem;
+ line-height: 1.25;
+ overflow-wrap: break-word;
+}
+h3,
+h4 {
+ margin: 1.25rem 0.3125rem;
+}
+h4 {
+ font-size: 1rem;
+}
+h2 > span,
+h3 > span {
+ float: right;
+ margin: 0 25px 0 0;
+ font-weight: normal;
+ color: #5279c7;
+}
+dl {
+ margin: 1.25rem;
+ max-width: 50rem;
+}
+dd {
+ margin: 0 0 0 1.25rem;
+}
+dl,
+dd {
+ font-size: 0.875rem;
+}
+div#nav table td {
+ vertical-align: top;
+}
+.ModTable {
+ border-collapse: collapse;
+ margin: 1.25rem;
+ max-width: 50rem;
+}
+.ModTable code {
+ white-space: nowrap;
+}
+.ModTable td,
+.ModTable th {
+ border: 1px solid #a9a9a9;
+ padding: 1rem;
+ vertical-align: top;
+}
+.ModTable td p {
+ margin: 0 0 1rem 0;
+}
+.ModTable td p:last-child {
+ margin-bottom: 0;
+}
+#pkg-index h3 {
+ font-size: 1rem;
+}
+.pkg-dir {
+ padding: 0 0.625rem;
+}
+.pkg-dir table {
+ border-collapse: collapse;
+ border-spacing: 0;
+}
+.pkg-name {
+ padding-right: 0.625rem;
+}
+.alert {
+ color: #aa0000;
+}
+#pkg-examples h3 {
+ float: left;
+}
+#pkg-examples dl {
+ clear: both;
+}
+.expandAll {
+ cursor: pointer;
+ float: left;
+ margin: 1.25rem 0;
+}
+.Site {
+ display: flex;
+ flex-direction: column;
+ min-height: 100vh;
+}
+.Site-content {
+ flex: 1;
+}
+#page {
+ width: 100%;
+}
+#page > .container,
+.Header-nav {
+ text-align: left;
+ margin-left: auto;
+ margin-right: auto;
+ padding: 0 1.25rem;
+}
+#page > .container,
+.Header-nav,
+.Footer {
+ max-width: 59.38rem;
+}
+#page.wide > .container,
+.Header-nav--wide,
+.Footer--wide {
+ max-width: none;
+}
+div#playground .buttons a {
+ background: #375eab;
+ border: 0.0625rem solid #757575;
+ color: white;
+}
+/* Style download button on doc/install page */
+a#start {
+ background: #e0ebf5;
+ border: 0.0625rem solid #375eab;
+ border-radius: 0.3125rem;
+ color: #222;
+ display: block;
+ padding: 0.625rem;
+ text-align: center;
+ text-decoration: none;
+}
+a#start .big {
+ display: block;
+ font-size: 1.25rem;
+ font-weight: bold;
+}
+a#start .desc {
+ display: block;
+ font-size: 0.875rem;
+ font-weight: normal;
+ margin-top: 0.3125rem;
+}
+.download {
+ width: 17.5rem;
+}
+::-webkit-input-placeholder {
+ color: #7f7f7f;
+ opacity: 1;
+}
+::placeholder {
+ color: #7f7f7f;
+ opacity: 1;
+}
+.Header {
+ align-items: center;
+ box-sizing: border-box;
+ display: flex;
+ font-size: 0.875rem;
+ justify-content: space-between;
+ padding: 1.375rem 0;
+}
+.Header.is-active {
+ background-color: #f7f9fa;
+}
+.Header-banner {
+ display: none;
+}
+.Header-logo {
+ height: 2rem;
+ width: 5.125rem;
+}
+.Header-nav {
+ align-items: center;
+ display: flex;
+ flex-wrap: wrap;
+ justify-content: space-between;
+ width: 100%;
+}
+.Header-menuButton {
+ background-color: transparent;
+ border: none;
+ box-sizing: content-box;
+ cursor: pointer;
+ display: inline-block;
+ height: 1.313rem;
+ padding: 0.375rem;
+ position: relative;
+ vertical-align: middle;
+ width: 1.313rem;
+}
+.Header-menuButtonInner {
+ position: relative;
+}
+.Header-menuButton::after,
+.Header-menuButtonInner,
+.Header-menuButtonInner::before,
+.Header-menuButtonInner::after {
+ background-color: #3e4042;
+ height: 0.1875rem;
+ transition: all 100ms ease-in;
+}
+.Header-menuButton::after {
+ opacity: 0;
+ top: 0.9375rem;
+}
+.Header-menuButton::after,
+.Header-menuButtonInner::before,
+.Header-menuButtonInner::after {
+ content: '';
+ display: block;
+ position: absolute;
+ width: 1.313rem;
+}
+.Header-menuButtonInner::before {
+ top: -0.375rem;
+}
+.Header-menuButtonInner::after {
+ bottom: -0.375rem;
+}
+.Header.is-active .Header-menuButton::after {
+ opacity: 1;
+ transform: rotate(-45deg);
+}
+.Header.is-active .Header-menuButton .Header-menuButtonInner {
+ transform: rotate(45deg);
+}
+.Header.is-active .Header-menuButton .Header-menuButtonInner::before,
+.Header.is-active .Header-menuButton .Header-menuButtonInner::after {
+ background-color: transparent;
+}
+.Header-menu {
+ align-items: center;
+ display: none;
+ flex-direction: column;
+ list-style: none;
+ margin: 0;
+ padding: 0;
+ width: 100%;
+}
+.Header.is-active .Header-menu {
+ display: flex;
+}
+.Header-menuItem:first-of-type {
+ /* Offset the padding of the inner link, maintaining its click target size,
+ while still placing the item as if it had no top margin or padding. */
+ margin-top: -0.5rem;
+}
+.Header-menuItem {
+ display: inline-flex;
+}
+.Header-menuItem,
+.Header-menuItem a:link,
+.Header-menuItem a:visited {
+ width: 100%;
+}
+.Header-menuItem,
+.Header-menuItem a:link,
+.Header-menuItem a:visited {
+ color: #3e4042;
+ text-align: center;
+}
+.Header-menuItem a:link,
+.Header-menuItem a:visited {
+ padding: 0.5rem 0;
+}
+@media only screen and (min-width: 56rem) {
+ .Header {
+ display: block;
+ padding: 0;
+ }
+ .Header-banner {
+ background-color: #000;
+ color: #fff;
+ display: block;
+ padding: 1rem;
+ }
+ .Header-banner a:link,
+ .Header-banner a:visited {
+ color: #fff;
+ text-decoration: underline;
+ }
+ .Header-nav {
+ width: auto;
+ }
+ .Header.is-active {
+ background-color: #fff;
+ }
+ .Header.is-active .Header-menu {
+ display: block;
+ }
+ .Header-menuButton {
+ display: none;
+ }
+ .Header-menu {
+ display: flex;
+ flex-direction: row;
+ width: auto;
+ }
+ .Header-menuItem:first-of-type {
+ margin-top: 0;
+ }
+ .Header-menuItem,
+ .Header-menuItem a:link,
+ .Header-menuItem a:visited {
+ width: auto;
+ }
+ .Header-menuItem a:link,
+ .Header-menuItem a:visited {
+ padding: 2rem 1.5rem;
+ }
+ .Header-menuItem a:hover,
+ .Header-menuItem a:focus {
+ text-decoration: underline;
+ }
+}
+@media only screen and (min-width: 57.5rem) {
+ .Header {
+ font-size: 1rem;
+ }
+}
+.Button,
+.Button:link,
+.Button:visited {
+ align-items: center;
+ background-color: #f7f9fa;
+ border: none;
+ border-radius: 0.1875rem;
+ box-shadow: 0 2px 5px rgba(0, 0, 0, 0.2);
+ box-sizing: border-box;
+ color: #007d9c;
+ cursor: pointer;
+ display: inline-flex;
+ font: bold 0.875rem Roboto, sans-serif;
+ height: 2.375rem;
+ padding: 0 0.625rem;
+ justify-content: center;
+ min-width: 4.063rem;
+ text-decoration: none;
+}
+.Button:active {
+ box-shadow: 0 1px 3px rgba(0, 0, 0, 0.2);
+}
+.Button--primary,
+.Button--primary:link,
+.Button--primary:visited {
+ border: 0.0625rem solid #00add8;
+}
+.Button--big,
+.Button--big:link,
+.Button--big:visited {
+ background-color: #7fd5ea;
+ border-radius: 0.3125rem;
+ color: #202224;
+ font-size: 1.5rem;
+ height: 4rem;
+ justify-content: center;
+}
+.HomeContainer {
+ align-items: top;
+ display: flex;
+ flex-wrap: wrap;
+ justify-content: space-between;
+}
+.HomeContainer * {
+ box-sizing: border-box;
+}
+.HomeSection {
+ flex: 0 0 100%;
+ margin-bottom: 2.5rem;
+ padding: 0 1rem;
+}
+.HomeSection-header {
+ background: none;
+ color: #202224;
+ margin: 0 0 0.625rem 0;
+ padding: 0;
+ font-weight: bold;
+}
+.Hero-header {
+ font: 1.5rem Roboto, sans-serif;
+ line-height: inherit;
+ margin: 0 0 1.875rem;
+}
+.Hero-gopher {
+ background: url('/lib/godoc/images/home-gopher.png') no-repeat;
+ background-position: center top;
+ display: block;
+ height: 9.688rem;
+ max-height: 200px;
+ /* Setting in px to prevent the gopher from blowing up in very high default font-sizes */
+}
+.HeroDownloadButton,
+.Hero-description {
+ text-align: center;
+}
+.HeroDownloadButton,
+.HeroDownloadButton:link,
+.HeroDownloadButton:visited {
+ display: flex;
+ margin-bottom: 0.5rem;
+}
+.HeroDownloadButton-image {
+ height: 2rem;
+ margin-right: 2rem;
+ width: 2rem;
+}
+.Hero-description {
+ color: #616161;
+ font-size: 0.875rem;
+ margin: 0;
+}
+@media only screen and (min-width: 57.1875rem) {
+ .HomeSection {
+ flex: 0 0 26.875rem;
+ padding: 0;
+ }
+ .Hero,
+ .Playground {
+ margin-top: 1rem;
+ }
+}
+.Playground-headerContainer {
+ align-items: baseline;
+ display: flex;
+ justify-content: space-between;
+}
+.Playground-popout {
+ background: url('/lib/godoc/images/play-link.svg') no-repeat;
+ background-position: right center;
+ cursor: pointer;
+ display: block;
+ font-size: 1rem;
+ padding: 0 1.688rem;
+}
+.Playground-input,
+.Playground-output {
+ padding: 0;
+ margin: 0;
+ font-family: Menlo, monospace;
+ font-size: 0.875rem;
+}
+.Playground-inputContainer {
+ border-top-left-radius: 0.3125rem;
+ border-top-right-radius: 0.3125rem;
+ overflow: hidden;
+ height: 11rem;
+}
+.Playground-input {
+ width: 100%;
+ height: 100%;
+ border: none;
+ outline: none;
+ resize: none;
+ padding: 0.625rem;
+}
+.Playground-outputContainer {
+ border-bottom-right-radius: 0.3125rem;
+ border-bottom-left-radius: 0.3125rem;
+ border-top: none !important;
+ padding: 0.625rem;
+ height: 5rem;
+ margin-bottom: 1rem;
+ overflow: auto;
+}
+.Playground-output {
+ padding: 0;
+ border-radius: 0;
+}
+.Playground-inputContainer,
+.Playground-input,
+.Playground-outputContainer,
+.Playground-output {
+ background: #f7f9fa;
+ color: #202224;
+}
+.Playground-inputContainer,
+.Playground-outputContainer {
+ border: 0.0625rem solid #c0c2c3;
+}
+.Playground-controls {
+ display: flex;
+ flex-wrap: wrap;
+}
+.Playground-buttons {
+ display: flex;
+ flex: 1;
+ flex-wrap: nowrap;
+ justify-content: space-between;
+}
+.Playground-selectExample {
+ background-color: white;
+ border-radius: 3px;
+ border: 0.0625rem solid #979797;
+ color: inherit;
+ font-family: inherit;
+ font-size: 16px;
+ /* Prevents automatic zoom on mobile devices */
+ height: 2.375rem;
+ margin: 0 0 0.5rem 0;
+ width: 100%;
+}
+.Playground-secondaryButtons {
+ white-space: nowrap;
+}
+.Playground-secondaryButtons .Button:not(:first-child) {
+ margin-left: 0.4375rem;
+}
+@media only screen and (min-width: 27.8125rem) {
+ .Playground-outputContainer {
+ margin-bottom: 1.688rem;
+ }
+ .Playground-controls {
+ flex-wrap: nowrap;
+ }
+ .Playground-selectExample {
+ margin: 0 0.4375rem 0 0;
+ width: auto;
+ }
+}
+.Blog-title {
+ display: block;
+ font-size: 1.25rem;
+ font-weight: normal;
+ margin: 0;
+}
+.Blog-title,
+.Blog-extract,
+.Blog-when {
+ margin-bottom: 0.625rem;
+}
+.Blog-when {
+ color: #666;
+ font-size: 0.875rem;
+}
+.Blog-footer {
+ text-align: right;
+}
+@supports (--c: 0) {
+ [style*='--aspect-ratio-padding:'] {
+ position: relative;
+ overflow: hidden;
+ padding-top: var(--aspect-ratio-padding);
+ }
+ [style*='--aspect-ratio-padding:'] > * {
+ position: absolute;
+ top: 0;
+ left: 0;
+ width: 100%;
+ height: 100%;
+ }
+}
+.Footer {
+ margin: 2rem auto 0;
+ padding: 1rem 1.25rem;
+ position: relative;
+ text-align: right;
+}
+.Footer-gopher {
+ bottom: 0;
+ left: 1.25rem;
+ position: absolute;
+ width: 5rem;
+}
+.Footer-links {
+ flex: 1;
+ list-style: none;
+ margin: 0;
+ padding: 0;
+}
+.Footer-link {
+ font-size: 0.875rem;
+ white-space: nowrap;
+}
+.Footer-link + .Footer-link {
+ margin-top: 0.5rem;
+}
+.Footer-supportedBy {
+ color: #6e7072;
+ display: inline-block;
+ font: 0.875rem 'Product Sans', 'Roboto', 'sans-serif';
+ margin-top: 1rem;
+}
+.Footer-supportedBy:hover {
+ text-decoration: none;
+}
+@media only screen and (min-width: 50rem) {
+ .Footer {
+ align-items: center;
+ display: flex;
+ margin: 5rem auto 0;
+ }
+ .Footer-links {
+ padding-left: 6.25rem;
+ text-align: left;
+ }
+ .Footer-link {
+ display: inline;
+ }
+ .Footer-link + .Footer-link {
+ border-left: 0.0625rem solid #3e4042;
+ margin-left: 0.75rem;
+ padding-left: 0.75rem;
+ }
+ .Footer-supportedBy {
+ margin-top: 0;
+ }
+}
+.toggleButton {
+ cursor: pointer;
+}
+.toggle > .collapsed {
+ display: block;
+}
+.toggle > .expanded {
+ display: none;
+}
+.toggleVisible > .collapsed {
+ display: none;
+}
+.toggleVisible > .expanded {
+ display: block;
+}
+table.codetable {
+ margin-left: auto;
+ margin-right: auto;
+ border-style: none;
+}
+table.codetable td {
+ padding-right: 0.625rem;
+}
+hr {
+ border-style: none;
+ border-top: 0.0625rem solid black;
+}
+img.gopher {
+ float: right;
+ margin-left: 0.625rem;
+ margin-bottom: 0.625rem;
+ z-index: -1;
+}
+h2 {
+ clear: right;
+}
+div.play {
+ padding: 0 1.25rem 2.5rem 1.25rem;
+}
+div.play pre,
+div.play textarea,
+div.play .lines {
+ padding: 0;
+ margin: 0;
+ font-family: Menlo, monospace;
+ font-size: 0.875rem;
+}
+div.play .input {
+ padding: 0.625rem;
+ margin-top: 0.625rem;
+
+ border-top-left-radius: 0.3125rem;
+ border-top-right-radius: 0.3125rem;
+
+ overflow: hidden;
+}
+div.play .input textarea {
+ width: 100%;
+ height: 100%;
+ border: none;
+ outline: none;
+ resize: none;
+
+ overflow: hidden;
+}
+div#playground .input textarea {
+ overflow: auto;
+ resize: auto;
+}
+div.play .output {
+ border-top: none !important;
+
+ padding: 0.625rem;
+ max-height: 12.5rem;
+ overflow: auto;
+
+ border-bottom-right-radius: 0.3125rem;
+ border-bottom-left-radius: 0.3125rem;
+}
+div.play .output pre {
+ padding: 0;
+ border-radius: 0;
+}
+div.play .input,
+div.play .input textarea,
+div.play .output,
+div.play .output pre {
+ background: #f7f9fa;
+ color: #202224;
+}
+div.play .input,
+div.play .output {
+ border: 0.0625rem solid #c0c2c3;
+}
+div.play .buttons {
+ float: right;
+ padding: 0.625rem 0;
+ text-align: right;
+}
+div.play .buttons .Button {
+ margin-left: 0.3125rem;
+}
+.output .stderr {
+ color: #933;
+}
+.output .system {
+ color: #999;
+}
+/* drop-down playground */
+div#playground {
+ /* start hidden; revealed by javascript */
+ display: none;
+}
+div#playground {
+ position: absolute;
+ top: 3.938rem;
+ right: 1.25rem;
+ padding: 0 0.625rem 0.625rem 0.625rem;
+ z-index: 1;
+ text-align: left;
+ background: #e0ebf5;
+
+ border: 0.0625rem solid #b0bbc5;
+ border-top: none;
+
+ border-bottom-left-radius: 0.3125rem;
+ border-bottom-right-radius: 0.3125rem;
+}
+div#playground .code {
+ width: 32.5rem;
+ height: 12.5rem;
+}
+div#playground .output {
+ height: 6.25rem;
+}
+/* Inline runnable snippets (play.js/initPlayground) */
+#content .code pre,
+#content .playground pre,
+#content .output pre {
+ margin: 0;
+ padding: 0;
+ background: none;
+ border: none;
+ outline: 0 solid transparent;
+ overflow: auto;
+}
+#content .playground .number,
+#content .code .number {
+ color: #999;
+}
+#content .code,
+#content .playground,
+#content .output {
+ width: auto;
+ margin: 1.25rem;
+ padding: 0.625rem;
+ border-radius: 0.3125rem;
+}
+#content .code,
+#content .playground {
+ background: #e9e9e9;
+}
+#content .output {
+ background: #202020;
+}
+#content .output .stdout,
+#content .output pre {
+ color: #e6e6e6;
+}
+#content .output .stderr,
+#content .output .error {
+ color: rgb(244, 74, 63);
+}
+#content .output .system,
+#content .output .exit {
+ color: rgb(255, 209, 77);
+}
+#content .buttons {
+ position: relative;
+ float: right;
+ top: -3.125rem;
+ right: 1.875rem;
+}
+#content .output .buttons {
+ top: -3.75rem;
+ right: 0;
+ height: 0;
+}
+#content .buttons .kill {
+ display: none;
+ visibility: hidden;
+}
+a.error {
+ font-weight: bold;
+ color: white;
+ background-color: darkred;
+ border-bottom-left-radius: 0.25rem;
+ border-bottom-right-radius: 0.25rem;
+ border-top-left-radius: 0.25rem;
+ border-top-right-radius: 0.25rem;
+ padding: 0.125rem 0.25rem 0.125rem 0.25rem;
+ /* TRBL */
+}
+.downloading {
+ background: #f9f9be;
+ padding: 0.625rem;
+ text-align: center;
+ border-radius: 0.3125rem;
+}
+@media (max-width: 43.75em) {
+ body {
+ font-size: 0.9375rem;
+ }
+ div#playground {
+ left: 0;
+ right: 0;
+ }
+ pre,
+ code {
+ font-size: 0.866rem;
+ }
+ #page > .container,
+ .Header-nav {
+ padding: 0 0.625rem;
+ }
+ p,
+ pre,
+ ul,
+ ol {
+ margin: 0.625rem;
+ }
+ .pkg-synopsis {
+ display: none;
+ }
+ img.gopher {
+ display: none;
+ }
+}
+@media print {
+ pre {
+ background: #fff;
+ border: 0.0625rem solid #bbb;
+ white-space: pre-wrap;
+ page-break-inside: avoid;
+ }
+}
\ No newline at end of file
diff --git a/_content/robots.txt b/_content/robots.txt
new file mode 100644
index 0000000..1f53798
--- /dev/null
+++ b/_content/robots.txt
@@ -0,0 +1,2 @@
+User-agent: *
+Disallow: /
diff --git a/cmd/admingolangorg/.gcloudignore b/cmd/admingolangorg/.gcloudignore
new file mode 100644
index 0000000..199e6d9
--- /dev/null
+++ b/cmd/admingolangorg/.gcloudignore
@@ -0,0 +1,25 @@
+# This file specifies files that are *not* uploaded to Google Cloud Platform
+# using gcloud. It follows the same syntax as .gitignore, with the addition of
+# "#!include" directives (which insert the entries of the given .gitignore-style
+# file at that point).
+#
+# For more information, run:
+# $ gcloud topic gcloudignore
+#
+.gcloudignore
+# If you would like to upload your .git directory, .gitignore file or files
+# from your .gitignore file, remove the corresponding line
+# below:
+.git
+.gitignore
+
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+# Test binary, build with `go test -c`
+*.test
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
\ No newline at end of file
diff --git a/cmd/admingolangorg/README.md b/cmd/admingolangorg/README.md
new file mode 100644
index 0000000..108b8ea
--- /dev/null
+++ b/cmd/admingolangorg/README.md
@@ -0,0 +1,12 @@
+# admingolangorg
+
+This app serves as the [admin interface](https://admin-dot-golang-org.appspot.com) for the golang.org/s link
+shortener. Its functionality may be expanded in the future.
+
+## Deployment:
+
+To update the public site, run:
+
+```
+gcloud app --account=username@domain.com --project=golang-org deploy app.yaml
+```
diff --git a/cmd/admingolangorg/app.yaml b/cmd/admingolangorg/app.yaml
new file mode 100644
index 0000000..6006441
--- /dev/null
+++ b/cmd/admingolangorg/app.yaml
@@ -0,0 +1,15 @@
+runtime: go111
+service: admin
+
+env_variables:
+ GOLANGORG_REDIS_ADDR: 10.0.0.4:6379 # instance "gophercache"
+ DATASTORE_PROJECT_ID: golang-org
+
+handlers:
+ - url: .*
+ script: auto
+ secure: always
+ login: admin # THIS MUST BE SET
+
+vpc_access_connector:
+ name: 'projects/golang-org/locations/us-central1/connectors/golang-vpc-connector'
diff --git a/cmd/admingolangorg/main.go b/cmd/admingolangorg/main.go
new file mode 100644
index 0000000..a8dd26a
--- /dev/null
+++ b/cmd/admingolangorg/main.go
@@ -0,0 +1,51 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// The admingolangorg command serves an administrative interface for owners of
+// the golang-org Google Cloud project.
+package main
+
+import (
+ "context"
+ "log"
+ "net/http"
+ "os"
+ "strings"
+
+ "cloud.google.com/go/datastore"
+ "golang.org/x/website/internal/memcache"
+ "golang.org/x/website/internal/short"
+)
+
+func main() {
+ http.HandleFunc("/", short.AdminHandler(getClients()))
+ port := os.Getenv("PORT")
+ if port == "" {
+ port = "8080"
+ log.Printf("Defaulting to port %s", port)
+ }
+
+ log.Printf("Listening on port %s", port)
+ log.Fatal(http.ListenAndServe(":"+port, nil))
+}
+
+func getClients() (*datastore.Client, *memcache.Client) {
+ ctx := context.Background()
+
+ datastoreClient, err := datastore.NewClient(ctx, "")
+ if err != nil {
+ if strings.Contains(err.Error(), "missing project") {
+ log.Fatalf("Missing datastore project. Set the DATASTORE_PROJECT_ID env variable. Use `gcloud beta emulators datastore` to start a local datastore.")
+ }
+ log.Fatalf("datastore.NewClient: %v.", err)
+ }
+
+ redisAddr := os.Getenv("GOLANGORG_REDIS_ADDR")
+ if redisAddr == "" {
+ log.Fatalf("Missing redis server for golangorg in production mode. set GOLANGORG_REDIS_ADDR environment variable.")
+ }
+ memcacheClient := memcache.New(redisAddr)
+
+ return datastoreClient, memcacheClient
+}
diff --git a/cmd/golangorg/Dockerfile.prod b/cmd/golangorg/Dockerfile.prod
new file mode 100644
index 0000000..e60c99e
--- /dev/null
+++ b/cmd/golangorg/Dockerfile.prod
@@ -0,0 +1,55 @@
+# Builder
+#########
+
+FROM golang:1.12 AS build
+
+# Check out the desired version of Go, both to build the golangorg binary and serve
+# as the goroot for content serving.
+ARG GO_REF
+RUN test -n "$GO_REF" # GO_REF is required.
+RUN git clone --single-branch --depth=1 -b $GO_REF https://go.googlesource.com/go /goroot
+RUN cd /goroot/src && ./make.bash
+
+ENV GOROOT /goroot
+ENV PATH=/goroot/bin:$PATH
+ENV GO111MODULE=on
+ENV GOPROXY=https://proxy.golang.org
+
+RUN go version
+
+COPY . /website
+
+WORKDIR /website/cmd/golangorg
+
+RUN go build -o /golangorg -tags=prod golang.org/x/website/cmd/golangorg
+
+# Clean up goroot for the final image.
+RUN cd /goroot && git clean -xdf
+
+# Add build metadata.
+RUN cd /goroot && echo "go repo HEAD: $(git rev-parse HEAD)" >> /goroot/buildinfo
+RUN echo "requested go ref: ${GO_REF}" >> /goroot/buildinfo
+ARG WEBSITE_HEAD
+RUN echo "x/website HEAD: ${WEBSITE_HEAD}" >> /goroot/buildinfo
+ARG WEBSITE_CLEAN
+RUN echo "x/website clean: ${WEBSITE_CLEAN}" >> /goroot/buildinfo
+ARG DOCKER_TAG
+RUN echo "image: ${DOCKER_TAG}" >> /goroot/buildinfo
+ARG BUILD_ENV
+RUN echo "build env: ${BUILD_ENV}" >> /goroot/buildinfo
+
+RUN rm -rf /goroot/.git
+
+# Final image
+#############
+
+FROM gcr.io/distroless/base
+
+WORKDIR /app
+COPY --from=build /golangorg /app/
+COPY --from=build /website/cmd/golangorg/hg-git-mapping.bin /app/
+
+COPY --from=build /goroot /goroot
+ENV GOROOT /goroot
+
+CMD ["/app/golangorg"]
diff --git a/cmd/golangorg/Makefile b/cmd/golangorg/Makefile
new file mode 100644
index 0000000..47dc4a3
--- /dev/null
+++ b/cmd/golangorg/Makefile
@@ -0,0 +1,78 @@
+# Copyright 2018 The Go Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+.PHONY: usage
+
+GO_REF ?= release-branch.go1.16
+WEBSITE_HEAD := $(shell git rev-parse HEAD)
+WEBSITE_CLEAN := $(shell (git status --porcelain | grep -q .) && echo dirty || echo clean)
+ifeq ($(WEBSITE_CLEAN),clean)
+ DOCKER_VERSION ?= $(WEBSITE_HEAD)
+else
+ DOCKER_VERSION ?= $(WEBSITE_HEAD)-dirty
+endif
+GCP_PROJECT := golang-org
+GCP_SERVICE := default
+DOCKER_TAG := gcr.io/$(GCP_PROJECT)/golangorg:$(DOCKER_VERSION)
+
+usage:
+ @echo "See Makefile and README.md"
+ @exit 1
+
+cloud-build: Dockerfile.prod
+ gcloud builds submit \
+ --project=$(GCP_PROJECT) \
+ --config=cloudbuild.yaml \
+ --substitutions=_GO_REF=$(GO_REF),_WEBSITE_HEAD=$(WEBSITE_HEAD),_WEBSITE_CLEAN=$(WEBSITE_CLEAN),_DOCKER_TAG=$(DOCKER_TAG) \
+ ../.. # source code
+
+docker-build: Dockerfile.prod
+ # NOTE(cbro): move up in directory to include entire tools repo.
+ # NOTE(cbro): any changes made to this command must also be made in cloudbuild.yaml.
+ cd ../..; docker build \
+ -f=cmd/golangorg/Dockerfile.prod \
+ --build-arg=GO_REF=$(GO_REF) \
+ --build-arg=WEBSITE_HEAD=$(WEBSITE_HEAD) \
+ --build-arg=WEBSITE_CLEAN=$(WEBSITE_CLEAN) \
+ --build-arg=DOCKER_TAG=$(DOCKER_TAG) \
+ --build-arg=BUILD_ENV=local \
+ --tag=$(DOCKER_TAG) \
+ .
+
+docker-push: docker-build
+ docker push $(DOCKER_TAG)
+
+deploy:
+ gcloud -q app deploy app.prod.yaml \
+ --project=$(GCP_PROJECT) \
+ --no-promote \
+ --image-url=$(DOCKER_TAG)
+
+get-latest-url:
+ @gcloud app versions list \
+ --service=$(GCP_SERVICE) \
+ --project=$(GCP_PROJECT) \
+ --sort-by=~version.createTime \
+ --format='value(version.versionUrl)' \
+ --limit 1 | cut -f1 # NOTE(cbro): gcloud prints out createTime as the second field.
+
+get-latest-id:
+ @gcloud app versions list \
+ --service=$(GCP_SERVICE) \
+ --project=$(GCP_PROJECT) \
+ --sort-by=~version.createTime \
+ --format='value(version.id)' \
+ --limit 1 | cut -f1 # NOTE(cbro): gcloud prints out createTime as the second field.
+
+regtest:
+ go test -v \
+ -regtest.host=$(shell make get-latest-url) \
+ -run=Live
+
+publish: regtest
+ gcloud -q app services set-traffic $(GCP_SERVICE) \
+ --splits=$(shell make get-latest-id)=1 \
+ --project=$(GCP_PROJECT)
+
+ @echo Continue with the rest of the steps in \"Deploying to golang.org\" in the README.
diff --git a/cmd/golangorg/README.md b/cmd/golangorg/README.md
new file mode 100644
index 0000000..b3bc44d
--- /dev/null
+++ b/cmd/golangorg/README.md
@@ -0,0 +1,82 @@
+# golangorg
+
+## Local Development
+
+For local development, simply build and run. It serves on localhost:6060.
+
+ go run .
+
+## Local Production Mode
+
+To run in production mode locally, you need:
+
+ * the Google Cloud SDK; see https://cloud.google.com/sdk/
+ * Redis
+ * Go sources under $GOROOT
+
+Run with the `prod` tag:
+
+ go run -tags prod .
+
+In production mode it serves on localhost:8080 (not 6060).
+The port is controlled by $PORT, as in:
+
+ PORT=8081 ./golangorg
+
+## Local Production Mode using Docker
+
+To run in production mode locally using Docker, build the app's Docker container:
+
+ make docker-build
+
+Make sure redis is running on port 6379:
+
+ $ echo PING | nc localhost 6379
+ +PONG
+ ^C
+
+Run the datastore emulator:
+
+ gcloud beta emulators datastore start --project golang-org
+
+In another terminal window, run the container:
+
+ $(gcloud beta emulators datastore env-init)
+
+ docker run --rm \
+ --net host \
+ --env GOLANGORG_REDIS_ADDR=localhost:6379 \
+ --env DATASTORE_EMULATOR_HOST=$DATASTORE_EMULATOR_HOST \
+ --env DATASTORE_PROJECT_ID=$DATASTORE_PROJECT_ID \
+ gcr.io/golang-org/golangorg
+
+It serves on localhost:8080.
+
+## Deploying to golang.org
+
+1. Run `make cloud-build deploy` to build the image, push it to gcr.io,
+ and deploy to Flex (but not yet update golang.org to point to it).
+
+2. Check that the new version, mentioned on "target url:" line, looks OK.
+
+3. If all is well, run `make publish` to publish the new version to golang.org.
+ It will run regression tests and then point the load balancer to the newly
+ deployed version.
+
+4. Stop and/or delete any very old versions. (Stopped versions can be re-started.)
+ Keep at least one older verson to roll back to, just in case.
+
+ You can view, stop/delete, or migrate traffic between versions via the
+ [GCP Console UI](https://console.cloud.google.com/appengine/versions?project=golang-org&serviceId=default&pageState=(%22versionsTable%22:(%22f%22:%22%255B%257B_22k_22_3A_22Environment_22_2C_22t_22_3A10_2C_22v_22_3A_22_5C_22Flexible_5C_22_22_2C_22s_22_3Atrue_2C_22i_22_3A_22env_22%257D%255D%22))).
+
+5. You're done.
+
+## Troubleshooting
+
+Ensure the Cloud SDK is on your PATH and you have the app-engine-go component
+installed (`gcloud components install app-engine-go`) and your components are
+up-to-date (`gcloud components update`).
+
+For deployment, make sure you're signed in to gcloud:
+
+ gcloud auth login
diff --git a/cmd/golangorg/app.dev.yaml b/cmd/golangorg/app.dev.yaml
new file mode 100644
index 0000000..0f8f1cc
--- /dev/null
+++ b/cmd/golangorg/app.dev.yaml
@@ -0,0 +1,13 @@
+runtime: go
+api_version: go1
+instance_class: F4_1G
+
+handlers:
+- url: /s
+ script: _go_app
+ login: admin
+- url: /dl/init
+ script: _go_app
+ login: admin
+- url: /.*
+ script: _go_app
diff --git a/cmd/golangorg/app.prod.yaml b/cmd/golangorg/app.prod.yaml
new file mode 100644
index 0000000..1ffe73e
--- /dev/null
+++ b/cmd/golangorg/app.prod.yaml
@@ -0,0 +1,23 @@
+service: default
+runtime: custom
+env: flex
+
+env_variables:
+ GOLANGORG_CHECK_COUNTRY: true
+ GOLANGORG_REQUIRE_DL_SECRET_KEY: true
+ GOLANGORG_ENFORCE_HOSTS: true
+ GOLANGORG_REDIS_ADDR: 10.0.0.4:6379 # instance "gophercache"
+ GOLANGORG_ANALYTICS: UA-11222381-2
+ DATASTORE_PROJECT_ID: golang-org
+
+network:
+ name: golang
+
+resources:
+ cpu: 4
+ memory_gb: 7.50
+
+liveness_check:
+ path: /_ah/health
+readiness_check:
+ path: /_ah/health
diff --git a/cmd/golangorg/cloudbuild.yaml b/cmd/golangorg/cloudbuild.yaml
new file mode 100644
index 0000000..af6e8a2
--- /dev/null
+++ b/cmd/golangorg/cloudbuild.yaml
@@ -0,0 +1,25 @@
+# Copyright 2018 The Go Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+# NOTE(cbro): any changes to the docker command must also be
+# made in docker-build in the Makefile.
+#
+# Variable substitutions must have a preceding underscore. See:
+# https://cloud.google.com/cloud-build/docs/configuring-builds/substitute-variable-values#using_user-defined_substitutions
+steps:
+- name: 'gcr.io/cloud-builders/docker'
+ args: [
+ 'build',
+ '-f=cmd/golangorg/Dockerfile.prod',
+ '--build-arg=GO_REF=${_GO_REF}',
+ '--build-arg=WEBSITE_HEAD=${_WEBSITE_HEAD}',
+ '--build-arg=WEBSITE_CLEAN=${_WEBSITE_CLEAN}',
+ '--build-arg=DOCKER_TAG=${_DOCKER_TAG}',
+ '--build-arg=BUILD_ENV=cloudbuild',
+ '--tag=${_DOCKER_TAG}',
+ '.',
+ ]
+images: ['${_DOCKER_TAG}']
+options:
+ machineType: 'N1_HIGHCPU_8' # building the godoc index takes a lot of memory.
diff --git a/cmd/golangorg/codewalk.go b/cmd/golangorg/codewalk.go
new file mode 100644
index 0000000..b571343
--- /dev/null
+++ b/cmd/golangorg/codewalk.go
@@ -0,0 +1,526 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+// The /doc/codewalk/ tree is synthesized from codewalk descriptions,
+// files named _content/doc/codewalk/*.xml.
+// For an example and a description of the format, see
+// http://golang.org/doc/codewalk/codewalk or run godoc -http=:6060
+// and see http://localhost:6060/doc/codewalk/codewalk .
+// That page is itself a codewalk; the source code for it is
+// _content/doc/codewalk/codewalk.xml.
+
+package main
+
+import (
+ "bytes"
+ "encoding/xml"
+ "errors"
+ "fmt"
+ "io"
+ "io/fs"
+ "log"
+ "net/http"
+ "os"
+ pathpkg "path"
+ "regexp"
+ "sort"
+ "strconv"
+ "strings"
+ "text/template"
+ "unicode/utf8"
+
+ "golang.org/x/website/internal/godoc"
+)
+
+var codewalkHTML, codewalkdirHTML *template.Template
+
+// Handler for /doc/codewalk/ and below.
+func codewalk(w http.ResponseWriter, r *http.Request) {
+ relpath := r.URL.Path[len("/doc/codewalk/"):]
+ abspath := r.URL.Path
+
+ r.ParseForm()
+ if f := r.FormValue("fileprint"); f != "" {
+ codewalkFileprint(w, r, f)
+ return
+ }
+
+ // If directory exists, serve list of code walks.
+ dir, err := fs.Stat(fsys, toFS(abspath))
+ if err == nil && dir.IsDir() {
+ codewalkDir(w, r, relpath, abspath)
+ return
+ }
+
+ // If file exists, serve using standard file server.
+ if err == nil {
+ pres.ServeFile(w, r)
+ return
+ }
+
+ // Otherwise append .xml and hope to find
+ // a codewalk description, but before trim
+ // the trailing /.
+ abspath = strings.TrimRight(abspath, "/")
+ cw, err := loadCodewalk(abspath + ".xml")
+ if err != nil {
+ log.Print(err)
+ pres.ServeError(w, r, relpath, err)
+ return
+ }
+
+ // Canonicalize the path and redirect if changed
+ if redir(w, r) {
+ return
+ }
+
+ pres.ServePage(w, godoc.Page{
+ Title: "Codewalk: " + cw.Title,
+ Tabtitle: cw.Title,
+ Body: applyTemplate(codewalkHTML, "codewalk", cw),
+ })
+}
+
+func redir(w http.ResponseWriter, r *http.Request) (redirected bool) {
+ canonical := pathpkg.Clean(r.URL.Path)
+ if !strings.HasSuffix(canonical, "/") {
+ canonical += "/"
+ }
+ if r.URL.Path != canonical {
+ url := *r.URL
+ url.Path = canonical
+ http.Redirect(w, r, url.String(), http.StatusMovedPermanently)
+ redirected = true
+ }
+ return
+}
+
+func applyTemplate(t *template.Template, name string, data interface{}) []byte {
+ var buf bytes.Buffer
+ if err := t.Execute(&buf, data); err != nil {
+ log.Printf("%s.Execute: %s", name, err)
+ }
+ return buf.Bytes()
+}
+
+// A Codewalk represents a single codewalk read from an XML file.
+type Codewalk struct {
+ Title string `xml:"title,attr"`
+ File []string `xml:"file"`
+ Step []*Codestep `xml:"step"`
+}
+
+// A Codestep is a single step in a codewalk.
+type Codestep struct {
+ // Filled in from XML
+ Src string `xml:"src,attr"`
+ Title string `xml:"title,attr"`
+ XML string `xml:",innerxml"`
+
+ // Derived from Src; not in XML.
+ Err error
+ File string
+ Lo int
+ LoByte int
+ Hi int
+ HiByte int
+ Data []byte
+}
+
+// String method for printing in template.
+// Formats file address nicely.
+func (st *Codestep) String() string {
+ s := st.File
+ if st.Lo != 0 || st.Hi != 0 {
+ s += fmt.Sprintf(":%d", st.Lo)
+ if st.Lo != st.Hi {
+ s += fmt.Sprintf(",%d", st.Hi)
+ }
+ }
+ return s
+}
+
+// loadCodewalk reads a codewalk from the named XML file.
+func loadCodewalk(filename string) (*Codewalk, error) {
+ f, err := fsys.Open(toFS(filename))
+ if err != nil {
+ return nil, err
+ }
+ defer f.Close()
+ cw := new(Codewalk)
+ d := xml.NewDecoder(f)
+ d.Entity = xml.HTMLEntity
+ err = d.Decode(cw)
+ if err != nil {
+ return nil, &os.PathError{Op: "parsing", Path: filename, Err: err}
+ }
+
+ // Compute file list, evaluate line numbers for addresses.
+ m := make(map[string]bool)
+ for _, st := range cw.Step {
+ i := strings.Index(st.Src, ":")
+ if i < 0 {
+ i = len(st.Src)
+ }
+ filename := st.Src[0:i]
+ data, err := fs.ReadFile(fsys, toFS(filename))
+ if err != nil {
+ st.Err = err
+ continue
+ }
+ if i < len(st.Src) {
+ lo, hi, err := addrToByteRange(st.Src[i+1:], 0, data)
+ if err != nil {
+ st.Err = err
+ continue
+ }
+ // Expand match to line boundaries.
+ for lo > 0 && data[lo-1] != '\n' {
+ lo--
+ }
+ for hi < len(data) && (hi == 0 || data[hi-1] != '\n') {
+ hi++
+ }
+ st.Lo = byteToLine(data, lo)
+ st.Hi = byteToLine(data, hi-1)
+ }
+ st.Data = data
+ st.File = filename
+ m[filename] = true
+ }
+
+ // Make list of files
+ cw.File = make([]string, len(m))
+ i := 0
+ for f := range m {
+ cw.File[i] = f
+ i++
+ }
+ sort.Strings(cw.File)
+
+ return cw, nil
+}
+
+// codewalkDir serves the codewalk directory listing.
+// It scans the directory for subdirectories or files named *.xml
+// and prepares a table.
+func codewalkDir(w http.ResponseWriter, r *http.Request, relpath, abspath string) {
+ type elem struct {
+ Name string
+ Title string
+ }
+
+ dir, err := fs.ReadDir(fsys, toFS(abspath))
+ if err != nil {
+ log.Print(err)
+ pres.ServeError(w, r, relpath, err)
+ return
+ }
+ var v []interface{}
+ for _, fi := range dir {
+ name := fi.Name()
+ if fi.IsDir() {
+ v = append(v, &elem{name + "/", ""})
+ } else if strings.HasSuffix(name, ".xml") {
+ cw, err := loadCodewalk(abspath + "/" + name)
+ if err != nil {
+ continue
+ }
+ v = append(v, &elem{name[0 : len(name)-len(".xml")], cw.Title})
+ }
+ }
+
+ pres.ServePage(w, godoc.Page{
+ Title: "Codewalks",
+ Body: applyTemplate(codewalkdirHTML, "codewalkdir", v),
+ })
+}
+
+// codewalkFileprint serves requests with ?fileprint=f&lo=lo&hi=hi.
+// The filename f has already been retrieved and is passed as an argument.
+// Lo and hi are the numbers of the first and last line to highlight
+// in the response. This format is used for the middle window pane
+// of the codewalk pages. It is a separate iframe and does not get
+// the usual godoc HTML wrapper.
+func codewalkFileprint(w http.ResponseWriter, r *http.Request, f string) {
+ abspath := f
+ data, err := fs.ReadFile(fsys, toFS(abspath))
+ if err != nil {
+ log.Print(err)
+ pres.ServeError(w, r, f, err)
+ return
+ }
+ lo, _ := strconv.Atoi(r.FormValue("lo"))
+ hi, _ := strconv.Atoi(r.FormValue("hi"))
+ if hi < lo {
+ hi = lo
+ }
+ lo = lineToByte(data, lo)
+ hi = lineToByte(data, hi+1)
+
+ // Put the mark 4 lines before lo, so that the iframe
+ // shows a few lines of context before the highlighted
+ // section.
+ n := 4
+ mark := lo
+ for ; mark > 0 && n > 0; mark-- {
+ if data[mark-1] == '\n' {
+ if n--; n == 0 {
+ break
+ }
+ }
+ }
+
+ io.WriteString(w, `<style type="text/css">@import "/doc/codewalk/codewalk.css";</style><pre>`)
+ template.HTMLEscape(w, data[0:mark])
+ io.WriteString(w, "<a name='mark'></a>")
+ template.HTMLEscape(w, data[mark:lo])
+ if lo < hi {
+ io.WriteString(w, "<div class='codewalkhighlight'>")
+ template.HTMLEscape(w, data[lo:hi])
+ io.WriteString(w, "</div>")
+ }
+ template.HTMLEscape(w, data[hi:])
+ io.WriteString(w, "</pre>")
+}
+
+// addrToByte evaluates the given address starting at offset start in data.
+// It returns the lo and hi byte offset of the matched region within data.
+// See https://9p.io/sys/doc/sam/sam.html Table II
+// for details on the syntax.
+func addrToByteRange(addr string, start int, data []byte) (lo, hi int, err error) {
+ var (
+ dir byte
+ prevc byte
+ charOffset bool
+ )
+ lo = start
+ hi = start
+ for addr != "" && err == nil {
+ c := addr[0]
+ switch c {
+ default:
+ err = errors.New("invalid address syntax near " + string(c))
+ case ',':
+ if len(addr) == 1 {
+ hi = len(data)
+ } else {
+ _, hi, err = addrToByteRange(addr[1:], hi, data)
+ }
+ return
+
+ case '+', '-':
+ if prevc == '+' || prevc == '-' {
+ lo, hi, err = addrNumber(data, lo, hi, prevc, 1, charOffset)
+ }
+ dir = c
+
+ case '$':
+ lo = len(data)
+ hi = len(data)
+ if len(addr) > 1 {
+ dir = '+'
+ }
+
+ case '#':
+ charOffset = true
+
+ case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+ var i int
+ for i = 1; i < len(addr); i++ {
+ if addr[i] < '0' || addr[i] > '9' {
+ break
+ }
+ }
+ var n int
+ n, err = strconv.Atoi(addr[0:i])
+ if err != nil {
+ break
+ }
+ lo, hi, err = addrNumber(data, lo, hi, dir, n, charOffset)
+ dir = 0
+ charOffset = false
+ prevc = c
+ addr = addr[i:]
+ continue
+
+ case '/':
+ var i, j int
+ Regexp:
+ for i = 1; i < len(addr); i++ {
+ switch addr[i] {
+ case '\\':
+ i++
+ case '/':
+ j = i + 1
+ break Regexp
+ }
+ }
+ if j == 0 {
+ j = i
+ }
+ pattern := addr[1:i]
+ lo, hi, err = addrRegexp(data, lo, hi, dir, pattern)
+ prevc = c
+ addr = addr[j:]
+ continue
+ }
+ prevc = c
+ addr = addr[1:]
+ }
+
+ if err == nil && dir != 0 {
+ lo, hi, err = addrNumber(data, lo, hi, dir, 1, charOffset)
+ }
+ if err != nil {
+ return 0, 0, err
+ }
+ return lo, hi, nil
+}
+
+// addrNumber applies the given dir, n, and charOffset to the address lo, hi.
+// dir is '+' or '-', n is the count, and charOffset is true if the syntax
+// used was #n. Applying +n (or +#n) means to advance n lines
+// (or characters) after hi. Applying -n (or -#n) means to back up n lines
+// (or characters) before lo.
+// The return value is the new lo, hi.
+func addrNumber(data []byte, lo, hi int, dir byte, n int, charOffset bool) (int, int, error) {
+ switch dir {
+ case 0:
+ lo = 0
+ hi = 0
+ fallthrough
+
+ case '+':
+ if charOffset {
+ pos := hi
+ for ; n > 0 && pos < len(data); n-- {
+ _, size := utf8.DecodeRune(data[pos:])
+ pos += size
+ }
+ if n == 0 {
+ return pos, pos, nil
+ }
+ break
+ }
+ // find next beginning of line
+ if hi > 0 {
+ for hi < len(data) && data[hi-1] != '\n' {
+ hi++
+ }
+ }
+ lo = hi
+ if n == 0 {
+ return lo, hi, nil
+ }
+ for ; hi < len(data); hi++ {
+ if data[hi] != '\n' {
+ continue
+ }
+ switch n--; n {
+ case 1:
+ lo = hi + 1
+ case 0:
+ return lo, hi + 1, nil
+ }
+ }
+
+ case '-':
+ if charOffset {
+ // Scan backward for bytes that are not UTF-8 continuation bytes.
+ pos := lo
+ for ; pos > 0 && n > 0; pos-- {
+ if data[pos]&0xc0 != 0x80 {
+ n--
+ }
+ }
+ if n == 0 {
+ return pos, pos, nil
+ }
+ break
+ }
+ // find earlier beginning of line
+ for lo > 0 && data[lo-1] != '\n' {
+ lo--
+ }
+ hi = lo
+ if n == 0 {
+ return lo, hi, nil
+ }
+ for ; lo >= 0; lo-- {
+ if lo > 0 && data[lo-1] != '\n' {
+ continue
+ }
+ switch n--; n {
+ case 1:
+ hi = lo
+ case 0:
+ return lo, hi, nil
+ }
+ }
+ }
+
+ return 0, 0, errors.New("address out of range")
+}
+
+// addrRegexp searches for pattern in the given direction starting at lo, hi.
+// The direction dir is '+' (search forward from hi) or '-' (search backward from lo).
+// Backward searches are unimplemented.
+func addrRegexp(data []byte, lo, hi int, dir byte, pattern string) (int, int, error) {
+ re, err := regexp.Compile(pattern)
+ if err != nil {
+ return 0, 0, err
+ }
+ if dir == '-' {
+ // Could implement reverse search using binary search
+ // through file, but that seems like overkill.
+ return 0, 0, errors.New("reverse search not implemented")
+ }
+ m := re.FindIndex(data[hi:])
+ if len(m) > 0 {
+ m[0] += hi
+ m[1] += hi
+ } else if hi > 0 {
+ // No match. Wrap to beginning of data.
+ m = re.FindIndex(data)
+ }
+ if len(m) == 0 {
+ return 0, 0, errors.New("no match for " + pattern)
+ }
+ return m[0], m[1], nil
+}
+
+// lineToByte returns the byte index of the first byte of line n.
+// Line numbers begin at 1.
+func lineToByte(data []byte, n int) int {
+ if n <= 1 {
+ return 0
+ }
+ n--
+ for i, c := range data {
+ if c == '\n' {
+ if n--; n == 0 {
+ return i + 1
+ }
+ }
+ }
+ return len(data)
+}
+
+// byteToLine returns the number of the line containing the byte at index i.
+func byteToLine(data []byte, i int) int {
+ l := 1
+ for j, c := range data {
+ if j == i {
+ return l
+ }
+ if c == '\n' {
+ l++
+ }
+ }
+ return l
+}
diff --git a/cmd/golangorg/go115.go b/cmd/golangorg/go115.go
new file mode 100644
index 0000000..38174dc
--- /dev/null
+++ b/cmd/golangorg/go115.go
@@ -0,0 +1,14 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build !go1.16
+// +build !go1.16
+
+package main
+
+import "log"
+
+func main() {
+ log.Fatalf("golangorg requires Go 1.16 or later")
+}
diff --git a/cmd/golangorg/godoc.go b/cmd/golangorg/godoc.go
new file mode 100644
index 0000000..2cd1b2a
--- /dev/null
+++ b/cmd/golangorg/godoc.go
@@ -0,0 +1,35 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+package main
+
+import (
+ "net/http"
+ "strings"
+
+ "golang.org/x/website/internal/env"
+)
+
+// googleCN reports whether request r is considered
+// to be served from golang.google.cn.
+// TODO: This is duplicated within internal/proxy. Move to a common location.
+func googleCN(r *http.Request) bool {
+ if r.FormValue("googlecn") != "" {
+ return true
+ }
+ if strings.HasSuffix(r.Host, ".cn") {
+ return true
+ }
+ if !env.CheckCountry() {
+ return false
+ }
+ switch r.Header.Get("X-Appengine-Country") {
+ case "", "ZZ", "CN":
+ return true
+ }
+ return false
+}
diff --git a/cmd/golangorg/godoc_test.go b/cmd/golangorg/godoc_test.go
new file mode 100644
index 0000000..4e4ce88
--- /dev/null
+++ b/cmd/golangorg/godoc_test.go
@@ -0,0 +1,315 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+package main_test
+
+import (
+ "bytes"
+ "fmt"
+ "go/build"
+ "io/ioutil"
+ "net"
+ "net/http"
+ "os"
+ "os/exec"
+ "path/filepath"
+ "regexp"
+ "runtime"
+ "testing"
+ "time"
+)
+
+// buildGodoc builds the godoc executable.
+// It returns its path, and a cleanup function.
+//
+// TODO(adonovan): opt: do this at most once, and do the cleanup
+// exactly once. How though? There's no atexit.
+func buildGodoc(t *testing.T) (bin string, cleanup func()) {
+ if runtime.GOARCH == "arm" {
+ t.Skip("skipping test on arm platforms; too slow")
+ }
+ if _, err := exec.LookPath("go"); err != nil {
+ t.Skipf("skipping test because 'go' command unavailable: %v", err)
+ }
+
+ tmp, err := ioutil.TempDir("", "godoc-regtest-")
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer func() {
+ if cleanup == nil { // probably, go build failed.
+ os.RemoveAll(tmp)
+ }
+ }()
+
+ bin = filepath.Join(tmp, "godoc")
+ if runtime.GOOS == "windows" {
+ bin += ".exe"
+ }
+ cmd := exec.Command("go", "build", "-o", bin)
+ if err := cmd.Run(); err != nil {
+ t.Fatalf("Building godoc: %v", err)
+ }
+
+ return bin, func() { os.RemoveAll(tmp) }
+}
+
+func serverAddress(t *testing.T) string {
+ ln, err := net.Listen("tcp", "127.0.0.1:0")
+ if err != nil {
+ ln, err = net.Listen("tcp6", "[::1]:0")
+ }
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer ln.Close()
+ return ln.Addr().String()
+}
+
+func waitForServerReady(t *testing.T, addr string) {
+ waitForServer(t,
+ fmt.Sprintf("http://%v/", addr),
+ "The Go Programming Language",
+ 15*time.Second,
+ false)
+}
+
+func waitUntilScanComplete(t *testing.T, addr string) {
+ waitForServer(t,
+ fmt.Sprintf("http://%v/pkg", addr),
+ "Scan is not yet complete",
+ 2*time.Minute,
+ true,
+ )
+ // setting reverse as true, which means this waits
+ // until the string is not returned in the response anymore
+}
+
+const pollInterval = 200 * time.Millisecond
+
+func waitForServer(t *testing.T, url, match string, timeout time.Duration, reverse bool) {
+ // "health check" duplicated from x/tools/cmd/tipgodoc/tip.go
+ deadline := time.Now().Add(timeout)
+ for time.Now().Before(deadline) {
+ time.Sleep(pollInterval)
+ res, err := http.Get(url)
+ if err != nil {
+ continue
+ }
+ rbody, err := ioutil.ReadAll(res.Body)
+ res.Body.Close()
+ if err == nil && res.StatusCode == http.StatusOK {
+ if bytes.Contains(rbody, []byte(match)) && !reverse {
+ return
+ }
+ if !bytes.Contains(rbody, []byte(match)) && reverse {
+ return
+ }
+ }
+ }
+ t.Fatalf("Server failed to respond in %v", timeout)
+}
+
+// hasTag checks whether a given release tag is contained in the current version
+// of the go binary.
+func hasTag(t string) bool {
+ for _, v := range build.Default.ReleaseTags {
+ if t == v {
+ return true
+ }
+ }
+ return false
+}
+
+func killAndWait(cmd *exec.Cmd) {
+ cmd.Process.Kill()
+ cmd.Wait()
+}
+
+// Basic integration test for godoc HTTP interface.
+func TestWeb(t *testing.T) {
+ testWeb(t)
+}
+
+// Basic integration test for godoc HTTP interface.
+func testWeb(t *testing.T) {
+ if runtime.GOOS == "plan9" {
+ t.Skip("skipping on plan9; fails to start up quickly enough")
+ }
+ bin, cleanup := buildGodoc(t)
+ defer cleanup()
+ addr := serverAddress(t)
+ args := []string{fmt.Sprintf("-http=%s", addr)}
+ cmd := exec.Command(bin, args...)
+ cmd.Stdout = os.Stderr
+ cmd.Stderr = os.Stderr
+ cmd.Args[0] = "godoc"
+
+ // Set GOPATH variable to non-existing path
+ // and GOPROXY=off to disable module fetches.
+ // We cannot just unset GOPATH variable because godoc would default it to ~/go.
+ // (We don't want the server looking at the local workspace during tests.)
+ cmd.Env = append(os.Environ(),
+ "GOPATH=does_not_exist",
+ "GOPROXY=off",
+ "GO111MODULE=off")
+
+ if err := cmd.Start(); err != nil {
+ t.Fatalf("failed to start godoc: %s", err)
+ }
+ defer killAndWait(cmd)
+
+ waitForServerReady(t, addr)
+ waitUntilScanComplete(t, addr)
+
+ tests := []struct {
+ path string
+ contains []string // substring
+ match []string // regexp
+ notContains []string
+ releaseTag string // optional release tag that must be in go/build.ReleaseTags
+ }{
+ {
+ path: "/",
+ contains: []string{"Go is an open source programming language"},
+ },
+ {
+ path: "/pkg/fmt/",
+ contains: []string{"Package fmt implements formatted I/O"},
+ },
+ {
+ path: "/src/fmt/",
+ contains: []string{"scan_test.go"},
+ },
+ {
+ path: "/src/fmt/print.go",
+ contains: []string{"// Println formats using"},
+ },
+ {
+ path: "/pkg",
+ contains: []string{
+ "Standard library",
+ "Package fmt implements formatted I/O",
+ },
+ notContains: []string{
+ "internal/syscall",
+ "cmd/gc",
+ },
+ },
+ {
+ path: "/pkg/?m=all",
+ contains: []string{
+ "Standard library",
+ "Package fmt implements formatted I/O",
+ "internal/syscall/?m=all",
+ },
+ notContains: []string{
+ "cmd/gc",
+ },
+ },
+ {
+ path: "/pkg/strings/",
+ contains: []string{
+ `href="/src/strings/strings.go"`,
+ },
+ },
+ {
+ path: "/cmd/compile/internal/amd64/",
+ contains: []string{
+ `href="/src/cmd/compile/internal/amd64/ssa.go"`,
+ },
+ },
+ {
+ path: "/pkg/math/bits/",
+ contains: []string{
+ `Added in Go 1.9`,
+ },
+ },
+ {
+ path: "/pkg/net/",
+ contains: []string{
+ `// IPv6 scoped addressing zone; added in Go 1.1`,
+ },
+ },
+ {
+ path: "/pkg/net/http/httptrace/",
+ match: []string{
+ `Got1xxResponse.*// Go 1\.11`,
+ },
+ releaseTag: "go1.11",
+ },
+ // Verify we don't add version info to a struct field added the same time
+ // as the struct itself:
+ {
+ path: "/pkg/net/http/httptrace/",
+ match: []string{
+ `(?m)GotFirstResponseByte func\(\)\s*$`,
+ },
+ },
+ // Remove trailing periods before adding semicolons:
+ {
+ path: "/pkg/database/sql/",
+ contains: []string{
+ "The number of connections currently in use; added in Go 1.11",
+ "The number of idle connections; added in Go 1.11",
+ },
+ releaseTag: "go1.11",
+ },
+ {
+ path: "/project/",
+ contains: []string{
+ `<li><a href="/doc/go1.14">Go 1.14</a> <small>(February 2020)</small></li>`,
+ `<li><a href="/doc/go1.1">Go 1.1</a> <small>(May 2013)</small></li>`,
+ },
+ },
+ }
+ for _, test := range tests {
+ url := fmt.Sprintf("http://%s%s", addr, test.path)
+ resp, err := http.Get(url)
+ if err != nil {
+ t.Errorf("GET %s failed: %s", url, err)
+ continue
+ }
+ body, err := ioutil.ReadAll(resp.Body)
+ strBody := string(body)
+ resp.Body.Close()
+ if err != nil {
+ t.Errorf("GET %s: failed to read body: %s (response: %v)", url, err, resp)
+ }
+ isErr := false
+ for _, substr := range test.contains {
+ if test.releaseTag != "" && !hasTag(test.releaseTag) {
+ continue
+ }
+ if !bytes.Contains(body, []byte(substr)) {
+ t.Errorf("GET %s: wanted substring %q in body", url, substr)
+ isErr = true
+ }
+ }
+ for _, re := range test.match {
+ if test.releaseTag != "" && !hasTag(test.releaseTag) {
+ continue
+ }
+ if ok, err := regexp.MatchString(re, strBody); !ok || err != nil {
+ if err != nil {
+ t.Fatalf("Bad regexp %q: %v", re, err)
+ }
+ t.Errorf("GET %s: wanted to match %s in body", url, re)
+ isErr = true
+ }
+ }
+ for _, substr := range test.notContains {
+ if bytes.Contains(body, []byte(substr)) {
+ t.Errorf("GET %s: didn't want substring %q in body", url, substr)
+ isErr = true
+ }
+ }
+ if isErr {
+ t.Errorf("GET %s: got:\n%s", url, body)
+ }
+ }
+}
diff --git a/cmd/golangorg/handlers.go b/cmd/golangorg/handlers.go
new file mode 100644
index 0000000..c000a97
--- /dev/null
+++ b/cmd/golangorg/handlers.go
@@ -0,0 +1,153 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+package main
+
+import (
+ "encoding/json"
+ "go/format"
+ "io/fs"
+ "log"
+ "net/http"
+ pathpkg "path"
+ "strings"
+ "text/template"
+
+ "golang.org/x/website/internal/env"
+ "golang.org/x/website/internal/godoc"
+ "golang.org/x/website/internal/redirect"
+)
+
+var (
+ pres *godoc.Presentation
+ fsys fs.FS
+)
+
+// toFS returns the io/fs name for path (no leading slash).
+func toFS(path string) string {
+ if path == "/" {
+ return "."
+ }
+ return pathpkg.Clean(strings.TrimPrefix(path, "/"))
+}
+
+// hostEnforcerHandler redirects requests to "http://foo.golang.org/bar"
+// to "https://golang.org/bar".
+// It permits requests to the host "godoc-test.golang.org" for testing and
+// golang.google.cn for Chinese users.
+type hostEnforcerHandler struct {
+ h http.Handler
+}
+
+func (h hostEnforcerHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+ if !env.EnforceHosts() {
+ h.h.ServeHTTP(w, r)
+ return
+ }
+ if !h.isHTTPS(r) || !h.validHost(r.Host) {
+ r.URL.Scheme = "https"
+ if h.validHost(r.Host) {
+ r.URL.Host = r.Host
+ } else {
+ r.URL.Host = "golang.org"
+ }
+ http.Redirect(w, r, r.URL.String(), http.StatusFound)
+ return
+ }
+ w.Header().Set("Strict-Transport-Security", "max-age=31536000; includeSubDomains; preload")
+ h.h.ServeHTTP(w, r)
+}
+
+func (h hostEnforcerHandler) isHTTPS(r *http.Request) bool {
+ return r.TLS != nil || r.Header.Get("X-Forwarded-Proto") == "https"
+}
+
+func (h hostEnforcerHandler) validHost(host string) bool {
+ switch strings.ToLower(host) {
+ case "golang.org", "golang.google.cn":
+ return true
+ }
+ if strings.HasSuffix(host, "-dot-golang-org.appspot.com") {
+ // staging/test
+ return true
+ }
+ return false
+}
+
+func registerHandlers(pres *godoc.Presentation) *http.ServeMux {
+ if pres == nil {
+ panic("nil Presentation")
+ }
+ mux := http.NewServeMux()
+ mux.Handle("/", pres)
+ mux.Handle("/blog/", http.HandlerFunc(blogHandler))
+ mux.Handle("/doc/codewalk/", http.HandlerFunc(codewalk))
+ mux.Handle("/doc/play/", pres.FileServer())
+ mux.Handle("/fmt", http.HandlerFunc(fmtHandler))
+ mux.Handle("/pkg/C/", redirect.Handler("/cmd/cgo/"))
+ mux.Handle("/robots.txt", pres.FileServer())
+ mux.Handle("/x/", http.HandlerFunc(xHandler))
+ redirect.Register(mux)
+
+ http.Handle("/", hostEnforcerHandler{mux})
+
+ return mux
+}
+
+func readTemplate(name string) *template.Template {
+ if pres == nil {
+ panic("no global Presentation set yet")
+ }
+ path := "lib/godoc/" + name
+
+ // use underlying file system fs to read the template file
+ // (cannot use template ParseFile functions directly)
+ data, err := fs.ReadFile(fsys, toFS(path))
+ if err != nil {
+ log.Fatal("readTemplate: ", err)
+ }
+ // be explicit with errors (for app engine use)
+ t, err := template.New(name).Funcs(pres.FuncMap()).Parse(string(data))
+ if err != nil {
+ log.Fatal("readTemplate: ", err)
+ }
+ return t
+}
+
+func readTemplates(p *godoc.Presentation) {
+ codewalkHTML = readTemplate("codewalk.html")
+ codewalkdirHTML = readTemplate("codewalkdir.html")
+ p.DirlistHTML = readTemplate("dirlist.html")
+ p.ErrorHTML = readTemplate("error.html")
+ p.ExampleHTML = readTemplate("example.html")
+ p.GodocHTML = readTemplate("godoc.html")
+ p.PackageHTML = readTemplate("package.html")
+ p.PackageRootHTML = readTemplate("packageroot.html")
+}
+
+type fmtResponse struct {
+ Body string
+ Error string
+}
+
+// fmtHandler takes a Go program in its "body" form value, formats it with
+// standard gofmt formatting, and writes a fmtResponse as a JSON object.
+func fmtHandler(w http.ResponseWriter, r *http.Request) {
+ resp := new(fmtResponse)
+ body, err := format.Source([]byte(r.FormValue("body")))
+ if err != nil {
+ resp.Error = err.Error()
+ } else {
+ resp.Body = string(body)
+ }
+ w.Header().Set("Content-type", "application/json; charset=utf-8")
+ json.NewEncoder(w).Encode(resp)
+}
+
+func blogHandler(w http.ResponseWriter, r *http.Request) {
+ http.Redirect(w, r, "https://blog.golang.org"+strings.TrimPrefix(r.URL.Path, "/blog"), http.StatusFound)
+}
diff --git a/cmd/golangorg/hg-git-mapping.bin b/cmd/golangorg/hg-git-mapping.bin
new file mode 100644
index 0000000..3f6ca77
--- /dev/null
+++ b/cmd/golangorg/hg-git-mapping.bin
Binary files differ
diff --git a/cmd/golangorg/local.go b/cmd/golangorg/local.go
new file mode 100644
index 0000000..37353b3
--- /dev/null
+++ b/cmd/golangorg/local.go
@@ -0,0 +1,40 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16 && !prod
+// +build go1.16,!prod
+
+package main
+
+import (
+ "fmt"
+ "log"
+ "net/http"
+ "os"
+ "path/filepath"
+ "runtime"
+
+ // This package registers "/compile" and "/share" handlers
+ // that redirect to the golang.org playground.
+ _ "golang.org/x/tools/playground"
+)
+
+func earlySetup() {
+ _, file, _, ok := runtime.Caller(0)
+ if !ok {
+ fmt.Fprintln(os.Stderr, "runtime.Caller failed: cannot find templates for -a mode.")
+ os.Exit(2)
+ }
+ dir := filepath.Join(file, "../../../_content")
+ if _, err := os.Stat(filepath.Join(dir, "lib/godoc/godoc.html")); err != nil {
+ log.Printf("warning: cannot find template dir; using embedded copy")
+ return
+ }
+ *templateDir = dir
+}
+
+func lateSetup(mux *http.ServeMux) {
+ // Register a redirect handler for /dl/ to the golang.org download page.
+ mux.Handle("/dl/", http.RedirectHandler("https://golang.org/dl/", http.StatusFound))
+}
diff --git a/cmd/golangorg/main.go b/cmd/golangorg/main.go
new file mode 100644
index 0000000..03f42a2
--- /dev/null
+++ b/cmd/golangorg/main.go
@@ -0,0 +1,173 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// golangorg: The Go Website (golang.org)
+
+// Web server tree:
+//
+// https://golang.org/ main landing page
+// https://golang.org/doc/ serve from content/doc, then $GOROOT/doc. spec, mem, etc.
+// https://golang.org/src/ serve files from $GOROOT/src; .go gets pretty-printed
+// https://golang.org/cmd/ serve documentation about commands
+// https://golang.org/pkg/ serve documentation about packages
+// (idea is if you say import "compress/zlib", you go to
+// https://golang.org/pkg/compress/zlib)
+//
+
+//go:build go1.16
+// +build go1.16
+
+package main
+
+import (
+ "flag"
+ "fmt"
+ "io/fs"
+ "log"
+ "net/http"
+ "os"
+ "runtime"
+
+ "golang.org/x/website"
+ "golang.org/x/website/internal/godoc"
+)
+
+var (
+ httpAddr = flag.String("http", "localhost:6060", "HTTP service address")
+ verbose = flag.Bool("v", false, "verbose mode")
+ goroot = flag.String("goroot", runtime.GOROOT(), "Go root directory")
+ templateDir = flag.String("templates", "", "load templates/JS/CSS from disk in this directory (usually /path-to-website/content)")
+)
+
+func usage() {
+ fmt.Fprintf(os.Stderr, "usage: golangorg\n")
+ flag.PrintDefaults()
+ os.Exit(2)
+}
+
+func loggingHandler(h http.Handler) http.Handler {
+ return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+ log.Printf("%s\t%s", req.RemoteAddr, req.URL)
+ h.ServeHTTP(w, req)
+ })
+}
+
+func main() {
+ earlySetup()
+
+ flag.Usage = usage
+ flag.Parse()
+
+ // Check usage.
+ if flag.NArg() > 0 {
+ fmt.Fprintln(os.Stderr, "Unexpected arguments.")
+ usage()
+ }
+ if *httpAddr == "" {
+ fmt.Fprintln(os.Stderr, "-http must be set")
+ usage()
+ }
+
+ // Serve files from _content, falling back to GOROOT.
+ var content fs.FS
+ if *templateDir != "" {
+ content = os.DirFS(*templateDir)
+ } else {
+ content = website.Content
+ }
+ fsys = unionFS{content, os.DirFS(*goroot)}
+
+ corpus := godoc.NewCorpus(fsys)
+ corpus.Verbose = *verbose
+ if err := corpus.Init(); err != nil {
+ log.Fatal(err)
+ }
+ // Initialize the version info before readTemplates, which saves
+ // the map value in a method value.
+ corpus.InitVersionInfo()
+
+ pres = godoc.NewPresentation(corpus)
+ pres.GoogleCN = googleCN
+
+ readTemplates(pres)
+ mux := registerHandlers(pres)
+ lateSetup(mux)
+
+ var handler http.Handler = http.DefaultServeMux
+ if *verbose {
+ log.Printf("golang.org server:")
+ log.Printf("\tversion = %s", runtime.Version())
+ log.Printf("\taddress = %s", *httpAddr)
+ log.Printf("\tgoroot = %s", *goroot)
+ handler = loggingHandler(handler)
+ }
+
+ // Start http server.
+ fmt.Fprintf(os.Stderr, "serving http://%s\n", *httpAddr)
+ if err := http.ListenAndServe(*httpAddr, handler); err != nil {
+ log.Fatalf("ListenAndServe %s: %v", *httpAddr, err)
+ }
+}
+
+var _ fs.ReadDirFS = unionFS{}
+
+// A unionFS is an FS presenting the union of the file systems in the slice.
+// If multiple file systems provide a particular file, Open uses the FS listed earlier in the slice.
+// If multiple file systems provide a particular directory, ReadDir presents the
+// concatenation of all the directories listed in the slice (with duplicates removed).
+type unionFS []fs.FS
+
+func (fsys unionFS) Open(name string) (fs.File, error) {
+ var errOut error
+ for _, sub := range fsys {
+ f, err := sub.Open(name)
+ if err == nil {
+ // Note: Should technically check for directory
+ // and return a synthetic directory that merges
+ // reads from all the matching directories,
+ // but all the directory reads in internal/godoc
+ // come from fsys.ReadDir, which does that for us.
+ // So we can ignore direct f.ReadDir calls.
+ return f, nil
+ }
+ if errOut == nil {
+ errOut = err
+ }
+ }
+ return nil, errOut
+}
+
+func (fsys unionFS) ReadDir(name string) ([]fs.DirEntry, error) {
+ var all []fs.DirEntry
+ var seen map[string]bool // seen[name] is true if name is listed in all; lazily initialized
+ var errOut error
+ for _, sub := range fsys {
+ list, err := fs.ReadDir(sub, toFS(name))
+ if err != nil {
+ errOut = err
+ }
+ if len(all) == 0 {
+ all = append(all, list...)
+ } else {
+ if seen == nil {
+ // Initialize seen only after we get two different directory listings.
+ seen = make(map[string]bool)
+ for _, d := range all {
+ seen[d.Name()] = true
+ }
+ }
+ for _, d := range list {
+ name := d.Name()
+ if !seen[name] {
+ seen[name] = true
+ all = append(all, d)
+ }
+ }
+ }
+ }
+ if len(all) > 0 {
+ return all, nil
+ }
+ return nil, errOut
+}
diff --git a/cmd/golangorg/prod.go b/cmd/golangorg/prod.go
new file mode 100644
index 0000000..e2b8328
--- /dev/null
+++ b/cmd/golangorg/prod.go
@@ -0,0 +1,83 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16 && prod
+// +build go1.16,prod
+
+package main
+
+import (
+ "context"
+ "io"
+ "log"
+ "net/http"
+ "os"
+ "strings"
+
+ "golang.org/x/website/internal/dl"
+ "golang.org/x/website/internal/proxy"
+ "golang.org/x/website/internal/redirect"
+ "golang.org/x/website/internal/short"
+
+ "cloud.google.com/go/datastore"
+ "golang.org/x/website/internal/memcache"
+)
+
+func earlySetup() {
+ log.SetFlags(log.Lshortfile | log.LstdFlags)
+ log.Println("initializing golang.org server ...")
+
+ port := "8080"
+ if p := os.Getenv("PORT"); p != "" {
+ port = p
+ }
+ *httpAddr = ":" + port
+}
+
+func lateSetup(mux *http.ServeMux) {
+ pres.GoogleAnalytics = os.Getenv("GOLANGORG_ANALYTICS")
+
+ datastoreClient, memcacheClient := getClients()
+
+ dl.RegisterHandlers(mux, datastoreClient, memcacheClient)
+ short.RegisterHandlers(mux, datastoreClient, memcacheClient)
+
+ // Register /compile and /share handlers against the default serve mux
+ // so that other app modules can make plain HTTP requests to those
+ // hosts. (For reasons, HTTPS communication between modules is broken.)
+ proxy.RegisterHandlers(http.DefaultServeMux)
+
+ http.HandleFunc("/_ah/health", func(w http.ResponseWriter, r *http.Request) {
+ io.WriteString(w, "ok")
+ })
+
+ http.HandleFunc("/robots.txt", func(w http.ResponseWriter, r *http.Request) {
+ io.WriteString(w, "User-agent: *\nDisallow: /search\n")
+ })
+
+ if err := redirect.LoadChangeMap("hg-git-mapping.bin"); err != nil {
+ log.Fatalf("LoadChangeMap: %v", err)
+ }
+
+ log.Println("godoc initialization complete")
+}
+
+func getClients() (*datastore.Client, *memcache.Client) {
+ ctx := context.Background()
+
+ datastoreClient, err := datastore.NewClient(ctx, "")
+ if err != nil {
+ if strings.Contains(err.Error(), "missing project") {
+ log.Fatalf("Missing datastore project. Set the DATASTORE_PROJECT_ID env variable. Use `gcloud beta emulators datastore` to start a local datastore.")
+ }
+ log.Fatalf("datastore.NewClient: %v.", err)
+ }
+
+ redisAddr := os.Getenv("GOLANGORG_REDIS_ADDR")
+ if redisAddr == "" {
+ log.Fatalf("Missing redis server for golangorg in production mode. set GOLANGORG_REDIS_ADDR environment variable.")
+ }
+ memcacheClient := memcache.New(redisAddr)
+ return datastoreClient, memcacheClient
+}
diff --git a/cmd/golangorg/regtest_test.go b/cmd/golangorg/regtest_test.go
new file mode 100644
index 0000000..9b7b48d
--- /dev/null
+++ b/cmd/golangorg/regtest_test.go
@@ -0,0 +1,193 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+// Regression tests to run against a production instance of godoc.
+
+package main_test
+
+import (
+ "bytes"
+ "flag"
+ "io"
+ "io/ioutil"
+ "net/http"
+ "net/url"
+ "regexp"
+ "strings"
+ "testing"
+)
+
+var host = flag.String("regtest.host", "", "host to run regression test against")
+
+func TestLiveServer(t *testing.T) {
+ *host = strings.TrimSuffix(*host, "/")
+ if *host == "" {
+ t.Skip("regtest.host flag missing.")
+ }
+ substringTests := []struct {
+ Message string
+ Path string
+ Substring string
+ Regexp string
+ NoAnalytics bool // expect the response to not contain GA.
+ PostBody string
+ StatusCode int // if 0, expect 2xx status code.
+ }{
+ {
+ Path: "/doc/",
+ Substring: "an introduction to using modules in a simple project",
+ },
+ {
+ Path: "/conduct",
+ Substring: "Project Stewards",
+ },
+ {
+ Path: "/doc/faq",
+ Substring: "What is the purpose of the project",
+ },
+ {
+ Path: "/pkg/",
+ Substring: "Package tar",
+ },
+ {
+ Path: "/pkg/os/",
+ Substring: "func Open",
+ },
+ {
+ Path: "/pkg/net/http/",
+ Substring: `title="Added in Go 1.11"`,
+ Message: "version information not present - failed InitVersionInfo?",
+ },
+ {
+ Path: "/robots.txt",
+ Substring: "Disallow: /search",
+ Message: "robots not present - not deployed from Dockerfile?",
+ NoAnalytics: true,
+ },
+ {
+ Path: "/change/75944e2e3a63",
+ Substring: "bdb10cf",
+ Message: "no change redirect - hg to git mapping not registered?",
+ NoAnalytics: true,
+ StatusCode: 302,
+ },
+ {
+ Path: "/dl/",
+ Substring: `href="/dl/go1.11.windows-amd64.msi"`,
+ Message: "missing data on dl page - misconfiguration of datastore?",
+ },
+ {
+ Path: "/dl/?mode=json",
+ Substring: ".windows-amd64.msi",
+ NoAnalytics: true,
+ },
+ {
+ Message: "broken shortlinks - misconfiguration of datastore or memcache?",
+ Path: "/s/go2design",
+ Regexp: "proposal.*Found",
+ NoAnalytics: true,
+ StatusCode: 302,
+ },
+ {
+ Path: "/compile",
+ PostBody: "body=" + url.QueryEscape("package main; func main() { print(6*7); }"),
+ Regexp: `^{"compile_errors":"","output":"42"}$`,
+ NoAnalytics: true,
+ },
+ {
+ Path: "/compile",
+ PostBody: "body=" + url.QueryEscape("//empty"),
+ Substring: "expected 'package', found 'EOF'",
+ NoAnalytics: true,
+ },
+ {
+ Path: "/compile",
+ PostBody: "version=2&body=package+main%3Bimport+(%22fmt%22%3B%22time%22)%3Bfunc+main()%7Bfmt.Print(%22A%22)%3Btime.Sleep(time.Second)%3Bfmt.Print(%22B%22)%7D",
+ Regexp: `^{"Errors":"","Events":\[{"Message":"A","Kind":"stdout","Delay":0},{"Message":"B","Kind":"stdout","Delay":1000000000}\]}$`,
+ NoAnalytics: true,
+ },
+ {
+ Path: "/share",
+ PostBody: "package main",
+ Substring: "", // just check it is a 2xx.
+ NoAnalytics: true,
+ },
+ {
+ Path: "/x/net",
+ Substring: `<meta name="go-import" content="golang.org/x/net git https://go.googlesource.com/net">`,
+ NoAnalytics: true,
+ },
+ {
+ Message: "release history page has an entry for Go 1.14.2",
+ Path: "/doc/devel/release.html",
+ Regexp: `go1\.14\.2\s+\(released 2020/04/08\)\s+includes\s+fixes to cgo, the go command, the runtime,`,
+ },
+ {
+ Message: "Go project page has an entry for Go 1.14",
+ Path: "/project/",
+ Substring: `<li><a href="/doc/go1.14">Go 1.14</a> <small>(February 2020)</small></li>`,
+ },
+ {
+ Message: "Go project subpath does not exist",
+ Path: "/project/notexist",
+ StatusCode: http.StatusNotFound,
+ },
+ }
+
+ for _, tc := range substringTests {
+ t.Run(tc.Path, func(t *testing.T) {
+ method := "GET"
+ var reqBody io.Reader
+ if tc.PostBody != "" {
+ method = "POST"
+ reqBody = strings.NewReader(tc.PostBody)
+ }
+ req, err := http.NewRequest(method, *host+tc.Path, reqBody)
+ if err != nil {
+ t.Fatalf("NewRequest: %v", err)
+ }
+ if reqBody != nil {
+ req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+ }
+ resp, err := http.DefaultTransport.RoundTrip(req)
+ if err != nil {
+ t.Fatalf("RoundTrip: %v", err)
+ }
+ if tc.StatusCode == 0 {
+ if resp.StatusCode > 299 {
+ t.Errorf("Non-OK status code: %v", resp.StatusCode)
+ }
+ } else if tc.StatusCode != resp.StatusCode {
+ t.Errorf("StatusCode; got %v, want %v", resp.StatusCode, tc.StatusCode)
+ }
+ body, err := ioutil.ReadAll(resp.Body)
+ if err != nil {
+ t.Fatalf("ReadAll: %v", err)
+ }
+
+ const googleAnalyticsID = "UA-11222381-2" // golang.org analytics ID
+ if !tc.NoAnalytics && !bytes.Contains(body, []byte(googleAnalyticsID)) {
+ t.Errorf("want response to contain analytics tracking ID")
+ }
+
+ if tc.Substring != "" {
+ tc.Regexp = regexp.QuoteMeta(tc.Substring)
+ }
+ re := regexp.MustCompile(tc.Regexp)
+
+ if !re.Match(body) {
+ t.Log("------ actual output -------")
+ t.Log(string(body))
+ t.Log("----------------------------")
+ if tc.Message != "" {
+ t.Log(tc.Message)
+ }
+ t.Fatalf("wanted response to match %s", tc.Regexp)
+ }
+ })
+ }
+}
diff --git a/cmd/golangorg/release_test.go b/cmd/golangorg/release_test.go
new file mode 100644
index 0000000..499eef4
--- /dev/null
+++ b/cmd/golangorg/release_test.go
@@ -0,0 +1,873 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+package main
+
+import (
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "testing"
+
+ "golang.org/x/website"
+ "golang.org/x/website/internal/godoc"
+)
+
+// Test that the release history page includes expected entries.
+//
+// At this time, the test is very strict and checks that all releases
+// from Go 1 to Go 1.14.2 are included with exact HTML content.
+// It can be relaxed whenever the presentation of the release history
+// page needs to be changed.
+func TestReleaseHistory(t *testing.T) {
+ origFS, origPres := fsys, pres
+ defer func() { fsys, pres = origFS, origPres }()
+ fsys = website.Content
+ pres = godoc.NewPresentation(godoc.NewCorpus(fsys))
+ readTemplates(pres)
+ mux := registerHandlers(pres)
+
+ req := httptest.NewRequest(http.MethodGet, "/doc/devel/release.html", nil)
+ rr := httptest.NewRecorder()
+ mux.ServeHTTP(rr, req)
+ resp := rr.Result()
+ if got, want := resp.StatusCode, http.StatusOK; got != want {
+ t.Errorf("got status code %d %s, want %d %s", got, http.StatusText(got), want, http.StatusText(want))
+ }
+ if got, want := resp.Header.Get("Content-Type"), "text/html; charset=utf-8"; got != want {
+ t.Errorf("got Content-Type header %q, want %q", got, want)
+ }
+ if !strings.Contains(foldSpace(rr.Body.String()), foldSpace(wantGo114HTML)) {
+ t.Errorf("got body that doesn't contain expected Go 1.14 release history entries")
+ println("HAVE")
+ println(rr.Body.String())
+ println("WANT")
+ println(wantGo114HTML)
+ }
+ if !strings.Contains(foldSpace(rr.Body.String()), foldSpace(wantGo113HTML)) {
+ t.Errorf("got body that doesn't contain expected Go 1.13 release history entries")
+ }
+ if !strings.Contains(foldSpace(rr.Body.String()), foldSpace(wantOldReleaseHTML)) {
+ t.Errorf("got body that doesn't contain expected Go 1.12 and older release history entries")
+ }
+}
+
+// foldSpace returns s with each instance of one or more consecutive
+// white space characters, as defined by unicode.IsSpace, replaced
+// by a single space ('\x20') character, with leading and trailing
+// white space removed.
+func foldSpace(s string) string {
+ return strings.Join(strings.Fields(s), " ")
+}
+
+const wantGo114HTML = `
+<h2 id="go1.14">go1.14 (released 2020-02-25)</h2>
+
+<p>
+Go 1.14 is a major release of Go.
+Read the <a href="/doc/go1.14">Go 1.14 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.14.minor">Minor revisions</h3>
+
+<p>
+go1.14.1 (released 2020-03-19) includes fixes to the go command, tools, and the runtime. See the
+<a href="https://github.com/golang/go/issues?q=milestone%3AGo1.14.1+label%3ACherryPickApproved">Go
+1.14.1 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.14.2 (released 2020-04-08) includes fixes to cgo, the go command, the runtime,
+and the <code>os/exec</code> and <code>testing</code> packages. See the
+<a href="https://github.com/golang/go/issues?q=milestone%3AGo1.14.2+label%3ACherryPickApproved">Go
+1.14.2 milestone</a> on our issue tracker for details.
+</p>
+`
+
+const wantGo113HTML = `
+<h2 id="go1.13">go1.13 (released 2019-09-03)</h2>
+
+<p>
+Go 1.13 is a major release of Go.
+Read the <a href="/doc/go1.13">Go 1.13 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.13.minor">Minor revisions</h3>
+
+<p>
+go1.13.1 (released 2019-09-25) includes security fixes to the
+<code>net/http</code> and <code>net/textproto</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.13.1+label%3ACherryPickApproved">Go
+1.13.1 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.13.2 (released 2019-10-17) includes security fixes to the
+compiler and the <code>crypto/dsa</code> package.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.13.2+label%3ACherryPickApproved">Go
+1.13.2 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.13.3 (released 2019-10-17) includes fixes to the go command,
+the toolchain, the runtime, and the <code>syscall</code>, <code>net</code>,
+<code>net/http</code>, and <code>crypto/ecdsa</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.13.3+label%3ACherryPickApproved">Go
+1.13.3 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.13.4 (released 2019-10-31) includes fixes to the <code>net/http</code> and
+<code>syscall</code> packages. It also fixes an issue on macOS 10.15 Catalina
+where the non-notarized installer and binaries were being
+<a href="https://golang.org/issue/34986">rejected by Gatekeeper</a>.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.13.4+label%3ACherryPickApproved">Go
+1.13.4 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.13.5 (released 2019-12-04) includes fixes to the go command, the runtime,
+the linker, and the <code>net/http</code> package. See the
+<a href="https://github.com/golang/go/issues?q=milestone%3AGo1.13.5+label%3ACherryPickApproved">Go
+1.13.5 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.13.6 (released 2020-01-09) includes fixes to the runtime and
+the <code>net/http</code> package. See
+the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.13.6+label%3ACherryPickApproved">Go
+1.13.6 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.13.7 (released 2020-01-28) includes two security fixes to
+the <code>crypto/x509</code> package. See the
+<a href="https://github.com/golang/go/issues?q=milestone%3AGo1.13.7+label%3ACherryPickApproved">Go
+1.13.7 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.13.8 (released 2020-02-12) includes fixes to the runtime, and the
+<code>crypto/x509</code> and <code>net/http</code> packages. See the
+<a href="https://github.com/golang/go/issues?q=milestone%3AGo1.13.8+label%3ACherryPickApproved">Go
+1.13.8 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.13.9 (released 2020-03-19) includes fixes to the go command, tools, the runtime, the
+toolchain, and the <code>crypto/cypher</code> package. See the
+<a href="https://github.com/golang/go/issues?q=milestone%3AGo1.13.9+label%3ACherryPickApproved">Go
+1.13.9 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.13.10 (released 2020-04-08) includes fixes to the go command, the runtime,
+and the <code>os/exec</code> and <code>time</code> packages. See the
+<a href="https://github.com/golang/go/issues?q=milestone%3AGo1.13.10+label%3ACherryPickApproved">Go
+1.13.10 milestone</a> on our issue tracker for details.
+</p>
+`
+
+const wantOldReleaseHTML = `
+<h2 id="go1.12">go1.12 (released 2019-02-25)</h2>
+
+<p>
+Go 1.12 is a major release of Go.
+Read the <a href="/doc/go1.12">Go 1.12 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.12.minor">Minor revisions</h3>
+
+<p>
+go1.12.1 (released 2019-03-14) includes fixes to cgo, the compiler, the go
+command, and the <code>fmt</code>, <code>net/smtp</code>, <code>os</code>,
+<code>path/filepath</code>, <code>sync</code>, and <code>text/template</code>
+packages. See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.12.1+label%3ACherryPickApproved">Go
+1.12.1 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.12.2 (released 2019-04-05) includes fixes to the compiler, the go
+command, the runtime, and the <code>doc</code>, <code>net</code>,
+<code>net/http/httputil</code>, and <code>os</code> packages. See the
+<a href="https://github.com/golang/go/issues?q=milestone%3AGo1.12.2+label%3ACherryPickApproved">Go
+1.12.2 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.12.3 (released 2019-04-08) was accidentally released without its
+intended fix. It is identical to go1.12.2, except for its version
+number. The intended fix is in go1.12.4.
+</p>
+
+<p>
+go1.12.4 (released 2019-04-11) fixes an issue where using the prebuilt binary
+releases on older versions of GNU/Linux
+<a href="https://golang.org/issues/31293">led to failures</a>
+when linking programs that used cgo.
+Only Linux users who hit this issue need to update.
+</p>
+
+<p>
+go1.12.5 (released 2019-05-06) includes fixes to the compiler, the linker,
+the go command, the runtime, and the <code>os</code> package. See the
+<a href="https://github.com/golang/go/issues?q=milestone%3AGo1.12.5+label%3ACherryPickApproved">Go
+1.12.5 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.12.6 (released 2019-06-11) includes fixes to the compiler, the linker,
+the go command, and the <code>crypto/x509</code>, <code>net/http</code>, and
+<code>os</code> packages. See the
+<a href="https://github.com/golang/go/issues?q=milestone%3AGo1.12.6+label%3ACherryPickApproved">Go
+1.12.6 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.12.7 (released 2019-07-08) includes fixes to cgo, the compiler,
+and the linker.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.12.7+label%3ACherryPickApproved">Go
+1.12.7 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.12.8 (released 2019-08-13) includes security fixes to the
+<code>net/http</code> and <code>net/url</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.12.8+label%3ACherryPickApproved">Go
+1.12.8 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.12.9 (released 2019-08-15) includes fixes to the linker,
+and the <code>os</code> and <code>math/big</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.12.9+label%3ACherryPickApproved">Go
+1.12.9 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.12.10 (released 2019-09-25) includes security fixes to the
+<code>net/http</code> and <code>net/textproto</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.12.10+label%3ACherryPickApproved">Go
+1.12.10 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.12.11 (released 2019-10-17) includes security fixes to the
+<code>crypto/dsa</code> package.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.12.11+label%3ACherryPickApproved">Go
+1.12.11 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.12.12 (released 2019-10-17) includes fixes to the go command,
+runtime, and the <code>syscall</code> and <code>net</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.12.12+label%3ACherryPickApproved">Go
+1.12.12 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.12.13 (released 2019-10-31) fixes an issue on macOS 10.15 Catalina
+where the non-notarized installer and binaries were being
+<a href="https://golang.org/issue/34986">rejected by Gatekeeper</a>.
+Only macOS users who hit this issue need to update.
+</p>
+
+<p>
+go1.12.14 (released 2019-12-04) includes a fix to the runtime. See
+the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.12.14+label%3ACherryPickApproved">Go
+1.12.14 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.12.15 (released 2020-01-09) includes fixes to the runtime and
+the <code>net/http</code> package. See
+the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.12.15+label%3ACherryPickApproved">Go
+1.12.15 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.12.16 (released 2020-01-28) includes two security fixes to
+the <code>crypto/x509</code> package. See the
+<a href="https://github.com/golang/go/issues?q=milestone%3AGo1.12.16+label%3ACherryPickApproved">Go
+1.12.16 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.12.17 (released 2020-02-12) includes a fix to the runtime. See
+the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.12.17+label%3ACherryPickApproved">Go
+1.12.17 milestone</a> on our issue tracker for details.
+</p>
+
+<h2 id="go1.11">go1.11 (released 2018-08-24)</h2>
+
+<p>
+Go 1.11 is a major release of Go.
+Read the <a href="/doc/go1.11">Go 1.11 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.11.minor">Minor revisions</h3>
+
+<p>
+go1.11.1 (released 2018-10-01) includes fixes to the compiler, documentation, go
+command, runtime, and the <code>crypto/x509</code>, <code>encoding/json</code>,
+<code>go/types</code>, <code>net</code>, <code>net/http</code>, and
+<code>reflect</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.11.1+label%3ACherryPickApproved">Go
+1.11.1 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.11.2 (released 2018-11-02) includes fixes to the compiler, linker,
+documentation, go command, and the <code>database/sql</code> and
+<code>go/types</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.11.2+label%3ACherryPickApproved">Go
+1.11.2 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.11.3 (released 2018-12-12) includes three security fixes to "go get" and
+the <code>crypto/x509</code> package.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.11.3+label%3ACherryPickApproved">Go
+1.11.3 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.11.4 (released 2018-12-14) includes fixes to cgo, the compiler, linker,
+runtime, documentation, go command, and the <code>net/http</code> and
+<code>go/types</code> packages.
+It includes a fix to a bug introduced in Go 1.11.3 that broke <code>go</code>
+<code>get</code> for import path patterns containing "<code>...</code>".
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.11.4+label%3ACherryPickApproved">Go
+1.11.4 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.11.5 (released 2019-01-23) includes a security fix to the
+<code>crypto/elliptic</code> package. See
+the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.11.5+label%3ACherryPickApproved">Go
+1.11.5 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.11.6 (released 2019-03-14) includes fixes to cgo, the compiler, linker,
+runtime, go command, and the <code>crypto/x509</code>, <code>encoding/json</code>,
+<code>net</code>, and <code>net/url</code> packages. See the
+<a href="https://github.com/golang/go/issues?q=milestone%3AGo1.11.6+label%3ACherryPickApproved">Go
+1.11.6 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.11.7 (released 2019-04-05) includes fixes to the runtime and the
+<code>net</code> package. See the
+<a href="https://github.com/golang/go/issues?q=milestone%3AGo1.11.7+label%3ACherryPickApproved">Go
+1.11.7 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.11.8 (released 2019-04-08) was accidentally released without its
+intended fix. It is identical to go1.11.7, except for its version
+number. The intended fix is in go1.11.9.
+</p>
+
+<p>
+go1.11.9 (released 2019-04-11) fixes an issue where using the prebuilt binary
+releases on older versions of GNU/Linux
+<a href="https://golang.org/issues/31293">led to failures</a>
+when linking programs that used cgo.
+Only Linux users who hit this issue need to update.
+</p>
+
+<p>
+go1.11.10 (released 2019-05-06) includes fixes to the runtime and the linker.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.11.10+label%3ACherryPickApproved">Go
+1.11.10 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.11.11 (released 2019-06-11) includes a fix to the <code>crypto/x509</code> package.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.11.11+label%3ACherryPickApproved">Go
+1.11.11 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.11.12 (released 2019-07-08) includes fixes to the compiler and the linker.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.11.12+label%3ACherryPickApproved">Go
+1.11.12 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.11.13 (released 2019-08-13) includes security fixes to the
+<code>net/http</code> and <code>net/url</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.11.13+label%3ACherryPickApproved">Go
+1.11.13 milestone</a> on our issue tracker for details.
+</p>
+
+<h2 id="go1.10">go1.10 (released 2018-02-16)</h2>
+
+<p>
+Go 1.10 is a major release of Go.
+Read the <a href="/doc/go1.10">Go 1.10 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.10.minor">Minor revisions</h3>
+
+<p>
+go1.10.1 (released 2018-03-28) includes fixes to the compiler, runtime, and the
+<code>archive/zip</code>, <code>crypto/tls</code>, <code>crypto/x509</code>,
+<code>encoding/json</code>, <code>net</code>, <code>net/http</code>, and
+<code>net/http/pprof</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.10.1+label%3ACherryPickApproved">Go
+1.10.1 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.10.2 (released 2018-05-01) includes fixes to the compiler, linker, and go
+command.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.10.2+label%3ACherryPickApproved">Go
+1.10.2 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.10.3 (released 2018-06-05) includes fixes to the go command, and the
+<code>crypto/tls</code>, <code>crypto/x509</code>, and <code>strings</code> packages.
+In particular, it adds <a href="https://go.googlesource.com/go/+/d4e21288e444d3ffd30d1a0737f15ea3fc3b8ad9">
+minimal support to the go command for the vgo transition</a>.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.10.3+label%3ACherryPickApproved">Go
+1.10.3 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.10.4 (released 2018-08-24) includes fixes to the go command, linker, and the
+<code>net/http</code>, <code>mime/multipart</code>, <code>ld/macho</code>,
+<code>bytes</code>, and <code>strings</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.10.4+label%3ACherryPickApproved">Go
+1.10.4 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.10.5 (released 2018-11-02) includes fixes to the go command, linker, runtime,
+and the <code>database/sql</code> package.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.10.5+label%3ACherryPickApproved">Go
+1.10.5 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.10.6 (released 2018-12-12) includes three security fixes to "go get" and
+the <code>crypto/x509</code> package.
+It contains the same fixes as Go 1.11.3 and was released at the same time.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.10.6+label%3ACherryPickApproved">Go
+1.10.6 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.10.7 (released 2018-12-14) includes a fix to a bug introduced in Go 1.10.6
+that broke <code>go</code> <code>get</code> for import path patterns containing
+"<code>...</code>".
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.10.7+label%3ACherryPickApproved">
+Go 1.10.7 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.10.8 (released 2019-01-23) includes a security fix to the
+<code>crypto/elliptic</code> package. See
+the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.10.8+label%3ACherryPickApproved">Go
+1.10.8 milestone</a> on our issue tracker for details.
+</p>
+
+<h2 id="go1.9">go1.9 (released 2017-08-24)</h2>
+
+<p>
+Go 1.9 is a major release of Go.
+Read the <a href="/doc/go1.9">Go 1.9 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.9.minor">Minor revisions</h3>
+
+<p>
+go1.9.1 (released 2017-10-04) includes two security fixes.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.9.1+label%3ACherryPickApproved">Go
+1.9.1 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.9.2 (released 2017-10-25) includes fixes to the compiler, linker, runtime,
+documentation, <code>go</code> command,
+and the <code>crypto/x509</code>, <code>database/sql</code>, <code>log</code>,
+and <code>net/smtp</code> packages.
+It includes a fix to a bug introduced in Go 1.9.1 that broke <code>go</code> <code>get</code>
+of non-Git repositories under certain conditions.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.9.2+label%3ACherryPickApproved">Go
+1.9.2 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.9.3 (released 2018-01-22) includes fixes to the compiler, runtime,
+and the <code>database/sql</code>, <code>math/big</code>, <code>net/http</code>,
+and <code>net/url</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.9.3+label%3ACherryPickApproved">Go
+1.9.3 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.9.4 (released 2018-02-07) includes a security fix to "go get".
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.9.4+label%3ACherryPickApproved">Go
+1.9.4 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.9.5 (released 2018-03-28) includes fixes to the compiler, go command, and the
+<code>net/http/pprof</code> package.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.9.5+label%3ACherryPickApproved">Go
+1.9.5 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.9.6 (released 2018-05-01) includes fixes to the compiler and go command.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.9.6+label%3ACherryPickApproved">Go
+1.9.6 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.9.7 (released 2018-06-05) includes fixes to the go command, and the
+<code>crypto/x509</code> and <code>strings</code> packages.
+In particular, it adds <a href="https://go.googlesource.com/go/+/d4e21288e444d3ffd30d1a0737f15ea3fc3b8ad9">
+minimal support to the go command for the vgo transition</a>.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.9.7+label%3ACherryPickApproved">Go
+1.9.7 milestone</a> on our issue tracker for details.
+</p>
+
+<h2 id="go1.8">go1.8 (released 2017-02-16)</h2>
+
+<p>
+Go 1.8 is a major release of Go.
+Read the <a href="/doc/go1.8">Go 1.8 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.8.minor">Minor revisions</h3>
+
+<p>
+go1.8.1 (released 2017-04-07) includes fixes to the compiler, linker, runtime,
+documentation, <code>go</code> command and the <code>crypto/tls</code>,
+<code>encoding/xml</code>, <code>image/png</code>, <code>net</code>,
+<code>net/http</code>, <code>reflect</code>, <code>text/template</code>,
+and <code>time</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.1">Go
+1.8.1 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.8.2 (released 2017-05-23) includes a security fix to the
+<code>crypto/elliptic</code> package.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.2">Go
+1.8.2 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.8.3 (released 2017-05-24) includes fixes to the compiler, runtime,
+documentation, and the <code>database/sql</code> package.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.3">Go
+1.8.3 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.8.4 (released 2017-10-04) includes two security fixes.
+It contains the same fixes as Go 1.9.1 and was released at the same time.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.4">Go
+1.8.4 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.8.5 (released 2017-10-25) includes fixes to the compiler, linker, runtime,
+documentation, <code>go</code> command,
+and the <code>crypto/x509</code> and <code>net/smtp</code> packages.
+It includes a fix to a bug introduced in Go 1.8.4 that broke <code>go</code> <code>get</code>
+of non-Git repositories under certain conditions.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.5">Go
+1.8.5 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.8.6 (released 2018-01-22) includes the same fix in <code>math/big</code>
+as Go 1.9.3 and was released at the same time.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.6">Go
+1.8.6 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.8.7 (released 2018-02-07) includes a security fix to "go get".
+It contains the same fix as Go 1.9.4 and was released at the same time.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.7">Go
+1.8.7</a> milestone on our issue tracker for details.
+</p>
+
+<h2 id="go1.7">go1.7 (released 2016-08-15)</h2>
+
+<p>
+Go 1.7 is a major release of Go.
+Read the <a href="/doc/go1.7">Go 1.7 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.7.minor">Minor revisions</h3>
+
+<p>
+go1.7.1 (released 2016-09-07) includes fixes to the compiler, runtime,
+documentation, and the <code>compress/flate</code>, <code>hash/crc32</code>,
+<code>io</code>, <code>net</code>, <code>net/http</code>,
+<code>path/filepath</code>, <code>reflect</code>, and <code>syscall</code>
+packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.7.1">Go
+1.7.1 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.7.2 should not be used. It was tagged but not fully released.
+The release was deferred due to a last minute bug report.
+Use go1.7.3 instead, and refer to the summary of changes below.
+</p>
+
+<p>
+go1.7.3 (released 2016-10-19) includes fixes to the compiler, runtime,
+and the <code>crypto/cipher</code>, <code>crypto/tls</code>,
+<code>net/http</code>, and <code>strings</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.7.3">Go
+1.7.3 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.7.4 (released 2016-12-01) includes two security fixes.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.7.4">Go
+1.7.4 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.7.5 (released 2017-01-26) includes fixes to the compiler, runtime,
+and the <code>crypto/x509</code> and <code>time</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.7.5">Go
+1.7.5 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.7.6 (released 2017-05-23) includes the same security fix as Go 1.8.2 and
+was released at the same time.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.8.2">Go
+1.8.2 milestone</a> on our issue tracker for details.
+</p>
+
+<h2 id="go1.6">go1.6 (released 2016-02-17)</h2>
+
+<p>
+Go 1.6 is a major release of Go.
+Read the <a href="/doc/go1.6">Go 1.6 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.6.minor">Minor revisions</h3>
+
+<p>
+go1.6.1 (released 2016-04-12) includes two security fixes.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.6.1">Go
+1.6.1 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.6.2 (released 2016-04-20) includes fixes to the compiler, runtime, tools,
+documentation, and the <code>mime/multipart</code>, <code>net/http</code>, and
+<code>sort</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.6.2">Go
+1.6.2 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.6.3 (released 2016-07-17) includes security fixes to the
+<code>net/http/cgi</code> package and <code>net/http</code> package when used in
+a CGI environment.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.6.3">Go
+1.6.3 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.6.4 (released 2016-12-01) includes two security fixes.
+It contains the same fixes as Go 1.7.4 and was released at the same time.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.7.4">Go
+1.7.4 milestone</a> on our issue tracker for details.
+</p>
+
+<h2 id="go1.5">go1.5 (released 2015-08-19)</h2>
+
+<p>
+Go 1.5 is a major release of Go.
+Read the <a href="/doc/go1.5">Go 1.5 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.5.minor">Minor revisions</h3>
+
+<p>
+go1.5.1 (released 2015-09-08) includes bug fixes to the compiler, assembler, and
+the <code>fmt</code>, <code>net/textproto</code>, <code>net/http</code>, and
+<code>runtime</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.5.1">Go
+1.5.1 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.5.2 (released 2015-12-02) includes bug fixes to the compiler, linker, and
+the <code>mime/multipart</code>, <code>net</code>, and <code>runtime</code>
+packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.5.2">Go
+1.5.2 milestone</a> on our issue tracker for details.
+</p>
+
+<p>
+go1.5.3 (released 2016-01-13) includes a security fix to the <code>math/big</code> package
+affecting the <code>crypto/tls</code> package.
+See the <a href="https://golang.org/s/go153announce">release announcement</a> for details.
+</p>
+
+<p>
+go1.5.4 (released 2016-04-12) includes two security fixes.
+It contains the same fixes as Go 1.6.1 and was released at the same time.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.6.1">Go
+1.6.1 milestone</a> on our issue tracker for details.
+</p>
+
+<h2 id="go1.4">go1.4 (released 2014-12-10)</h2>
+
+<p>
+Go 1.4 is a major release of Go.
+Read the <a href="/doc/go1.4">Go 1.4 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.4.minor">Minor revisions</h3>
+
+<p>
+go1.4.1 (released 2015-01-15) includes bug fixes to the linker and the <code>log</code>, <code>syscall</code>, and <code>runtime</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.4.1">Go 1.4.1 milestone on our issue tracker</a> for details.
+</p>
+
+<p>
+go1.4.2 (released 2015-02-17) includes bug fixes to the <code>go</code> command, the compiler and linker, and the <code>runtime</code>, <code>syscall</code>, <code>reflect</code>, and <code>math/big</code> packages.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.4.2">Go 1.4.2 milestone on our issue tracker</a> for details.
+</p>
+
+<p>
+go1.4.3 (released 2015-09-22) includes security fixes to the <code>net/http</code> package and bug fixes to the <code>runtime</code> package.
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.4.3">Go 1.4.3 milestone on our issue tracker</a> for details.
+</p>
+
+<h2 id="go1.3">go1.3 (released 2014-06-18)</h2>
+
+<p>
+Go 1.3 is a major release of Go.
+Read the <a href="/doc/go1.3">Go 1.3 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.3.minor">Minor revisions</h3>
+
+<p>
+go1.3.1 (released 2014-08-13) includes bug fixes to the compiler and the <code>runtime</code>, <code>net</code>, and <code>crypto/rsa</code> packages.
+See the <a href="https://github.com/golang/go/commits/go1.3.1">change history</a> for details.
+</p>
+
+<p>
+go1.3.2 (released 2014-09-25) includes bug fixes to cgo and the crypto/tls packages.
+See the <a href="https://github.com/golang/go/commits/go1.3.2">change history</a> for details.
+</p>
+
+<p>
+go1.3.3 (released 2014-09-30) includes further bug fixes to cgo, the runtime package, and the nacl port.
+See the <a href="https://github.com/golang/go/commits/go1.3.3">change history</a> for details.
+</p>
+
+<h2 id="go1.2">go1.2 (released 2013-12-01)</h2>
+
+<p>
+Go 1.2 is a major release of Go.
+Read the <a href="/doc/go1.2">Go 1.2 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.2.minor">Minor revisions</h3>
+
+<p>
+go1.2.1 (released 2014-03-02) includes bug fixes to the <code>runtime</code>, <code>net</code>, and <code>database/sql</code> packages.
+See the <a href="https://github.com/golang/go/commits/go1.2.1">change history</a> for details.
+</p>
+
+<p>
+go1.2.2 (released 2014-05-05) includes a
+<a href="https://github.com/golang/go/commits/go1.2.2">security fix</a>
+that affects the tour binary included in the binary distributions (thanks to Guillaume T).
+</p>
+
+<h2 id="go1.1">go1.1 (released 2013-05-13)</h2>
+
+<p>
+Go 1.1 is a major release of Go.
+Read the <a href="/doc/go1.1">Go 1.1 Release Notes</a> for more information.
+</p>
+
+<h3 id="go1.1.minor">Minor revisions</h3>
+
+<p>
+go1.1.1 (released 2013-06-13) includes several compiler and runtime bug fixes.
+See the <a href="https://github.com/golang/go/commits/go1.1.1">change history</a> for details.
+</p>
+
+<p>
+go1.1.2 (released 2013-08-13) includes fixes to the <code>gc</code> compiler
+and <code>cgo</code>, and the <code>bufio</code>, <code>runtime</code>,
+<code>syscall</code>, and <code>time</code> packages.
+See the <a href="https://github.com/golang/go/commits/go1.1.2">change history</a> for details.
+If you use package syscall's <code>Getrlimit</code> and <code>Setrlimit</code>
+functions under Linux on the ARM or 386 architectures, please note change
+<a href="//golang.org/cl/11803043">11803043</a>
+that fixes <a href="//golang.org/issue/5949">issue 5949</a>.
+</p>
+
+<h2 id="go1">go1 (released 2012-03-28)</h2>
+
+<p>
+Go 1 is a major release of Go that will be stable in the long term.
+Read the <a href="/doc/go1.html">Go 1 Release Notes</a> for more information.
+</p>
+
+<p>
+It is intended that programs written for Go 1 will continue to compile and run
+correctly, unchanged, under future versions of Go 1.
+Read the <a href="/doc/go1compat.html">Go 1 compatibility document</a> for more
+about the future of Go 1.
+</p>
+
+<p>
+The go1 release corresponds to
+<code><a href="weekly.html#2012-03-27">weekly.2012-03-27</a></code>.
+</p>
+
+<h3 id="go1.minor">Minor revisions</h3>
+
+<p>
+go1.0.1 (released 2012-04-25) was issued to
+<a href="//golang.org/cl/6061043">fix</a> an
+<a href="//golang.org/issue/3545">escape analysis bug</a>
+that can lead to memory corruption.
+It also includes several minor code and documentation fixes.
+</p>
+
+<p>
+go1.0.2 (released 2012-06-13) was issued to fix two bugs in the implementation
+of maps using struct or array keys:
+<a href="//golang.org/issue/3695">issue 3695</a> and
+<a href="//golang.org/issue/3573">issue 3573</a>.
+It also includes many minor code and documentation fixes.
+</p>
+
+<p>
+go1.0.3 (released 2012-09-21) includes minor code and documentation fixes.
+</p>
+
+<p>
+See the <a href="https://github.com/golang/go/commits/release-branch.go1">go1 release branch history</a> for the complete list of changes.
+</p>
+`
diff --git a/cmd/golangorg/x.go b/cmd/golangorg/x.go
new file mode 100644
index 0000000..a3c8412
--- /dev/null
+++ b/cmd/golangorg/x.go
@@ -0,0 +1,63 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+// This file contains the handlers that serve go-import redirects for Go
+// sub-repositories. It specifies the mapping from import paths like
+// "golang.org/x/tools" to the actual repository locations.
+
+package main
+
+import (
+ "html/template"
+ "log"
+ "net/http"
+ "strings"
+
+ "golang.org/x/build/repos"
+)
+
+func xHandler(w http.ResponseWriter, r *http.Request) {
+ if !strings.HasPrefix(r.URL.Path, "/x/") {
+ // Shouldn't happen if handler is registered correctly.
+ http.Redirect(w, r, "https://pkg.go.dev/search?q=golang.org/x", http.StatusTemporaryRedirect)
+ return
+ }
+ proj, suffix := strings.TrimPrefix(r.URL.Path, "/x/"), ""
+ if i := strings.Index(proj, "/"); i != -1 {
+ proj, suffix = proj[:i], proj[i:]
+ }
+ if proj == "" {
+ http.Redirect(w, r, "https://pkg.go.dev/search?q=golang.org/x", http.StatusTemporaryRedirect)
+ return
+ }
+ repo, ok := repos.ByGerritProject[proj]
+ if !ok || !strings.HasPrefix(repo.ImportPath, "golang.org/x/") {
+ http.NotFound(w, r)
+ return
+ }
+ data := struct {
+ Proj string // Gerrit project ("net", "sys", etc)
+ Suffix string // optional "/path" for requests like /x/PROJ/path
+ }{proj, suffix}
+ if err := xTemplate.Execute(w, data); err != nil {
+ log.Println("xHandler:", err)
+ }
+}
+
+var xTemplate = template.Must(template.New("x").Parse(`<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+<meta name="go-import" content="golang.org/x/{{.Proj}} git https://go.googlesource.com/{{.Proj}}">
+<meta name="go-source" content="golang.org/x/{{.Proj}} https://github.com/golang/{{.Proj}}/ https://github.com/golang/{{.Proj}}/tree/master{/dir} https://github.com/golang/{{.Proj}}/blob/master{/dir}/{file}#L{line}">
+<meta http-equiv="refresh" content="0; url=https://pkg.go.dev/golang.org/x/{{.Proj}}{{.Suffix}}">
+</head>
+<body>
+<a href="https://pkg.go.dev/golang.org/x/{{.Proj}}{{.Suffix}}">Redirecting to documentation...</a>
+</body>
+</html>
+`))
diff --git a/cmd/golangorg/x_test.go b/cmd/golangorg/x_test.go
new file mode 100644
index 0000000..1968807
--- /dev/null
+++ b/cmd/golangorg/x_test.go
@@ -0,0 +1,105 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+package main
+
+import (
+ "net/http/httptest"
+ "strings"
+ "testing"
+)
+
+func TestXHandler(t *testing.T) {
+ type check func(t *testing.T, rec *httptest.ResponseRecorder)
+ status := func(v int) check {
+ return func(t *testing.T, rec *httptest.ResponseRecorder) {
+ t.Helper()
+ if rec.Code != v {
+ t.Errorf("response status = %v; want %v", rec.Code, v)
+ }
+ }
+ }
+ substr := func(s string) check {
+ return func(t *testing.T, rec *httptest.ResponseRecorder) {
+ t.Helper()
+ if !strings.Contains(rec.Body.String(), s) {
+ t.Errorf("missing expected substring %q in value: %#q", s, rec.Body)
+ }
+ }
+ }
+ hasHeader := func(k, v string) check {
+ return func(t *testing.T, rec *httptest.ResponseRecorder) {
+ t.Helper()
+ if got := rec.HeaderMap.Get(k); got != v {
+ t.Errorf("header[%q] = %q; want %q", k, got, v)
+ }
+ }
+ }
+
+ tests := []struct {
+ name string
+ path string
+ checks []check
+ }{
+ {
+ name: "net",
+ path: "/x/net",
+ checks: []check{
+ status(200),
+ substr(`<meta name="go-import" content="golang.org/x/net git https://go.googlesource.com/net">`),
+ substr(`http-equiv="refresh" content="0; url=https://pkg.go.dev/golang.org/x/net">`),
+ },
+ },
+ {
+ name: "net-suffix",
+ path: "/x/net/suffix",
+ checks: []check{
+ status(200),
+ substr(`<meta name="go-import" content="golang.org/x/net git https://go.googlesource.com/net">`),
+ substr(`http-equiv="refresh" content="0; url=https://pkg.go.dev/golang.org/x/net/suffix">`),
+ },
+ },
+ {
+ name: "pkgsite",
+ path: "/x/pkgsite",
+ checks: []check{
+ status(200),
+ substr(`<meta name="go-import" content="golang.org/x/pkgsite git https://go.googlesource.com/pkgsite">`),
+ substr(`<a href="https://pkg.go.dev/golang.org/x/pkgsite">Redirecting to documentation...</a>`),
+ substr(`http-equiv="refresh" content="0; url=https://pkg.go.dev/golang.org/x/pkgsite">`),
+ },
+ },
+ {
+ name: "notexist",
+ path: "/x/notexist",
+ checks: []check{status(404)},
+ },
+ {
+ name: "empty",
+ path: "/x/",
+ checks: []check{
+ status(307),
+ hasHeader("Location", "https://pkg.go.dev/search?q=golang.org/x"),
+ },
+ },
+ {
+ name: "invalid",
+ path: "/x/In%20Valid,X",
+ checks: []check{status(404)},
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ req := httptest.NewRequest("GET", tt.path, nil)
+ rec := httptest.NewRecorder()
+ xHandler(rec, req)
+ for _, check := range tt.checks {
+ check(t, rec)
+ }
+ })
+ }
+}
diff --git a/cmd/googlegolangorg/.gcloudignore b/cmd/googlegolangorg/.gcloudignore
new file mode 100644
index 0000000..199e6d9
--- /dev/null
+++ b/cmd/googlegolangorg/.gcloudignore
@@ -0,0 +1,25 @@
+# This file specifies files that are *not* uploaded to Google Cloud Platform
+# using gcloud. It follows the same syntax as .gitignore, with the addition of
+# "#!include" directives (which insert the entries of the given .gitignore-style
+# file at that point).
+#
+# For more information, run:
+# $ gcloud topic gcloudignore
+#
+.gcloudignore
+# If you would like to upload your .git directory, .gitignore file or files
+# from your .gitignore file, remove the corresponding line
+# below:
+.git
+.gitignore
+
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+# Test binary, build with `go test -c`
+*.test
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
\ No newline at end of file
diff --git a/cmd/googlegolangorg/README.md b/cmd/googlegolangorg/README.md
new file mode 100644
index 0000000..4e1aeac
--- /dev/null
+++ b/cmd/googlegolangorg/README.md
@@ -0,0 +1,18 @@
+This trivial App Engine app serves the small meta+redirector HTML pages
+for https://google.golang.org/. For example:
+
+- https://google.golang.org/appengine
+- https://google.golang.org/cloud
+- https://google.golang.org/api/
+- https://google.golang.org/api/storage/v1
+- https://google.golang.org/grpc
+
+The page includes a meta tag to instruct the go tool to translate e.g. the
+import path "google.golang.org/appengine" to "github.com/golang/appengine".
+See `go help importpath` for the mechanics.
+
+To update the public site, run:
+
+```
+gcloud app --account=username@domain.com --project=golang-org deploy --no-promote -v google app.yaml
+```
diff --git a/cmd/googlegolangorg/app.yaml b/cmd/googlegolangorg/app.yaml
new file mode 100644
index 0000000..ac11081
--- /dev/null
+++ b/cmd/googlegolangorg/app.yaml
@@ -0,0 +1 @@
+runtime: go112
diff --git a/cmd/googlegolangorg/main.go b/cmd/googlegolangorg/main.go
new file mode 100644
index 0000000..daf3966
--- /dev/null
+++ b/cmd/googlegolangorg/main.go
@@ -0,0 +1,139 @@
+// A trivial redirector for google.golang.org.
+package main
+
+import (
+ "fmt"
+ "html/template"
+ "net/http"
+ "os"
+ "strings"
+)
+
+var repoMap = map[string]*repoImport{
+ "api": {
+ VCS: "git",
+ URL: "https://github.com/googleapis/google-api-go-client",
+ Src: github("googleapis/google-api-go-client"),
+ },
+ "appengine": {
+ VCS: "git",
+ URL: "https://github.com/golang/appengine",
+ Src: github("golang/appengine"),
+ },
+ "cloud": {
+ // This repo is now at "cloud.google.com/go", but still specifying the repo
+ // here gives nicer errors in the go tool.
+ VCS: "git",
+ URL: "https://github.com/googleapis/google-cloud-go",
+ Src: github("googleapis/google-cloud-go"),
+ },
+ "genproto": {
+ VCS: "git",
+ URL: "https://github.com/googleapis/go-genproto",
+ Src: github("googleapis/go-genproto"),
+ },
+ "grpc": {
+ VCS: "git",
+ URL: "https://github.com/grpc/grpc-go",
+ Src: github("grpc/grpc-go"),
+ },
+ "protobuf": {
+ VCS: "git",
+ URL: "https://go.googlesource.com/protobuf",
+ Src: github("protocolbuffers/protobuf-go"),
+ },
+}
+
+// repoImport represents an import meta-tag, as per
+// https://golang.org/cmd/go/#hdr-Import_path_syntax
+type repoImport struct {
+ VCS string
+ URL string
+ Src *src
+}
+
+// src represents a pkg.go.dev source redirect.
+// https://github.com/golang/gddo/search?utf8=%E2%9C%93&q=sourceMeta
+type src struct {
+ URL string
+ DirTpl string
+ FileTpl string
+}
+
+// github returns the *src representing a github repo.
+func github(base string) *src {
+ return &src{
+ URL: fmt.Sprintf("https://github.com/%s", base),
+ DirTpl: fmt.Sprintf("https://github.com/%s/tree/master{/dir}", base),
+ FileTpl: fmt.Sprintf("https://github.com/%s/tree/master{/dir}/{file}#L{line}", base),
+ }
+}
+
+func googsource(repo, base string) *src {
+ return &src{
+ URL: fmt.Sprintf("https://%s.googlesource.com/%s", repo, base),
+ DirTpl: fmt.Sprintf("https://%s.googlesource.com/%s/+/master{/dir}", repo, base),
+ FileTpl: fmt.Sprintf("https://%s.googlesource.com/%s/+/master{/dir}/{file}#{line}", repo, base),
+ }
+}
+
+func main() {
+ http.HandleFunc("/", handler)
+
+ port := os.Getenv("PORT")
+ if port == "" {
+ port = "8080"
+ fmt.Printf("Defaulting to port %s\n", port)
+ }
+
+ fmt.Printf("Listening on port %s\n", port)
+ if err := http.ListenAndServe(fmt.Sprintf(":%s", port), nil); err != nil {
+ fmt.Fprintf(os.Stderr, "http.ListenAndServe: %v\n", err)
+ return
+ }
+}
+
+func handler(w http.ResponseWriter, r *http.Request) {
+ head, tail := strings.TrimPrefix(r.URL.Path, "/"), ""
+ if i := strings.Index(head, "/"); i != -1 {
+ head, tail = head[:i], head[i:]
+ }
+ if head == "" {
+ http.Redirect(w, r, "https://cloud.google.com/go/google.golang.org", http.StatusFound)
+ return
+ }
+ repo, ok := repoMap[head]
+ if !ok {
+ http.NotFound(w, r)
+ return
+ }
+ godoc := "https://pkg.go.dev/google.golang.org/" + head + tail
+ // For users visting in a browser, redirect straight to pkg.go.dev.
+ if isBrowser := r.FormValue("go-get") == ""; isBrowser {
+ http.Redirect(w, r, godoc, http.StatusFound)
+ return
+ }
+ data := struct {
+ Head, GoDoc string
+ Repo *repoImport
+ }{head, godoc, repo}
+ w.Header().Set("Content-Type", "text/html; charset=utf-8")
+ if err := tmpl.Execute(w, data); err != nil {
+ fmt.Fprintf(os.Stderr, "tmpl.Execute: %v\n", err)
+ }
+}
+
+var tmpl = template.Must(template.New("redir").Parse(`<!DOCTYPE html>
+<html>
+<head>
+<meta name="go-import" content="google.golang.org/{{.Head}} {{.Repo.VCS}} {{.Repo.URL}}">
+{{if .Repo.Src}}
+<meta name="go-source" content="google.golang.org/{{.Head}} {{.Repo.Src.URL}} {{.Repo.Src.DirTpl}} {{.Repo.Src.FileTpl}}">
+{{end}}
+<meta http-equiv="refresh" content="0; url={{.GoDoc}}">
+</head>
+<body>
+Nothing to see here. Please <a href="{{.GoDoc}}">move along</a>.
+</body>
+</html>
+`))
diff --git a/codereview.cfg b/codereview.cfg
new file mode 100644
index 0000000..3f8b14b
--- /dev/null
+++ b/codereview.cfg
@@ -0,0 +1 @@
+issuerepo: golang/go
diff --git a/content.go b/content.go
new file mode 100644
index 0000000..1e4d26f
--- /dev/null
+++ b/content.go
@@ -0,0 +1,28 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+// Package website exports the static content as an embed.FS.
+package website
+
+import (
+ "embed"
+ "io/fs"
+)
+
+// Content is the website's static content.
+var Content = subdir(embedded, "_content")
+
+//go:embed _content
+var embedded embed.FS
+
+func subdir(fsys fs.FS, path string) fs.FS {
+ s, err := fs.Sub(fsys, path)
+ if err != nil {
+ panic(err)
+ }
+ return s
+}
diff --git a/go.mod b/go.mod
new file mode 100644
index 0000000..b22ee88
--- /dev/null
+++ b/go.mod
@@ -0,0 +1,15 @@
+module golang.org/x/website
+
+go 1.16
+
+require (
+ cloud.google.com/go v0.58.0 // indirect
+ cloud.google.com/go/datastore v1.2.0
+ github.com/gomodule/redigo v2.0.0+incompatible
+ github.com/yuin/goldmark v1.2.1
+ golang.org/x/build v0.0.0-20210422214718-6469a76194d9
+ golang.org/x/net v0.0.0-20201110031124-69a78807bb2b
+ golang.org/x/tools v0.1.1-0.20210215123931-123adc86bcb6
+ google.golang.org/api v0.27.0 // indirect
+ google.golang.org/genproto v0.0.0-20200617032506-f1bdc9086088 // indirect
+)
diff --git a/go.sum b/go.sum
new file mode 100644
index 0000000..6e68972
--- /dev/null
+++ b/go.sum
@@ -0,0 +1,698 @@
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
+cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
+cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
+cloud.google.com/go v0.44.3/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
+cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
+cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
+cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=
+cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4=
+cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M=
+cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc=
+cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk=
+cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs=
+cloud.google.com/go v0.58.0 h1:vtAfVc723K3xKq1BQydk/FyCldnaNFhGhpJxaJzgRMQ=
+cloud.google.com/go v0.58.0/go.mod h1:W+9FnSUw6nhVwXlFcp1eL+krq5+HQUJeUogSeJZZiWg=
+cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
+cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
+cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc=
+cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg=
+cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc=
+cloud.google.com/go/bigquery v1.8.0 h1:PQcPefKFdaIzjQFbiyOgAqyx8q5djaE7x9Sqe712DPA=
+cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ=
+cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
+cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk=
+cloud.google.com/go/datastore v1.2.0 h1:906wMszEeOl3+WoaxXeoBpZbSWmZ/q2xRHMIVLBLCJc=
+cloud.google.com/go/datastore v1.2.0/go.mod h1:FKd9dFEjRui5757lkOJ7z/eKtL74o5hsbY0o6Z0ozz8=
+cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
+cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
+cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA=
+cloud.google.com/go/pubsub v1.3.1 h1:ukjixP1wl0LpnZ6LWtZJ0mX5tBmjp1f8Sqer8Z2OMUU=
+cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU=
+cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
+cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
+cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk=
+cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs=
+contrib.go.opencensus.io/exporter/prometheus v0.3.0/go.mod h1:rpCPVQKhiyH8oomWgm34ZmgIdZa8OVYO5WAIygPbBBE=
+contrib.go.opencensus.io/exporter/stackdriver v0.13.5/go.mod h1:aXENhDJ1Y4lIg4EUaVTwzvYETVNZk10Pu26tevFKLUc=
+dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
+github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
+github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0=
+github.com/NYTimes/gziphandler v1.1.1/go.mod h1:n/CVRwUEOgIxrgPvAQhUUr9oeUtvrhMomdKFjzJNB0c=
+github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo=
+github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI=
+github.com/VividCortex/gohistogram v1.0.0/go.mod h1:Pf5mBqqDxYaXu3hDrrU+w6nw50o/4+TcAqDqk/vUH7g=
+github.com/afex/hystrix-go v0.0.0-20180502004556-fa1af6a1f4f5/go.mod h1:SkGFH1ia65gfNATL8TAiHDNxPzPdmEL5uirI2Uyuz6c=
+github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho=
+github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239/go.mod h1:2FmKhYUyUczH0OGQWaF5ceTx0UBShxjsH6f8oGKYe2c=
+github.com/apache/thrift v0.12.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ=
+github.com/apache/thrift v0.13.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ=
+github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o=
+github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY=
+github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
+github.com/aryann/difflib v0.0.0-20170710044230-e206f873d14a/go.mod h1:DAHtR1m6lCRdSC2Tm3DSWRPvIPr6xNKyeHdqDQSQT+A=
+github.com/aws/aws-lambda-go v1.13.3/go.mod h1:4UKl9IzQMoD+QF79YdCuzCwp8VbmG4VAQwij/eHl5CU=
+github.com/aws/aws-sdk-go v1.23.20/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
+github.com/aws/aws-sdk-go v1.27.0/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
+github.com/aws/aws-sdk-go v1.30.15/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0=
+github.com/aws/aws-sdk-go-v2 v0.18.0/go.mod h1:JWVYvqSMppoMJC0x5wdwiImzgXTI9FuZwxzkQq9wy+g=
+github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
+github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
+github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
+github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
+github.com/bradfitz/go-smtpd v0.0.0-20170404230938-deb6d6237625/go.mod h1:HYsPBTaaSFSlLx/70C2HPIMNZpVV8+vt/A+FMnYP11g=
+github.com/casbin/casbin/v2 v2.1.2/go.mod h1:YcPU1XXisHhLzuxH9coDNf2FbKpjGlbCg3n9yuLkIJQ=
+github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM=
+github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
+github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
+github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
+github.com/clbanning/x2j v0.0.0-20191024224557-825249438eec/go.mod h1:jMjuTZXRI4dUb/I5gc9Hdhagfvm9+RyrPryS/auMzxE=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
+github.com/cockroachdb/datadriven v0.0.0-20190809214429-80d97fb3cbaa/go.mod h1:zn76sxSg3SzpJ0PPJaLDCu+Bu0Lg3sKTORVIj19EIF8=
+github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd/go.mod h1:sE/e/2PUdi/liOCUjSTXgM1o87ZssimdTWN964YiIeI=
+github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
+github.com/coreos/go-systemd v0.0.0-20180511133405-39ca1b05acc7/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
+github.com/coreos/go-systemd v0.0.0-20181012123002-c6f51f82210d/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
+github.com/coreos/pkg v0.0.0-20160727233714-3ac0863d7acf/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
+github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
+github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
+github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
+github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs=
+github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU=
+github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I=
+github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
+github.com/envoyproxy/go-control-plane v0.6.9/go.mod h1:SBwIajubJHhxtWwsL9s8ss4safvEdbitLhGGK48rN6g=
+github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
+github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
+github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
+github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc=
+github.com/franela/goblin v0.0.0-20200105215937-c9ffbefa60db/go.mod h1:7dvUGVsVBjqR7JHJk0brhHOZYGmfBYOrK0ZhYMEtBr4=
+github.com/franela/goreq v0.0.0-20171204163338-bcd34c9993f8/go.mod h1:ZhphrRTfi2rbfLwlschooIH4+wKKDR4Pdxhh+TRoA20=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
+github.com/gliderlabs/ssh v0.1.1/go.mod h1:U7qILu1NlMHj9FlMhZLlkCdDnU1DBEAqr0aevW3Awn0=
+github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
+github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-kit/kit v0.10.0/go.mod h1:xUsJbQ/Fp4kEt7AFgCuvyX4a71u8h9jB8tj/ORgOZ7o=
+github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
+github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
+github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
+github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
+github.com/go-sql-driver/mysql v1.5.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
+github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/gogo/googleapis v1.1.0/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s=
+github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
+github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
+github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e h1:1r7pUrabqp18hOBcwBwiTsbnFeTZHV9eER/QT5JVZxY=
+github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
+github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
+github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.4.3 h1:JjCZWpVbqXDqFVmTfYWEVTMIYrL/NPdPSCHPJ0T/raM=
+github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/gomodule/redigo v2.0.0+incompatible h1:K/R+8tc58AaqLkqG2Ol3Qk+DR/TlNuhuh457pBFPtt0=
+github.com/gomodule/redigo v2.0.0+incompatible/go.mod h1:B4C85qUVwatsJoIUNIfCRsp7qO0iAmpGFZ4EELWSbC4=
+github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-github v17.0.0+incompatible/go.mod h1:zLgOLi98H3fifZn+44m+umXrS52loVEgC2AApnigrVQ=
+github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
+github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200507031123-427632fa3b1c/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
+github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
+github.com/googleapis/gax-go/v2 v2.0.5 h1:sjZBwGj9Jlw33ImPtvFviGYvseOtDM7hkSKB7+Tv3SM=
+github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
+github.com/googleapis/google-cloud-go-testing v0.0.0-20200911160855-bcd43fbb19e8/go.mod h1:dvDLG8qkwmyD9a/MJJN3XJcT3xFxOKAvTZGvuZmac9g=
+github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
+github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg=
+github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
+github.com/gorilla/mux v1.7.3/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
+github.com/gorilla/websocket v0.0.0-20170926233335-4201258b820c/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
+github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA=
+github.com/grpc-ecosystem/go-grpc-middleware v1.0.1-0.20190118093823-f849b5445de4/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
+github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
+github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
+github.com/hashicorp/consul/api v1.3.0/go.mod h1:MmDNSzIMUjNpY/mQ398R4bk2FnqQLoPndWW5VkKPlCE=
+github.com/hashicorp/consul/sdk v0.3.0/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8=
+github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
+github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
+github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
+github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM=
+github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk=
+github.com/hashicorp/go-rootcerts v1.0.0/go.mod h1:K6zTfqpRlCUIjkwsN4Z+hiSfzSTQa6eBIzfwKfwNnHU=
+github.com/hashicorp/go-sockaddr v1.0.0/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU=
+github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdvsLplgctolz4=
+github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
+github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
+github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
+github.com/hashicorp/go.net v0.0.1/go.mod h1:hjKkEWcCURg++eb33jQU7oqQcI9XDCnUzHA0oac0k90=
+github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
+github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64=
+github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ=
+github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I=
+github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/hudl/fargo v1.3.0/go.mod h1:y3CKSmjA+wD2gak7sUSXTAoopbhU08POFhmITJgmKTg=
+github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
+github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
+github.com/influxdata/influxdb1-client v0.0.0-20191209144304-8bf82d3c094d/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo=
+github.com/jellevandenhooff/dkim v0.0.0-20150330215556-f50fe3d243e1/go.mod h1:E0B/fFc00Y+Rasa88328GlI/XbtyysCtTHZS8h7IrBU=
+github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
+github.com/jmespath/go-jmespath v0.3.0/go.mod h1:9QtRXoHjLGCJ5IBSaohpXITPlowMeeYCZ7fLUTSywik=
+github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
+github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=
+github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
+github.com/json-iterator/go v1.1.7/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.8/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
+github.com/jstemmer/go-junit-report v0.9.1 h1:6QPYqodiu3GuPL+7mfx+NwDdp2eTkp9IfEUpgAwUN0o=
+github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
+github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
+github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
+github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=
+github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/pty v1.1.3/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/lightstep/lightstep-tracer-common/golang/gogo v0.0.0-20190605223551-bc2310a04743/go.mod h1:qklhhLq1aX+mtWk9cPHPzaBjWImj5ULL6C7HFJtXQMM=
+github.com/lightstep/lightstep-tracer-go v0.18.1/go.mod h1:jlF1pusYV4pidLvZ+XD0UBX0ZE6WURAspgAczcDHrL4=
+github.com/lyft/protoc-gen-validate v0.0.13/go.mod h1:XbGvPuh87YZc5TdIa2/I4pLk0QoUACkjt2znoq26NVQ=
+github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
+github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
+github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
+github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
+github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc=
+github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
+github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI=
+github.com/mitchellh/gox v0.4.0/go.mod h1:Sd9lOJ0+aimLBi73mGofS1ycjY8lL3uZM3JPS42BGNg=
+github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0QubkSMEySY=
+github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
+github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/nats-io/jwt v0.3.0/go.mod h1:fRYCDE99xlTsqUzISS1Bi75UBJ6ljOJQOAAu5VglpSg=
+github.com/nats-io/jwt v0.3.2/go.mod h1:/euKqTS1ZD+zzjYrY7pseZrTtWQSjujC7xjPc8wL6eU=
+github.com/nats-io/nats-server/v2 v2.1.2/go.mod h1:Afk+wRZqkMQs/p45uXdrVLuab3gwv3Z8C4HTBu8GD/k=
+github.com/nats-io/nats.go v1.9.1/go.mod h1:ZjDU1L/7fJ09jvUSRVBR2e7+RnLiiIQyqyzEE/Zbp4w=
+github.com/nats-io/nkeys v0.1.0/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w=
+github.com/nats-io/nkeys v0.1.3/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w=
+github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
+github.com/oklog/oklog v0.3.2/go.mod h1:FCV+B7mhrz4o+ueLpx+KqkyXRGMWOYEvfiXtdGtbWGs=
+github.com/oklog/run v1.0.0/go.mod h1:dlhp/R75TPv97u0XWUtDeV/lRKWPKSdTuV0TZvrmrQA=
+github.com/olekukonko/tablewriter v0.0.0-20170122224234-a0225b3f23b5/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/op/go-logging v0.0.0-20160315200505-970db520ece7/go.mod h1:HzydrMdWErDVzsI23lYNej1Htcns9BCg93Dk0bBINWk=
+github.com/opentracing-contrib/go-observer v0.0.0-20170622124052-a52f23424492/go.mod h1:Ngi6UdF0k5OKD5t5wlmGhe/EDKPoUM3BXZSSfIuJbis=
+github.com/opentracing/basictracer-go v1.0.0/go.mod h1:QfBfYuafItcjQuMwinw9GhYKwFXS9KnPs5lxoYwgW74=
+github.com/opentracing/opentracing-go v1.0.2/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
+github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
+github.com/openzipkin-contrib/zipkin-go-opentracing v0.4.5/go.mod h1:/wsWhb9smxSfWAKL3wpBW7V8scJMt8N8gnaMCS9E/cA=
+github.com/openzipkin/zipkin-go v0.1.6/go.mod h1:QgAqvLzwWbR/WpD4A3cGpPtJrZXNIiJc5AZX7/PBEpw=
+github.com/openzipkin/zipkin-go v0.2.1/go.mod h1:NaW6tEwdmWMaCDZzg8sh+IBNOxHMPnhQw8ySjnjRyN4=
+github.com/openzipkin/zipkin-go v0.2.2/go.mod h1:NaW6tEwdmWMaCDZzg8sh+IBNOxHMPnhQw8ySjnjRyN4=
+github.com/pact-foundation/pact-go v1.0.4/go.mod h1:uExwJY4kCzNPcHRj+hCR/HBbOOIwwtUjcrb0b5/5kLM=
+github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
+github.com/pborman/uuid v1.2.0/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k=
+github.com/performancecopilot/speed v3.0.0+incompatible/go.mod h1:/CLtqpZ5gBg1M9iaPbIdPPGyKcA8hKdoy6hAWba7Yac=
+github.com/pierrec/lz4 v1.0.2-0.20190131084431-473cd7ce01a1/go.mod h1:3/3N9NVKO0jef7pBehbT1qWhCMrIgbYNnFAZCqQ5LRc=
+github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
+github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/profile v1.2.1/go.mod h1:hJw3o1OdXxsrSjjVksARp5W95eeEaEfptyVZyv6JUPA=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI=
+github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
+github.com/prometheus/client_golang v0.9.3-0.20190127221311-3c4408c8b829/go.mod h1:p2iRAGwDERtqlqzRXnrOVns+ignqQo//hLXqYxZYVNs=
+github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
+github.com/prometheus/client_golang v1.3.0/go.mod h1:hJaj2vgQTGQmVCsAACORcieXFeDPbaTKGT+JTgUa3og=
+github.com/prometheus/client_golang v1.6.0/go.mod h1:ZLOG9ck3JLRdB5MgO8f+lLTe83AXG6ro35rLTxvnIl4=
+github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
+github.com/prometheus/client_golang v1.9.0/go.mod h1:FqZLKOZnGdFAhOK4nqGHa7D66IdsO+O441Eve7ptJDU=
+github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
+github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
+github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.1.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/common v0.2.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/common v0.7.0/go.mod h1:DjGbpBbp5NYNiECxcL/VnbXCCaQpKd3tt26CguLLsqA=
+github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8bs7vj7HSQ4=
+github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
+github.com/prometheus/common v0.15.0/go.mod h1:U+gB1OBLb1lF3O42bTCL+FK18tX9Oar16Clt/msog/s=
+github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
+github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
+github.com/prometheus/procfs v0.0.11/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
+github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
+github.com/prometheus/procfs v0.2.0/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
+github.com/prometheus/statsd_exporter v0.20.0/go.mod h1:YL3FWCG8JBBtaUSxAg4Gz2ZYu22bS84XM89ZQXXTWmQ=
+github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
+github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
+github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
+github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
+github.com/samuel/go-zookeeper v0.0.0-20190923202752-2cc03de413da/go.mod h1:gi+0XIa01GRL2eRQVjQkKGqKF3SF9vZR/HnPullcV2E=
+github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
+github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
+github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
+github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
+github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
+github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
+github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
+github.com/sony/gobreaker v0.4.1/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJOjmxWY=
+github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
+github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/streadway/amqp v0.0.0-20190404075320-75d898a42a94/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw=
+github.com/streadway/amqp v0.0.0-20190827072141-edfb9018d271/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw=
+github.com/streadway/handy v0.0.0-20190108123426-d5acb3125c2a/go.mod h1:qNTQ5P5JnDBl6z3cMAg/SywNDC5ABu5ApDIw6lUbRmI=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07/go.mod h1:kDXzergiv9cbyO7IOYJZWg1U88JhDg3PB6klq9Hg2pA=
+github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
+github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA=
+github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
+github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
+github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.2.1 h1:ruQGxdhGHe7FWOJPT0mKs5+pD2Xs1Bm/kdGlHO04FmM=
+github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+go.etcd.io/bbolt v1.3.3/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
+go.etcd.io/etcd v0.0.0-20191023171146-3cf2f69b5738/go.mod h1:dnLIgRNXwCJa5e+c6mIZCrds/GIG4ncV9HhK5PX7jPg=
+go.opencensus.io v0.20.1/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
+go.opencensus.io v0.20.2/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
+go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
+go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
+go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opencensus.io v0.23.0 h1:gqCw0LfLxScz8irSi8exQc7fyQ0fKQU/qnC/X8+V/1M=
+go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E=
+go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
+go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
+go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
+go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4=
+go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA=
+go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
+go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM=
+go4.org v0.0.0-20180809161055-417644f6feb5/go.mod h1:MkTOUMDaeVYJUOUsaDXIhWPZYa1yOyC1qaOBpL57BhE=
+golang.org/x/build v0.0.0-20210422214718-6469a76194d9 h1:X178jTdCyBwL1VKB0ZnGiujIkkzvkdfMRf4ysjqB6rs=
+golang.org/x/build v0.0.0-20210422214718-6469a76194d9/go.mod h1:AWukj6xAY8m81WLZfhGiC/BdldwDqBCg5k8orN36R1U=
+golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
+golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
+golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
+golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
+golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
+golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
+golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
+golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
+golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/lint v0.0.0-20200302205851-738671d3881b h1:Wh+f8QHJXR411sJR8/vRBTZ7YapZaRvUcLFFJhusH0k=
+golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
+golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
+golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
+golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.1 h1:Kvvh58BN8Y9/lBi7hTekvtMpm07eUZ0ck5pRHpsMWrY=
+golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181023162649-9b4f9f5ad519/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190125091013-d26f9f9a57f3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190813141303-74dc4d7220e7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME=
+golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d h1:TzXSXBo42m9gQenoE3b9BGiEpg5IG2JkU5FkPIawgtw=
+golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/perf v0.0.0-20180704124530-6e6d33e29852/go.mod h1:JLpeXjPJfIyPr5TlbXLkXWLhP8nz10XfvxElABhCtcw=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9 h1:SQFwaSi55rU7vdNs9Yr0Z324VNlrF+0wMqRXT4St8ck=
+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181026203630-95b1ffbd15a5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181122145206-62eef0e2fa9b/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190826190057-c7b8b68b1456/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191220142924-d4481acd189f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200420163511-1957bb5e6d1f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201214210602-f9fddec55a1e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c h1:VwygUrnw9jn88c4u8GD3rZQbqrP/tgas88tPUbBxQrk=
+golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.3.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
+golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191010075000-0337d82405ff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
+golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
+golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=
+golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200606014950-c42cb6316fb6/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200612220849-54c614fe050c/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.1.1-0.20210215123931-123adc86bcb6 h1:GZ5npTh1qUGmauzey32dt41k2308lqvKwwsxdvSQD9g=
+golang.org/x/tools v0.1.1-0.20210215123931-123adc86bcb6/go.mod h1:9bzcO0MWcOuT0tm1iBGzDVPshzfwoVvREIui8C+MHqU=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/api v0.3.1/go.mod h1:6wY9I6uQWHQ8EM57III9mq/AjF+i8G65rmVagqKMtkk=
+google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
+google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
+google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.10.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
+google.golang.org/api v0.26.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
+google.golang.org/api v0.27.0 h1:L02vxokXh9byvvyTw3PLA4MmNri7cY29nliyK4MnIxY=
+google.golang.org/api v0.27.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
+google.golang.org/appengine v1.6.2/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
+google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/appengine v1.6.6 h1:lMO5rYAqUxkmaj76jAkRUvt5JZgFymx/+Q5Mzfivuhc=
+google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190530194941-fb225487d101/go.mod h1:z3L6/3dTEVtUr6QSP8miRzeRqwQOioJ9I66odjN4I7s=
+google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
+google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA=
+google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U=
+google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
+google.golang.org/genproto v0.0.0-20200608115520-7c474a2e3482/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
+google.golang.org/genproto v0.0.0-20200612171551-7676ae05be11/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
+google.golang.org/genproto v0.0.0-20200617032506-f1bdc9086088 h1:XXo4PvhJkaWYIkwn7bX7mcdB8RdcOvn12HbaUUAwX3E=
+google.golang.org/genproto v0.0.0-20200617032506-f1bdc9086088/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
+google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs=
+google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+google.golang.org/grpc v1.20.0/go.mod h1:chYK+tFQF0nDUGJgXMSgLCQk3phJEuONr2DCgLDdAQM=
+google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
+google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
+google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
+google.golang.org/grpc v1.22.1/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.23.1/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
+google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60=
+google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
+google.golang.org/grpc v1.33.2 h1:EQyQC3sa8M+p6Ulc8yy9SWSS2GVwyRc83gAbG8lrl4o=
+google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
+google.golang.org/protobuf v1.25.0 h1:Ejskq+SyPohKW+1uil0JJMtmHCgJPJ/qWTxr8qp+R4c=
+google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
+gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/cheggaaa/pb.v1 v1.0.25/go.mod h1:V/YB90LKu/1FcN3WVnfiiE5oMCibMjukxqG/qStrOgw=
+gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/gcfg.v1 v1.2.3/go.mod h1:yesOnuUOFQAhST5vPY4nbZsb/huCgGGXlipJsBn0b3o=
+gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
+gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
+gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+grpc.go4.org v0.0.0-20170609214715-11d0a25b4919/go.mod h1:77eQGdRu53HpSqPFJFmuJdjuHRquDANNeA4x7B8WQ9o=
+honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
+honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
+honnef.co/go/tools v0.0.1-2020.1.4 h1:UoveltGrhghAA7ePc+e+QYDHXrBps2PqFZiHkGR/xK8=
+honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
+rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
+rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
+rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
+sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o=
+sourcegraph.com/sourcegraph/appdash v0.0.0-20190731080439-ebfcffb1b5c0/go.mod h1:hI742Nqp5OhwiqlzhgfbWU4mW4yO10fP+LoT9WOswdU=
diff --git a/internal/api/api.go b/internal/api/api.go
new file mode 100644
index 0000000..59e6740
--- /dev/null
+++ b/internal/api/api.go
@@ -0,0 +1,256 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+// This file caches information about which standard library types, methods,
+// and functions appeared in what version of Go
+
+package api
+
+import (
+ "bufio"
+ "go/build"
+ "os"
+ "path/filepath"
+ "sort"
+ "strconv"
+ "strings"
+ "unicode"
+)
+
+// DB is a map of packages to information about those packages'
+// symbols and when they were added to Go.
+//
+// Only things added after Go1 are tracked. Version strings are of the
+// form "1.1", "1.2", etc.
+type DB map[string]PkgDB // keyed by Go package ("net/http")
+
+// PkgDB contains information about which version of Go added
+// certain package symbols.
+//
+// Only things added after Go1 are tracked. Version strings are of the
+// form "1.1", "1.2", etc.
+type PkgDB struct {
+ Type map[string]string // "Server" -> "1.7"
+ Method map[string]map[string]string // "*Server" ->"Shutdown"->1.8
+ Func map[string]string // "NewServer" -> "1.7"
+ Field map[string]map[string]string // "ClientTrace" -> "Got1xxResponse" -> "1.11"
+}
+
+// Func returns a string (such as "1.7") specifying which Go
+// version introduced a symbol, unless it was introduced in Go1, in
+// which case it returns the empty string.
+//
+// The kind is one of "type", "method", or "func".
+//
+// The receiver is only used for "methods" and specifies the receiver type,
+// such as "*Server".
+//
+// The name is the symbol name ("Server") and the pkg is the package
+// ("net/http").
+func (v DB) Func(kind, receiver, name, pkg string) string {
+ pv := v[pkg]
+ switch kind {
+ case "func":
+ return pv.Func[name]
+ case "type":
+ return pv.Type[name]
+ case "method":
+ return pv.Method[receiver][name]
+ }
+ return ""
+}
+
+func Load() (DB, error) {
+ var apiGlob string
+ if os.Getenv("GOROOT") == "" {
+ apiGlob = filepath.Join(build.Default.GOROOT, "api", "go*.txt")
+ } else {
+ apiGlob = filepath.Join(os.Getenv("GOROOT"), "api", "go*.txt")
+ }
+
+ files, err := filepath.Glob(apiGlob)
+ if err != nil {
+ return nil, err
+ }
+
+ // Process files in go1.n, go1.n-1, ..., go1.2, go1.1, go1 order.
+ //
+ // It's rare, but the signature of an identifier may change
+ // (for example, a function that accepts a type replaced with
+ // an alias), and so an existing symbol may show up again in
+ // a later api/go1.N.txt file. Parsing in reverse version
+ // order means we end up with the earliest version of Go
+ // when the symbol was added. See golang.org/issue/44081.
+ //
+ ver := func(name string) int {
+ base := filepath.Base(name)
+ ver := strings.TrimPrefix(strings.TrimSuffix(base, ".txt"), "go1.")
+ if ver == "go1" {
+ return 0
+ }
+ v, _ := strconv.Atoi(ver)
+ return v
+ }
+ sort.Slice(files, func(i, j int) bool { return ver(files[i]) > ver(files[j]) })
+ vp := new(parser)
+ for _, f := range files {
+ if err := vp.parseFile(f); err != nil {
+ return nil, err
+ }
+ }
+ return vp.res, nil
+}
+
+// parser parses $GOROOT/api/go*.txt files and stores them in in its rows field.
+type parser struct {
+ res DB // initialized lazily
+}
+
+// parseFile parses the named $GOROOT/api/goVERSION.txt file.
+//
+// For each row, it updates the corresponding entry in
+// vp.res to VERSION, overwriting any previous value.
+// As a special case, if goVERSION is "go1", it deletes
+// from the map instead.
+func (vp *parser) parseFile(name string) error {
+ f, err := os.Open(name)
+ if err != nil {
+ return err
+ }
+ defer f.Close()
+
+ base := filepath.Base(name)
+ ver := strings.TrimPrefix(strings.TrimSuffix(base, ".txt"), "go")
+
+ sc := bufio.NewScanner(f)
+ for sc.Scan() {
+ row, ok := parseRow(sc.Text())
+ if !ok {
+ continue
+ }
+ if vp.res == nil {
+ vp.res = make(DB)
+ }
+ pkgi, ok := vp.res[row.pkg]
+ if !ok {
+ pkgi = PkgDB{
+ Type: make(map[string]string),
+ Method: make(map[string]map[string]string),
+ Func: make(map[string]string),
+ Field: make(map[string]map[string]string),
+ }
+ vp.res[row.pkg] = pkgi
+ }
+ switch row.kind {
+ case "func":
+ if ver == "1" {
+ delete(pkgi.Func, row.name)
+ break
+ }
+ pkgi.Func[row.name] = ver
+ case "type":
+ if ver == "1" {
+ delete(pkgi.Type, row.name)
+ break
+ }
+ pkgi.Type[row.name] = ver
+ case "method":
+ if ver == "1" {
+ delete(pkgi.Method[row.recv], row.name)
+ break
+ }
+ if _, ok := pkgi.Method[row.recv]; !ok {
+ pkgi.Method[row.recv] = make(map[string]string)
+ }
+ pkgi.Method[row.recv][row.name] = ver
+ case "field":
+ if ver == "1" {
+ delete(pkgi.Field[row.structName], row.name)
+ break
+ }
+ if _, ok := pkgi.Field[row.structName]; !ok {
+ pkgi.Field[row.structName] = make(map[string]string)
+ }
+ pkgi.Field[row.structName][row.name] = ver
+ }
+ }
+ return sc.Err()
+}
+
+// row represents an API feature, a parsed line of a
+// $GOROOT/api/go.*txt file.
+type row struct {
+ pkg string // "net/http"
+ kind string // "type", "func", "method", "field" TODO: "const", "var"
+ recv string // for methods, the receiver type ("Server", "*Server")
+ name string // name of type, (struct) field, func, method
+ structName string // for struct fields, the outer struct name
+}
+
+func parseRow(s string) (vr row, ok bool) {
+ if !strings.HasPrefix(s, "pkg ") {
+ // Skip comments, blank lines, etc.
+ return
+ }
+ rest := s[len("pkg "):]
+ endPkg := strings.IndexFunc(rest, func(r rune) bool { return !(unicode.IsLetter(r) || r == '/' || unicode.IsDigit(r)) })
+ if endPkg == -1 {
+ return
+ }
+ vr.pkg, rest = rest[:endPkg], rest[endPkg:]
+ if !strings.HasPrefix(rest, ", ") {
+ // If the part after the pkg name isn't ", ", then it's a OS/ARCH-dependent line of the form:
+ // pkg syscall (darwin-amd64), const ImplementsGetwd = false
+ // We skip those for now.
+ return
+ }
+ rest = rest[len(", "):]
+
+ switch {
+ case strings.HasPrefix(rest, "type "):
+ rest = rest[len("type "):]
+ sp := strings.IndexByte(rest, ' ')
+ if sp == -1 {
+ return
+ }
+ vr.name, rest = rest[:sp], rest[sp+1:]
+ if !strings.HasPrefix(rest, "struct, ") {
+ vr.kind = "type"
+ return vr, true
+ }
+ rest = rest[len("struct, "):]
+ if i := strings.IndexByte(rest, ' '); i != -1 {
+ vr.kind = "field"
+ vr.structName = vr.name
+ vr.name = rest[:i]
+ return vr, true
+ }
+ case strings.HasPrefix(rest, "func "):
+ vr.kind = "func"
+ rest = rest[len("func "):]
+ if i := strings.IndexByte(rest, '('); i != -1 {
+ vr.name = rest[:i]
+ return vr, true
+ }
+ case strings.HasPrefix(rest, "method "): // "method (*File) SetModTime(time.Time)"
+ vr.kind = "method"
+ rest = rest[len("method "):] // "(*File) SetModTime(time.Time)"
+ sp := strings.IndexByte(rest, ' ')
+ if sp == -1 {
+ return
+ }
+ vr.recv = strings.Trim(rest[:sp], "()") // "*File"
+ rest = rest[sp+1:] // SetMode(os.FileMode)
+ paren := strings.IndexByte(rest, '(')
+ if paren == -1 {
+ return
+ }
+ vr.name = rest[:paren]
+ return vr, true
+ }
+ return // TODO: handle more cases
+}
diff --git a/internal/api/api_test.go b/internal/api/api_test.go
new file mode 100644
index 0000000..bfddc5d
--- /dev/null
+++ b/internal/api/api_test.go
@@ -0,0 +1,142 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+package api
+
+import (
+ "go/build"
+ "testing"
+)
+
+func TestParseVersionRow(t *testing.T) {
+ tests := []struct {
+ row string
+ want row
+ }{
+ {
+ row: "# comment",
+ },
+ {
+ row: "",
+ },
+ {
+ row: "pkg archive/tar, type Writer struct",
+ want: row{
+ pkg: "archive/tar",
+ kind: "type",
+ name: "Writer",
+ },
+ },
+ {
+ row: "pkg archive/tar, type Header struct, AccessTime time.Time",
+ want: row{
+ pkg: "archive/tar",
+ kind: "field",
+ structName: "Header",
+ name: "AccessTime",
+ },
+ },
+ {
+ row: "pkg archive/tar, method (*Reader) Read([]uint8) (int, error)",
+ want: row{
+ pkg: "archive/tar",
+ kind: "method",
+ name: "Read",
+ recv: "*Reader",
+ },
+ },
+ {
+ row: "pkg archive/zip, func FileInfoHeader(os.FileInfo) (*FileHeader, error)",
+ want: row{
+ pkg: "archive/zip",
+ kind: "func",
+ name: "FileInfoHeader",
+ },
+ },
+ {
+ row: "pkg encoding/base32, method (Encoding) WithPadding(int32) *Encoding",
+ want: row{
+ pkg: "encoding/base32",
+ kind: "method",
+ name: "WithPadding",
+ recv: "Encoding",
+ },
+ },
+ }
+
+ for i, tt := range tests {
+ got, ok := parseRow(tt.row)
+ if !ok {
+ got = row{}
+ }
+ if got != tt.want {
+ t.Errorf("%d. parseRow(%q) = %+v; want %+v", i, tt.row, got, tt.want)
+ }
+ }
+}
+
+// hasTag checks whether a given release tag is contained in the current version
+// of the go binary.
+func hasTag(t string) bool {
+ for _, v := range build.Default.ReleaseTags {
+ if t == v {
+ return true
+ }
+ }
+ return false
+}
+
+func TestAPIVersion(t *testing.T) {
+ av, err := Load()
+ if err != nil {
+ t.Fatal(err)
+ }
+ for _, tc := range []struct {
+ kind string
+ pkg string
+ name string
+ receiver string
+ want string
+ }{
+ // Things that were added post-1.0 should appear
+ {"func", "archive/tar", "FileInfoHeader", "", "1.1"},
+ {"type", "bufio", "Scanner", "", "1.1"},
+ {"method", "bufio", "WriteTo", "*Reader", "1.1"},
+
+ {"func", "bytes", "LastIndexByte", "", "1.5"},
+ {"type", "crypto", "Decrypter", "", "1.5"},
+ {"method", "crypto/rsa", "Decrypt", "*PrivateKey", "1.5"},
+ {"method", "debug/dwarf", "GoString", "Class", "1.5"},
+
+ {"func", "os", "IsTimeout", "", "1.10"},
+ {"type", "strings", "Builder", "", "1.10"},
+ {"method", "strings", "WriteString", "*Builder", "1.10"},
+
+ // Should get the earliest Go version when an identifier
+ // was initially added, rather than a later version when
+ // it may have been updated. See issue 44081.
+ {"func", "os", "Chmod", "", ""}, // Go 1 era function, updated in Go 1.16.
+ {"method", "os", "Readdir", "*File", ""}, // Go 1 era method, updated in Go 1.16.
+ {"method", "os", "ReadDir", "*File", "1.16"}, // New to Go 1.16.
+
+ // Things from package syscall should never appear
+ {"func", "syscall", "FchFlags", "", ""},
+ {"type", "syscall", "Inet4Pktinfo", "", ""},
+
+ // Things added in Go 1 should never appear
+ {"func", "archive/tar", "NewReader", "", ""},
+ {"type", "archive/tar", "Header", "", ""},
+ {"method", "archive/tar", "Next", "*Reader", ""},
+ } {
+ if tc.want != "" && !hasTag("go"+tc.want) {
+ continue
+ }
+ if got := av.Func(tc.kind, tc.receiver, tc.name, tc.pkg); got != tc.want {
+ t.Errorf(`sinceFunc("%s", "%s", "%s", "%s") = "%s"; want "%s"`, tc.kind, tc.receiver, tc.name, tc.pkg, got, tc.want)
+ }
+ }
+}
diff --git a/internal/dl/dl.go b/internal/dl/dl.go
new file mode 100644
index 0000000..2ef1c9a
--- /dev/null
+++ b/internal/dl/dl.go
@@ -0,0 +1,374 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package dl implements a simple downloads frontend server.
+//
+// It accepts HTTP POST requests to create a new download metadata entity, and
+// lists entities with sorting and filtering.
+// It is designed to run only on the instance of godoc that serves golang.org.
+//
+// The package also serves the list of downloads and individual files at:
+// https://golang.org/dl/
+// https://golang.org/dl/{file}
+//
+// An optional query param, mode=json, serves the list of stable release
+// downloads in JSON format:
+// https://golang.org/dl/?mode=json
+//
+// An additional query param, include=all, when used with the mode=json
+// query param, will serve a full list of available downloads, including
+// stable, unstable, and archived releases in JSON format:
+// https://golang.org/dl/?mode=json&include=all
+package dl
+
+import (
+ "fmt"
+ "html/template"
+ "regexp"
+ "sort"
+ "strconv"
+ "strings"
+ "time"
+)
+
+const (
+ cacheKey = "download_list_4" // increment if listTemplateData changes
+ cacheDuration = time.Hour
+)
+
+// File represents a file on the golang.org downloads page.
+// It should be kept in sync with the upload code in x/build/cmd/release.
+type File struct {
+ Filename string `json:"filename"`
+ OS string `json:"os"`
+ Arch string `json:"arch"`
+ Version string `json:"version"`
+ Checksum string `json:"-" datastore:",noindex"` // SHA1; deprecated
+ ChecksumSHA256 string `json:"sha256" datastore:",noindex"`
+ Size int64 `json:"size" datastore:",noindex"`
+ Kind string `json:"kind"` // "archive", "installer", "source"
+ Uploaded time.Time `json:"-"`
+}
+
+func (f File) ChecksumType() string {
+ if f.ChecksumSHA256 != "" {
+ return "SHA256"
+ }
+ return "SHA1"
+}
+
+func (f File) PrettyChecksum() string {
+ if f.ChecksumSHA256 != "" {
+ return f.ChecksumSHA256
+ }
+ return f.Checksum
+}
+
+func (f File) PrettyOS() string {
+ if f.OS == "darwin" {
+ // Some older releases, like Go 1.4,
+ // still contain "osx" in the filename.
+ switch {
+ case strings.Contains(f.Filename, "osx10.8"):
+ return "OS X 10.8+"
+ case strings.Contains(f.Filename, "osx10.6"):
+ return "OS X 10.6+"
+ }
+ }
+ return pretty(f.OS)
+}
+
+func (f File) PrettySize() string {
+ const mb = 1 << 20
+ if f.Size == 0 {
+ return ""
+ }
+ if f.Size < mb {
+ // All Go releases are >1mb, but handle this case anyway.
+ return fmt.Sprintf("%v bytes", f.Size)
+ }
+ return fmt.Sprintf("%.0fMB", float64(f.Size)/mb)
+}
+
+var primaryPorts = map[string]bool{
+ "darwin/amd64": true,
+ "darwin/arm64": true,
+ "linux/386": true,
+ "linux/amd64": true,
+ "linux/armv6l": true,
+ "linux/arm64": true,
+ "windows/386": true,
+ "windows/amd64": true,
+}
+
+func (f File) PrimaryPort() bool {
+ if f.Kind == "source" {
+ return true
+ }
+ return primaryPorts[f.OS+"/"+f.Arch]
+}
+
+func (f File) Highlight() bool {
+ switch {
+ case f.Kind == "source":
+ return true
+ case f.OS == "linux" && f.Arch == "amd64":
+ return true
+ case f.OS == "windows" && f.Kind == "installer" && f.Arch == "amd64":
+ return true
+ case f.OS == "darwin" && f.Kind == "installer" && !strings.Contains(f.Filename, "osx10.6"):
+ return true
+ }
+ return false
+}
+
+// URL returns the canonical URL of the file.
+func (f File) URL() string {
+ // The download URL of a Go release file is /dl/{name}. It is handled by getHandler.
+ // Use a relative URL so it works for any host like golang.org and golang.google.cn.
+ // Don't shortcut to the redirect target here, we want canonical URLs to be visible. See issue 38713.
+ return "/dl/" + f.Filename
+}
+
+type Release struct {
+ Version string `json:"version"`
+ Stable bool `json:"stable"`
+ Files []File `json:"files"`
+ Visible bool `json:"-"` // show files on page load
+ SplitPortTable bool `json:"-"` // whether files should be split by primary/other ports.
+}
+
+type Feature struct {
+ // The File field will be filled in by the first stable File
+ // whose name matches the given fileRE.
+ File
+ fileRE *regexp.Regexp
+
+ Platform string // "Microsoft Windows", "Apple macOS", "Linux"
+ Requirements string // "Windows XP and above, 64-bit Intel Processor"
+}
+
+// featuredFiles lists the platforms and files to be featured
+// at the top of the downloads page.
+var featuredFiles = []Feature{
+ {
+ Platform: "Microsoft Windows",
+ Requirements: "Windows 7 or later, Intel 64-bit processor",
+ fileRE: regexp.MustCompile(`\.windows-amd64\.msi$`),
+ },
+ {
+ Platform: "Apple macOS",
+ Requirements: "macOS 10.12 or later, Intel 64-bit processor",
+ fileRE: regexp.MustCompile(`\.darwin-amd64\.pkg$`),
+ },
+ {
+ Platform: "Linux",
+ Requirements: "Linux 2.6.23 or later, Intel 64-bit processor",
+ fileRE: regexp.MustCompile(`\.linux-amd64\.tar\.gz$`),
+ },
+ {
+ Platform: "Source",
+ fileRE: regexp.MustCompile(`\.src\.tar\.gz$`),
+ },
+}
+
+// data to send to the template; increment cacheKey if you change this.
+type listTemplateData struct {
+ Featured []Feature
+ Stable, Unstable, Archive []Release
+ GoogleCN bool
+}
+
+var (
+ listTemplate = template.Must(template.New("").Funcs(templateFuncs).Parse(templateHTML))
+ templateFuncs = template.FuncMap{"pretty": pretty}
+)
+
+func filesToFeatured(fs []File) (featured []Feature) {
+ for _, feature := range featuredFiles {
+ for _, file := range fs {
+ if feature.fileRE.MatchString(file.Filename) {
+ feature.File = file
+ featured = append(featured, feature)
+ break
+ }
+ }
+ }
+ return
+}
+
+func filesToReleases(fs []File) (stable, unstable, archive []Release) {
+ sort.Sort(fileOrder(fs))
+
+ var r *Release
+ var stableMaj, stableMin int
+ add := func() {
+ if r == nil {
+ return
+ }
+ if !r.Stable {
+ if len(unstable) != 0 {
+ // Only show one (latest) unstable version,
+ // consider the older ones to be archived.
+ archive = append(archive, *r)
+ return
+ }
+ maj, min, _ := parseVersion(r.Version)
+ if maj < stableMaj || maj == stableMaj && min <= stableMin {
+ // Display unstable version only if newer than the
+ // latest stable release, otherwise consider it archived.
+ archive = append(archive, *r)
+ return
+ }
+ unstable = append(unstable, *r)
+ return
+ }
+
+ // Reports whether the release is the most recent minor version of the
+ // two most recent major versions.
+ shouldAddStable := func() bool {
+ if len(stable) >= 2 {
+ // Show up to two stable versions.
+ return false
+ }
+ if len(stable) == 0 {
+ // Most recent stable version.
+ stableMaj, stableMin, _ = parseVersion(r.Version)
+ return true
+ }
+ if maj, _, _ := parseVersion(r.Version); maj == stableMaj {
+ // Older minor version of most recent major version.
+ return false
+ }
+ // Second most recent stable version.
+ return true
+ }
+ if !shouldAddStable() {
+ archive = append(archive, *r)
+ return
+ }
+
+ // Split the file list into primary/other ports for the stable releases.
+ // NOTE(cbro): This is only done for stable releases because maintaining the historical
+ // nature of primary/other ports for older versions is infeasible.
+ // If freebsd is considered primary some time in the future, we'd not want to
+ // mark all of the older freebsd binaries as "primary".
+ // It might be better if we set that as a flag when uploading.
+ r.SplitPortTable = true
+ r.Visible = true // Toggle open all stable releases.
+ stable = append(stable, *r)
+ }
+ for _, f := range fs {
+ if r == nil || f.Version != r.Version {
+ add()
+ r = &Release{
+ Version: f.Version,
+ Stable: isStable(f.Version),
+ }
+ }
+ r.Files = append(r.Files, f)
+ }
+ add()
+ return
+}
+
+// isStable reports whether the version string v is a stable version.
+func isStable(v string) bool {
+ return !strings.Contains(v, "beta") && !strings.Contains(v, "rc")
+}
+
+type fileOrder []File
+
+func (s fileOrder) Len() int { return len(s) }
+func (s fileOrder) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+func (s fileOrder) Less(i, j int) bool {
+ a, b := s[i], s[j]
+ if av, bv := a.Version, b.Version; av != bv {
+ return versionLess(av, bv)
+ }
+ if a.OS != b.OS {
+ return a.OS < b.OS
+ }
+ if a.Arch != b.Arch {
+ return a.Arch < b.Arch
+ }
+ if a.Kind != b.Kind {
+ return a.Kind < b.Kind
+ }
+ return a.Filename < b.Filename
+}
+
+func versionLess(a, b string) bool {
+ // Put stable releases first.
+ if isStable(a) != isStable(b) {
+ return isStable(a)
+ }
+ maja, mina, ta := parseVersion(a)
+ majb, minb, tb := parseVersion(b)
+ if maja == majb {
+ if mina == minb {
+ return ta >= tb
+ }
+ return mina >= minb
+ }
+ return maja >= majb
+}
+
+func parseVersion(v string) (maj, min int, tail string) {
+ if i := strings.Index(v, "beta"); i > 0 {
+ tail = v[i:]
+ v = v[:i]
+ }
+ if i := strings.Index(v, "rc"); i > 0 {
+ tail = v[i:]
+ v = v[:i]
+ }
+ p := strings.Split(strings.TrimPrefix(v, "go1."), ".")
+ maj, _ = strconv.Atoi(p[0])
+ if len(p) < 2 {
+ return
+ }
+ min, _ = strconv.Atoi(p[1])
+ return
+}
+
+// validUser controls whether the named gomote user is allowed to upload
+// Go release binaries via the /dl/upload endpoint.
+func validUser(user string) bool {
+ switch user {
+ case "amedee", "cherryyz", "dmitshur", "drchase", "katiehockman", "mknyszek", "rakoczy", "valsorda":
+ return true
+ }
+ return false
+}
+
+var (
+ fileRe = regexp.MustCompile(`^go[0-9a-z.]+\.[0-9a-z.-]+\.(tar\.gz|tar\.gz\.asc|pkg|msi|zip)$`)
+ goGetRe = regexp.MustCompile(`^go[0-9a-z.]+\.[0-9a-z.-]+$`)
+)
+
+// pretty returns a human-readable version of the given OS, Arch, or Kind.
+func pretty(s string) string {
+ t, ok := prettyStrings[s]
+ if !ok {
+ return s
+ }
+ return t
+}
+
+var prettyStrings = map[string]string{
+ "darwin": "macOS",
+ "freebsd": "FreeBSD",
+ "linux": "Linux",
+ "windows": "Windows",
+
+ "386": "x86",
+ "amd64": "x86-64",
+ "armv6l": "ARMv6",
+ "arm64": "ARMv8",
+
+ "archive": "Archive",
+ "installer": "Installer",
+ "source": "Source",
+}
diff --git a/internal/dl/dl_test.go b/internal/dl/dl_test.go
new file mode 100644
index 0000000..1e562b3
--- /dev/null
+++ b/internal/dl/dl_test.go
@@ -0,0 +1,239 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package dl
+
+import (
+ "sort"
+ "strings"
+ "testing"
+)
+
+func TestParseVersion(t *testing.T) {
+ for _, c := range []struct {
+ in string
+ maj, min int
+ tail string
+ }{
+ {"go1.5", 5, 0, ""},
+ {"go1.5beta1", 5, 0, "beta1"},
+ {"go1.5.1", 5, 1, ""},
+ {"go1.5.1rc1", 5, 1, "rc1"},
+ } {
+ maj, min, tail := parseVersion(c.in)
+ if maj != c.maj || min != c.min || tail != c.tail {
+ t.Errorf("parseVersion(%q) = %v, %v, %q; want %v, %v, %q",
+ c.in, maj, min, tail, c.maj, c.min, c.tail)
+ }
+ }
+}
+
+func TestFileOrder(t *testing.T) {
+ fs := []File{
+ {Filename: "go1.16.src.tar.gz", Version: "go1.16", OS: "", Arch: "", Kind: "source"},
+ {Filename: "go1.16.1.src.tar.gz", Version: "go1.16.1", OS: "", Arch: "", Kind: "source"},
+ {Filename: "go1.16.linux-amd64.tar.gz", Version: "go1.16", OS: "linux", Arch: "amd64", Kind: "archive"},
+ {Filename: "go1.16.1.linux-amd64.tar.gz", Version: "go1.16.1", OS: "linux", Arch: "amd64", Kind: "archive"},
+ {Filename: "go1.16.darwin-amd64.tar.gz", Version: "go1.16", OS: "darwin", Arch: "amd64", Kind: "archive"},
+ {Filename: "go1.16.darwin-amd64.pkg", Version: "go1.16", OS: "darwin", Arch: "amd64", Kind: "installer"},
+ {Filename: "go1.16.darwin-arm64.tar.gz", Version: "go1.16", OS: "darwin", Arch: "arm64", Kind: "archive"},
+ {Filename: "go1.16.darwin-arm64.pkg", Version: "go1.16", OS: "darwin", Arch: "arm64", Kind: "installer"},
+ {Filename: "go1.16beta1.linux-amd64.tar.gz", Version: "go1.16beta1", OS: "linux", Arch: "amd64", Kind: "archive"},
+ {Filename: "go1.16beta2.linux-amd64.tar.gz", Version: "go1.16beta2", OS: "linux", Arch: "amd64", Kind: "archive"},
+ {Filename: "go1.16rc1.linux-amd64.tar.gz", Version: "go1.16rc1", OS: "linux", Arch: "amd64", Kind: "archive"},
+ {Filename: "go1.15.linux-amd64.tar.gz", Version: "go1.15", OS: "linux", Arch: "amd64", Kind: "archive"},
+ {Filename: "go1.15.2.linux-amd64.tar.gz", Version: "go1.15.2", OS: "linux", Arch: "amd64", Kind: "archive"},
+ }
+ sort.Sort(fileOrder(fs))
+ var s []string
+ for _, f := range fs {
+ s = append(s, f.Filename)
+ }
+ got := strings.Join(s, "\n")
+ want := strings.Join([]string{
+ "go1.16.1.src.tar.gz",
+ "go1.16.1.linux-amd64.tar.gz",
+ "go1.16.src.tar.gz",
+ "go1.16.darwin-amd64.tar.gz",
+ "go1.16.darwin-amd64.pkg",
+ "go1.16.darwin-arm64.tar.gz",
+ "go1.16.darwin-arm64.pkg",
+ "go1.16.linux-amd64.tar.gz",
+ "go1.15.2.linux-amd64.tar.gz",
+ "go1.15.linux-amd64.tar.gz",
+ "go1.16rc1.linux-amd64.tar.gz",
+ "go1.16beta2.linux-amd64.tar.gz",
+ "go1.16beta1.linux-amd64.tar.gz",
+ }, "\n")
+ if got != want {
+ t.Errorf("sort order is\n%s\nwant:\n%s", got, want)
+ }
+}
+
+func TestFilesToReleases(t *testing.T) {
+ fs := []File{
+ {Version: "go1.7.4", OS: "darwin"},
+ {Version: "go1.7.4", OS: "windows"},
+ {Version: "go1.7", OS: "darwin"},
+ {Version: "go1.7", OS: "windows"},
+ {Version: "go1.6.2", OS: "darwin"},
+ {Version: "go1.6.2", OS: "windows"},
+ {Version: "go1.6", OS: "darwin"},
+ {Version: "go1.6", OS: "windows"},
+ {Version: "go1.5.2", OS: "darwin"},
+ {Version: "go1.5.2", OS: "windows"},
+ {Version: "go1.5", OS: "darwin"},
+ {Version: "go1.5", OS: "windows"},
+ {Version: "go1.5beta1", OS: "windows"},
+ }
+ stable, unstable, archive := filesToReleases(fs)
+ if got, want := list(stable), "go1.7.4, go1.6.2"; got != want {
+ t.Errorf("stable = %q; want %q", got, want)
+ }
+ if got, want := list(unstable), ""; got != want {
+ t.Errorf("unstable = %q; want %q", got, want)
+ }
+ if got, want := list(archive), "go1.7, go1.6, go1.5.2, go1.5, go1.5beta1"; got != want {
+ t.Errorf("archive = %q; want %q", got, want)
+ }
+}
+
+func TestHighlightedFiles(t *testing.T) {
+ fs := []File{
+ {Filename: "go1.16beta1.src.tar.gz", Version: "go1.16beta1", OS: "", Arch: "", Kind: "source"},
+ {Filename: "go1.16beta1.linux-386.tar.gz", Version: "go1.16beta1", OS: "linux", Arch: "386", Kind: "archive"},
+ {Filename: "go1.16beta1.linux-amd64.tar.gz", Version: "go1.16beta1", OS: "linux", Arch: "amd64", Kind: "archive"},
+ {Filename: "go1.16beta1.darwin-amd64.tar.gz", Version: "go1.16beta1", OS: "darwin", Arch: "amd64", Kind: "archive"},
+ {Filename: "go1.16beta1.darwin-amd64.pkg", Version: "go1.16beta1", OS: "darwin", Arch: "amd64", Kind: "installer"},
+ {Filename: "go1.16beta1.darwin-arm64.tar.gz", Version: "go1.16beta1", OS: "darwin", Arch: "arm64", Kind: "archive"},
+ {Filename: "go1.16beta1.darwin-arm64.pkg", Version: "go1.16beta1", OS: "darwin", Arch: "arm64", Kind: "installer"},
+ {Filename: "go1.16beta1.windows-386.zip", Version: "go1.16beta1", OS: "windows", Arch: "386", Kind: "archive"},
+ {Filename: "go1.16beta1.windows-386.msi", Version: "go1.16beta1", OS: "windows", Arch: "386", Kind: "installer"},
+ {Filename: "go1.16beta1.windows-amd64.zip", Version: "go1.16beta1", OS: "windows", Arch: "amd64", Kind: "archive"},
+ {Filename: "go1.16beta1.windows-amd64.msi", Version: "go1.16beta1", OS: "windows", Arch: "amd64", Kind: "installer"},
+ }
+ sort.Sort(fileOrder(fs))
+ var highlighted []string
+ for _, f := range fs {
+ if !f.Highlight() {
+ continue
+ }
+ highlighted = append(highlighted, f.Filename)
+ }
+ got := strings.Join(highlighted, "\n")
+ want := strings.Join([]string{
+ "go1.16beta1.src.tar.gz",
+ "go1.16beta1.darwin-amd64.pkg",
+ "go1.16beta1.darwin-arm64.pkg",
+ "go1.16beta1.linux-amd64.tar.gz",
+ "go1.16beta1.windows-amd64.msi",
+ }, "\n")
+ if got != want {
+ t.Errorf("highlighted files:\n%s\nwant:\n%s", got, want)
+ }
+}
+
+func TestOldUnstableNotShown(t *testing.T) {
+ fs := []File{
+ {Version: "go1.7.4"},
+ {Version: "go1.7"},
+ {Version: "go1.7beta1"},
+ }
+ _, unstable, archive := filesToReleases(fs)
+ if len(unstable) != 0 {
+ t.Errorf("got unstable, want none")
+ }
+ if got, want := list(archive), "go1.7, go1.7beta1"; got != want {
+ t.Errorf("archive = %q; want %q", got, want)
+ }
+}
+
+// A new beta should show up under unstable, but not show up under archive. See golang.org/issue/29669.
+func TestNewUnstableShownOnce(t *testing.T) {
+ fs := []File{
+ {Version: "go1.12beta2"},
+ {Version: "go1.11.4"},
+ {Version: "go1.11"},
+ {Version: "go1.10.7"},
+ {Version: "go1.10"},
+ {Version: "go1.9"},
+ }
+ stable, unstable, archive := filesToReleases(fs)
+ if got, want := list(stable), "go1.11.4, go1.10.7"; got != want {
+ t.Errorf("stable = %q; want %q", got, want)
+ }
+ if got, want := list(unstable), "go1.12beta2"; got != want {
+ t.Errorf("unstable = %q; want %q", got, want)
+ }
+ if got, want := list(archive), "go1.11, go1.10, go1.9"; got != want {
+ t.Errorf("archive = %q; want %q", got, want)
+ }
+}
+
+func TestUnstableShown(t *testing.T) {
+ fs := []File{
+ {Version: "go1.8beta2"},
+ {Version: "go1.8rc1"},
+ {Version: "go1.7.4"},
+ {Version: "go1.7"},
+ {Version: "go1.7beta1"},
+ }
+ _, unstable, archive := filesToReleases(fs)
+ // Show RCs ahead of betas.
+ if got, want := list(unstable), "go1.8rc1"; got != want {
+ t.Errorf("unstable = %q; want %q", got, want)
+ }
+ if got, want := list(archive), "go1.7, go1.8beta2, go1.7beta1"; got != want {
+ t.Errorf("archive = %q; want %q", got, want)
+ }
+}
+
+func TestFilesToFeatured(t *testing.T) {
+ fs := []File{
+ {Filename: "go1.16.3.src.tar.gz", Version: "go1.16.3", OS: "", Arch: "", Kind: "source"},
+ {Filename: "go1.16.3.darwin-amd64.tar.gz", Version: "go1.16.3", OS: "darwin", Arch: "amd64", Kind: "archive"},
+ {Filename: "go1.16.3.darwin-amd64.pkg", Version: "go1.16.3", OS: "darwin", Arch: "amd64", Kind: "installer"},
+ {Filename: "go1.16.3.darwin-arm64.tar.gz", Version: "go1.16.3", OS: "darwin", Arch: "arm64", Kind: "archive"},
+ {Filename: "go1.16.3.darwin-arm64.pkg", Version: "go1.16.3", OS: "darwin", Arch: "arm64", Kind: "installer"},
+ {Filename: "go1.16.3.freebsd-386.tar.gz", Version: "go1.16.3", OS: "freebsd", Arch: "386", Kind: "archive"},
+ {Filename: "go1.16.3.freebsd-amd64.tar.gz", Version: "go1.16.3", OS: "freebsd", Arch: "amd64", Kind: "archive"},
+ {Filename: "go1.16.3.linux-386.tar.gz", Version: "go1.16.3", OS: "linux", Arch: "386", Kind: "archive"},
+ {Filename: "go1.16.3.linux-amd64.tar.gz", Version: "go1.16.3", OS: "linux", Arch: "amd64", Kind: "archive"},
+ {Filename: "go1.16.3.linux-arm64.tar.gz", Version: "go1.16.3", OS: "linux", Arch: "arm64", Kind: "archive"},
+ {Filename: "go1.16.3.linux-armv6l.tar.gz", Version: "go1.16.3", OS: "linux", Arch: "armv6l", Kind: "archive"},
+ {Filename: "go1.16.3.linux-ppc64le.tar.gz", Version: "go1.16.3", OS: "linux", Arch: "ppc64le", Kind: "archive"},
+ {Filename: "go1.16.3.linux-s390x.tar.gz", Version: "go1.16.3", OS: "linux", Arch: "s390x", Kind: "archive"},
+ {Filename: "go1.16.3.windows-386.zip", Version: "go1.16.3", OS: "windows", Arch: "386", Kind: "archive"},
+ {Filename: "go1.16.3.windows-386.msi", Version: "go1.16.3", OS: "windows", Arch: "386", Kind: "installer"},
+ {Filename: "go1.16.3.windows-amd64.zip", Version: "go1.16.3", OS: "windows", Arch: "amd64", Kind: "archive"},
+ {Filename: "go1.16.3.windows-amd64.msi", Version: "go1.16.3", OS: "windows", Arch: "amd64", Kind: "installer"},
+ }
+ featured := filesToFeatured(fs)
+ var s []string
+ for _, f := range featured {
+ s = append(s, f.Filename)
+ }
+ got := strings.Join(s, "\n")
+ want := strings.Join([]string{
+ "go1.16.3.windows-amd64.msi",
+ "go1.16.3.darwin-amd64.pkg",
+ "go1.16.3.linux-amd64.tar.gz",
+ "go1.16.3.src.tar.gz",
+ }, "\n")
+ if got != want {
+ t.Errorf("featured files:\n%s\nwant:\n%s", got, want)
+ }
+}
+
+// list returns a version list string for the given releases.
+func list(rs []Release) string {
+ var s string
+ for i, r := range rs {
+ if i > 0 {
+ s += ", "
+ }
+ s += r.Version
+ }
+ return s
+}
diff --git a/internal/dl/server.go b/internal/dl/server.go
new file mode 100644
index 0000000..7ec45a6
--- /dev/null
+++ b/internal/dl/server.go
@@ -0,0 +1,313 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package dl
+
+import (
+ "context"
+ "crypto/hmac"
+ "crypto/md5"
+ "encoding/json"
+ "fmt"
+ "html"
+ "io"
+ "log"
+ "net/http"
+ "strings"
+ "sync"
+ "time"
+
+ "cloud.google.com/go/datastore"
+ "golang.org/x/website/internal/env"
+ "golang.org/x/website/internal/memcache"
+)
+
+type server struct {
+ datastore *datastore.Client
+ memcache *memcache.CodecClient
+}
+
+func RegisterHandlers(mux *http.ServeMux, dc *datastore.Client, mc *memcache.Client) {
+ s := server{dc, mc.WithCodec(memcache.Gob)}
+ mux.HandleFunc("/dl", s.getHandler)
+ mux.HandleFunc("/dl/", s.getHandler) // also serves listHandler
+ mux.HandleFunc("/dl/upload", s.uploadHandler)
+
+ // NOTE(cbro): this only needs to be run once per project,
+ // and should be behind an admin login.
+ // TODO(cbro): move into a locally-run program? or remove?
+ // mux.HandleFunc("/dl/init", initHandler)
+}
+
+// rootKey is the ancestor of all File entities.
+var rootKey = datastore.NameKey("FileRoot", "root", nil)
+
+func (h server) listHandler(w http.ResponseWriter, r *http.Request) {
+ if r.Method != "GET" && r.Method != "OPTIONS" {
+ http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+ return
+ }
+ ctx := r.Context()
+ d := listTemplateData{
+ GoogleCN: googleCN(r),
+ }
+
+ if err := h.memcache.Get(ctx, cacheKey, &d); err != nil {
+ if err != memcache.ErrCacheMiss {
+ log.Printf("ERROR cache get error: %v", err)
+ // NOTE(cbro): continue to hit datastore if the memcache is down.
+ }
+
+ var fs []File
+ q := datastore.NewQuery("File").Ancestor(rootKey)
+ if _, err := h.datastore.GetAll(ctx, q, &fs); err != nil {
+ log.Printf("ERROR error listing: %v", err)
+ http.Error(w, "Could not get download page. Try again in a few minutes.", 500)
+ return
+ }
+ d.Stable, d.Unstable, d.Archive = filesToReleases(fs)
+ if len(d.Stable) > 0 {
+ d.Featured = filesToFeatured(d.Stable[0].Files)
+ }
+
+ item := &memcache.Item{Key: cacheKey, Object: &d, Expiration: cacheDuration}
+ if err := h.memcache.Set(ctx, item); err != nil {
+ log.Printf("ERROR cache set error: %v", err)
+ }
+ }
+
+ if r.URL.Query().Get("mode") == "json" {
+ serveJSON(w, r, d)
+ return
+ }
+
+ if err := listTemplate.ExecuteTemplate(w, "root", d); err != nil {
+ log.Printf("ERROR executing template: %v", err)
+ }
+}
+
+// serveJSON serves a JSON representation of d. It assumes that requests are
+// limited to GET and OPTIONS, the latter used for CORS requests, which this
+// endpoint supports.
+func serveJSON(w http.ResponseWriter, r *http.Request, d listTemplateData) {
+ w.Header().Set("Access-Control-Allow-Origin", "*")
+ w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS")
+ if r.Method == "OPTIONS" {
+ // Likely a CORS preflight request.
+ w.WriteHeader(http.StatusNoContent)
+ return
+ }
+ var releases []Release
+ switch r.URL.Query().Get("include") {
+ case "all":
+ releases = append(append(d.Stable, d.Archive...), d.Unstable...)
+ default:
+ releases = d.Stable
+ }
+ w.Header().Set("Content-Type", "application/json")
+ enc := json.NewEncoder(w)
+ enc.SetIndent("", " ")
+ if err := enc.Encode(releases); err != nil {
+ log.Printf("ERROR rendering JSON for releases: %v", err)
+ }
+}
+
+// googleCN reports whether request r is considered
+// to be served from golang.google.cn.
+// TODO: This is duplicated within internal/proxy. Move to a common location.
+func googleCN(r *http.Request) bool {
+ if r.FormValue("googlecn") != "" {
+ return true
+ }
+ if strings.HasSuffix(r.Host, ".cn") {
+ return true
+ }
+ if !env.CheckCountry() {
+ return false
+ }
+ switch r.Header.Get("X-Appengine-Country") {
+ case "", "ZZ", "CN":
+ return true
+ }
+ return false
+}
+
+func (h server) uploadHandler(w http.ResponseWriter, r *http.Request) {
+ if r.Method != "POST" {
+ http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+ return
+ }
+ ctx := r.Context()
+
+ // Authenticate using a user token (same as gomote).
+ user := r.FormValue("user")
+ if !validUser(user) {
+ http.Error(w, "bad user", http.StatusForbidden)
+ return
+ }
+ if r.FormValue("key") != h.userKey(ctx, user) {
+ http.Error(w, "bad key", http.StatusForbidden)
+ return
+ }
+
+ var f File
+ defer r.Body.Close()
+ if err := json.NewDecoder(r.Body).Decode(&f); err != nil {
+ log.Printf("ERROR decoding upload JSON: %v", err)
+ http.Error(w, "Something broke", http.StatusInternalServerError)
+ return
+ }
+ if f.Filename == "" {
+ http.Error(w, "Must provide Filename", http.StatusBadRequest)
+ return
+ }
+ if f.Uploaded.IsZero() {
+ f.Uploaded = time.Now()
+ }
+ k := datastore.NameKey("File", f.Filename, rootKey)
+ if _, err := h.datastore.Put(ctx, k, &f); err != nil {
+ log.Printf("ERROR File entity: %v", err)
+ http.Error(w, "could not put File entity", http.StatusInternalServerError)
+ return
+ }
+ if err := h.memcache.Delete(ctx, cacheKey); err != nil {
+ log.Printf("ERROR delete error: %v", err)
+ }
+ io.WriteString(w, "OK")
+}
+
+func (h server) getHandler(w http.ResponseWriter, r *http.Request) {
+ isGoGet := (r.Method == "GET" || r.Method == "HEAD") && r.FormValue("go-get") == "1"
+ // For go get, we need to serve the same meta tags at /dl for cmd/go to
+ // validate against the import path.
+ if r.URL.Path == "/dl" && isGoGet {
+ w.Header().Set("Content-Type", "text/html; charset=utf-8")
+ fmt.Fprintf(w, `<!DOCTYPE html><html><head>
+<meta name="go-import" content="golang.org/dl git https://go.googlesource.com/dl">
+</head></html>`)
+ return
+ }
+ if r.URL.Path == "/dl" {
+ http.Redirect(w, r, "/dl/", http.StatusFound)
+ return
+ }
+
+ name := strings.TrimPrefix(r.URL.Path, "/dl/")
+ var redirectURL string
+ switch {
+ case name == "":
+ h.listHandler(w, r)
+ return
+ case fileRe.MatchString(name):
+ // This is a /dl/{file} request to download a file. It's implemented by
+ // redirecting to another host, which serves the bytes more efficiently.
+ //
+ // The redirect target is an internal implementation detail and may change
+ // if there is a good reason to do so. Last time was in CL 76971 (in 2017).
+ const downloadBaseURL = "https://dl.google.com/go/"
+ http.Redirect(w, r, downloadBaseURL+name, http.StatusFound)
+ return
+ case name == "gotip":
+ redirectURL = "https://pkg.go.dev/golang.org/dl/gotip"
+ case goGetRe.MatchString(name):
+ redirectURL = "https://golang.org/dl/#" + name
+ default:
+ http.NotFound(w, r)
+ return
+ }
+ w.Header().Set("Content-Type", "text/html; charset=utf-8")
+ if !isGoGet {
+ w.Header().Set("Location", redirectURL)
+ }
+ fmt.Fprintf(w, `<!DOCTYPE html>
+<html>
+<head>
+<meta name="go-import" content="golang.org/dl git https://go.googlesource.com/dl">
+<meta http-equiv="refresh" content="0; url=%s">
+</head>
+<body>
+Nothing to see here; <a href="%s">move along</a>.
+</body>
+</html>
+`, html.EscapeString(redirectURL), html.EscapeString(redirectURL))
+}
+
+func (h server) initHandler(w http.ResponseWriter, r *http.Request) {
+ var fileRoot struct {
+ Root string
+ }
+ ctx := r.Context()
+ k := rootKey
+ _, err := h.datastore.RunInTransaction(ctx, func(tx *datastore.Transaction) error {
+ err := tx.Get(k, &fileRoot)
+ if err != nil && err != datastore.ErrNoSuchEntity {
+ return err
+ }
+ _, err = tx.Put(k, &fileRoot)
+ return err
+ }, nil)
+ if err != nil {
+ http.Error(w, err.Error(), 500)
+ return
+ }
+ io.WriteString(w, "OK")
+}
+
+func (h server) userKey(c context.Context, user string) string {
+ hash := hmac.New(md5.New, []byte(h.secret(c)))
+ hash.Write([]byte("user-" + user))
+ return fmt.Sprintf("%x", hash.Sum(nil))
+}
+
+// Code below copied from x/build/app/key
+
+var theKey struct {
+ sync.RWMutex
+ builderKey
+}
+
+type builderKey struct {
+ Secret string
+}
+
+func (k *builderKey) Key() *datastore.Key {
+ return datastore.NameKey("BuilderKey", "root", nil)
+}
+
+func (h server) secret(ctx context.Context) string {
+ // check with rlock
+ theKey.RLock()
+ k := theKey.Secret
+ theKey.RUnlock()
+ if k != "" {
+ return k
+ }
+
+ // prepare to fill; check with lock and keep lock
+ theKey.Lock()
+ defer theKey.Unlock()
+ if theKey.Secret != "" {
+ return theKey.Secret
+ }
+
+ // fill
+ if err := h.datastore.Get(ctx, theKey.Key(), &theKey.builderKey); err != nil {
+ if err == datastore.ErrNoSuchEntity {
+ // If the key is not stored in datastore, write it.
+ // This only happens at the beginning of a new deployment.
+ // The code is left here for SDK use and in case a fresh
+ // deployment is ever needed. "gophers rule" is not the
+ // real key.
+ if env.RequireDLSecretKey() {
+ panic("lost key from datastore")
+ }
+ theKey.Secret = "gophers rule"
+ h.datastore.Put(ctx, theKey.Key(), &theKey.builderKey)
+ return theKey.Secret
+ }
+ panic("cannot load builder key: " + err.Error())
+ }
+
+ return theKey.Secret
+}
diff --git a/internal/dl/server_test.go b/internal/dl/server_test.go
new file mode 100644
index 0000000..2cff8d7
--- /dev/null
+++ b/internal/dl/server_test.go
@@ -0,0 +1,92 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package dl
+
+import (
+ "encoding/json"
+ "net/http/httptest"
+ "sort"
+ "testing"
+)
+
+func TestServeJSON(t *testing.T) {
+ data := listTemplateData{
+ Stable: []Release{{Version: "Stable"}},
+ Unstable: []Release{{Version: "Unstable"}},
+ Archive: []Release{{Version: "Archived"}},
+ }
+ testCases := []struct {
+ desc string
+ method string
+ target string
+ status int
+ versions []string
+ }{
+ {
+ desc: "basic",
+ method: "GET",
+ target: "/",
+ status: 200,
+ versions: []string{"Stable"},
+ },
+ {
+ desc: "include all versions",
+ method: "GET",
+ target: "/?include=all",
+ status: 200,
+ versions: []string{"Stable", "Unstable", "Archived"},
+ },
+ {
+ desc: "CORS preflight request",
+ method: "OPTIONS",
+ target: "/",
+ status: 204,
+ },
+ }
+ for _, tc := range testCases {
+ t.Run(tc.desc, func(t *testing.T) {
+ r := httptest.NewRequest(tc.method, tc.target, nil)
+ w := httptest.NewRecorder()
+ serveJSON(w, r, data)
+
+ resp := w.Result()
+ defer resp.Body.Close()
+ if got, want := resp.StatusCode, tc.status; got != want {
+ t.Errorf("Response status code = %d; want %d", got, want)
+ }
+ for k, v := range map[string]string{
+ "Access-Control-Allow-Origin": "*",
+ "Access-Control-Allow-Methods": "GET, OPTIONS",
+ } {
+ if got, want := resp.Header.Get(k), v; got != want {
+ t.Errorf("%s = %q; want %q", k, got, want)
+ }
+ }
+ if tc.versions == nil {
+ return
+ }
+
+ if got, want := resp.Header.Get("Content-Type"), "application/json"; got != want {
+ t.Errorf("Content-Type = %q; want %q", got, want)
+ }
+ var rs []Release
+ if err := json.NewDecoder(resp.Body).Decode(&rs); err != nil {
+ t.Fatalf("json.Decode: got unexpected error: %v", err)
+ }
+ sort.Slice(rs, func(i, j int) bool {
+ return rs[i].Version < rs[j].Version
+ })
+ sort.Strings(tc.versions)
+ if got, want := len(rs), len(tc.versions); got != want {
+ t.Fatalf("Number of releases = %d; want %d", got, want)
+ }
+ for i := range rs {
+ if got, want := rs[i].Version, tc.versions[i]; got != want {
+ t.Errorf("Got version %q; want %q", got, want)
+ }
+ }
+ })
+ }
+}
diff --git a/internal/dl/tmpl.go b/internal/dl/tmpl.go
new file mode 100644
index 0000000..d0005f2
--- /dev/null
+++ b/internal/dl/tmpl.go
@@ -0,0 +1,298 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package dl
+
+// TODO(adg): refactor this to use the tools/godoc/static template.
+
+const templateHTML = `
+{{define "root"}}
+<!DOCTYPE html>
+<html lang="en">
+<meta charset="utf-8">
+<meta name="description" content="Go is an open source programming language that makes it easy to build simple, reliable, and efficient software.">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="theme-color" content="#00ADD8">
+<title>Downloads - The Go Programming Language</title>
+<link href="https://fonts.googleapis.com/css?family=Work+Sans:600|Roboto:400,700" rel="stylesheet">
+<link href="https://fonts.googleapis.com/css?family=Product+Sans&text=Supported%20by%20Google&display=swap" rel="stylesheet">
+<link type="text/css" rel="stylesheet" href="/lib/godoc/style.css">
+<script>window.initFuncs = [];</script>
+<style>
+ table.codetable {
+ margin-left: 20px;
+ margin-right: 20px;
+ border-collapse: collapse;
+ }
+ table.codetable tr {
+ background-color: #f0f0f0;
+ }
+ table.codetable tr:nth-child(2n), table.codetable tr.first {
+ background-color: white;
+ }
+ table.codetable td, table.codetable th {
+ white-space: nowrap;
+ padding: 6px 10px;
+ }
+ table.codetable tt {
+ font-size: xx-small;
+ }
+ table.codetable tr.highlight td {
+ font-weight: bold;
+ }
+ a.downloadBox {
+ display: block;
+ color: #222;
+ border: 1px solid #375EAB;
+ border-radius: 5px;
+ background: #E0EBF5;
+ width: 280px;
+ float: left;
+ margin-left: 10px;
+ margin-bottom: 10px;
+ padding: 10px;
+ }
+ a.downloadBox:hover {
+ text-decoration: none;
+ }
+ .downloadBox .platform {
+ font-size: large;
+ }
+ .downloadBox .filename {
+ color: #007d9c;
+ font-weight: bold;
+ line-height: 1.5em;
+ }
+ a.downloadBox:hover .filename {
+ text-decoration: underline;
+ }
+ .downloadBox .size {
+ font-size: small;
+ font-weight: normal;
+ }
+ .downloadBox .reqs {
+ font-size: small;
+ font-style: italic;
+ }
+ .downloadBox .checksum {
+ font-size: 5pt;
+ }
+</style>
+<body class="Site">
+<header class="Header js-header">
+ <div class="Header-banner">
+ Black Lives Matter.
+ <a href="https://support.eji.org/give/153413/#!/donation/checkout"
+ target="_blank"
+ rel="noopener">Support the Equal Justice Initiative.</a>
+ </div>
+ <nav class="Header-nav">
+ <a href="/"><img class="Header-logo" src="/lib/godoc/images/go-logo-blue.svg" alt="Go"></a>
+ <button class="Header-menuButton js-headerMenuButton" aria-label="Main menu" aria-expanded="false">
+ <div class="Header-menuButtonInner"></div>
+ </button>
+ <ul class="Header-menu">
+ <li class="Header-menuItem"><a href="/doc/">Documents</a></li>
+ <li class="Header-menuItem"><a href="/pkg/">Packages</a></li>
+ <li class="Header-menuItem"><a href="/project/">The Project</a></li>
+ <li class="Header-menuItem"><a href="/help/">Help</a></li>
+ {{if not .GoogleCN}}
+ <li class="Header-menuItem"><a href="/blog/">Blog</a></li>
+ <li class="Header-menuItem"><a href="https://play.golang.org/">Play</a></li>
+ {{end}}
+ </ul>
+ </nav>
+</header>
+
+<main id="page" class="Site-content">
+<div class="container">
+
+<h1>Downloads</h1>
+
+<p>
+After downloading a binary release suitable for your system,
+please follow the <a href="/doc/install">installation instructions</a>.
+</p>
+
+<p>
+If you are building from source,
+follow the <a href="/doc/install/source">source installation instructions</a>.
+</p>
+
+<p>
+See the <a href="/doc/devel/release.html">release history</a> for more
+information about Go releases.
+</p>
+
+<p>
+ As of Go 1.13, the go command by default downloads and authenticates
+ modules using the Go module mirror and Go checksum database run by Google. See
+ <a href="https://proxy.golang.org/privacy">https://proxy.golang.org/privacy</a>
+ for privacy information about these services and the
+ <a href="/cmd/go/">go command documentation</a>
+ for configuration details including how to disable the use of these servers or use
+ different ones.
+</p>
+
+{{with .Featured}}
+<h3 id="featured">Featured downloads</h3>
+{{range .}}
+{{template "download" .}}
+{{end}}
+{{end}}
+
+<div style="clear: both;"></div>
+
+{{with .Stable}}
+<h3 id="stable">Stable versions</h3>
+{{template "releases" .}}
+{{end}}
+
+{{with .Unstable}}
+<h3 id="unstable">Unstable version</h3>
+{{template "releases" .}}
+{{end}}
+
+{{with .Archive}}
+<div class="toggle" id="archive">
+ <div class="collapsed">
+ <h3 class="toggleButton" title="Click to show versions">Archived versions ▹</h3>
+ </div>
+ <div class="expanded">
+ <h3 class="toggleButton" title="Click to hide versions">Archived versions ▾</h3>
+ {{template "releases" .}}
+ </div>
+</div>
+{{end}}
+
+</div><!-- .container -->
+</main><!-- #page -->
+<footer>
+ <div class="Footer">
+ <img class="Footer-gopher" src="/lib/godoc/images/footer-gopher.jpg" alt="The Go Gopher">
+ <ul class="Footer-links">
+ <li class="Footer-link"><a href="/doc/copyright.html">Copyright</a></li>
+ <li class="Footer-link"><a href="/doc/tos.html">Terms of Service</a></li>
+ <li class="Footer-link"><a href="http://www.google.com/intl/en/policies/privacy/">Privacy Policy</a></li>
+ <li class="Footer-link"><a href="http://golang.org/issues/new?title=x/website:" target="_blank" rel="noopener">Report a website issue</a></li>
+ </ul>
+ <a class="Footer-supportedBy" href="https://google.com">Supported by Google</a>
+ </div>
+</footer>
+<script>
+ (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
+ (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
+ m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
+ })(window,document,'script','//www.google-analytics.com/analytics.js','ga');
+
+ ga('create', 'UA-11222381-2', 'auto');
+ ga('send', 'pageview');
+
+</script>
+</body>
+<script src="/lib/godoc/jquery.js"></script>
+<script src="/lib/godoc/godocs.js"></script>
+<script>
+$(document).ready(function() {
+ $('a.download').click(function(e) {
+ // Try using the link text as the file name,
+ // unless there's a child element of class 'filename'.
+ var filename = $(this).text();
+ var child = $(this).find('.filename');
+ if (child.length > 0) {
+ filename = child.text();
+ }
+
+ // This must be kept in sync with the filenameRE in godocs.js.
+ var filenameRE = /^go1\.\d+(\.\d+)?([a-z0-9]+)?\.([a-z0-9]+)(-[a-z0-9]+)?(-osx10\.[68])?\.([a-z.]+)$/;
+ var m = filenameRE.exec(filename);
+ if (!m) {
+ // Don't redirect to the download page if it won't recognize this file.
+ // (Should not happen.)
+ return;
+ }
+
+ var dest = "/doc/install";
+ if (filename.indexOf(".src.") != -1) {
+ dest += "/source";
+ }
+ dest += "?download=" + filename;
+
+ e.preventDefault();
+ e.stopPropagation();
+ window.location = dest;
+ });
+});
+</script>
+{{end}}
+
+{{define "releases"}}
+{{range .}}
+<div class="toggle{{if .Visible}}Visible{{end}}" id="{{.Version}}">
+ <div class="collapsed">
+ <h2 class="toggleButton" title="Click to show downloads for this version">{{.Version}} ▹</h2>
+ </div>
+ <div class="expanded">
+ <h2 class="toggleButton" title="Click to hide downloads for this version">{{.Version}} ▾</h2>
+ {{if .Stable}}{{else}}
+ <p>This is an <b>unstable</b> version of Go. Use with caution.</p>
+ <p>If you already have Go installed, you can install this version by running:</p>
+<pre>
+go get golang.org/dl/{{.Version}}
+</pre>
+ <p>Then, use the <code>{{.Version}}</code> command instead of the <code>go</code> command to use {{.Version}}.</p>
+ {{end}}
+ {{template "files" .}}
+ </div>
+</div>
+{{end}}
+{{end}}
+
+{{define "files"}}
+<table class="codetable">
+<thead>
+<tr class="first">
+ <th>File name</th>
+ <th>Kind</th>
+ <th>OS</th>
+ <th>Arch</th>
+ <th>Size</th>
+ {{/* Use the checksum type of the first file for the column heading. */}}
+ <th>{{(index .Files 0).ChecksumType}} Checksum</th>
+</tr>
+</thead>
+{{if .SplitPortTable}}
+ {{range .Files}}{{if .PrimaryPort}}{{template "file" .}}{{end}}{{end}}
+
+ {{/* TODO(cbro): add a link to an explanatory doc page */}}
+ <tr class="first"><th colspan="6" class="first">Other Ports</th></tr>
+ {{range .Files}}{{if not .PrimaryPort}}{{template "file" .}}{{end}}{{end}}
+{{else}}
+ {{range .Files}}{{template "file" .}}{{end}}
+{{end}}
+</table>
+{{end}}
+
+{{define "file"}}
+<tr{{if .Highlight}} class="highlight"{{end}}>
+ <td class="filename"><a class="download" href="{{.URL}}">{{.Filename}}</a></td>
+ <td>{{pretty .Kind}}</td>
+ <td>{{.PrettyOS}}</td>
+ <td>{{pretty .Arch}}</td>
+ <td>{{.PrettySize}}</td>
+ <td><tt>{{.PrettyChecksum}}</tt></td>
+</tr>
+{{end}}
+
+{{define "download"}}
+<a class="download downloadBox" href="{{.URL}}">
+<div class="platform">{{.Platform}}</div>
+{{with .Requirements}}<div class="reqs">{{.}}</div>{{end}}
+<div>
+ <span class="filename">{{.Filename}}</span>
+ {{if .Size}}<span class="size">({{.PrettySize}})</span>{{end}}
+</div>
+</a>
+{{end}}
+`
diff --git a/internal/env/env.go b/internal/env/env.go
new file mode 100644
index 0000000..80575a3
--- /dev/null
+++ b/internal/env/env.go
@@ -0,0 +1,50 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package env provides environment information for the golangorg server
+// running on golang.org.
+package env
+
+import (
+ "log"
+ "os"
+ "strconv"
+)
+
+var (
+ checkCountry = boolEnv("GOLANGORG_CHECK_COUNTRY")
+ enforceHosts = boolEnv("GOLANGORG_ENFORCE_HOSTS")
+ requireDLSecretKey = boolEnv("GOLANGORG_REQUIRE_DL_SECRET_KEY")
+)
+
+// RequireDLSecretKey reports whether the download server secret key
+// is expected to already exist, and the download server should panic
+// on missing key instead of creating a new one.
+func RequireDLSecretKey() bool {
+ return requireDLSecretKey
+}
+
+// CheckCountry reports whether country restrictions should be enforced.
+func CheckCountry() bool {
+ return checkCountry
+}
+
+// EnforceHosts reports whether host filtering should be enforced.
+func EnforceHosts() bool {
+ return enforceHosts
+}
+
+func boolEnv(key string) bool {
+ v := os.Getenv(key)
+ if v == "" {
+ // TODO(dmitshur): In the future, consider detecting if running in App Engine,
+ // and if so, making the environment variables mandatory rather than optional.
+ return false
+ }
+ b, err := strconv.ParseBool(v)
+ if err != nil {
+ log.Fatalf("environment variable %s (%q) must be a boolean", key, v)
+ }
+ return b
+}
diff --git a/internal/godoc/astfuncs.go b/internal/godoc/astfuncs.go
new file mode 100644
index 0000000..22e1bdc
--- /dev/null
+++ b/internal/godoc/astfuncs.go
@@ -0,0 +1,194 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+package godoc
+
+import (
+ "bufio"
+ "bytes"
+ "go/ast"
+ "go/doc"
+ "go/printer"
+ "go/token"
+ "io"
+ "log"
+ "unicode"
+
+ "golang.org/x/website/internal/api"
+ "golang.org/x/website/internal/pkgdoc"
+ "golang.org/x/website/internal/texthtml"
+)
+
+var slashSlash = []byte("//")
+
+func (p *Presentation) nodeFunc(info *pkgdoc.Page, node interface{}) string {
+ var buf bytes.Buffer
+ p.writeNode(&buf, info, info.FSet, node)
+ return buf.String()
+}
+
+func (p *Presentation) node_htmlFunc(info *pkgdoc.Page, node interface{}, linkify bool) string {
+ var buf1 bytes.Buffer
+ p.writeNode(&buf1, info, info.FSet, node)
+
+ var buf2 bytes.Buffer
+ var n ast.Node
+ if linkify {
+ n, _ = node.(ast.Node)
+ }
+ buf2.Write(texthtml.Format(buf1.Bytes(), texthtml.Config{
+ AST: n,
+ GoComments: true,
+ }))
+ return buf2.String()
+}
+
+const TabWidth = 4
+
+// writeNode writes the AST node x to w.
+//
+// The provided fset must be non-nil. The pageInfo is optional. If
+// present, the pageInfo is used to add comments to struct fields to
+// say which version of Go introduced them.
+func (p *Presentation) writeNode(w io.Writer, pageInfo *pkgdoc.Page, fset *token.FileSet, x interface{}) {
+ // convert trailing tabs into spaces using a tconv filter
+ // to ensure a good outcome in most browsers (there may still
+ // be tabs in comments and strings, but converting those into
+ // the right number of spaces is much harder)
+ //
+ // TODO(gri) rethink printer flags - perhaps tconv can be eliminated
+ // with an another printer mode (which is more efficiently
+ // implemented in the printer than here with another layer)
+
+ var pkgName, structName string
+ var apiInfo api.PkgDB
+ if gd, ok := x.(*ast.GenDecl); ok && pageInfo != nil && pageInfo.PDoc != nil &&
+ p.Corpus != nil &&
+ gd.Tok == token.TYPE && len(gd.Specs) != 0 {
+ pkgName = pageInfo.PDoc.ImportPath
+ if ts, ok := gd.Specs[0].(*ast.TypeSpec); ok {
+ if _, ok := ts.Type.(*ast.StructType); ok {
+ structName = ts.Name.Name
+ }
+ }
+ apiInfo = p.Corpus.pkgAPIInfo[pkgName]
+ }
+
+ var out = w
+ var buf bytes.Buffer
+ if structName != "" {
+ out = &buf
+ }
+
+ mode := printer.TabIndent | printer.UseSpaces
+ err := (&printer.Config{Mode: mode, Tabwidth: TabWidth}).Fprint(TabSpacer(out, TabWidth), fset, x)
+ if err != nil {
+ log.Print(err)
+ }
+
+ // Add comments to struct fields saying which Go version introduced them.
+ if structName != "" {
+ fieldSince := apiInfo.Field[structName]
+ typeSince := apiInfo.Type[structName]
+ // Add/rewrite comments on struct fields to note which Go version added them.
+ var buf2 bytes.Buffer
+ buf2.Grow(buf.Len() + len(" // Added in Go 1.n")*10)
+ bs := bufio.NewScanner(&buf)
+ for bs.Scan() {
+ line := bs.Bytes()
+ field := firstIdent(line)
+ var since string
+ if field != "" {
+ since = fieldSince[field]
+ if since != "" && since == typeSince {
+ // Don't highlight field versions if they were the
+ // same as the struct itself.
+ since = ""
+ }
+ }
+ if since == "" {
+ buf2.Write(line)
+ } else {
+ if bytes.Contains(line, slashSlash) {
+ line = bytes.TrimRight(line, " \t.")
+ buf2.Write(line)
+ buf2.WriteString("; added in Go ")
+ } else {
+ buf2.Write(line)
+ buf2.WriteString(" // Go ")
+ }
+ buf2.WriteString(since)
+ }
+ buf2.WriteByte('\n')
+ }
+ w.Write(buf2.Bytes())
+ }
+}
+
+// firstIdent returns the first identifier in x.
+// This actually parses "identifiers" that begin with numbers too, but we
+// never feed it such input, so it's fine.
+func firstIdent(x []byte) string {
+ x = bytes.TrimSpace(x)
+ i := bytes.IndexFunc(x, func(r rune) bool { return !unicode.IsLetter(r) && !unicode.IsNumber(r) })
+ if i == -1 {
+ return string(x)
+ }
+ return string(x[:i])
+}
+
+func comment_htmlFunc(comment string) string {
+ var buf bytes.Buffer
+ // TODO(gri) Provide list of words (e.g. function parameters)
+ // to be emphasized by ToHTML.
+ doc.ToHTML(&buf, comment, nil) // does html-escaping
+ return buf.String()
+}
+
+// sanitizeFunc sanitizes the argument src by replacing newlines with
+// blanks, removing extra blanks, and by removing trailing whitespace
+// and commas before closing parentheses.
+func sanitizeFunc(src string) string {
+ buf := make([]byte, len(src))
+ j := 0 // buf index
+ comma := -1 // comma index if >= 0
+ for i := 0; i < len(src); i++ {
+ ch := src[i]
+ switch ch {
+ case '\t', '\n', ' ':
+ // ignore whitespace at the beginning, after a blank, or after opening parentheses
+ if j == 0 {
+ continue
+ }
+ if p := buf[j-1]; p == ' ' || p == '(' || p == '{' || p == '[' {
+ continue
+ }
+ // replace all whitespace with blanks
+ ch = ' '
+ case ',':
+ comma = j
+ case ')', '}', ']':
+ // remove any trailing comma
+ if comma >= 0 {
+ j = comma
+ }
+ // remove any trailing whitespace
+ if j > 0 && buf[j-1] == ' ' {
+ j--
+ }
+ default:
+ comma = -1
+ }
+ buf[j] = ch
+ j++
+ }
+ // remove trailing blank, if any
+ if j > 0 && buf[j-1] == ' ' {
+ j--
+ }
+ return string(buf[:j])
+}
diff --git a/internal/godoc/corpus.go b/internal/godoc/corpus.go
new file mode 100644
index 0000000..7c403f6
--- /dev/null
+++ b/internal/godoc/corpus.go
@@ -0,0 +1,73 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+package godoc
+
+import (
+ "io/fs"
+ "sync"
+ "time"
+
+ "golang.org/x/website/internal/api"
+)
+
+// A Corpus holds all the state related to serving and indexing a
+// collection of Go code.
+//
+// Construct a new Corpus with NewCorpus, then modify options,
+// then call its Init method.
+type Corpus struct {
+ fs fs.FS
+
+ // Verbose logging.
+ Verbose bool
+
+ // Send a value on this channel to trigger a metadata refresh.
+ // It is buffered so that if a signal is not lost if sent
+ // during a refresh.
+ refreshMetadataSignal chan bool
+
+ // file system information
+ fsModified rwValue // timestamp of last call to invalidateIndex
+ docMetadata rwValue // mapping from paths to *Metadata
+
+ // flag to check whether a corpus is initialized or not
+ initMu sync.RWMutex
+ initDone bool
+
+ // pkgAPIInfo contains the information about which package API
+ // features were added in which version of Go.
+ pkgAPIInfo api.DB
+}
+
+// NewCorpus returns a new Corpus from a filesystem.
+// The returned corpus has all indexing enabled and MaxResults set to 1000.
+// Change or set any options on Corpus before calling the Corpus.Init method.
+func NewCorpus(fsys fs.FS) *Corpus {
+ c := &Corpus{
+ fs: fsys,
+ refreshMetadataSignal: make(chan bool, 1),
+ }
+ return c
+}
+
+func (c *Corpus) FSModifiedTime() time.Time {
+ _, ts := c.fsModified.Get()
+ return ts
+}
+
+// Init initializes Corpus, once options on Corpus are set.
+// It must be called before any subsequent method calls.
+func (c *Corpus) Init() error {
+ c.updateMetadata()
+ go c.refreshMetadataLoop()
+
+ c.initMu.Lock()
+ c.initDone = true
+ c.initMu.Unlock()
+ return nil
+}
diff --git a/internal/godoc/examplefuncs.go b/internal/godoc/examplefuncs.go
new file mode 100644
index 0000000..3d10fc1
--- /dev/null
+++ b/internal/godoc/examplefuncs.go
@@ -0,0 +1,209 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+package godoc
+
+import (
+ "bytes"
+ "go/ast"
+ "go/format"
+ "go/printer"
+ "log"
+ "regexp"
+ "strings"
+ "unicode/utf8"
+
+ "golang.org/x/website/internal/pkgdoc"
+)
+
+func (p *Presentation) example_htmlFunc(info *pkgdoc.Page, funcName string) string {
+ var buf bytes.Buffer
+ for _, eg := range info.Examples {
+ name := pkgdoc.TrimExampleSuffix(eg.Name)
+
+ if name != funcName {
+ continue
+ }
+
+ // print code
+ cnode := &printer.CommentedNode{Node: eg.Code, Comments: eg.Comments}
+ code := p.node_htmlFunc(info, cnode, true)
+ out := eg.Output
+ wholeFile := true
+
+ // Additional formatting if this is a function body.
+ if n := len(code); n >= 2 && code[0] == '{' && code[n-1] == '}' {
+ wholeFile = false
+ // remove surrounding braces
+ code = code[1 : n-1]
+ // unindent
+ code = replaceLeadingIndentation(code, strings.Repeat(" ", TabWidth), "")
+ // remove output comment
+ if loc := exampleOutputRx.FindStringIndex(code); loc != nil {
+ code = strings.TrimSpace(code[:loc[0]])
+ }
+ }
+
+ // Write out the playground code in standard Go style
+ // (use tabs, no comment highlight, etc).
+ play := ""
+ if eg.Play != nil {
+ var buf bytes.Buffer
+ eg.Play.Comments = filterOutBuildAnnotations(eg.Play.Comments)
+ if err := format.Node(&buf, info.FSet, eg.Play); err != nil {
+ log.Print(err)
+ } else {
+ play = buf.String()
+ }
+ }
+
+ // Drop output, as the output comment will appear in the code.
+ if wholeFile && play == "" {
+ out = ""
+ }
+
+ if p.ExampleHTML == nil {
+ out = ""
+ return ""
+ }
+
+ err := p.ExampleHTML.Execute(&buf, struct {
+ Name, Doc, Code, Play, Output string
+ GoogleCN bool
+ }{eg.Name, eg.Doc, code, play, out, info.GoogleCN})
+ if err != nil {
+ log.Print(err)
+ }
+ }
+ return buf.String()
+}
+
+// replaceLeadingIndentation replaces oldIndent at the beginning of each line
+// with newIndent. This is used for formatting examples. Raw strings that
+// span multiple lines are handled specially: oldIndent is not removed (since
+// go/printer will not add any indentation there), but newIndent is added
+// (since we may still want leading indentation).
+func replaceLeadingIndentation(body, oldIndent, newIndent string) string {
+ // Handle indent at the beginning of the first line. After this, we handle
+ // indentation only after a newline.
+ var buf bytes.Buffer
+ if strings.HasPrefix(body, oldIndent) {
+ buf.WriteString(newIndent)
+ body = body[len(oldIndent):]
+ }
+
+ // Use a state machine to keep track of whether we're in a string or
+ // rune literal while we process the rest of the code.
+ const (
+ codeState = iota
+ runeState
+ interpretedStringState
+ rawStringState
+ )
+ searchChars := []string{
+ "'\"`\n", // codeState
+ `\'`, // runeState
+ `\"`, // interpretedStringState
+ "`\n", // rawStringState
+ // newlineState does not need to search
+ }
+ state := codeState
+ for {
+ i := strings.IndexAny(body, searchChars[state])
+ if i < 0 {
+ buf.WriteString(body)
+ break
+ }
+ c := body[i]
+ buf.WriteString(body[:i+1])
+ body = body[i+1:]
+ switch state {
+ case codeState:
+ switch c {
+ case '\'':
+ state = runeState
+ case '"':
+ state = interpretedStringState
+ case '`':
+ state = rawStringState
+ case '\n':
+ if strings.HasPrefix(body, oldIndent) {
+ buf.WriteString(newIndent)
+ body = body[len(oldIndent):]
+ }
+ }
+
+ case runeState:
+ switch c {
+ case '\\':
+ r, size := utf8.DecodeRuneInString(body)
+ buf.WriteRune(r)
+ body = body[size:]
+ case '\'':
+ state = codeState
+ }
+
+ case interpretedStringState:
+ switch c {
+ case '\\':
+ r, size := utf8.DecodeRuneInString(body)
+ buf.WriteRune(r)
+ body = body[size:]
+ case '"':
+ state = codeState
+ }
+
+ case rawStringState:
+ switch c {
+ case '`':
+ state = codeState
+ case '\n':
+ buf.WriteString(newIndent)
+ }
+ }
+ }
+ return buf.String()
+}
+
+var exampleOutputRx = regexp.MustCompile(`(?i)//[[:space:]]*(unordered )?output:`)
+
+func filterOutBuildAnnotations(cg []*ast.CommentGroup) []*ast.CommentGroup {
+ if len(cg) == 0 {
+ return cg
+ }
+
+ for i := range cg {
+ if !strings.HasPrefix(cg[i].Text(), "+build ") {
+ // Found the first non-build tag, return from here until the end
+ // of the slice.
+ return cg[i:]
+ }
+ }
+
+ // There weren't any non-build tags, return an empty slice.
+ return []*ast.CommentGroup{}
+}
+
+// example_nameFunc takes an example function name and returns its display
+// name. For example, "Foo_Bar_quux" becomes "Foo.Bar (Quux)".
+func (p *Presentation) example_nameFunc(s string) string {
+ name, suffix := pkgdoc.SplitExampleName(s)
+ // replace _ with . for method names
+ name = strings.Replace(name, "_", ".", 1)
+ // use "Package" if no name provided
+ if name == "" {
+ name = "Package"
+ }
+ return name + suffix
+}
+
+// example_suffixFunc takes an example function name and returns its suffix in
+// parenthesized form. For example, "Foo_Bar_quux" becomes " (Quux)".
+func (p *Presentation) example_suffixFunc(name string) string {
+ _, suffix := pkgdoc.SplitExampleName(name)
+ return suffix
+}
diff --git a/internal/godoc/godoc.go b/internal/godoc/godoc.go
new file mode 100644
index 0000000..5b8ca55
--- /dev/null
+++ b/internal/godoc/godoc.go
@@ -0,0 +1,216 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+package godoc
+
+import (
+ "bytes"
+ "fmt"
+ "go/ast"
+ "go/doc"
+ "go/token"
+ "path"
+ "strconv"
+ "strings"
+ "text/template"
+
+ "golang.org/x/website/internal/history"
+ "golang.org/x/website/internal/pkgdoc"
+)
+
+// FuncMap defines template functions used in godoc templates.
+//
+// Convention: template function names ending in "_html" or "_url" produce
+// HTML- or URL-escaped strings; all other function results may
+// require explicit escaping in the template.
+func (p *Presentation) FuncMap() template.FuncMap {
+ p.initFuncMapOnce.Do(p.initFuncMap)
+ return p.funcMap
+}
+
+func (p *Presentation) TemplateFuncs() template.FuncMap {
+ p.initFuncMapOnce.Do(p.initFuncMap)
+ return p.templateFuncs
+}
+
+func (p *Presentation) initFuncMap() {
+ if p.Corpus == nil {
+ panic("nil Presentation.Corpus")
+ }
+ p.templateFuncs = template.FuncMap{
+ "code": p.code,
+ "releases": func() []*history.Major { return history.Majors },
+ }
+ p.funcMap = template.FuncMap{
+ // various helpers
+ "filename": filenameFunc,
+ "since": p.Corpus.pkgAPIInfo.Func,
+
+ // formatting of AST nodes
+ "node": p.nodeFunc,
+ "node_html": p.node_htmlFunc,
+ "comment_html": comment_htmlFunc,
+ "sanitize": sanitizeFunc,
+
+ // support for URL attributes
+ "pkgLink": pkgLinkFunc,
+ "srcLink": srcLinkFunc,
+ "posLink_url": posLink_urlFunc,
+ "docLink": docLinkFunc,
+ "queryLink": queryLinkFunc,
+ "srcBreadcrumb": srcBreadcrumbFunc,
+ "srcToPkgLink": srcToPkgLinkFunc,
+
+ // formatting of Examples
+ "example_html": p.example_htmlFunc,
+ "example_name": p.example_nameFunc,
+ "example_suffix": p.example_suffixFunc,
+
+ // Number operation
+ "multiply": multiply,
+
+ // formatting of PageInfoMode query string
+ "modeQueryString": modeQueryString,
+ }
+}
+
+func multiply(a, b int) int { return a * b }
+
+func filenameFunc(name string) string {
+ _, localname := path.Split(name)
+ return localname
+}
+
+func pkgLinkFunc(path string) string {
+ // because of the irregular mapping under goroot
+ // we need to correct certain relative paths
+ path = strings.TrimPrefix(path, "/")
+ path = strings.TrimPrefix(path, "src/")
+ path = strings.TrimPrefix(path, "pkg/")
+ return "pkg/" + path
+}
+
+// srcToPkgLinkFunc builds an <a> tag linking to the package
+// documentation of relpath.
+func srcToPkgLinkFunc(relpath string) string {
+ relpath = pkgLinkFunc(relpath)
+ relpath = path.Dir(relpath)
+ if relpath == "pkg" {
+ return `<a href="/pkg">Index</a>`
+ }
+ return fmt.Sprintf(`<a href="/%s">%s</a>`, relpath, relpath[len("pkg/"):])
+}
+
+// srcBreadcrumbFun converts each segment of relpath to a HTML <a>.
+// Each segment links to its corresponding src directories.
+func srcBreadcrumbFunc(relpath string) string {
+ segments := strings.Split(relpath, "/")
+ var buf bytes.Buffer
+ var selectedSegment string
+ var selectedIndex int
+
+ if strings.HasSuffix(relpath, "/") {
+ // relpath is a directory ending with a "/".
+ // Selected segment is the segment before the last slash.
+ selectedIndex = len(segments) - 2
+ selectedSegment = segments[selectedIndex] + "/"
+ } else {
+ selectedIndex = len(segments) - 1
+ selectedSegment = segments[selectedIndex]
+ }
+
+ for i := range segments[:selectedIndex] {
+ buf.WriteString(fmt.Sprintf(`<a href="/%s">%s</a>/`,
+ strings.Join(segments[:i+1], "/"),
+ segments[i],
+ ))
+ }
+
+ buf.WriteString(`<span class="text-muted">`)
+ buf.WriteString(selectedSegment)
+ buf.WriteString(`</span>`)
+ return buf.String()
+}
+
+func posLink_urlFunc(info *pkgdoc.Page, n interface{}) string {
+ // n must be an ast.Node or a *doc.Note
+ var pos, end token.Pos
+
+ switch n := n.(type) {
+ case ast.Node:
+ pos = n.Pos()
+ end = n.End()
+ case *doc.Note:
+ pos = n.Pos
+ end = n.End
+ default:
+ panic(fmt.Sprintf("wrong type for posLink_url template formatter: %T", n))
+ }
+
+ var relpath string
+ var line int
+ var low, high int // selection offset range
+
+ if pos.IsValid() {
+ p := info.FSet.Position(pos)
+ relpath = p.Filename
+ line = p.Line
+ low = p.Offset
+ }
+ if end.IsValid() {
+ high = info.FSet.Position(end).Offset
+ }
+
+ return srcPosLinkFunc(relpath, line, low, high)
+}
+
+func srcPosLinkFunc(s string, line, low, high int) string {
+ s = srcLinkFunc(s)
+ var buf bytes.Buffer
+ template.HTMLEscape(&buf, []byte(s))
+ // selection ranges are of form "s=low:high"
+ if low < high {
+ fmt.Fprintf(&buf, "?s=%d:%d", low, high) // no need for URL escaping
+ // if we have a selection, position the page
+ // such that the selection is a bit below the top
+ line -= 10
+ if line < 1 {
+ line = 1
+ }
+ }
+ // line id's in html-printed source are of the
+ // form "L%d" where %d stands for the line number
+ if line > 0 {
+ fmt.Fprintf(&buf, "#L%d", line) // no need for URL escaping
+ }
+ return buf.String()
+}
+
+func srcLinkFunc(s string) string {
+ s = path.Clean("/" + s)
+ if !strings.HasPrefix(s, "/src/") {
+ s = "/src" + s
+ }
+ return s
+}
+
+// queryLinkFunc returns a URL for a line in a source file with a highlighted
+// query term.
+// s is expected to be a path to a source file.
+// query is expected to be a string that has already been appropriately escaped
+// for use in a URL query.
+func queryLinkFunc(s, query string, line int) string {
+ url := path.Clean("/"+s) + "?h=" + query
+ if line > 0 {
+ url += "#L" + strconv.Itoa(line)
+ }
+ return url
+}
+
+func docLinkFunc(s string, ident string) string {
+ return path.Clean("/pkg/"+s) + "/#" + ident
+}
diff --git a/internal/godoc/godoc_test.go b/internal/godoc/godoc_test.go
new file mode 100644
index 0000000..74e472c
--- /dev/null
+++ b/internal/godoc/godoc_test.go
@@ -0,0 +1,377 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+package godoc
+
+import (
+ "bytes"
+ "fmt"
+ "go/parser"
+ "go/token"
+ "strings"
+ "testing"
+
+ "golang.org/x/website/internal/pkgdoc"
+)
+
+func TestPkgLinkFunc(t *testing.T) {
+ for _, tc := range []struct {
+ path string
+ want string
+ }{
+ {"/src/fmt", "pkg/fmt"},
+ {"src/fmt", "pkg/fmt"},
+ {"/fmt", "pkg/fmt"},
+ {"fmt", "pkg/fmt"},
+ } {
+ if got := pkgLinkFunc(tc.path); got != tc.want {
+ t.Errorf("pkgLinkFunc(%v) = %v; want %v", tc.path, got, tc.want)
+ }
+ }
+}
+
+func TestSrcPosLinkFunc(t *testing.T) {
+ for _, tc := range []struct {
+ src string
+ line int
+ low int
+ high int
+ want string
+ }{
+ {"/src/fmt/print.go", 42, 30, 50, "/src/fmt/print.go?s=30:50#L32"},
+ {"/src/fmt/print.go", 2, 1, 5, "/src/fmt/print.go?s=1:5#L1"},
+ {"/src/fmt/print.go", 2, 0, 0, "/src/fmt/print.go#L2"},
+ {"/src/fmt/print.go", 0, 0, 0, "/src/fmt/print.go"},
+ {"/src/fmt/print.go", 0, 1, 5, "/src/fmt/print.go?s=1:5#L1"},
+ {"fmt/print.go", 0, 0, 0, "/src/fmt/print.go"},
+ {"fmt/print.go", 0, 1, 5, "/src/fmt/print.go?s=1:5#L1"},
+ } {
+ if got := srcPosLinkFunc(tc.src, tc.line, tc.low, tc.high); got != tc.want {
+ t.Errorf("srcLinkFunc(%v, %v, %v, %v) = %v; want %v", tc.src, tc.line, tc.low, tc.high, got, tc.want)
+ }
+ }
+}
+
+func TestSrcLinkFunc(t *testing.T) {
+ for _, tc := range []struct {
+ src string
+ want string
+ }{
+ {"/src/fmt/print.go", "/src/fmt/print.go"},
+ {"src/fmt/print.go", "/src/fmt/print.go"},
+ {"/fmt/print.go", "/src/fmt/print.go"},
+ {"fmt/print.go", "/src/fmt/print.go"},
+ } {
+ if got := srcLinkFunc(tc.src); got != tc.want {
+ t.Errorf("srcLinkFunc(%v) = %v; want %v", tc.src, got, tc.want)
+ }
+ }
+}
+
+func TestQueryLinkFunc(t *testing.T) {
+ for _, tc := range []struct {
+ src string
+ query string
+ line int
+ want string
+ }{
+ {"/src/fmt/print.go", "Sprintf", 33, "/src/fmt/print.go?h=Sprintf#L33"},
+ {"/src/fmt/print.go", "Sprintf", 0, "/src/fmt/print.go?h=Sprintf"},
+ {"src/fmt/print.go", "EOF", 33, "/src/fmt/print.go?h=EOF#L33"},
+ {"src/fmt/print.go", "a%3f+%26b", 1, "/src/fmt/print.go?h=a%3f+%26b#L1"},
+ } {
+ if got := queryLinkFunc(tc.src, tc.query, tc.line); got != tc.want {
+ t.Errorf("queryLinkFunc(%v, %v, %v) = %v; want %v", tc.src, tc.query, tc.line, got, tc.want)
+ }
+ }
+}
+
+func TestDocLinkFunc(t *testing.T) {
+ for _, tc := range []struct {
+ src string
+ ident string
+ want string
+ }{
+ {"fmt", "Sprintf", "/pkg/fmt/#Sprintf"},
+ {"fmt", "EOF", "/pkg/fmt/#EOF"},
+ } {
+ if got := docLinkFunc(tc.src, tc.ident); got != tc.want {
+ t.Errorf("docLinkFunc(%v, %v) = %v; want %v", tc.src, tc.ident, got, tc.want)
+ }
+ }
+}
+
+func TestSanitizeFunc(t *testing.T) {
+ for _, tc := range []struct {
+ src string
+ want string
+ }{
+ {},
+ {"foo", "foo"},
+ {"func f()", "func f()"},
+ {"func f(a int,)", "func f(a int)"},
+ {"func f(a int,\n)", "func f(a int)"},
+ {"func f(\n\ta int,\n\tb int,\n\tc int,\n)", "func f(a int, b int, c int)"},
+ {" ( a, b, c ) ", "(a, b, c)"},
+ {"( a, b, c int, foo bar , )", "(a, b, c int, foo bar)"},
+ {"{ a, b}", "{a, b}"},
+ {"[ a, b]", "[a, b]"},
+ } {
+ if got := sanitizeFunc(tc.src); got != tc.want {
+ t.Errorf("sanitizeFunc(%v) = %v; want %v", tc.src, got, tc.want)
+ }
+ }
+}
+
+// Test that we add <span id="StructName.FieldName"> elements
+// to the HTML of struct fields.
+func TestStructFieldsIDAttributes(t *testing.T) {
+ got := linkifySource(t, []byte(`
+package foo
+
+type T struct {
+ NoDoc string
+
+ // Doc has a comment.
+ Doc string
+
+ // Opt, if non-nil, is an option.
+ Opt *int
+
+ // Опция - другое поле.
+ Опция bool
+}
+`))
+ want := `type T struct {
+<span id="T.NoDoc"></span> NoDoc <a href="/pkg/builtin/#string">string</a>
+
+<span id="T.Doc"></span> <span class="comment">// Doc has a comment.</span>
+ Doc <a href="/pkg/builtin/#string">string</a>
+
+<span id="T.Opt"></span> <span class="comment">// Opt, if non-nil, is an option.</span>
+ Opt *<a href="/pkg/builtin/#int">int</a>
+
+<span id="T.Опция"></span> <span class="comment">// Опция - другое поле.</span>
+ Опция <a href="/pkg/builtin/#bool">bool</a>
+}`
+ if got != want {
+ t.Errorf("got: %s\n\nwant: %s\n", got, want)
+ }
+}
+
+// Test that we add <span id="ConstName"> elements to the HTML
+// of definitions in const and var specs.
+func TestValueSpecIDAttributes(t *testing.T) {
+ got := linkifySource(t, []byte(`
+package foo
+
+const (
+ NoDoc string = "NoDoc"
+
+ // Doc has a comment
+ Doc = "Doc"
+
+ NoVal
+)`))
+ want := `const (
+ <span id="NoDoc">NoDoc</span> <a href="/pkg/builtin/#string">string</a> = "NoDoc"
+
+ <span class="comment">// Doc has a comment</span>
+ <span id="Doc">Doc</span> = "Doc"
+
+ <span id="NoVal">NoVal</span>
+)`
+ if got != want {
+ t.Errorf("got: %s\n\nwant: %s\n", got, want)
+ }
+}
+
+func TestCompositeLitLinkFields(t *testing.T) {
+ got := linkifySource(t, []byte(`
+package foo
+
+type T struct {
+ X int
+}
+
+var S T = T{X: 12}`))
+ want := `type T struct {
+<span id="T.X"></span> X <a href="/pkg/builtin/#int">int</a>
+}
+var <span id="S">S</span> <a href="#T">T</a> = <a href="#T">T</a>{<a href="#T.X">X</a>: 12}`
+ if got != want {
+ t.Errorf("got: %s\n\nwant: %s\n", got, want)
+ }
+}
+
+func TestFuncDeclNotLink(t *testing.T) {
+ // Function.
+ got := linkifySource(t, []byte(`
+package http
+
+func Get(url string) (resp *Response, err error)`))
+ want := `func Get(url <a href="/pkg/builtin/#string">string</a>) (resp *<a href="#Response">Response</a>, err <a href="/pkg/builtin/#error">error</a>)`
+ if got != want {
+ t.Errorf("got: %s\n\nwant: %s\n", got, want)
+ }
+
+ // Method.
+ got = linkifySource(t, []byte(`
+package http
+
+func (h Header) Get(key string) string`))
+ want = `func (h <a href="#Header">Header</a>) Get(key <a href="/pkg/builtin/#string">string</a>) <a href="/pkg/builtin/#string">string</a>`
+ if got != want {
+ t.Errorf("got: %s\n\nwant: %s\n", got, want)
+ }
+}
+
+func linkifySource(t *testing.T, src []byte) string {
+ p := &Presentation{}
+ fset := token.NewFileSet()
+ af, err := parser.ParseFile(fset, "foo.go", src, parser.ParseComments)
+ if err != nil {
+ t.Fatal(err)
+ }
+ var buf bytes.Buffer
+ pi := &pkgdoc.Page{
+ FSet: fset,
+ }
+ sep := ""
+ for _, decl := range af.Decls {
+ buf.WriteString(sep)
+ sep = "\n"
+ buf.WriteString(p.node_htmlFunc(pi, decl, true))
+ }
+ return buf.String()
+}
+
+func TestReplaceLeadingIndentation(t *testing.T) {
+ oldIndent := strings.Repeat(" ", 2)
+ newIndent := strings.Repeat(" ", 4)
+ tests := []struct {
+ src, want string
+ }{
+ {" foo\n bar\n baz", " foo\n bar\n baz"},
+ {" '`'\n '`'\n", " '`'\n '`'\n"},
+ {" '\\''\n '`'\n", " '\\''\n '`'\n"},
+ {" \"`\"\n \"`\"\n", " \"`\"\n \"`\"\n"},
+ {" `foo\n bar`", " `foo\n bar`"},
+ {" `foo\\`\n bar", " `foo\\`\n bar"},
+ {" '\\`'`foo\n bar", " '\\`'`foo\n bar"},
+ {
+ " if true {\n foo := `One\n \tTwo\nThree`\n }\n",
+ " if true {\n foo := `One\n \tTwo\n Three`\n }\n",
+ },
+ }
+ for _, tc := range tests {
+ if got := replaceLeadingIndentation(tc.src, oldIndent, newIndent); got != tc.want {
+ t.Errorf("replaceLeadingIndentation:\n%v\n---\nhave:\n%v\n---\nwant:\n%v\n",
+ tc.src, got, tc.want)
+ }
+ }
+}
+
+func TestSrcBreadcrumbFunc(t *testing.T) {
+ for _, tc := range []struct {
+ path string
+ want string
+ }{
+ {"src/", `<span class="text-muted">src/</span>`},
+ {"src/fmt/", `<a href="/src">src</a>/<span class="text-muted">fmt/</span>`},
+ {"src/fmt/print.go", `<a href="/src">src</a>/<a href="/src/fmt">fmt</a>/<span class="text-muted">print.go</span>`},
+ } {
+ if got := srcBreadcrumbFunc(tc.path); got != tc.want {
+ t.Errorf("srcBreadcrumbFunc(%v) = %v; want %v", tc.path, got, tc.want)
+ }
+ }
+}
+
+func TestSrcToPkgLinkFunc(t *testing.T) {
+ for _, tc := range []struct {
+ path string
+ want string
+ }{
+ {"src/", `<a href="/pkg">Index</a>`},
+ {"src/fmt/", `<a href="/pkg/fmt">fmt</a>`},
+ {"pkg/", `<a href="/pkg">Index</a>`},
+ {"pkg/LICENSE", `<a href="/pkg">Index</a>`},
+ } {
+ if got := srcToPkgLinkFunc(tc.path); got != tc.want {
+ t.Errorf("srcToPkgLinkFunc(%v) = %v; want %v", tc.path, got, tc.want)
+ }
+ }
+}
+
+func TestFilterOutBuildAnnotations(t *testing.T) {
+ // TODO: simplify this by using a multiline string once we stop
+ // using go vet from 1.10 on the build dashboard.
+ // https://golang.org/issue/26627
+ src := []byte("// +build !foo\n" +
+ "// +build !anothertag\n" +
+ "\n" +
+ "// non-tag comment\n" +
+ "\n" +
+ "package foo\n" +
+ "\n" +
+ "func bar() int {\n" +
+ " return 42\n" +
+ "}\n")
+
+ fset := token.NewFileSet()
+ af, err := parser.ParseFile(fset, "foo.go", src, parser.ParseComments)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ var found bool
+ for _, cg := range af.Comments {
+ if strings.HasPrefix(cg.Text(), "+build ") {
+ found = true
+ break
+ }
+ }
+ if !found {
+ t.Errorf("TestFilterOutBuildAnnotations is broken: missing build tag in test input")
+ }
+
+ found = false
+ for _, cg := range filterOutBuildAnnotations(af.Comments) {
+ if strings.HasPrefix(cg.Text(), "+build ") {
+ t.Errorf("filterOutBuildAnnotations failed to filter build tag")
+ }
+
+ if strings.Contains(cg.Text(), "non-tag comment") {
+ found = true
+ }
+ }
+ if !found {
+ t.Errorf("filterOutBuildAnnotations should not remove non-build tag comment")
+ }
+}
+
+// Verify that scanIdentifier isn't quadratic.
+// This doesn't actually measure and fail on its own, but it was previously
+// very obvious when running by hand.
+//
+// TODO: if there's a reliable and non-flaky way to test this, do so.
+// Maybe count user CPU time instead of wall time? But that's not easy
+// to do portably in Go.
+func TestStructField(t *testing.T) {
+ for _, n := range []int{10, 100, 1000, 10000} {
+ n := n
+ t.Run(fmt.Sprint(n), func(t *testing.T) {
+ var buf bytes.Buffer
+ fmt.Fprintf(&buf, "package foo\n\ntype T struct {\n")
+ for i := 0; i < n; i++ {
+ fmt.Fprintf(&buf, "\t// Field%d is foo.\n\tField%d int\n\n", i, i)
+ }
+ fmt.Fprintf(&buf, "}\n")
+ linkifySource(t, buf.Bytes())
+ })
+ }
+}
diff --git a/internal/godoc/markdown.go b/internal/godoc/markdown.go
new file mode 100644
index 0000000..9149bca
--- /dev/null
+++ b/internal/godoc/markdown.go
@@ -0,0 +1,34 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+package godoc
+
+import (
+ "bytes"
+
+ "github.com/yuin/goldmark"
+ "github.com/yuin/goldmark/parser"
+ "github.com/yuin/goldmark/renderer/html"
+)
+
+// renderMarkdown converts a limited and opinionated flavor of Markdown (compliant with
+// CommonMark 0.29) to HTML for the purposes of Go websites.
+//
+// The Markdown source may contain raw HTML,
+// but Go templates have already been processed.
+func renderMarkdown(src []byte) ([]byte, error) {
+ // parser.WithHeadingAttribute allows custom ids on headings.
+ // html.WithUnsafe allows use of raw HTML, which we need for tables.
+ md := goldmark.New(
+ goldmark.WithParserOptions(parser.WithHeadingAttribute()),
+ goldmark.WithRendererOptions(html.WithUnsafe()))
+ var buf bytes.Buffer
+ if err := md.Convert(src, &buf); err != nil {
+ return nil, err
+ }
+ return buf.Bytes(), nil
+}
diff --git a/internal/godoc/meta.go b/internal/godoc/meta.go
new file mode 100644
index 0000000..14ff6b8
--- /dev/null
+++ b/internal/godoc/meta.go
@@ -0,0 +1,163 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+package godoc
+
+import (
+ "bytes"
+ "encoding/json"
+ "errors"
+ "io/fs"
+ "log"
+ "os"
+ "path"
+ "strings"
+ "time"
+)
+
+var (
+ doctype = []byte("<!DOCTYPE ")
+ jsonStart = []byte("<!--{")
+ jsonEnd = []byte("}-->")
+)
+
+// ----------------------------------------------------------------------------
+// Documentation Metadata
+
+type Metadata struct {
+ // These fields can be set in the JSON header at the top of a doc.
+ Title string
+ Subtitle string
+ Template bool // execute as template
+ Path string // canonical path for this page
+ AltPaths []string // redirect these other paths to this page
+
+ // These are internal to the implementation.
+ filePath string // filesystem path relative to goroot
+}
+
+func (m *Metadata) FilePath() string { return m.filePath }
+
+// extractMetadata extracts the Metadata from a byte slice.
+// It returns the Metadata value and the remaining data.
+// If no metadata is present the original byte slice is returned.
+//
+func extractMetadata(b []byte) (meta Metadata, tail []byte, err error) {
+ tail = b
+ if !bytes.HasPrefix(b, jsonStart) {
+ return
+ }
+ end := bytes.Index(b, jsonEnd)
+ if end < 0 {
+ return
+ }
+ b = b[len(jsonStart)-1 : end+1] // drop leading <!-- and include trailing }
+ if err = json.Unmarshal(b, &meta); err != nil {
+ return
+ }
+ tail = tail[end+len(jsonEnd):]
+ return
+}
+
+// UpdateMetadata scans $GOROOT/doc for HTML and Markdown files, reads their metadata,
+// and updates the DocMetadata map.
+func (c *Corpus) updateMetadata() {
+ metadata := make(map[string]*Metadata)
+ var scan func(string) // scan is recursive
+ scan = func(dir string) {
+ fis, err := fs.ReadDir(c.fs, toFS(dir))
+ if err != nil {
+ if dir == "/doc" && errors.Is(err, os.ErrNotExist) {
+ // Be quiet during tests that don't have a /doc tree.
+ return
+ }
+ log.Printf("updateMetadata %s: %v", dir, err)
+ return
+ }
+ for _, fi := range fis {
+ name := path.Join(dir, fi.Name())
+ if fi.IsDir() {
+ scan(name) // recurse
+ continue
+ }
+ if !strings.HasSuffix(name, ".html") && !strings.HasSuffix(name, ".md") {
+ continue
+ }
+ // Extract metadata from the file.
+ b, err := fs.ReadFile(c.fs, toFS(name))
+ if err != nil {
+ log.Printf("updateMetadata %s: %v", name, err)
+ continue
+ }
+ meta, _, err := extractMetadata(b)
+ if err != nil {
+ log.Printf("updateMetadata: %s: %v", name, err)
+ continue
+ }
+ // Present all .md as if they were .html,
+ // so that it doesn't matter which one a page is written in.
+ if strings.HasSuffix(name, ".md") {
+ name = strings.TrimSuffix(name, ".md") + ".html"
+ }
+ // Store relative filesystem path in Metadata.
+ meta.filePath = name
+ if meta.Path == "" {
+ // If no Path, canonical path is actual path with .html removed.
+ meta.Path = strings.TrimSuffix(name, ".html")
+ }
+ // Store under both paths.
+ metadata[meta.Path] = &meta
+ metadata[meta.filePath] = &meta
+ for _, path := range meta.AltPaths {
+ metadata[path] = &meta
+ }
+ }
+ }
+ scan("/doc")
+ c.docMetadata.Set(metadata)
+}
+
+// MetadataFor returns the *Metadata for a given relative path or nil if none
+// exists.
+//
+func (c *Corpus) MetadataFor(relpath string) *Metadata {
+ if m, _ := c.docMetadata.Get(); m != nil {
+ meta := m.(map[string]*Metadata)
+ // If metadata for this relpath exists, return it.
+ if p := meta[relpath]; p != nil {
+ return p
+ }
+ // Try with or without trailing slash.
+ if strings.HasSuffix(relpath, "/") {
+ relpath = relpath[:len(relpath)-1]
+ } else {
+ relpath = relpath + "/"
+ }
+ return meta[relpath]
+ }
+ return nil
+}
+
+// refreshMetadata sends a signal to update DocMetadata. If a refresh is in
+// progress the metadata will be refreshed again afterward.
+//
+func (c *Corpus) refreshMetadata() {
+ select {
+ case c.refreshMetadataSignal <- true:
+ default:
+ }
+}
+
+// RefreshMetadataLoop runs forever, updating DocMetadata when the underlying
+// file system changes. It should be launched in a goroutine.
+func (c *Corpus) refreshMetadataLoop() {
+ for {
+ <-c.refreshMetadataSignal
+ c.updateMetadata()
+ time.Sleep(10 * time.Second) // at most once every 10 seconds
+ }
+}
diff --git a/internal/godoc/page.go b/internal/godoc/page.go
new file mode 100644
index 0000000..6c06ba5
--- /dev/null
+++ b/internal/godoc/page.go
@@ -0,0 +1,58 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+package godoc
+
+import (
+ "net/http"
+ "os"
+ "path/filepath"
+ "runtime"
+)
+
+// Page describes the contents of the top-level godoc webpage.
+type Page struct {
+ Title string
+ Tabtitle string
+ Subtitle string
+ SrcPath string
+ Query string
+ Body []byte
+ GoogleCN bool // page is being served from golang.google.cn
+
+ // filled in by ServePage
+ Version string
+ GoogleAnalytics string
+}
+
+func (p *Presentation) ServePage(w http.ResponseWriter, page Page) {
+ if page.Tabtitle == "" {
+ page.Tabtitle = page.Title
+ }
+ page.Version = runtime.Version()
+ page.GoogleAnalytics = p.GoogleAnalytics
+ applyTemplateToResponseWriter(w, p.GodocHTML, page)
+}
+
+func (p *Presentation) ServeError(w http.ResponseWriter, r *http.Request, relpath string, err error) {
+ w.WriteHeader(http.StatusNotFound)
+ if perr, ok := err.(*os.PathError); ok {
+ rel, err := filepath.Rel(runtime.GOROOT(), perr.Path)
+ if err != nil {
+ perr.Path = "REDACTED"
+ } else {
+ perr.Path = filepath.Join("$GOROOT", rel)
+ }
+ }
+ p.ServePage(w, Page{
+ Title: "File " + relpath,
+ Subtitle: relpath,
+ Body: applyTemplate(p.ErrorHTML, "errorHTML", err),
+ GoogleCN: p.googleCN(r),
+ GoogleAnalytics: p.GoogleAnalytics,
+ })
+}
diff --git a/internal/godoc/pres.go b/internal/godoc/pres.go
new file mode 100644
index 0000000..4aaa41b
--- /dev/null
+++ b/internal/godoc/pres.go
@@ -0,0 +1,75 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+package godoc
+
+import (
+ "net/http"
+ "sync"
+ "text/template"
+
+ "golang.org/x/website/internal/pkgdoc"
+)
+
+// Presentation generates output from a corpus.
+type Presentation struct {
+ Corpus *Corpus
+
+ mux *http.ServeMux
+ fileServer http.Handler
+
+ DirlistHTML,
+ ErrorHTML,
+ ExampleHTML,
+ GodocHTML,
+ PackageHTML,
+ PackageRootHTML *template.Template
+
+ // GoogleCN reports whether this request should be marked GoogleCN.
+ // If the function is nil, no requests are marked GoogleCN.
+ GoogleCN func(*http.Request) bool
+
+ // GoogleAnalytics optionally adds Google Analytics via the provided
+ // tracking ID to each page.
+ GoogleAnalytics string
+
+ initFuncMapOnce sync.Once
+ funcMap template.FuncMap
+ templateFuncs template.FuncMap
+}
+
+// NewPresentation returns a new Presentation from a corpus.
+func NewPresentation(c *Corpus) *Presentation {
+ if c == nil {
+ panic("nil Corpus")
+ }
+ p := &Presentation{
+ Corpus: c,
+ mux: http.NewServeMux(),
+ fileServer: http.FileServer(http.FS(c.fs)),
+ }
+ docs := &docServer{
+ p: p,
+ d: pkgdoc.NewDocs(c.fs),
+ }
+ p.mux.Handle("/cmd/", docs)
+ p.mux.Handle("/pkg/", docs)
+ p.mux.HandleFunc("/", p.ServeFile)
+ return p
+}
+
+func (p *Presentation) FileServer() http.Handler {
+ return p.fileServer
+}
+
+func (p *Presentation) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+ p.mux.ServeHTTP(w, r)
+}
+
+func (p *Presentation) googleCN(r *http.Request) bool {
+ return p.GoogleCN != nil && p.GoogleCN(r)
+}
diff --git a/internal/godoc/server.go b/internal/godoc/server.go
new file mode 100644
index 0000000..883ef0f
--- /dev/null
+++ b/internal/godoc/server.go
@@ -0,0 +1,433 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+package godoc
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+ htmlpkg "html"
+ "io"
+ "io/fs"
+ "log"
+ "net/http"
+ "path"
+ "regexp"
+ "strconv"
+ "strings"
+ "text/template"
+
+ "golang.org/x/website/internal/pkgdoc"
+ "golang.org/x/website/internal/spec"
+ "golang.org/x/website/internal/texthtml"
+)
+
+// toFS returns the io/fs name for path (no leading slash).
+func toFS(name string) string {
+ if name == "/" {
+ return "."
+ }
+ return path.Clean(strings.TrimPrefix(name, "/"))
+}
+
+// docServer serves a package doc tree (/cmd or /pkg).
+type docServer struct {
+ p *Presentation
+ d *pkgdoc.Docs
+}
+
+func (h *docServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+ if redirect(w, r) {
+ return
+ }
+
+ // TODO(rsc): URL should be clean already.
+ relpath := path.Clean(strings.TrimPrefix(r.URL.Path, "/pkg/"))
+
+ abspath := path.Join("/src", relpath)
+ mode := pkgdoc.ParseMode(r.FormValue("m"))
+ if relpath == "builtin" {
+ // The fake built-in package contains unexported identifiers,
+ // but we want to show them. Also, disable type association,
+ // since it's not helpful for this fake package (see issue 6645).
+ mode |= pkgdoc.ModeAll | pkgdoc.ModeBuiltin
+ }
+ info := pkgdoc.Doc(h.d, abspath, relpath, mode, r.FormValue("GOOS"), r.FormValue("GOARCH"))
+ if info.Err != nil {
+ log.Print(info.Err)
+ h.p.ServeError(w, r, relpath, info.Err)
+ return
+ }
+
+ var tabtitle, title, subtitle string
+ switch {
+ case info.PAst != nil:
+ for _, ast := range info.PAst {
+ tabtitle = ast.Name.Name
+ break
+ }
+ case info.PDoc != nil:
+ tabtitle = info.PDoc.Name
+ default:
+ tabtitle = info.Dirname
+ title = "Directory "
+ }
+ if title == "" {
+ if info.IsMain {
+ // assume that the directory name is the command name
+ _, tabtitle = path.Split(relpath)
+ title = "Command "
+ } else {
+ title = "Package "
+ }
+ }
+ title += tabtitle
+
+ // special cases for top-level package/command directories
+ switch tabtitle {
+ case "/src":
+ title = "Packages"
+ tabtitle = "Packages"
+ case "/src/cmd":
+ title = "Commands"
+ tabtitle = "Commands"
+ }
+
+ info.GoogleCN = h.p.googleCN(r)
+ var body []byte
+ if info.Dirname == "/src" {
+ body = applyTemplate(h.p.PackageRootHTML, "packageRootHTML", info)
+ } else {
+ body = applyTemplate(h.p.PackageHTML, "packageHTML", info)
+ }
+ h.p.ServePage(w, Page{
+ Title: title,
+ Tabtitle: tabtitle,
+ Subtitle: subtitle,
+ Body: body,
+ GoogleCN: info.GoogleCN,
+ })
+}
+
+func modeQueryString(m pkgdoc.Mode) string {
+ s := m.String()
+ if s == "" {
+ return ""
+ }
+ return "?m=" + s
+}
+
+func applyTemplate(t *template.Template, name string, data interface{}) []byte {
+ var buf bytes.Buffer
+ if err := t.Execute(&buf, data); err != nil {
+ log.Printf("%s.Execute: %s", name, err)
+ }
+ return buf.Bytes()
+}
+
+type writerCapturesErr struct {
+ w io.Writer
+ err error
+}
+
+func (w *writerCapturesErr) Write(p []byte) (int, error) {
+ n, err := w.w.Write(p)
+ if err != nil {
+ w.err = err
+ }
+ return n, err
+}
+
+// applyTemplateToResponseWriter uses an http.ResponseWriter as the io.Writer
+// for the call to template.Execute. It uses an io.Writer wrapper to capture
+// errors from the underlying http.ResponseWriter. Errors are logged only when
+// they come from the template processing and not the Writer; this avoid
+// polluting log files with error messages due to networking issues, such as
+// client disconnects and http HEAD protocol violations.
+func applyTemplateToResponseWriter(rw http.ResponseWriter, t *template.Template, data interface{}) {
+ w := &writerCapturesErr{w: rw}
+ err := t.Execute(w, data)
+ // There are some cases where template.Execute does not return an error when
+ // rw returns an error, and some where it does. So check w.err first.
+ if w.err == nil && err != nil {
+ // Log template errors.
+ log.Printf("%s.Execute: %s", t.Name(), err)
+ }
+}
+
+func redirect(w http.ResponseWriter, r *http.Request) (redirected bool) {
+ canonical := path.Clean(r.URL.Path)
+ if !strings.HasSuffix(canonical, "/") {
+ canonical += "/"
+ }
+ if r.URL.Path != canonical {
+ url := *r.URL
+ url.Path = canonical
+ http.Redirect(w, r, url.String(), http.StatusMovedPermanently)
+ redirected = true
+ }
+ return
+}
+
+func redirectFile(w http.ResponseWriter, r *http.Request) (redirected bool) {
+ c := path.Clean(r.URL.Path)
+ c = strings.TrimRight(c, "/")
+ if r.URL.Path != c {
+ url := *r.URL
+ url.Path = c
+ http.Redirect(w, r, url.String(), http.StatusMovedPermanently)
+ redirected = true
+ }
+ return
+}
+
+var selRx = regexp.MustCompile(`^([0-9]+):([0-9]+)`)
+
+// rangeSelection computes the Selection for a text range described
+// by the argument str, of the form Start:End, where Start and End
+// are decimal byte offsets.
+func rangeSelection(str string) texthtml.Selection {
+ m := selRx.FindStringSubmatch(str)
+ if len(m) >= 2 {
+ from, _ := strconv.Atoi(m[1])
+ to, _ := strconv.Atoi(m[2])
+ if from < to {
+ return texthtml.Spans(texthtml.Span{Start: from, End: to})
+ }
+ }
+ return nil
+}
+
+func (p *Presentation) serveTextFile(w http.ResponseWriter, r *http.Request, abspath, relpath, title string) {
+ src, err := fs.ReadFile(p.Corpus.fs, toFS(abspath))
+ if err != nil {
+ log.Printf("ReadFile: %s", err)
+ p.ServeError(w, r, relpath, err)
+ return
+ }
+
+ if r.FormValue("m") == "text" {
+ p.ServeText(w, src)
+ return
+ }
+
+ cfg := texthtml.Config{
+ GoComments: path.Ext(abspath) == ".go",
+ Highlight: r.FormValue("h"),
+ Selection: rangeSelection(r.FormValue("s")),
+ Line: 1,
+ }
+
+ var buf bytes.Buffer
+ buf.WriteString("<pre>")
+ buf.Write(texthtml.Format(src, cfg))
+ buf.WriteString("</pre>")
+
+ fmt.Fprintf(&buf, `<p><a href="/%s?m=text">View as plain text</a></p>`, htmlpkg.EscapeString(relpath))
+
+ p.ServePage(w, Page{
+ Title: title,
+ SrcPath: relpath,
+ Tabtitle: relpath,
+ Body: buf.Bytes(),
+ GoogleCN: p.googleCN(r),
+ })
+}
+
+func (p *Presentation) serveDirectory(w http.ResponseWriter, r *http.Request, abspath, relpath string) {
+ if redirect(w, r) {
+ return
+ }
+
+ list, err := fs.ReadDir(p.Corpus.fs, toFS(abspath))
+ if err != nil {
+ p.ServeError(w, r, relpath, err)
+ return
+ }
+
+ var info []fs.FileInfo
+ for _, d := range list {
+ i, err := d.Info()
+ if err == nil {
+ info = append(info, i)
+ }
+ }
+
+ p.ServePage(w, Page{
+ Title: "Directory",
+ SrcPath: relpath,
+ Tabtitle: relpath,
+ Body: applyTemplate(p.DirlistHTML, "dirlistHTML", info),
+ GoogleCN: p.googleCN(r),
+ })
+}
+
+func (p *Presentation) ServeHTMLDoc(w http.ResponseWriter, r *http.Request, abspath, relpath string) {
+ // get HTML body contents
+ isMarkdown := false
+ src, err := fs.ReadFile(p.Corpus.fs, toFS(abspath))
+ if err != nil && strings.HasSuffix(abspath, ".html") {
+ if md, errMD := fs.ReadFile(p.Corpus.fs, toFS(strings.TrimSuffix(abspath, ".html")+".md")); errMD == nil {
+ src = md
+ isMarkdown = true
+ err = nil
+ }
+ }
+ if err != nil {
+ log.Printf("ReadFile: %s", err)
+ p.ServeError(w, r, relpath, err)
+ return
+ }
+
+ // if it begins with "<!DOCTYPE " assume it is standalone
+ // html that doesn't need the template wrapping.
+ if bytes.HasPrefix(src, doctype) {
+ w.Write(src)
+ return
+ }
+
+ // if it begins with a JSON blob, read in the metadata.
+ meta, src, err := extractMetadata(src)
+ if err != nil {
+ log.Printf("decoding metadata %s: %v", relpath, err)
+ }
+
+ page := Page{
+ Title: meta.Title,
+ Subtitle: meta.Subtitle,
+ GoogleCN: p.googleCN(r),
+ }
+
+ // evaluate as template if indicated
+ if meta.Template {
+ tmpl, err := template.New("main").Funcs(p.TemplateFuncs()).Parse(string(src))
+ if err != nil {
+ log.Printf("parsing template %s: %v", relpath, err)
+ p.ServeError(w, r, relpath, err)
+ return
+ }
+ var buf bytes.Buffer
+ if err := tmpl.Execute(&buf, page); err != nil {
+ log.Printf("executing template %s: %v", relpath, err)
+ p.ServeError(w, r, relpath, err)
+ return
+ }
+ src = buf.Bytes()
+ }
+
+ // Apply markdown as indicated.
+ // (Note template applies before Markdown.)
+ if isMarkdown {
+ html, err := renderMarkdown(src)
+ if err != nil {
+ log.Printf("executing markdown %s: %v", relpath, err)
+ p.ServeError(w, r, relpath, err)
+ return
+ }
+ src = html
+ }
+
+ // if it's the language spec, add tags to EBNF productions
+ if strings.HasSuffix(abspath, "go_spec.html") {
+ var buf bytes.Buffer
+ spec.Linkify(&buf, src)
+ src = buf.Bytes()
+ }
+
+ page.Body = src
+ p.ServePage(w, page)
+}
+
+func (p *Presentation) ServeFile(w http.ResponseWriter, r *http.Request) {
+ p.serveFile(w, r)
+}
+
+func (p *Presentation) serveFile(w http.ResponseWriter, r *http.Request) {
+ if strings.HasSuffix(r.URL.Path, "/index.html") {
+ // We'll show index.html for the directory.
+ // Use the dir/ version as canonical instead of dir/index.html.
+ http.Redirect(w, r, r.URL.Path[0:len(r.URL.Path)-len("index.html")], http.StatusMovedPermanently)
+ return
+ }
+
+ // Check to see if we need to redirect or serve another file.
+ relpath := r.URL.Path
+ if m := p.Corpus.MetadataFor(relpath); m != nil {
+ if m.Path != relpath {
+ // Redirect to canonical path.
+ http.Redirect(w, r, m.Path, http.StatusMovedPermanently)
+ return
+ }
+ // Serve from the actual filesystem path.
+ relpath = m.filePath
+ }
+
+ abspath := relpath
+ relpath = relpath[1:] // strip leading slash
+
+ switch path.Ext(relpath) {
+ case ".html":
+ p.ServeHTMLDoc(w, r, abspath, relpath)
+ return
+
+ case ".go":
+ p.serveTextFile(w, r, abspath, relpath, "Source file")
+ return
+ }
+
+ dir, err := fs.Stat(p.Corpus.fs, toFS(abspath))
+ if err != nil {
+ log.Print(err)
+ p.ServeError(w, r, relpath, err)
+ return
+ }
+
+ fsPath := toFS(abspath)
+ if dir != nil && dir.IsDir() {
+ if redirect(w, r) {
+ return
+ }
+ index := path.Join(fsPath, "index.html")
+ if isTextFile(p.Corpus.fs, index) || isTextFile(p.Corpus.fs, path.Join(fsPath, "index.md")) {
+ p.ServeHTMLDoc(w, r, index, index)
+ return
+ }
+ p.serveDirectory(w, r, abspath, relpath)
+ return
+ }
+
+ if isTextFile(p.Corpus.fs, fsPath) {
+ if redirectFile(w, r) {
+ return
+ }
+ p.serveTextFile(w, r, abspath, relpath, "Text file")
+ return
+ }
+
+ p.fileServer.ServeHTTP(w, r)
+}
+
+func (p *Presentation) ServeText(w http.ResponseWriter, text []byte) {
+ w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+ w.Write(text)
+}
+
+func marshalJSON(x interface{}) []byte {
+ var data []byte
+ var err error
+ const indentJSON = false // for easier debugging
+ if indentJSON {
+ data, err = json.MarshalIndent(x, "", " ")
+ } else {
+ data, err = json.Marshal(x)
+ }
+ if err != nil {
+ panic(fmt.Sprintf("json.Marshal failed: %s", err))
+ }
+ return data
+}
diff --git a/internal/godoc/server_test.go b/internal/godoc/server_test.go
new file mode 100644
index 0000000..a0ca02b
--- /dev/null
+++ b/internal/godoc/server_test.go
@@ -0,0 +1,75 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+package godoc
+
+import (
+ "net/http"
+ "net/http/httptest"
+ "net/url"
+ "strings"
+ "testing"
+ "testing/fstest"
+ "text/template"
+)
+
+func testServeBody(t *testing.T, p *Presentation, path, body string) {
+ t.Helper()
+ r := &http.Request{URL: &url.URL{Path: path}}
+ rw := httptest.NewRecorder()
+ p.ServeFile(rw, r)
+ if rw.Code != 200 || !strings.Contains(rw.Body.String(), body) {
+ t.Fatalf("GET %s: expected 200 w/ %q: got %d w/ body:\n%s",
+ path, body, rw.Code, rw.Body)
+ }
+}
+
+func TestRedirectAndMetadata(t *testing.T) {
+ c := NewCorpus(fstest.MapFS{
+ "doc/y/index.html": {Data: []byte("Hello, y.")},
+ "doc/x/index.html": {Data: []byte(`<!--{
+ "Path": "/doc/x/"
+}-->
+
+Hello, x.
+`)},
+ })
+ c.updateMetadata()
+ p := &Presentation{
+ Corpus: c,
+ GodocHTML: template.Must(template.New("").Parse(`{{printf "%s" .Body}}`)),
+ }
+
+ // Test that redirect is sent back correctly.
+ // Used to panic. See golang.org/issue/40665.
+ for _, elem := range []string{"x", "y"} {
+ dir := "/doc/" + elem + "/"
+
+ r := &http.Request{URL: &url.URL{Path: dir + "index.html"}}
+ rw := httptest.NewRecorder()
+ p.ServeFile(rw, r)
+ loc := rw.Result().Header.Get("Location")
+ if rw.Code != 301 || loc != dir {
+ t.Errorf("GET %s: expected 301 -> %q, got %d -> %q", r.URL.Path, dir, rw.Code, loc)
+ }
+
+ testServeBody(t, p, dir, "Hello, "+elem)
+ }
+}
+
+func TestMarkdown(t *testing.T) {
+ p := &Presentation{
+ Corpus: NewCorpus(fstest.MapFS{
+ "doc/test.md": {Data: []byte("**bold**")},
+ "doc/test2.md": {Data: []byte(`{{"*template*"}}`)},
+ }),
+ GodocHTML: template.Must(template.New("").Parse(`{{printf "%s" .Body}}`)),
+ }
+
+ testServeBody(t, p, "/doc/test.html", "<strong>bold</strong>")
+ testServeBody(t, p, "/doc/test2.html", "<em>template</em>")
+}
diff --git a/internal/godoc/tab.go b/internal/godoc/tab.go
new file mode 100644
index 0000000..17fe293
--- /dev/null
+++ b/internal/godoc/tab.go
@@ -0,0 +1,89 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+package godoc
+
+import "io"
+
+var spaces = []byte(" ") // 32 spaces seems like a good number
+
+const (
+ indenting = iota
+ collecting
+)
+
+// TabSpacer returns a writer that passes writes through to w,
+// expanding tabs to one or more spaces ending at a width-spaces-aligned boundary.
+func TabSpacer(w io.Writer, width int) io.Writer {
+ return &tconv{output: w, tabWidth: width}
+}
+
+// A tconv is an io.Writer filter for converting leading tabs into spaces.
+type tconv struct {
+ output io.Writer
+ state int // indenting or collecting
+ indent int // valid if state == indenting
+ tabWidth int
+}
+
+func (t *tconv) writeIndent() (err error) {
+ i := t.indent
+ for i >= len(spaces) {
+ i -= len(spaces)
+ if _, err = t.output.Write(spaces); err != nil {
+ return
+ }
+ }
+ // i < len(spaces)
+ if i > 0 {
+ _, err = t.output.Write(spaces[0:i])
+ }
+ return
+}
+
+func (t *tconv) Write(data []byte) (n int, err error) {
+ if len(data) == 0 {
+ return
+ }
+ pos := 0 // valid if p.state == collecting
+ var b byte
+ for n, b = range data {
+ switch t.state {
+ case indenting:
+ switch b {
+ case '\t':
+ t.indent += t.tabWidth
+ case '\n':
+ t.indent = 0
+ if _, err = t.output.Write(data[n : n+1]); err != nil {
+ return
+ }
+ case ' ':
+ t.indent++
+ default:
+ t.state = collecting
+ pos = n
+ if err = t.writeIndent(); err != nil {
+ return
+ }
+ }
+ case collecting:
+ if b == '\n' {
+ t.state = indenting
+ t.indent = 0
+ if _, err = t.output.Write(data[pos : n+1]); err != nil {
+ return
+ }
+ }
+ }
+ }
+ n = len(data)
+ if pos < n && t.state == collecting {
+ _, err = t.output.Write(data[pos:])
+ }
+ return
+}
diff --git a/internal/godoc/template.go b/internal/godoc/template.go
new file mode 100644
index 0000000..5baa140
--- /dev/null
+++ b/internal/godoc/template.go
@@ -0,0 +1,183 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+// Template support for writing HTML documents.
+// Documents that include Template: true in their
+// metadata are executed as input to text/template.
+//
+// This file defines functions for those templates to invoke.
+
+// The template uses the function "code" to inject program
+// source into the output by extracting code from files and
+// injecting them as HTML-escaped <pre> blocks.
+//
+// The syntax is simple: 1, 2, or 3 space-separated arguments:
+//
+// Whole file:
+// {{code "foo.go"}}
+// One line (here the signature of main):
+// {{code "foo.go" `/^func.main/`}}
+// Block of text, determined by start and end (here the body of main):
+// {{code "foo.go" `/^func.main/` `/^}/`
+//
+// Patterns can be `/regular expression/`, a decimal number, or "$"
+// to signify the end of the file. In multi-line matches,
+// lines that end with the four characters
+// OMIT
+// are omitted from the output, making it easy to provide marker
+// lines in the input that will not appear in the output but are easy
+// to identify by pattern.
+
+package godoc
+
+import (
+ "bytes"
+ "fmt"
+ "io/fs"
+ "log"
+ "regexp"
+ "strings"
+
+ "golang.org/x/website/internal/texthtml"
+)
+
+// Functions in this file panic on error, but the panic is recovered
+// to an error by 'code'.
+
+// contents reads and returns the content of the named file
+// (from the virtual file system, so for example /doc refers to $GOROOT/doc).
+func (c *Corpus) contents(name string) string {
+ file, err := fs.ReadFile(c.fs, toFS(name))
+ if err != nil {
+ log.Panic(err)
+ }
+ return string(file)
+}
+
+// stringFor returns a textual representation of the arg, formatted according to its nature.
+func stringFor(arg interface{}) string {
+ switch arg := arg.(type) {
+ case int:
+ return fmt.Sprintf("%d", arg)
+ case string:
+ if len(arg) > 2 && arg[0] == '/' && arg[len(arg)-1] == '/' {
+ return fmt.Sprintf("%#q", arg)
+ }
+ return fmt.Sprintf("%q", arg)
+ default:
+ log.Panicf("unrecognized argument: %v type %T", arg, arg)
+ }
+ return ""
+}
+
+func (p *Presentation) code(file string, arg ...interface{}) (s string, err error) {
+ defer func() {
+ if r := recover(); r != nil {
+ err = fmt.Errorf("%v", r)
+ }
+ }()
+
+ text := p.Corpus.contents(file)
+ var command string
+ switch len(arg) {
+ case 0:
+ // text is already whole file.
+ command = fmt.Sprintf("code %q", file)
+ case 1:
+ command = fmt.Sprintf("code %q %s", file, stringFor(arg[0]))
+ text = p.Corpus.oneLine(file, text, arg[0])
+ case 2:
+ command = fmt.Sprintf("code %q %s %s", file, stringFor(arg[0]), stringFor(arg[1]))
+ text = p.Corpus.multipleLines(file, text, arg[0], arg[1])
+ default:
+ return "", fmt.Errorf("incorrect code invocation: code %q [%v, ...] (%d arguments)", file, arg[0], len(arg))
+ }
+ // Trim spaces from output.
+ text = strings.Trim(text, "\n")
+ // Replace tabs by spaces, which work better in HTML.
+ text = strings.Replace(text, "\t", " ", -1)
+ var buf bytes.Buffer
+ // HTML-escape text and syntax-color comments like elsewhere.
+ buf.Write(texthtml.Format([]byte(text), texthtml.Config{GoComments: true}))
+ // Include the command as a comment.
+ text = fmt.Sprintf("<pre><!--{{%s}}\n-->%s</pre>", command, buf.Bytes())
+ return text, nil
+}
+
+// parseArg returns the integer or string value of the argument and tells which it is.
+func parseArg(arg interface{}, file string, max int) (ival int, sval string, isInt bool) {
+ switch n := arg.(type) {
+ case int:
+ if n <= 0 || n > max {
+ log.Panicf("%q:%d is out of range", file, n)
+ }
+ return n, "", true
+ case string:
+ return 0, n, false
+ }
+ log.Panicf("unrecognized argument %v type %T", arg, arg)
+ return
+}
+
+// oneLine returns the single line generated by a two-argument code invocation.
+func (c *Corpus) oneLine(file, text string, arg interface{}) string {
+ lines := strings.SplitAfter(c.contents(file), "\n")
+ line, pattern, isInt := parseArg(arg, file, len(lines))
+ if isInt {
+ return lines[line-1]
+ }
+ return lines[match(file, 0, lines, pattern)-1]
+}
+
+// multipleLines returns the text generated by a three-argument code invocation.
+func (c *Corpus) multipleLines(file, text string, arg1, arg2 interface{}) string {
+ lines := strings.SplitAfter(c.contents(file), "\n")
+ line1, pattern1, isInt1 := parseArg(arg1, file, len(lines))
+ line2, pattern2, isInt2 := parseArg(arg2, file, len(lines))
+ if !isInt1 {
+ line1 = match(file, 0, lines, pattern1)
+ }
+ if !isInt2 {
+ line2 = match(file, line1, lines, pattern2)
+ } else if line2 < line1 {
+ log.Panicf("lines out of order for %q: %d %d", text, line1, line2)
+ }
+ for k := line1 - 1; k < line2; k++ {
+ if strings.HasSuffix(lines[k], "OMIT\n") {
+ lines[k] = ""
+ }
+ }
+ return strings.Join(lines[line1-1:line2], "")
+}
+
+// match identifies the input line that matches the pattern in a code invocation.
+// If start>0, match lines starting there rather than at the beginning.
+// The return value is 1-indexed.
+func match(file string, start int, lines []string, pattern string) int {
+ // $ matches the end of the file.
+ if pattern == "$" {
+ if len(lines) == 0 {
+ log.Panicf("%q: empty file", file)
+ }
+ return len(lines)
+ }
+ // /regexp/ matches the line that matches the regexp.
+ if len(pattern) > 2 && pattern[0] == '/' && pattern[len(pattern)-1] == '/' {
+ re, err := regexp.Compile(pattern[1 : len(pattern)-1])
+ if err != nil {
+ log.Panic(err)
+ }
+ for i := start; i < len(lines); i++ {
+ if re.MatchString(lines[i]) {
+ return i + 1
+ }
+ }
+ log.Panicf("%s: no match for %#q", file, pattern)
+ }
+ log.Panicf("unrecognized pattern: %q", pattern)
+ return 0
+}
diff --git a/internal/godoc/util.go b/internal/godoc/util.go
new file mode 100644
index 0000000..a113673
--- /dev/null
+++ b/internal/godoc/util.go
@@ -0,0 +1,91 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+package godoc
+
+import (
+ "io/fs"
+ "path"
+ "sync"
+ "time"
+ "unicode/utf8"
+)
+
+// An rwValue wraps a value and permits mutually exclusive
+// access to it and records the time the value was last set.
+type rwValue struct {
+ mutex sync.RWMutex
+ value interface{}
+ timestamp time.Time // time of last set()
+}
+
+func (v *rwValue) Set(value interface{}) {
+ v.mutex.Lock()
+ v.value = value
+ v.timestamp = time.Now()
+ v.mutex.Unlock()
+}
+
+func (v *rwValue) Get() (interface{}, time.Time) {
+ v.mutex.RLock()
+ defer v.mutex.RUnlock()
+ return v.value, v.timestamp
+}
+
+// IsText reports whether a significant prefix of s looks like correct UTF-8;
+// that is, if it is likely that s is human-readable text.
+func IsText(s []byte) bool {
+ const max = 1024 // at least utf8.UTFMax
+ if len(s) > max {
+ s = s[0:max]
+ }
+ for i, c := range string(s) {
+ if i+utf8.UTFMax > len(s) {
+ // last char may be incomplete - ignore
+ break
+ }
+ if c == 0xFFFD || c < ' ' && c != '\n' && c != '\t' && c != '\f' {
+ // decoding error or control character - not a text file
+ return false
+ }
+ }
+ return true
+}
+
+// textExt[x] is true if the extension x indicates a text file, and false otherwise.
+var textExt = map[string]bool{
+ ".css": false, // must be served raw
+ ".js": false, // must be served raw
+ ".svg": false, // must be served raw
+}
+
+// isTextFile reports whether the file has a known extension indicating
+// a text file, or if a significant chunk of the specified file looks like
+// correct UTF-8; that is, if it is likely that the file contains human-
+// readable text.
+func isTextFile(fsys fs.FS, filename string) bool {
+ // if the extension is known, use it for decision making
+ if isText, found := textExt[path.Ext(filename)]; found {
+ return isText
+ }
+
+ // the extension is not known; read an initial chunk
+ // of the file and check if it looks like text
+ f, err := fsys.Open(filename)
+ if err != nil {
+ return false
+ }
+ defer f.Close()
+
+ var buf [1024]byte
+ n, err := f.Read(buf[0:])
+ if err != nil {
+ return false
+ }
+
+ return IsText(buf[0:n])
+}
diff --git a/internal/godoc/versions.go b/internal/godoc/versions.go
new file mode 100644
index 0000000..9f18fb4
--- /dev/null
+++ b/internal/godoc/versions.go
@@ -0,0 +1,28 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+// This file caches information about which standard library types, methods,
+// and functions appeared in what version of Go
+
+package godoc
+
+import (
+ "log"
+
+ "golang.org/x/website/internal/api"
+)
+
+// InitVersionInfo parses the $GOROOT/api/go*.txt API definition files to discover
+// which API features were added in which Go releases.
+func (c *Corpus) InitVersionInfo() {
+ var err error
+ c.pkgAPIInfo, err = api.Load()
+ if err != nil {
+ // TODO: consider making this fatal, after the Go 1.11 cycle.
+ log.Printf("godoc: error parsing API version files: %v", err)
+ }
+}
diff --git a/internal/history/history.go b/internal/history/history.go
new file mode 100644
index 0000000..327b214
--- /dev/null
+++ b/internal/history/history.go
@@ -0,0 +1,210 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package history holds the Go project release history.
+package history
+
+import (
+ "fmt"
+ "html"
+ "html/template"
+ "sort"
+ "strings"
+ "time"
+)
+
+// A Release describes a single Go release.
+type Release struct {
+ Version Version
+ Date Date
+ Security bool // whether this is a security release
+ Future bool // if true, the release hasn't happened yet
+
+ // Release content summary.
+ Quantifier string // Optional quantifier. Empty string for unspecified amount of fixes (typical), "a" for a single fix, "two", "three" for multiple fixes, etc.
+ Components []template.HTML // Components involved. For example, "cgo", "the <code>go</code> command", "the runtime", etc.
+ Packages []string // Packages involved. For example, "net/http", "crypto/x509", etc.
+ More template.HTML // Additional release content.
+ CustomSummary template.HTML // CustomSummary, if non-empty, replaces the entire release content summary with custom HTML.
+}
+
+// A Version is a Go release version.
+//
+// In contrast to Semantic Versioning 2.0.0,
+// trailing zero components are omitted,
+// a version like Go 1.14 is considered a major Go release,
+// a version like Go 1.14.1 is considered a minor Go release.
+//
+// See proposal golang.org/issue/32450 for background, details,
+// and a discussion of the costs involved in making a change.
+type Version struct {
+ X int // X is the 1st component of a Go X.Y.Z version. It must be 1 or higher.
+ Y int // Y is the 2nd component of a Go X.Y.Z version. It must be 0 or higher.
+ Z int // Z is the 3rd component of a Go X.Y.Z version. It must be 0 or higher.
+}
+
+// String returns the Go release version string,
+// like "1.14", "1.14.1", "1.14.2", and so on.
+func (v Version) String() string {
+ switch {
+ case v.Z != 0:
+ return fmt.Sprintf("%d.%d.%d", v.X, v.Y, v.Z)
+ case v.Y != 0:
+ return fmt.Sprintf("%d.%d", v.X, v.Y)
+ default:
+ return fmt.Sprintf("%d", v.X)
+ }
+}
+
+func (v Version) Before(u Version) bool {
+ if v.X != u.X {
+ return v.X < u.X
+ }
+ if v.Y != u.Y {
+ return v.Y < u.Y
+ }
+ return v.Z < u.Z
+}
+
+// IsMajor reports whether version v is considered to be a major Go release.
+// For example, Go 1.14 and 1.13 are major Go releases.
+func (v Version) IsMajor() bool { return v.Z == 0 }
+
+// IsMinor reports whether version v is considered to be a minor Go release.
+// For example, Go 1.14.1 and 1.13.9 are minor Go releases.
+func (v Version) IsMinor() bool { return v.Z != 0 }
+
+// A Date represents the date (year, month, day) of a Go release.
+//
+// This type does not include location information, and
+// therefore does not describe a unique 24-hour timespan.
+type Date struct {
+ Year int // Year (e.g., 2009).
+ Month time.Month // Month of the year (January = 1, ...).
+ Day int // Day of the month, starting at 1.
+}
+
+func (d Date) String() string {
+ return d.Format("2006-01-02")
+}
+
+func (d Date) Format(format string) string {
+ return time.Date(d.Year, d.Month, d.Day, 0, 0, 0, 0, time.UTC).Format(format)
+}
+
+// A Major describes a major Go release and its minor revisions.
+type Major struct {
+ *Release
+ Minor []*Release // oldest first
+}
+
+var Majors []*Major = majors() // major versions, newest first
+
+// majors returns a list of major versions, sorted newest first.
+func majors() []*Major {
+ byVersion := make(map[Version]*Major)
+ for _, r := range Releases {
+ v := r.Version
+ v.Z = 0 // make major version
+ m := byVersion[v]
+ if m == nil {
+ m = new(Major)
+ byVersion[v] = m
+ }
+ if r.Version.Z == 0 {
+ m.Release = r
+ } else {
+ m.Minor = append(m.Minor, r)
+ }
+ }
+
+ var majors []*Major
+ for _, m := range byVersion {
+ majors = append(majors, m)
+ // minors oldest first
+ sort.Slice(m.Minor, func(i, j int) bool {
+ return m.Minor[i].Version.Before(m.Minor[j].Version)
+ })
+ }
+ // majors newest first
+ sort.Slice(majors, func(i, j int) bool {
+ return !majors[i].Version.Before(majors[j].Version)
+ })
+ return majors
+}
+
+// ComponentsAndPackages joins components and packages involved
+// in a Go release for the purposes of being displayed on the
+// release history page, keeping English grammar rules in mind.
+//
+// The different special cases are:
+//
+// c1
+// c1 and c2
+// c1, c2, and c3
+//
+// the p1 package
+// the p1 and p2 packages
+// the p1, p2, and p3 packages
+//
+// c1 and [1 package]
+// c1, and [2 or more packages]
+// c1, c2, and [1 or more packages]
+//
+func (r *Release) ComponentsAndPackages() template.HTML {
+ var buf strings.Builder
+
+ // List components, if any.
+ for i, comp := range r.Components {
+ if len(r.Packages) == 0 {
+ // No packages, so components are joined with more rules.
+ switch {
+ case i != 0 && len(r.Components) == 2:
+ buf.WriteString(" and ")
+ case i != 0 && len(r.Components) >= 3 && i != len(r.Components)-1:
+ buf.WriteString(", ")
+ case i != 0 && len(r.Components) >= 3 && i == len(r.Components)-1:
+ buf.WriteString(", and ")
+ }
+ } else {
+ // When there are packages, all components are comma-separated.
+ if i != 0 {
+ buf.WriteString(", ")
+ }
+ }
+ buf.WriteString(string(comp))
+ }
+
+ // Join components and packages using a comma and/or "and" as needed.
+ if len(r.Components) > 0 && len(r.Packages) > 0 {
+ if len(r.Components)+len(r.Packages) >= 3 {
+ buf.WriteString(",")
+ }
+ buf.WriteString(" and ")
+ }
+
+ // List packages, if any.
+ if len(r.Packages) > 0 {
+ buf.WriteString("the ")
+ }
+ for i, pkg := range r.Packages {
+ switch {
+ case i != 0 && len(r.Packages) == 2:
+ buf.WriteString(" and ")
+ case i != 0 && len(r.Packages) >= 3 && i != len(r.Packages)-1:
+ buf.WriteString(", ")
+ case i != 0 && len(r.Packages) >= 3 && i == len(r.Packages)-1:
+ buf.WriteString(", and ")
+ }
+ buf.WriteString("<code>" + html.EscapeString(pkg) + "</code>")
+ }
+ switch {
+ case len(r.Packages) == 1:
+ buf.WriteString(" package")
+ case len(r.Packages) >= 2:
+ buf.WriteString(" packages")
+ }
+
+ return template.HTML(buf.String())
+}
diff --git a/internal/history/release.go b/internal/history/release.go
new file mode 100644
index 0000000..1459eeb
--- /dev/null
+++ b/internal/history/release.go
@@ -0,0 +1,539 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package history stores historical data for the Go project.
+package history
+
+import "html/template"
+
+// Releases summarizes the changes between official stable releases of Go.
+// It contains entries for all releases of Go, but releases older than Go 1.9
+// omit information about minor versions, which is instead hard-coded in
+// _content/doc/devel/release.html.
+//
+// The table is sorted by date, breaking ties with newer versions first.
+var Releases = []*Release{
+ {
+ Date: Date{2021, 5, 6}, Version: Version{1, 16, 4},
+ CustomSummary: `includes a security fix to the
+<code>net/http</code> package, as well as bug fixes to the runtime,
+the compiler, and the <code>archive/zip</code>, <code>time</code>,
+and <code>syscall</code> packages. See the
+<a href="https://github.com/golang/go/issues?q=milestone%3AGo1.16.4+label%3ACherryPickApproved">Go
+1.16.4 milestone</a> on our issue tracker for details.`,
+ },
+ {
+ Date: Date{2021, 5, 6}, Version: Version{1, 15, 12},
+ CustomSummary: `includes a security fix to the
+<code>net/http</code> package, as well as bug fixes to the runtime,
+the compiler, and the <code>archive/zip</code>, <code>time</code>,
+and <code>syscall</code> packages. See the
+<a href="https://github.com/golang/go/issues?q=milestone%3AGo1.16.4+label%3ACherryPickApproved">Go
+1.16.4 milestone</a> on our issue tracker for details.`,
+ },
+ {
+ Date: Date{2021, 4, 1}, Version: Version{1, 16, 3},
+ Components: []template.HTML{"the compiler", "linker", "runtime", "the <code>go</code> command"},
+ Packages: []string{"testing", "time"},
+ },
+ {
+ Date: Date{2021, 4, 1}, Version: Version{1, 15, 11},
+ Components: []template.HTML{"cgo", "the compiler", "linker", "runtime", "the <code>go</code> command"},
+ Packages: []string{"database/sql", "net/http"},
+ },
+ {
+ Date: Date{2021, 3, 11}, Version: Version{1, 16, 2},
+ Components: []template.HTML{"cgo", "the compiler", "linker", "the <code>go</code> command"},
+ Packages: []string{"syscall", "time"},
+ },
+ {
+ Date: Date{2021, 3, 11}, Version: Version{1, 15, 10},
+ Components: []template.HTML{"the compiler", "the <code>go</code> command"},
+ Packages: []string{"net/http", "os", "syscall", "time"},
+ },
+ {
+ Date: Date{2021, 3, 10}, Version: Version{1, 16, 1}, Security: true,
+ Packages: []string{"archive/zip", "encoding/xml"},
+ },
+ {
+ Date: Date{2021, 3, 10}, Version: Version{1, 15, 9}, Security: true,
+ Packages: []string{"encoding/xml"},
+ },
+ {
+ Date: Date{2021, 2, 16}, Version: Version{1, 16, 0},
+ },
+ {
+ Date: Date{2021, 2, 4}, Version: Version{1, 15, 8},
+ Components: []template.HTML{"the compiler", "linker", "runtime", "the <code>go</code> command"},
+ Packages: []string{"net/http"},
+ },
+ {
+ Date: Date{2021, 2, 4}, Version: Version{1, 14, 15},
+ Components: []template.HTML{"the compiler", "runtime", "the <code>go</code> command"},
+ Packages: []string{"net/http"},
+ },
+ {
+ Date: Date{2021, 1, 19}, Version: Version{1, 15, 7}, Security: true,
+ Components: []template.HTML{"the <code>go</code> command"},
+ Packages: []string{"crypto/elliptic"},
+ },
+ {
+ Date: Date{2021, 1, 19}, Version: Version{1, 14, 14}, Security: true,
+ Components: []template.HTML{"the <code>go</code> command"},
+ Packages: []string{"crypto/elliptic"},
+ },
+ {
+ Date: Date{2020, 12, 3}, Version: Version{1, 15, 6},
+ Components: []template.HTML{"the compiler", "linker", "runtime", "the <code>go</code> command"},
+ Packages: []string{"io"},
+ },
+ {
+ Date: Date{2020, 12, 3}, Version: Version{1, 14, 13},
+ Components: []template.HTML{"the compiler", "runtime", "the <code>go</code> command"},
+ },
+ {
+ Date: Date{2020, 11, 12}, Version: Version{1, 15, 5}, Security: true,
+ Components: []template.HTML{"the <code>go</code> command"},
+ Packages: []string{"math/big"},
+ },
+ {
+ Date: Date{2020, 11, 12}, Version: Version{1, 14, 12}, Security: true,
+ Components: []template.HTML{"the <code>go</code> command"},
+ Packages: []string{"math/big"},
+ },
+ {
+ Date: Date{2020, 11, 5}, Version: Version{1, 15, 4},
+ Components: []template.HTML{"cgo", "the compiler", "linker", "runtime"},
+ Packages: []string{"compress/flate", "net/http", "reflect", "time"},
+ },
+ {
+ Date: Date{2020, 11, 5}, Version: Version{1, 14, 11},
+ Components: []template.HTML{"the runtime"},
+ Packages: []string{"net/http", "time"},
+ },
+ {
+ Date: Date{2020, 10, 14}, Version: Version{1, 15, 3},
+ Components: []template.HTML{"cgo", "the compiler", "runtime", "the <code>go</code> command"},
+ Packages: []string{"bytes", "plugin", "testing"},
+ },
+ {
+ Date: Date{2020, 10, 14}, Version: Version{1, 14, 10},
+ Components: []template.HTML{"the compiler", "runtime"},
+ Packages: []string{"plugin", "testing"},
+ },
+ {
+ Date: Date{2020, 9, 9}, Version: Version{1, 15, 2},
+ Components: []template.HTML{"the compiler", "runtime", "documentation", "the <code>go</code> command"},
+ Packages: []string{"net/mail", "os", "sync", "testing"},
+ },
+ {
+ Date: Date{2020, 9, 9}, Version: Version{1, 14, 9},
+ Components: []template.HTML{"the compiler", "linker", "runtime", "documentation"},
+ Packages: []string{"net/http", "testing"},
+ },
+ {
+ Date: Date{2020, 9, 1}, Version: Version{1, 15, 1}, Security: true,
+ Packages: []string{"net/http/cgi", "net/http/fcgi"},
+ },
+ {
+ Date: Date{2020, 9, 1}, Version: Version{1, 14, 8}, Security: true,
+ Packages: []string{"net/http/cgi", "net/http/fcgi"},
+ },
+ {
+ Date: Date{2020, 8, 11}, Version: Version{1, 15, 0},
+ },
+ {
+ Date: Date{2020, 8, 6}, Version: Version{1, 14, 7}, Security: true,
+ Packages: []string{"encoding/binary"},
+ },
+ {
+ Date: Date{2020, 8, 6}, Version: Version{1, 13, 15}, Security: true,
+ Packages: []string{"encoding/binary"},
+ },
+ {
+ Date: Date{2020, 7, 16}, Version: Version{1, 14, 6},
+ Components: []template.HTML{"the <code>go</code> command", "the compiler", "the linker", "vet"},
+ Packages: []string{"database/sql", "encoding/json", "net/http", "reflect", "testing"},
+ },
+ {
+ Date: Date{2020, 7, 16}, Version: Version{1, 13, 14},
+ Components: []template.HTML{"the compiler", "vet"},
+ Packages: []string{"database/sql", "net/http", "reflect"},
+ },
+ {
+ Date: Date{2020, 7, 14}, Version: Version{1, 14, 5}, Security: true,
+ Packages: []string{"crypto/x509", "net/http"},
+ },
+ {
+ Date: Date{2020, 7, 14}, Version: Version{1, 13, 13}, Security: true,
+ Packages: []string{"crypto/x509", "net/http"},
+ },
+ {
+ Date: Date{2020, 6, 1}, Version: Version{1, 14, 4},
+ Components: []template.HTML{"the <code>go</code> <code>doc</code> command", "the runtime"},
+ Packages: []string{"encoding/json", "os"},
+ },
+ {
+ Date: Date{2020, 6, 1}, Version: Version{1, 13, 12},
+ Components: []template.HTML{"the runtime"},
+ Packages: []string{"go/types", "math/big"},
+ },
+ {
+ Date: Date{2020, 5, 14}, Version: Version{1, 14, 3},
+ Components: []template.HTML{"cgo", "the compiler", "the runtime"},
+ Packages: []string{"go/doc", "math/big"},
+ },
+ {
+ Date: Date{2020, 5, 14}, Version: Version{1, 13, 11},
+ Components: []template.HTML{"the compiler"},
+ },
+ {
+ Date: Date{2020, 4, 8}, Version: Version{1, 14, 2},
+ Components: []template.HTML{"cgo", "the go command", "the runtime"},
+ Packages: []string{"os/exec", "testing"},
+ },
+ {
+ Date: Date{2020, 4, 8}, Version: Version{1, 13, 10},
+ Components: []template.HTML{"the go command", "the runtime"},
+ Packages: []string{"os/exec", "time"},
+ },
+ {
+ Date: Date{2020, 3, 19}, Version: Version{1, 14, 1},
+ Components: []template.HTML{"the go command", "tools", "the runtime"},
+ },
+ {
+ Date: Date{2020, 3, 19}, Version: Version{1, 13, 9},
+ Components: []template.HTML{"the go command", "tools", "the runtime", "the toolchain"},
+ Packages: []string{"crypto/cypher"},
+ },
+ {
+ Date: Date{2020, 2, 25}, Version: Version{1, 14, 0},
+ },
+ {
+ Date: Date{2020, 2, 12}, Version: Version{1, 13, 8},
+ Components: []template.HTML{"the runtime"},
+ Packages: []string{"crypto/x509", "net/http"},
+ },
+ {
+ Date: Date{2020, 2, 12}, Version: Version{1, 12, 17},
+ Quantifier: "a",
+ Components: []template.HTML{"the runtime"},
+ },
+ {
+ Date: Date{2020, 1, 28}, Version: Version{1, 13, 7}, Security: true,
+ Quantifier: "two",
+ Packages: []string{"crypto/x509"},
+ },
+ {
+ Date: Date{2020, 1, 28}, Version: Version{1, 12, 16}, Security: true,
+ Quantifier: "two",
+ Packages: []string{"crypto/x509"},
+ },
+ {
+ Date: Date{2020, 1, 9}, Version: Version{1, 13, 6},
+ Components: []template.HTML{"the runtime"},
+ Packages: []string{"net/http"},
+ },
+ {
+ Date: Date{2020, 1, 9}, Version: Version{1, 12, 15},
+ Components: []template.HTML{"the runtime"},
+ Packages: []string{"net/http"},
+ },
+ {
+ Date: Date{2019, 12, 4}, Version: Version{1, 13, 5},
+ Components: []template.HTML{"the go command", "the runtime", "the linker"},
+ Packages: []string{"net/http"},
+ },
+ {
+ Date: Date{2019, 12, 4}, Version: Version{1, 12, 14},
+ Quantifier: "a",
+ Components: []template.HTML{"the runtime"},
+ },
+ {
+ Date: Date{2019, 10, 31}, Version: Version{1, 13, 4},
+ Packages: []string{"net/http", "syscall"},
+ More: `It also fixes an issue on macOS 10.15 Catalina
+where the non-notarized installer and binaries were being
+<a href="https://golang.org/issue/34986">rejected by Gatekeeper</a>.`,
+ },
+ {
+ Date: Date{2019, 10, 31}, Version: Version{1, 12, 13},
+ CustomSummary: `fixes an issue on macOS 10.15 Catalina
+where the non-notarized installer and binaries were being
+<a href="https://golang.org/issue/34986">rejected by Gatekeeper</a>.
+Only macOS users who hit this issue need to update.`,
+ },
+ {
+ Date: Date{2019, 10, 17}, Version: Version{1, 13, 3},
+ Components: []template.HTML{"the go command", "the toolchain", "the runtime"},
+ Packages: []string{"syscall", "net", "net/http", "crypto/ecdsa"},
+ },
+ {
+ Date: Date{2019, 10, 17}, Version: Version{1, 12, 12},
+ Components: []template.HTML{"the go command", "runtime"},
+ Packages: []string{"syscall", "net"},
+ },
+ {
+ Date: Date{2019, 10, 17}, Version: Version{1, 13, 2}, Security: true,
+ Components: []template.HTML{"the compiler"},
+ Packages: []string{"crypto/dsa"},
+ },
+ {
+ Date: Date{2019, 10, 17}, Version: Version{1, 12, 11}, Security: true,
+ Packages: []string{"crypto/dsa"},
+ },
+ {
+ Date: Date{2019, 9, 25}, Version: Version{1, 13, 1}, Security: true,
+ Packages: []string{"net/http", "net/textproto"},
+ },
+ {
+ Date: Date{2019, 9, 25}, Version: Version{1, 12, 10}, Security: true,
+ Packages: []string{"net/http", "net/textproto"},
+ },
+ {
+ Date: Date{2019, 9, 3}, Version: Version{1, 13, 0},
+ },
+ {
+ Date: Date{2019, 8, 15}, Version: Version{1, 12, 9},
+ Components: []template.HTML{"the linker"},
+ Packages: []string{"os", "math/big"},
+ },
+ {
+ Date: Date{2019, 8, 13}, Version: Version{1, 12, 8}, Security: true,
+ Packages: []string{"net/http", "net/url"},
+ },
+ {
+ Date: Date{2019, 8, 13}, Version: Version{1, 11, 13}, Security: true,
+ Packages: []string{"net/http", "net/url"},
+ },
+ {
+ Date: Date{2019, 7, 8}, Version: Version{1, 12, 7},
+ Components: []template.HTML{"cgo", "the compiler", "the linker"},
+ },
+ {
+ Date: Date{2019, 7, 8}, Version: Version{1, 11, 12},
+ Components: []template.HTML{"the compiler", "the linker"},
+ },
+ {
+ Date: Date{2019, 6, 11}, Version: Version{1, 12, 6},
+ Components: []template.HTML{"the compiler", "the linker", "the go command"},
+ Packages: []string{"crypto/x509", "net/http", "os"},
+ },
+ {
+ Date: Date{2019, 6, 11}, Version: Version{1, 11, 11},
+ Quantifier: "a",
+ Packages: []string{"crypto/x509"},
+ },
+ {
+ Date: Date{2019, 5, 6}, Version: Version{1, 12, 5},
+ Components: []template.HTML{"the compiler", "the linker", "the go command", "the runtime"},
+ Packages: []string{"os"},
+ },
+ {
+ Date: Date{2019, 5, 6}, Version: Version{1, 11, 10},
+ Components: []template.HTML{"the runtime", "the linker"},
+ },
+ {
+ Date: Date{2019, 4, 11}, Version: Version{1, 12, 4},
+ CustomSummary: `fixes an issue where using the prebuilt binary
+releases on older versions of GNU/Linux
+<a href="https://golang.org/issues/31293">led to failures</a>
+when linking programs that used cgo.
+Only Linux users who hit this issue need to update.`,
+ },
+ {
+ Date: Date{2019, 4, 11}, Version: Version{1, 11, 9},
+ CustomSummary: `fixes an issue where using the prebuilt binary
+releases on older versions of GNU/Linux
+<a href="https://golang.org/issues/31293">led to failures</a>
+when linking programs that used cgo.
+Only Linux users who hit this issue need to update.`,
+ },
+ {
+ Date: Date{2019, 4, 8}, Version: Version{1, 12, 3},
+ CustomSummary: `was accidentally released without its
+intended fix. It is identical to go1.12.2, except for its version
+number. The intended fix is in go1.12.4.`,
+ },
+ {
+ Date: Date{2019, 4, 8}, Version: Version{1, 11, 8},
+ CustomSummary: `was accidentally released without its
+intended fix. It is identical to go1.11.7, except for its version
+number. The intended fix is in go1.11.9.`,
+ },
+ {
+ Date: Date{2019, 4, 5}, Version: Version{1, 12, 2},
+ Components: []template.HTML{"the compiler", "the go command", "the runtime"},
+ Packages: []string{"doc", "net", "net/http/httputil", "os"},
+ },
+ {
+ Date: Date{2019, 4, 5}, Version: Version{1, 11, 7},
+ Components: []template.HTML{"the runtime"},
+ Packages: []string{"net"},
+ },
+ {
+ Date: Date{2019, 3, 14}, Version: Version{1, 12, 1},
+ Components: []template.HTML{"cgo", "the compiler", "the go command"},
+ Packages: []string{"fmt", "net/smtp", "os", "path/filepath", "sync", "text/template"},
+ },
+ {
+ Date: Date{2019, 3, 14}, Version: Version{1, 11, 6},
+ Components: []template.HTML{"cgo", "the compiler", "linker", "runtime", "go command"},
+ Packages: []string{"crypto/x509", "encoding/json", "net", "net/url"},
+ },
+ {
+ Date: Date{2019, 2, 25}, Version: Version{1, 12, 0},
+ },
+ {
+ Date: Date{2019, 1, 23}, Version: Version{1, 11, 5}, Security: true,
+ Quantifier: "a",
+ Packages: []string{"crypto/elliptic"},
+ },
+ {
+ Date: Date{2019, 1, 23}, Version: Version{1, 10, 8}, Security: true,
+ Quantifier: "a",
+ Packages: []string{"crypto/elliptic"},
+ },
+ {
+ Date: Date{2018, 12, 14}, Version: Version{1, 11, 4},
+ Components: []template.HTML{"cgo", "the compiler", "linker", "runtime", "documentation", "go command"},
+ Packages: []string{"net/http", "go/types"},
+ More: `It includes a fix to a bug introduced in Go 1.11.3 that broke <code>go</code>
+<code>get</code> for import path patterns containing "<code>...</code>".`,
+ },
+ {
+ Date: Date{2018, 12, 14}, Version: Version{1, 10, 7},
+ // TODO: Modify to follow usual pattern, say it includes a fix to the go command.
+ CustomSummary: `includes a fix to a bug introduced in Go 1.10.6
+that broke <code>go</code> <code>get</code> for import path patterns containing
+"<code>...</code>".
+See the <a href="https://github.com/golang/go/issues?q=milestone%3AGo1.10.7+label%3ACherryPickApproved">
+Go 1.10.7 milestone</a> on our issue tracker for details.`,
+ },
+ {
+ Date: Date{2018, 12, 12}, Version: Version{1, 11, 3}, Security: true,
+ Quantifier: "three",
+ Components: []template.HTML{`"go get"`},
+ Packages: []string{"crypto/x509"},
+ },
+ {
+ Date: Date{2018, 12, 12}, Version: Version{1, 10, 6}, Security: true,
+ Quantifier: "three",
+ Components: []template.HTML{`"go get"`},
+ Packages: []string{"crypto/x509"},
+ More: "It contains the same fixes as Go 1.11.3 and was released at the same time.",
+ },
+ {
+ Date: Date{2018, 11, 2}, Version: Version{1, 11, 2},
+ Components: []template.HTML{"the compiler", "linker", "documentation", "go command"},
+ Packages: []string{"database/sql", "go/types"},
+ },
+ {
+ Date: Date{2018, 11, 2}, Version: Version{1, 10, 5},
+ Components: []template.HTML{"the go command", "linker", "runtime"},
+ Packages: []string{"database/sql"},
+ },
+ {
+ Date: Date{2018, 10, 1}, Version: Version{1, 11, 1},
+ Components: []template.HTML{"the compiler", "documentation", "go command", "runtime"},
+ Packages: []string{"crypto/x509", "encoding/json", "go/types", "net", "net/http", "reflect"},
+ },
+ {
+ Date: Date{2018, 8, 24}, Version: Version{1, 11, 0},
+ },
+ {
+ Date: Date{2018, 8, 24}, Version: Version{1, 10, 4},
+ Components: []template.HTML{"the go command", "linker"},
+ Packages: []string{"net/http", "mime/multipart", "ld/macho", "bytes", "strings"},
+ },
+ {
+ Date: Date{2018, 6, 5}, Version: Version{1, 10, 3},
+ Components: []template.HTML{"the go command"},
+ Packages: []string{"crypto/tls", "crypto/x509", "strings"},
+ More: `In particular, it adds <a href="https://go.googlesource.com/go/+/d4e21288e444d3ffd30d1a0737f15ea3fc3b8ad9">
+minimal support to the go command for the vgo transition</a>.`,
+ },
+ {
+ Date: Date{2018, 6, 5}, Version: Version{1, 9, 7},
+ Components: []template.HTML{"the go command"},
+ Packages: []string{"crypto/x509", "strings"},
+ More: `In particular, it adds <a href="https://go.googlesource.com/go/+/d4e21288e444d3ffd30d1a0737f15ea3fc3b8ad9">
+minimal support to the go command for the vgo transition</a>.`,
+ },
+ {
+ Date: Date{2018, 5, 1}, Version: Version{1, 10, 2},
+ Components: []template.HTML{"the compiler", "linker", "go command"},
+ },
+ {
+ Date: Date{2018, 5, 1}, Version: Version{1, 9, 6},
+ Components: []template.HTML{"the compiler", "go command"},
+ },
+ {
+ Date: Date{2018, 3, 28}, Version: Version{1, 10, 1},
+ Components: []template.HTML{"the compiler", "runtime"},
+ Packages: []string{"archive/zip", "crypto/tls", "crypto/x509", "encoding/json", "net", "net/http", "net/http/pprof"},
+ },
+ {
+ Date: Date{2018, 3, 28}, Version: Version{1, 9, 5},
+ Components: []template.HTML{"the compiler", "go command"},
+ Packages: []string{"net/http/pprof"},
+ },
+ {
+ Date: Date{2018, 2, 16}, Version: Version{1, 10, 0},
+ },
+ {
+ Date: Date{2018, 2, 7}, Version: Version{1, 9, 4}, Security: true,
+ Quantifier: "a",
+ Components: []template.HTML{`"go get"`},
+ },
+ {
+ Date: Date{2018, 1, 22}, Version: Version{1, 9, 3},
+ Components: []template.HTML{"the compiler", "runtime"},
+ Packages: []string{"database/sql", "math/big", "net/http", "net/url"},
+ },
+ {
+ Date: Date{2017, 10, 25}, Version: Version{1, 9, 2},
+ Components: []template.HTML{"the compiler", "linker", "runtime", "documentation", "<code>go</code> command"},
+ Packages: []string{"crypto/x509", "database/sql", "log", "net/smtp"},
+ More: `It includes a fix to a bug introduced in Go 1.9.1 that broke <code>go</code> <code>get</code>
+of non-Git repositories under certain conditions.`,
+ },
+ {
+ Date: Date{2017, 10, 4}, Version: Version{1, 9, 1}, Security: true,
+ Quantifier: "two",
+ },
+ {
+ Date: Date{2017, 8, 24}, Version: Version{1, 9, 0},
+ },
+
+ // Older releases do not have point release information here.
+ // See _content/doc/devel/release.html.
+ {
+ Date: Date{2017, 2, 16}, Version: Version{1, 8, 0},
+ },
+ {
+ Date: Date{2016, 8, 15}, Version: Version{1, 7, 0},
+ },
+ {
+ Date: Date{2016, 2, 17}, Version: Version{1, 6, 0},
+ },
+ {
+ Date: Date{2015, 8, 19}, Version: Version{1, 5, 0},
+ },
+ {
+ Date: Date{2014, 12, 10}, Version: Version{1, 4, 0},
+ },
+ {
+ Date: Date{2014, 6, 18}, Version: Version{1, 3, 0},
+ },
+ {
+ Date: Date{2013, 12, 1}, Version: Version{1, 2, 0},
+ },
+ {
+ Date: Date{2013, 5, 13}, Version: Version{1, 1, 0},
+ },
+ {
+ Date: Date{2012, 3, 28}, Version: Version{1, 0, 0},
+ },
+}
diff --git a/internal/history/release_test.go b/internal/history/release_test.go
new file mode 100644
index 0000000..d0759ca
--- /dev/null
+++ b/internal/history/release_test.go
@@ -0,0 +1,40 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package history
+
+import (
+ "testing"
+ "time"
+)
+
+func dateTime(d Date) time.Time {
+ return time.Date(d.Year, time.Month(d.Month), d.Day, 0, 0, 0, 0, time.UTC)
+}
+
+func TestReleases(t *testing.T) {
+ seen := make(map[Version]bool)
+ lastMinor := make(map[Version]int)
+ var last time.Time
+ for _, r := range Releases {
+ if seen[r.Version] {
+ t.Errorf("version %v duplicated", r.Version)
+ continue
+ }
+ seen[r.Version] = true
+ rt := dateTime(r.Date)
+ if !last.IsZero() && rt.After(last) {
+ t.Errorf("version %v out of order: %v vs %v", r.Version, r.Date, last.Format("2006-01-02"))
+ }
+ last = rt
+ major := r.Version
+ major.Z = 0
+ if z, ok := lastMinor[major]; ok && r.Version.Z != z-1 {
+ old := major
+ old.Z = z
+ t.Errorf("jumped from %v to %v", old, r.Version)
+ }
+ lastMinor[major] = r.Version.Z
+ }
+}
diff --git a/internal/memcache/memcache.go b/internal/memcache/memcache.go
new file mode 100644
index 0000000..25d5a62
--- /dev/null
+++ b/internal/memcache/memcache.go
@@ -0,0 +1,157 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package memcache provides a minimally compatible interface for
+// google.golang.org/appengine/memcache
+// and stores the data in Redis (e.g., via Cloud Memorystore).
+package memcache
+
+import (
+ "bytes"
+ "context"
+ "encoding/gob"
+ "encoding/json"
+ "errors"
+ "time"
+
+ "github.com/gomodule/redigo/redis"
+)
+
+var ErrCacheMiss = errors.New("memcache: cache miss")
+
+func New(addr string) *Client {
+ const maxConns = 20
+
+ pool := redis.NewPool(func() (redis.Conn, error) {
+ return redis.Dial("tcp", addr)
+ }, maxConns)
+
+ return &Client{
+ pool: pool,
+ }
+}
+
+type Client struct {
+ pool *redis.Pool
+}
+
+type CodecClient struct {
+ client *Client
+ codec Codec
+}
+
+type Item struct {
+ Key string
+ Value []byte
+ Object interface{} // Used with Codec.
+ Expiration time.Duration // Read-only.
+}
+
+func (c *Client) WithCodec(codec Codec) *CodecClient {
+ return &CodecClient{
+ c, codec,
+ }
+}
+
+func (c *Client) Delete(ctx context.Context, key string) error {
+ conn, err := c.pool.GetContext(ctx)
+ if err != nil {
+ return err
+ }
+ defer conn.Close()
+
+ _, err = conn.Do("DEL", key)
+ return err
+}
+
+func (c *CodecClient) Delete(ctx context.Context, key string) error {
+ return c.client.Delete(ctx, key)
+}
+
+func (c *Client) Set(ctx context.Context, item *Item) error {
+ if item.Value == nil {
+ return errors.New("nil item value")
+ }
+ return c.set(ctx, item.Key, item.Value, item.Expiration)
+}
+
+func (c *CodecClient) Set(ctx context.Context, item *Item) error {
+ if item.Object == nil {
+ return errors.New("nil object value")
+ }
+ b, err := c.codec.Marshal(item.Object)
+ if err != nil {
+ return err
+ }
+ return c.client.set(ctx, item.Key, b, item.Expiration)
+}
+
+func (c *Client) set(ctx context.Context, key string, value []byte, expiration time.Duration) error {
+ conn, err := c.pool.GetContext(ctx)
+ if err != nil {
+ return err
+ }
+ defer conn.Close()
+
+ if expiration == 0 {
+ _, err := conn.Do("SET", key, value)
+ return err
+ }
+
+ // NOTE(cbro): redis does not support expiry in units more granular than a second.
+ exp := int64(expiration.Seconds())
+ if exp == 0 {
+ // Redis doesn't allow a zero expiration, delete the key instead.
+ _, err := conn.Do("DEL", key)
+ return err
+ }
+
+ _, err = conn.Do("SETEX", key, exp, value)
+ return err
+}
+
+// Get gets the item.
+func (c *Client) Get(ctx context.Context, key string) ([]byte, error) {
+ conn, err := c.pool.GetContext(ctx)
+ if err != nil {
+ return nil, err
+ }
+ defer conn.Close()
+
+ b, err := redis.Bytes(conn.Do("GET", key))
+ if err == redis.ErrNil {
+ err = ErrCacheMiss
+ }
+ return b, err
+}
+
+func (c *CodecClient) Get(ctx context.Context, key string, v interface{}) error {
+ b, err := c.client.Get(ctx, key)
+ if err != nil {
+ return err
+ }
+ return c.codec.Unmarshal(b, v)
+}
+
+var (
+ Gob = Codec{gobMarshal, gobUnmarshal}
+ JSON = Codec{json.Marshal, json.Unmarshal}
+)
+
+type Codec struct {
+ Marshal func(interface{}) ([]byte, error)
+ Unmarshal func([]byte, interface{}) error
+}
+
+func gobMarshal(v interface{}) ([]byte, error) {
+ var buf bytes.Buffer
+ if err := gob.NewEncoder(&buf).Encode(v); err != nil {
+ return nil, err
+ }
+ return buf.Bytes(), nil
+}
+
+func gobUnmarshal(data []byte, v interface{}) error {
+ return gob.NewDecoder(bytes.NewBuffer(data)).Decode(v)
+}
diff --git a/internal/memcache/memcache_test.go b/internal/memcache/memcache_test.go
new file mode 100644
index 0000000..74f6ade
--- /dev/null
+++ b/internal/memcache/memcache_test.go
@@ -0,0 +1,83 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package memcache
+
+import (
+ "context"
+ "os"
+ "testing"
+ "time"
+)
+
+func getClient(t *testing.T) *Client {
+ t.Helper()
+
+ addr := os.Getenv("GOLANG_REDIS_ADDR")
+ if addr == "" {
+ t.Skip("skipping because GOLANG_REDIS_ADDR is unset")
+ }
+
+ return New(addr)
+}
+
+func TestCacheMiss(t *testing.T) {
+ c := getClient(t)
+ ctx := context.Background()
+
+ if _, err := c.Get(ctx, "doesnotexist"); err != ErrCacheMiss {
+ t.Errorf("got %v; want ErrCacheMiss", err)
+ }
+}
+
+func TestExpiry(t *testing.T) {
+ c := getClient(t).WithCodec(Gob)
+ ctx := context.Background()
+
+ key := "testexpiry"
+
+ firstTime := time.Now()
+ err := c.Set(ctx, &Item{
+ Key: key,
+ Object: firstTime,
+ Expiration: 3500 * time.Millisecond, // NOTE: check that non-rounded expiries work.
+ })
+ if err != nil {
+ t.Fatalf("Set: %v", err)
+ }
+
+ var newTime time.Time
+ if err := c.Get(ctx, key, &newTime); err != nil {
+ t.Fatalf("Get: %v", err)
+ }
+ if !firstTime.Equal(newTime) {
+ t.Errorf("Get: got value %v, want %v", newTime, firstTime)
+ }
+
+ time.Sleep(4 * time.Second)
+
+ if err := c.Get(ctx, key, &newTime); err != ErrCacheMiss {
+ t.Errorf("Get: got %v, want ErrCacheMiss", err)
+ }
+}
+
+func TestShortExpiry(t *testing.T) {
+ c := getClient(t).WithCodec(Gob)
+ ctx := context.Background()
+
+ key := "testshortexpiry"
+
+ err := c.Set(ctx, &Item{
+ Key: key,
+ Value: []byte("ok"),
+ Expiration: time.Millisecond,
+ })
+ if err != nil {
+ t.Fatalf("Set: %v", err)
+ }
+
+ if err := c.Get(ctx, key, nil); err != ErrCacheMiss {
+ t.Errorf("GetBytes: got %v, want ErrCacheMiss", err)
+ }
+}
diff --git a/internal/pkgdoc/dir.go b/internal/pkgdoc/dir.go
new file mode 100644
index 0000000..e8b2c61
--- /dev/null
+++ b/internal/pkgdoc/dir.go
@@ -0,0 +1,303 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+// This file contains the code dealing with package directory trees.
+
+package pkgdoc
+
+import (
+ "bytes"
+ "go/ast"
+ "go/doc"
+ "go/parser"
+ "go/token"
+ "io/fs"
+ "log"
+ "path"
+ "sort"
+ "strings"
+)
+
+// toFS returns the io/fs name for path (no leading slash).
+func toFS(name string) string {
+ if name == "/" {
+ return "."
+ }
+ return path.Clean(strings.TrimPrefix(name, "/"))
+}
+
+type Dir struct {
+ Path string // directory path
+ HasPkg bool // true if the directory contains at least one package
+ Synopsis string // package documentation, if any
+ Dirs []*Dir // subdirectories
+}
+
+func (d *Dir) Name() string {
+ return path.Base(d.Path)
+}
+
+type DirList struct {
+ List []DirEntry
+}
+
+// DirEntry describes a directory entry.
+// The Depth gives the directory depth relative to the overall list,
+// for use in presenting a hierarchical directory entry.
+type DirEntry struct {
+ Depth int // >= 0
+ Path string // relative path to directory from listing start
+ HasPkg bool // true if the directory contains at least one package
+ Synopsis string // package documentation, if any
+}
+
+func (d *DirEntry) Name() string {
+ return path.Base(d.Path)
+}
+
+// Lookup looks for the *Directory for a given named path, relative to dir.
+func (dir *Dir) Lookup(name string) *Dir {
+ name = path.Join(dir.Path, name)
+ if name == dir.Path {
+ return dir
+ }
+ dirPathLen := len(dir.Path)
+ if dir.Path == "/" {
+ dirPathLen = 0 // so path[dirPathLen] is a slash
+ }
+ if !strings.HasPrefix(name, dir.Path) || name[dirPathLen] != '/' {
+ println("NO", name, dir.Path)
+ return nil
+ }
+ d := dir
+Walk:
+ for i := dirPathLen + 1; i <= len(name); i++ {
+ if i == len(name) || name[i] == '/' {
+ // Find next child along path.
+ for _, sub := range d.Dirs {
+ if sub.Path == name[:i] {
+ d = sub
+ continue Walk
+ }
+ }
+ println("LOST", name[:i])
+ return nil
+ }
+ }
+ return d
+}
+
+// List creates a (linear) directory List from a directory tree.
+// If skipRoot is set, the root directory itself is excluded from the list.
+// If filter is set, only the directory entries whose paths match the filter
+// are included.
+//
+func (dir *Dir) List(filter func(string) bool) *DirList {
+ if dir == nil {
+ return nil
+ }
+
+ var list []DirEntry
+ dir.walk(func(d *Dir, depth int) {
+ if depth == 0 || filter != nil && !filter(d.Path) {
+ return
+ }
+ // the path is relative to root.Path - remove the root.Path
+ // prefix (the prefix should always be present but avoid
+ // crashes and check)
+ path := strings.TrimPrefix(d.Path, dir.Path)
+ // remove leading separator if any - path must be relative
+ path = strings.TrimPrefix(path, "/")
+ list = append(list, DirEntry{
+ Depth: depth,
+ Path: path,
+ HasPkg: d.HasPkg,
+ Synopsis: d.Synopsis,
+ })
+ })
+
+ if len(list) == 0 {
+ return nil
+ }
+ return &DirList{list}
+}
+
+func newDir(fsys fs.FS, fset *token.FileSet, abspath string) *Dir {
+ var synopses [3]string // prioritized package documentation (0 == highest priority)
+
+ hasPkgFiles := false
+ haveSummary := false
+
+ list, err := fs.ReadDir(fsys, toFS(abspath))
+ if err != nil {
+ // TODO: propagate more. See golang.org/issue/14252.
+ log.Printf("newDirTree reading %s: %v", abspath, err)
+ }
+
+ // determine number of subdirectories and if there are package files
+ var dirchs []chan *Dir
+ var dirs []*Dir
+
+ for _, d := range list {
+ filename := path.Join(abspath, d.Name())
+ switch {
+ case isPkgDir(d):
+ dir := newDir(fsys, fset, filename)
+ if dir != nil {
+ dirs = append(dirs, dir)
+ }
+
+ case !haveSummary && isPkgFile(d):
+ // looks like a package file, but may just be a file ending in ".go";
+ // don't just count it yet (otherwise we may end up with hasPkgFiles even
+ // though the directory doesn't contain any real package files - was bug)
+ // no "optimal" package synopsis yet; continue to collect synopses
+ const flags = parser.ParseComments | parser.PackageClauseOnly
+ file, err := parseFile(fsys, fset, filename, flags)
+ if err != nil {
+ log.Printf("parsing %v: %v", filename, err)
+ break
+ }
+
+ hasPkgFiles = true
+ if file.Doc != nil {
+ // prioritize documentation
+ i := -1
+ switch file.Name.Name {
+ case path.Base(abspath):
+ i = 0 // normal case: directory name matches package name
+ case "main":
+ i = 1 // directory contains a main package
+ default:
+ i = 2 // none of the above
+ }
+ if 0 <= i && i < len(synopses) && synopses[i] == "" {
+ synopses[i] = doc.Synopsis(file.Doc.Text())
+ }
+ }
+ haveSummary = synopses[0] != ""
+ }
+ }
+
+ // create subdirectory tree
+ for _, ch := range dirchs {
+ if d := <-ch; d != nil {
+ dirs = append(dirs, d)
+ }
+ }
+
+ // We need to sort the dirs slice because
+ // it is appended again after reading from dirchs.
+ sort.Slice(dirs, func(i, j int) bool {
+ return dirs[i].Path < dirs[j].Path
+ })
+
+ // if there are no package files and no subdirectories
+ // containing package files, ignore the directory
+ if !hasPkgFiles && len(dirs) == 0 {
+ return nil
+ }
+
+ // select the highest-priority synopsis for the directory entry, if any
+ synopsis := ""
+ for _, synopsis = range synopses {
+ if synopsis != "" {
+ break
+ }
+ }
+
+ return &Dir{
+ Path: abspath,
+ HasPkg: hasPkgFiles,
+ Synopsis: synopsis,
+ Dirs: dirs,
+ }
+}
+
+func isPkgFile(fi fs.DirEntry) bool {
+ name := fi.Name()
+ return !fi.IsDir() &&
+ path.Ext(name) == ".go" &&
+ !strings.HasSuffix(fi.Name(), "_test.go") // ignore test files
+}
+
+func isPkgDir(fi fs.DirEntry) bool {
+ name := fi.Name()
+ return fi.IsDir() &&
+ name != "testdata" &&
+ len(name) > 0 && name[0] != '_' && name[0] != '.' // ignore _files and .files
+}
+
+// walk calls f(d, depth) for each directory d in the tree rooted at dir, including dir itself.
+// The depth argument specifies the depth of d in the tree.
+// The depth of dir itself is 0.
+func (dir *Dir) walk(f func(d *Dir, depth int)) {
+ walkDirs(f, dir, 0)
+}
+
+func walkDirs(f func(d *Dir, depth int), d *Dir, depth int) {
+ f(d, depth)
+ for _, sub := range d.Dirs {
+ walkDirs(f, sub, depth+1)
+ }
+}
+
+func parseFile(fsys fs.FS, fset *token.FileSet, filename string, mode parser.Mode) (*ast.File, error) {
+ src, err := fs.ReadFile(fsys, toFS(filename))
+ if err != nil {
+ return nil, err
+ }
+
+ // Temporary ad-hoc fix for issue 5247.
+ // TODO(gri,dmitshur) Remove this in favor of a better fix, eventually (see issue 32092).
+ replaceLinePrefixCommentsWithBlankLine(src)
+
+ return parser.ParseFile(fset, filename, src, mode)
+}
+
+func parseFiles(fsys fs.FS, fset *token.FileSet, relpath string, abspath string, localnames []string) (map[string]*ast.File, error) {
+ files := make(map[string]*ast.File)
+ for _, f := range localnames {
+ absname := path.Join(abspath, f)
+ file, err := parseFile(fsys, fset, absname, parser.ParseComments)
+ if err != nil {
+ return nil, err
+ }
+ files[path.Join(relpath, f)] = file
+ }
+
+ return files, nil
+}
+
+var linePrefix = []byte("//line ")
+
+// This function replaces source lines starting with "//line " with a blank line.
+// It does this irrespective of whether the line is truly a line comment or not;
+// e.g., the line may be inside a string, or a /*-style comment; however that is
+// rather unlikely (proper testing would require a full Go scan which we want to
+// avoid for performance).
+func replaceLinePrefixCommentsWithBlankLine(src []byte) {
+ for {
+ i := bytes.Index(src, linePrefix)
+ if i < 0 {
+ break // we're done
+ }
+ // 0 <= i && i+len(linePrefix) <= len(src)
+ if i == 0 || src[i-1] == '\n' {
+ // at beginning of line: blank out line
+ for i < len(src) && src[i] != '\n' {
+ src[i] = ' '
+ i++
+ }
+ } else {
+ // not at beginning of line: skip over prefix
+ i += len(linePrefix)
+ }
+ // i <= len(src)
+ src = src[i:]
+ }
+}
diff --git a/internal/pkgdoc/dir_test.go b/internal/pkgdoc/dir_test.go
new file mode 100644
index 0000000..9441274
--- /dev/null
+++ b/internal/pkgdoc/dir_test.go
@@ -0,0 +1,67 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+package pkgdoc
+
+import (
+ "go/token"
+ "os"
+ "runtime"
+ "sort"
+ "testing"
+ "testing/fstest"
+)
+
+func TestNewDirTree(t *testing.T) {
+ dir := newDir(os.DirFS(runtime.GOROOT()), token.NewFileSet(), "/src")
+ processDir(t, dir)
+}
+
+func processDir(t *testing.T, dir *Dir) {
+ var list []string
+ for _, d := range dir.Dirs {
+ list = append(list, d.Name())
+ // recursively process the lower level
+ processDir(t, d)
+ }
+
+ if sort.StringsAreSorted(list) == false {
+ t.Errorf("list: %v is not sorted\n", list)
+ }
+}
+
+func TestIssue45614(t *testing.T) {
+ fs := fstest.MapFS{
+ "src/index/suffixarray/gen.go": {
+ Data: []byte(`// P1: directory contains a main package
+package main
+`)},
+ "src/index/suffixarray/suffixarray.go": {
+ Data: []byte(`// P0: directory name matches package name
+package suffixarray
+`)},
+ }
+
+ dir := newDir(fs, token.NewFileSet(), "src/index/suffixarray")
+ if got, want := dir.Synopsis, "P0: directory name matches package name"; got != want {
+ t.Errorf("dir.Synopsis = %q; want %q", got, want)
+ }
+}
+
+func BenchmarkNewDirectory(b *testing.B) {
+ if testing.Short() {
+ b.Skip("not running tests requiring large file scan in short mode")
+ }
+
+ fs := os.DirFS(runtime.GOROOT())
+
+ b.ResetTimer()
+ b.ReportAllocs()
+ for tries := 0; tries < b.N; tries++ {
+ newDir(fs, token.NewFileSet(), "/src")
+ }
+}
diff --git a/internal/pkgdoc/doc.go b/internal/pkgdoc/doc.go
new file mode 100644
index 0000000..219e673
--- /dev/null
+++ b/internal/pkgdoc/doc.go
@@ -0,0 +1,402 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+package pkgdoc
+
+import (
+ "bytes"
+ "go/ast"
+ "go/build"
+ "go/doc"
+ "go/token"
+ "io"
+ "io/fs"
+ "io/ioutil"
+ "log"
+ "os"
+ "path"
+ "path/filepath"
+ "sort"
+ "strings"
+ "unicode"
+ "unicode/utf8"
+)
+
+type Docs struct {
+ fs fs.FS
+ root *Dir
+}
+
+func NewDocs(fsys fs.FS) *Docs {
+ src := newDir(fsys, token.NewFileSet(), "/src")
+ root := &Dir{
+ Path: "/",
+ Dirs: []*Dir{src},
+ }
+ return &Docs{
+ fs: fsys,
+ root: root,
+ }
+}
+
+type Page struct {
+ Dirname string // directory containing the package
+ Err error // error or nil
+ GoogleCN bool // page is being served from golang.google.cn
+
+ Mode Mode // display metadata from query string
+
+ // package info
+ FSet *token.FileSet // nil if no package documentation
+ PDoc *doc.Package // nil if no package documentation
+ Examples []*doc.Example // nil if no example code
+ Bugs []*doc.Note // nil if no BUG comments
+ PAst map[string]*ast.File // nil if no AST with package exports
+ IsMain bool // true for package main
+ IsFiltered bool // true if results were filtered
+
+ // directory info
+ Dirs *DirList // nil if no directory information
+ DirFlat bool // if set, show directory in a flat (non-indented) manner
+}
+
+func (info *Page) IsEmpty() bool {
+ return info.Err != nil || info.PAst == nil && info.PDoc == nil && info.Dirs == nil
+}
+
+type Mode uint
+
+const (
+ ModeAll Mode = 1 << iota // do not filter exports
+ ModeFlat // show directory in a flat (non-indented) manner
+ ModeMethods // show all embedded methods
+ ModeSrc // show source code, do not extract documentation
+ ModeBuiltin // don't associate consts, vars, and factory functions with types (not exposed via ?m= query parameter, used for package builtin, see issue 6645)
+)
+
+// modeNames defines names for each PageInfoMode flag.
+// The order here must match the order of the constants above.
+var modeNames = []string{
+ "all",
+ "flat",
+ "methods",
+ "src",
+}
+
+// generate a query string for persisting PageInfoMode between pages.
+func (m Mode) String() string {
+ s := ""
+ for i, name := range modeNames {
+ if m&(1<<i) != 0 && name != "" {
+ if s != "" {
+ s += ","
+ }
+ s += name
+ }
+ }
+ return s
+}
+
+// ParseMode computes the PageInfoMode flags by analyzing the request
+// URL form value "m". It is value is a comma-separated list of mode names (for example, "all,flat").
+func ParseMode(text string) Mode {
+ var mode Mode
+ for _, k := range strings.Split(text, ",") {
+ k = strings.TrimSpace(k)
+ for i, name := range modeNames {
+ if name == k {
+ mode |= 1 << i
+ }
+ }
+ }
+ return mode
+}
+
+// GetPageInfo returns the PageInfo for a package directory abspath. If the
+// parameter genAST is set, an AST containing only the package exports is
+// computed (PageInfo.PAst), otherwise package documentation (PageInfo.Doc)
+// is extracted from the AST. If there is no corresponding package in the
+// directory, PageInfo.PAst and PageInfo.PDoc are nil. If there are no sub-
+// directories, PageInfo.Dirs is nil. If an error occurred, PageInfo.Err is
+// set to the respective error but the error is not logged.
+func Doc(d *Docs, abspath, relpath string, mode Mode, goos, goarch string) *Page {
+ info := &Page{Dirname: abspath, Mode: mode}
+
+ // Restrict to the package files that would be used when building
+ // the package on this system. This makes sure that if there are
+ // separate implementations for, say, Windows vs Unix, we don't
+ // jumble them all together.
+ // Note: If goos/goarch aren't set, the current binary's GOOS/GOARCH
+ // are used.
+ ctxt := build.Default
+ ctxt.IsAbsPath = path.IsAbs
+ ctxt.IsDir = func(path string) bool {
+ fi, err := fs.Stat(d.fs, toFS(filepath.ToSlash(path)))
+ return err == nil && fi.IsDir()
+ }
+ ctxt.ReadDir = func(dir string) ([]os.FileInfo, error) {
+ f, err := fs.ReadDir(d.fs, toFS(filepath.ToSlash(dir)))
+ filtered := make([]os.FileInfo, 0, len(f))
+ for _, i := range f {
+ if mode&ModeAll != 0 || i.Name() != "internal" {
+ info, err := i.Info()
+ if err == nil {
+ filtered = append(filtered, info)
+ }
+ }
+ }
+ return filtered, err
+ }
+ ctxt.OpenFile = func(name string) (r io.ReadCloser, err error) {
+ data, err := fs.ReadFile(d.fs, toFS(filepath.ToSlash(name)))
+ if err != nil {
+ return nil, err
+ }
+ return ioutil.NopCloser(bytes.NewReader(data)), nil
+ }
+
+ // Make the syscall/js package always visible by default.
+ // It defaults to the host's GOOS/GOARCH, and golang.org's
+ // linux/amd64 means the wasm syscall/js package was blank.
+ // And you can't run godoc on js/wasm anyway, so host defaults
+ // don't make sense here.
+ if goos == "" && goarch == "" && relpath == "syscall/js" {
+ goos, goarch = "js", "wasm"
+ }
+ if goos != "" {
+ ctxt.GOOS = goos
+ }
+ if goarch != "" {
+ ctxt.GOARCH = goarch
+ }
+
+ pkginfo, err := ctxt.ImportDir(abspath, 0)
+ // continue if there are no Go source files; we still want the directory info
+ if _, nogo := err.(*build.NoGoError); err != nil && !nogo {
+ info.Err = err
+ return info
+ }
+
+ // collect package files
+ pkgname := pkginfo.Name
+ pkgfiles := append(pkginfo.GoFiles, pkginfo.CgoFiles...)
+ if len(pkgfiles) == 0 {
+ // Commands written in C have no .go files in the build.
+ // Instead, documentation may be found in an ignored file.
+ // The file may be ignored via an explicit +build ignore
+ // constraint (recommended), or by defining the package
+ // documentation (historic).
+ pkgname = "main" // assume package main since pkginfo.Name == ""
+ pkgfiles = pkginfo.IgnoredGoFiles
+ }
+
+ // get package information, if any
+ if len(pkgfiles) > 0 {
+ // build package AST
+ fset := token.NewFileSet()
+ files, err := parseFiles(d.fs, fset, relpath, abspath, pkgfiles)
+ if err != nil {
+ info.Err = err
+ return info
+ }
+
+ // ignore any errors - they are due to unresolved identifiers
+ pkg, _ := ast.NewPackage(fset, files, simpleImporter, nil)
+
+ // extract package documentation
+ info.FSet = fset
+ if mode&ModeSrc == 0 {
+ // show extracted documentation
+ var m doc.Mode
+ if mode&ModeAll != 0 {
+ m |= doc.AllDecls
+ }
+ if mode&ModeMethods != 0 {
+ m |= doc.AllMethods
+ }
+ info.PDoc = doc.New(pkg, path.Clean(relpath), m) // no trailing '/' in importpath
+ if mode&ModeBuiltin != 0 {
+ for _, t := range info.PDoc.Types {
+ info.PDoc.Consts = append(info.PDoc.Consts, t.Consts...)
+ info.PDoc.Vars = append(info.PDoc.Vars, t.Vars...)
+ info.PDoc.Funcs = append(info.PDoc.Funcs, t.Funcs...)
+ t.Consts = nil
+ t.Vars = nil
+ t.Funcs = nil
+ }
+ // for now we cannot easily sort consts and vars since
+ // go/doc.Value doesn't export the order information
+ sort.Sort(funcsByName(info.PDoc.Funcs))
+ }
+
+ // collect examples
+ testfiles := append(pkginfo.TestGoFiles, pkginfo.XTestGoFiles...)
+ files, err = parseFiles(d.fs, fset, relpath, abspath, testfiles)
+ if err != nil {
+ log.Println("parsing examples:", err)
+ }
+ info.Examples = collectExamples(pkg, files)
+ info.Bugs = info.PDoc.Notes["BUG"]
+ } else {
+ // show source code
+ // TODO(gri) Consider eliminating export filtering in this mode,
+ // or perhaps eliminating the mode altogether.
+ if mode&ModeAll == 0 {
+ packageExports(fset, pkg)
+ }
+ info.PAst = files
+ }
+ info.IsMain = pkgname == "main"
+ }
+
+ info.Dirs = d.root.Lookup(abspath).List(func(path string) bool { return d.includePath(path, mode) })
+ info.DirFlat = mode&ModeFlat != 0
+
+ return info
+}
+
+func (d *Docs) includePath(path string, mode Mode) (r bool) {
+ // if the path includes 'internal', don't list unless we are in the NoFiltering mode.
+ if mode&ModeAll != 0 {
+ return true
+ }
+ if strings.Contains(path, "internal") || strings.Contains(path, "vendor") {
+ for _, c := range strings.Split(filepath.Clean(path), string(os.PathSeparator)) {
+ if c == "internal" || c == "vendor" {
+ return false
+ }
+ }
+ }
+ return true
+}
+
+// simpleImporter returns a (dummy) package object named
+// by the last path component of the provided package path
+// (as is the convention for packages). This is sufficient
+// to resolve package identifiers without doing an actual
+// import. It never returns an error.
+//
+func simpleImporter(imports map[string]*ast.Object, path string) (*ast.Object, error) {
+ pkg := imports[path]
+ if pkg == nil {
+ // note that strings.LastIndex returns -1 if there is no "/"
+ pkg = ast.NewObj(ast.Pkg, path[strings.LastIndex(path, "/")+1:])
+ pkg.Data = ast.NewScope(nil) // required by ast.NewPackage for dot-import
+ imports[path] = pkg
+ }
+ return pkg, nil
+}
+
+// packageExports is a local implementation of ast.PackageExports
+// which correctly updates each package file's comment list.
+// (The ast.PackageExports signature is frozen, hence the local
+// implementation).
+//
+func packageExports(fset *token.FileSet, pkg *ast.Package) {
+ for _, src := range pkg.Files {
+ cmap := ast.NewCommentMap(fset, src, src.Comments)
+ ast.FileExports(src)
+ src.Comments = cmap.Filter(src).Comments()
+ }
+}
+
+type funcsByName []*doc.Func
+
+func (s funcsByName) Len() int { return len(s) }
+
+func (s funcsByName) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+
+func (s funcsByName) Less(i, j int) bool { return s[i].Name < s[j].Name }
+
+// collectExamples collects examples for pkg from testfiles.
+func collectExamples(pkg *ast.Package, testfiles map[string]*ast.File) []*doc.Example {
+ var files []*ast.File
+ for _, f := range testfiles {
+ files = append(files, f)
+ }
+
+ var examples []*doc.Example
+ globals := globalNames(pkg)
+ for _, e := range doc.Examples(files...) {
+ name := TrimExampleSuffix(e.Name)
+ if name == "" || globals[name] {
+ examples = append(examples, e)
+ }
+ }
+
+ return examples
+}
+
+// globalNames returns a set of the names declared by all package-level
+// declarations. Method names are returned in the form Receiver_Method.
+func globalNames(pkg *ast.Package) map[string]bool {
+ names := make(map[string]bool)
+ for _, file := range pkg.Files {
+ for _, decl := range file.Decls {
+ addNames(names, decl)
+ }
+ }
+ return names
+}
+
+// addNames adds the names declared by decl to the names set.
+// Method names are added in the form ReceiverTypeName_Method.
+func addNames(names map[string]bool, decl ast.Decl) {
+ switch d := decl.(type) {
+ case *ast.FuncDecl:
+ name := d.Name.Name
+ if d.Recv != nil {
+ var typeName string
+ switch r := d.Recv.List[0].Type.(type) {
+ case *ast.StarExpr:
+ typeName = r.X.(*ast.Ident).Name
+ case *ast.Ident:
+ typeName = r.Name
+ }
+ name = typeName + "_" + name
+ }
+ names[name] = true
+ case *ast.GenDecl:
+ for _, spec := range d.Specs {
+ switch s := spec.(type) {
+ case *ast.TypeSpec:
+ names[s.Name.Name] = true
+ case *ast.ValueSpec:
+ for _, id := range s.Names {
+ names[id.Name] = true
+ }
+ }
+ }
+ }
+}
+
+func SplitExampleName(s string) (name, suffix string) {
+ i := strings.LastIndex(s, "_")
+ if 0 <= i && i < len(s)-1 && !startsWithUppercase(s[i+1:]) {
+ name = s[:i]
+ suffix = " (" + strings.Title(s[i+1:]) + ")"
+ return
+ }
+ name = s
+ return
+}
+
+// TrimExampleSuffix strips lowercase braz in Foo_braz or Foo_Bar_braz from name
+// while keeping uppercase Braz in Foo_Braz.
+func TrimExampleSuffix(name string) string {
+ if i := strings.LastIndex(name, "_"); i != -1 {
+ if i < len(name)-1 && !startsWithUppercase(name[i+1:]) {
+ name = name[:i]
+ }
+ }
+ return name
+}
+
+func startsWithUppercase(s string) bool {
+ r, _ := utf8.DecodeRuneInString(s)
+ return unicode.IsUpper(r)
+}
diff --git a/internal/pkgdoc/doc_test.go b/internal/pkgdoc/doc_test.go
new file mode 100644
index 0000000..c82d042
--- /dev/null
+++ b/internal/pkgdoc/doc_test.go
@@ -0,0 +1,65 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.16
+// +build go1.16
+
+package pkgdoc
+
+import (
+ "testing"
+ "testing/fstest"
+)
+
+// TestIgnoredGoFiles tests the scenario where a folder has no .go or .c files,
+// but has an ignored go file.
+func TestIgnoredGoFiles(t *testing.T) {
+ packagePath := "github.com/package"
+ packageComment := "main is documented in an ignored .go file"
+
+ fs := fstest.MapFS{
+ "src/" + packagePath + "/ignored.go": {Data: []byte(`// +build ignore
+
+// ` + packageComment + `
+package main`)},
+ }
+ d := NewDocs(fs)
+ pInfo := Doc(d, "/src/"+packagePath, packagePath, ModeAll, "linux", "amd64")
+
+ if pInfo.PDoc == nil {
+ t.Error("pInfo.PDoc = nil; want non-nil.")
+ } else {
+ if got, want := pInfo.PDoc.Doc, packageComment+"\n"; got != want {
+ t.Errorf("pInfo.PDoc.Doc = %q; want %q.", got, want)
+ }
+ if got, want := pInfo.PDoc.Name, "main"; got != want {
+ t.Errorf("pInfo.PDoc.Name = %q; want %q.", got, want)
+ }
+ if got, want := pInfo.PDoc.ImportPath, packagePath; got != want {
+ t.Errorf("pInfo.PDoc.ImportPath = %q; want %q.", got, want)
+ }
+ }
+ if pInfo.FSet == nil {
+ t.Error("pInfo.FSet = nil; want non-nil.")
+ }
+}
+
+func TestIssue5247(t *testing.T) {
+ const packagePath = "example.com/p"
+ fs := fstest.MapFS{
+ "src/" + packagePath + "/p.go": {Data: []byte(`package p
+
+//line notgen.go:3
+// F doc //line 1 should appear
+// line 2 should appear
+func F()
+//line foo.go:100`)}, // No newline at end to check corner cases.
+ }
+
+ d := NewDocs(fs)
+ pInfo := Doc(d, "/src/"+packagePath, packagePath, 0, "linux", "amd64")
+ if got, want := pInfo.PDoc.Funcs[0].Doc, "F doc //line 1 should appear\nline 2 should appear\n"; got != want {
+ t.Errorf("pInfo.PDoc.Funcs[0].Doc = %q; want %q", got, want)
+ }
+}
diff --git a/internal/proxy/proxy.go b/internal/proxy/proxy.go
new file mode 100644
index 0000000..cc740d6
--- /dev/null
+++ b/internal/proxy/proxy.go
@@ -0,0 +1,172 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package proxy proxies requests to the playground's compile and share handlers.
+// It is designed to run only on the instance of godoc that serves golang.org.
+package proxy
+
+import (
+ "bytes"
+ "context"
+ "encoding/json"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "log"
+ "net/http"
+ "strings"
+ "time"
+
+ "golang.org/x/website/internal/env"
+)
+
+const playgroundURL = "https://play.golang.org"
+
+type Request struct {
+ Body string
+}
+
+type Response struct {
+ Errors string
+ Events []Event
+}
+
+type Event struct {
+ Message string
+ Kind string // "stdout" or "stderr"
+ Delay time.Duration // time to wait before printing Message
+}
+
+const expires = 7 * 24 * time.Hour // 1 week
+var cacheControlHeader = fmt.Sprintf("public, max-age=%d", int(expires.Seconds()))
+
+func RegisterHandlers(mux *http.ServeMux) {
+ mux.HandleFunc("/compile", compile)
+ mux.HandleFunc("/share", share)
+}
+
+func compile(w http.ResponseWriter, r *http.Request) {
+ if r.Method != "POST" {
+ http.Error(w, "I only answer to POST requests.", http.StatusMethodNotAllowed)
+ return
+ }
+
+ ctx := r.Context()
+
+ body := r.FormValue("body")
+ res := &Response{}
+ req := &Request{Body: body}
+ if err := makeCompileRequest(ctx, req, res); err != nil {
+ log.Printf("ERROR compile error: %v", err)
+ http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+ return
+ }
+
+ var out interface{}
+ switch r.FormValue("version") {
+ case "2":
+ out = res
+ default: // "1"
+ out = struct {
+ CompileErrors string `json:"compile_errors"`
+ Output string `json:"output"`
+ }{res.Errors, flatten(res.Events)}
+ }
+ b, err := json.Marshal(out)
+ if err != nil {
+ log.Printf("ERROR encoding response: %v", err)
+ http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+ return
+ }
+
+ expiresTime := time.Now().Add(expires).UTC()
+ w.Header().Set("Expires", expiresTime.Format(time.RFC1123))
+ w.Header().Set("Cache-Control", cacheControlHeader)
+ w.Write(b)
+}
+
+// makePlaygroundRequest sends the given Request to the playground compile
+// endpoint and stores the response in the given Response.
+func makeCompileRequest(ctx context.Context, req *Request, res *Response) error {
+ reqJ, err := json.Marshal(req)
+ if err != nil {
+ return fmt.Errorf("marshalling request: %v", err)
+ }
+ hReq, _ := http.NewRequest("POST", playgroundURL+"/compile", bytes.NewReader(reqJ))
+ hReq.Header.Set("Content-Type", "application/json")
+ hReq = hReq.WithContext(ctx)
+
+ r, err := http.DefaultClient.Do(hReq)
+ if err != nil {
+ return fmt.Errorf("making request: %v", err)
+ }
+ defer r.Body.Close()
+
+ if r.StatusCode != http.StatusOK {
+ b, _ := ioutil.ReadAll(r.Body)
+ return fmt.Errorf("bad status: %v body:\n%s", r.Status, b)
+ }
+
+ if err := json.NewDecoder(r.Body).Decode(res); err != nil {
+ return fmt.Errorf("unmarshalling response: %v", err)
+ }
+ return nil
+}
+
+// flatten takes a sequence of Events and returns their contents, concatenated.
+func flatten(seq []Event) string {
+ var buf bytes.Buffer
+ for _, e := range seq {
+ buf.WriteString(e.Message)
+ }
+ return buf.String()
+}
+
+func share(w http.ResponseWriter, r *http.Request) {
+ if googleCN(r) {
+ http.Error(w, http.StatusText(http.StatusForbidden), http.StatusForbidden)
+ return
+ }
+
+ // HACK(cbro): use a simple proxy rather than httputil.ReverseProxy because of Issue #28168.
+ // TODO: investigate using ReverseProxy with a Director, unsetting whatever's necessary to make that work.
+ req, _ := http.NewRequest("POST", playgroundURL+"/share", r.Body)
+ req.Header.Set("Content-Type", r.Header.Get("Content-Type"))
+ req = req.WithContext(r.Context())
+ resp, err := http.DefaultClient.Do(req)
+ if err != nil {
+ log.Printf("ERROR share error: %v", err)
+ http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+ return
+ }
+ copyHeader := func(k string) {
+ if v := resp.Header.Get(k); v != "" {
+ w.Header().Set(k, v)
+ }
+ }
+ copyHeader("Content-Type")
+ copyHeader("Content-Length")
+ defer resp.Body.Close()
+ w.WriteHeader(resp.StatusCode)
+ io.Copy(w, resp.Body)
+}
+
+// googleCN reports whether request r is considered
+// to be served from golang.google.cn.
+func googleCN(r *http.Request) bool {
+ if r.FormValue("googlecn") != "" {
+ return true
+ }
+ if strings.HasSuffix(r.Host, ".cn") {
+ return true
+ }
+ if !env.CheckCountry() {
+ return false
+ }
+ switch r.Header.Get("X-Appengine-Country") {
+ case "", "ZZ", "CN":
+ return true
+ }
+ return false
+}
diff --git a/internal/redirect/hash.go b/internal/redirect/hash.go
new file mode 100644
index 0000000..d5a1e3e
--- /dev/null
+++ b/internal/redirect/hash.go
@@ -0,0 +1,138 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file provides a compact encoding of
+// a map of Mercurial hashes to Git hashes.
+
+package redirect
+
+import (
+ "encoding/binary"
+ "fmt"
+ "io"
+ "os"
+ "sort"
+ "strconv"
+ "strings"
+)
+
+// hashMap is a map of Mercurial hashes to Git hashes.
+type hashMap struct {
+ file *os.File
+ entries int
+}
+
+// newHashMap takes a file handle that contains a map of Mercurial to Git
+// hashes. The file should be a sequence of pairs of little-endian encoded
+// uint32s, representing a hgHash and a gitHash respectively.
+// The sequence must be sorted by hgHash.
+// The file must remain open for as long as the returned hashMap is used.
+func newHashMap(f *os.File) (*hashMap, error) {
+ fi, err := f.Stat()
+ if err != nil {
+ return nil, err
+ }
+ return &hashMap{file: f, entries: int(fi.Size() / 8)}, nil
+}
+
+// Lookup finds an hgHash in the map that matches the given prefix, and returns
+// its corresponding gitHash. The prefix must be at least 8 characters long.
+func (m *hashMap) Lookup(s string) gitHash {
+ if m == nil {
+ return 0
+ }
+ hg, err := hgHashFromString(s)
+ if err != nil {
+ return 0
+ }
+ var git gitHash
+ b := make([]byte, 8)
+ sort.Search(m.entries, func(i int) bool {
+ n, err := m.file.ReadAt(b, int64(i*8))
+ if err != nil {
+ panic(err)
+ }
+ if n != 8 {
+ panic(io.ErrUnexpectedEOF)
+ }
+ v := hgHash(binary.LittleEndian.Uint32(b[:4]))
+ if v == hg {
+ git = gitHash(binary.LittleEndian.Uint32(b[4:]))
+ }
+ return v >= hg
+ })
+ return git
+}
+
+// hgHash represents the lower (leftmost) 32 bits of a Mercurial hash.
+type hgHash uint32
+
+func (h hgHash) String() string {
+ return intToHash(int64(h))
+}
+
+func hgHashFromString(s string) (hgHash, error) {
+ if len(s) < 8 {
+ return 0, fmt.Errorf("string too small: len(s) = %d", len(s))
+ }
+ hash := s[:8]
+ i, err := strconv.ParseInt(hash, 16, 64)
+ if err != nil {
+ return 0, err
+ }
+ return hgHash(i), nil
+}
+
+// gitHash represents the leftmost 28 bits of a Git hash in its upper 28 bits,
+// and it encodes hash's repository in the lower 4 bits.
+type gitHash uint32
+
+func (h gitHash) Hash() string {
+ return intToHash(int64(h))[:7]
+}
+
+func (h gitHash) Repo() string {
+ return repo(h & 0xF).String()
+}
+
+func intToHash(i int64) string {
+ s := strconv.FormatInt(i, 16)
+ if len(s) < 8 {
+ s = strings.Repeat("0", 8-len(s)) + s
+ }
+ return s
+}
+
+// repo represents a Go Git repository.
+type repo byte
+
+const (
+ repoGo repo = iota
+ repoBlog
+ repoCrypto
+ repoExp
+ repoImage
+ repoMobile
+ repoNet
+ repoSys
+ repoTalks
+ repoText
+ repoTools
+)
+
+func (r repo) String() string {
+ return map[repo]string{
+ repoGo: "go",
+ repoBlog: "blog",
+ repoCrypto: "crypto",
+ repoExp: "exp",
+ repoImage: "image",
+ repoMobile: "mobile",
+ repoNet: "net",
+ repoSys: "sys",
+ repoTalks: "talks",
+ repoText: "text",
+ repoTools: "tools",
+ }[r]
+}
diff --git a/internal/redirect/redirect.go b/internal/redirect/redirect.go
new file mode 100644
index 0000000..bcfd6a0
--- /dev/null
+++ b/internal/redirect/redirect.go
@@ -0,0 +1,324 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package redirect provides hooks to register HTTP handlers that redirect old
+// godoc paths to their new equivalents and assist in accessing the issue
+// tracker, wiki, code review system, etc.
+package redirect // import "golang.org/x/website/internal/redirect"
+
+import (
+ "context"
+ "fmt"
+ "html/template"
+ "net/http"
+ "os"
+ "regexp"
+ "strconv"
+ "strings"
+ "sync"
+ "time"
+
+ "golang.org/x/net/context/ctxhttp"
+)
+
+// Register registers HTTP handlers that redirect old godoc paths to their new
+// equivalents and assist in accessing the issue tracker, wiki, code review
+// system, etc. If mux is nil it uses http.DefaultServeMux.
+func Register(mux *http.ServeMux) {
+ if mux == nil {
+ mux = http.DefaultServeMux
+ }
+ handlePathRedirects(mux, pkgRedirects, "/pkg/")
+ handlePathRedirects(mux, cmdRedirects, "/cmd/")
+ for prefix, redirect := range prefixHelpers {
+ p := "/" + prefix + "/"
+ mux.Handle(p, PrefixHandler(p, redirect))
+ }
+ for path, redirect := range redirects {
+ mux.Handle(path, Handler(redirect))
+ }
+ // NB: /src/pkg (sans trailing slash) is the index of packages.
+ mux.HandleFunc("/src/pkg/", srcPkgHandler)
+ mux.HandleFunc("/cl/", clHandler)
+ mux.HandleFunc("/change/", changeHandler)
+ mux.HandleFunc("/design/", designHandler)
+}
+
+func handlePathRedirects(mux *http.ServeMux, redirects map[string]string, prefix string) {
+ for source, target := range redirects {
+ h := Handler(prefix + target + "/")
+ p := prefix + source
+ mux.Handle(p, h)
+ mux.Handle(p+"/", h)
+ }
+}
+
+// Packages that were renamed between r60 and go1.
+var pkgRedirects = map[string]string{
+ "asn1": "encoding/asn1",
+ "big": "math/big",
+ "cmath": "math/cmplx",
+ "csv": "encoding/csv",
+ "exec": "os/exec",
+ "exp/template/html": "html/template",
+ "gob": "encoding/gob",
+ "http": "net/http",
+ "http/cgi": "net/http/cgi",
+ "http/fcgi": "net/http/fcgi",
+ "http/httptest": "net/http/httptest",
+ "http/pprof": "net/http/pprof",
+ "json": "encoding/json",
+ "mail": "net/mail",
+ "rand": "math/rand",
+ "rpc": "net/rpc",
+ "rpc/jsonrpc": "net/rpc/jsonrpc",
+ "scanner": "text/scanner",
+ "smtp": "net/smtp",
+ "tabwriter": "text/tabwriter",
+ "template": "text/template",
+ "template/parse": "text/template/parse",
+ "url": "net/url",
+ "utf16": "unicode/utf16",
+ "utf8": "unicode/utf8",
+ "xml": "encoding/xml",
+}
+
+// Commands that were renamed between r60 and go1.
+var cmdRedirects = map[string]string{
+ "gofix": "fix",
+ "goinstall": "go",
+ "gopack": "pack",
+ "gotest": "go",
+ "govet": "vet",
+ "goyacc": "yacc",
+}
+
+var redirects = map[string]string{
+ "/blog": "/blog/",
+ "/build": "http://build.golang.org",
+ "/change": "https://go.googlesource.com/go",
+ "/cl": "https://go-review.googlesource.com",
+ "/cmd/godoc/": "https://pkg.go.dev/golang.org/x/tools/cmd/godoc",
+ "/issue": "https://github.com/golang/go/issues",
+ "/issue/new": "https://github.com/golang/go/issues/new",
+ "/issues": "https://github.com/golang/go/issues",
+ "/issues/new": "https://github.com/golang/go/issues/new",
+ "/play": "http://play.golang.org",
+ "/design": "https://go.googlesource.com/proposal/+/master/design",
+
+ // In Go 1.2 the references page is part of /doc/.
+ "/ref": "/doc/#references",
+ // This next rule clobbers /ref/spec and /ref/mem.
+ // TODO(adg): figure out what to do here, if anything.
+ // "/ref/": "/doc/#references",
+
+ // Be nice to people who are looking in the wrong place.
+ "/doc/mem": "/ref/mem",
+ "/doc/spec": "/ref/spec",
+
+ "/talks": "http://talks.golang.org",
+ "/tour": "http://tour.golang.org",
+ "/wiki": "https://github.com/golang/go/wiki",
+
+ "/doc/articles/c_go_cgo.html": "/blog/c-go-cgo",
+ "/doc/articles/concurrency_patterns.html": "/blog/go-concurrency-patterns-timing-out-and",
+ "/doc/articles/defer_panic_recover.html": "/blog/defer-panic-and-recover",
+ "/doc/articles/error_handling.html": "/blog/error-handling-and-go",
+ "/doc/articles/gobs_of_data.html": "/blog/gobs-of-data",
+ "/doc/articles/godoc_documenting_go_code.html": "/blog/godoc-documenting-go-code",
+ "/doc/articles/gos_declaration_syntax.html": "/blog/gos-declaration-syntax",
+ "/doc/articles/image_draw.html": "/blog/go-imagedraw-package",
+ "/doc/articles/image_package.html": "/blog/go-image-package",
+ "/doc/articles/json_and_go.html": "/blog/json-and-go",
+ "/doc/articles/json_rpc_tale_of_interfaces.html": "/blog/json-rpc-tale-of-interfaces",
+ "/doc/articles/laws_of_reflection.html": "/blog/laws-of-reflection",
+ "/doc/articles/slices_usage_and_internals.html": "/blog/go-slices-usage-and-internals",
+ "/doc/go_for_cpp_programmers.html": "/wiki/GoForCPPProgrammers",
+ "/doc/go_tutorial.html": "http://tour.golang.org/",
+}
+
+var prefixHelpers = map[string]string{
+ "issue": "https://github.com/golang/go/issues/",
+ "issues": "https://github.com/golang/go/issues/",
+ "play": "http://play.golang.org/",
+ "talks": "http://talks.golang.org/",
+ "wiki": "https://github.com/golang/go/wiki/",
+}
+
+func Handler(target string) http.Handler {
+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ url := target
+ if qs := r.URL.RawQuery; qs != "" {
+ url += "?" + qs
+ }
+ http.Redirect(w, r, url, http.StatusMovedPermanently)
+ })
+}
+
+var validID = regexp.MustCompile(`^[A-Za-z0-9-]*/?$`)
+
+func PrefixHandler(prefix, baseURL string) http.Handler {
+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if p := r.URL.Path; p == prefix {
+ // redirect /prefix/ to /prefix
+ http.Redirect(w, r, p[:len(p)-1], http.StatusFound)
+ return
+ }
+ id := r.URL.Path[len(prefix):]
+ if !validID.MatchString(id) {
+ http.Error(w, "Not found", http.StatusNotFound)
+ return
+ }
+ target := baseURL + id
+ http.Redirect(w, r, target, http.StatusFound)
+ })
+}
+
+// Redirect requests from the old "/src/pkg/foo" to the new "/src/foo".
+// See http://golang.org/s/go14nopkg
+func srcPkgHandler(w http.ResponseWriter, r *http.Request) {
+ r.URL.Path = "/src/" + r.URL.Path[len("/src/pkg/"):]
+ http.Redirect(w, r, r.URL.String(), http.StatusMovedPermanently)
+}
+
+func clHandler(w http.ResponseWriter, r *http.Request) {
+ const prefix = "/cl/"
+ if p := r.URL.Path; p == prefix {
+ // redirect /prefix/ to /prefix
+ http.Redirect(w, r, p[:len(p)-1], http.StatusFound)
+ return
+ }
+ id := r.URL.Path[len(prefix):]
+ // support /cl/152700045/, which is used in commit 0edafefc36.
+ id = strings.TrimSuffix(id, "/")
+ if !validID.MatchString(id) {
+ http.Error(w, "Not found", http.StatusNotFound)
+ return
+ }
+ target := ""
+
+ if n, err := strconv.Atoi(id); err == nil && isRietveldCL(n) {
+ // Issue 28836: if this Rietveld CL happens to
+ // also be a Gerrit CL, render a disambiguation HTML
+ // page with two links instead. We need to make a
+ // Gerrit API call to figure that out, but we cache
+ // known Gerrit CLs so it's done at most once per CL.
+ if ok, err := isGerritCL(r.Context(), n); err == nil && ok {
+ w.Header().Set("Content-Type", "text/html; charset=utf-8")
+ clDisambiguationHTML.Execute(w, n)
+ return
+ }
+
+ target = "https://codereview.appspot.com/" + id
+ } else {
+ target = "https://go-review.googlesource.com/" + id
+ }
+ http.Redirect(w, r, target, http.StatusFound)
+}
+
+var clDisambiguationHTML = template.Must(template.New("").Parse(`<!DOCTYPE html>
+<html lang="en">
+ <head>
+ <title>Go CL {{.}} Disambiguation</title>
+ <meta name="viewport" content="width=device-width">
+ </head>
+ <body>
+ CL number {{.}} exists in both Gerrit (the current code review system)
+ and Rietveld (the previous code review system). Please make a choice:
+
+ <ul>
+ <li><a href="https://go-review.googlesource.com/{{.}}">Gerrit CL {{.}}</a></li>
+ <li><a href="https://codereview.appspot.com/{{.}}">Rietveld CL {{.}}</a></li>
+ </ul>
+ </body>
+</html>`))
+
+// isGerritCL reports whether a Gerrit CL with the specified numeric change ID (e.g., "4247")
+// is known to exist by querying the Gerrit API at https://go-review.googlesource.com.
+// isGerritCL uses gerritCLCache as a cache of Gerrit CL IDs that exist.
+func isGerritCL(ctx context.Context, id int) (bool, error) {
+ // Check cache first.
+ gerritCLCache.Lock()
+ ok := gerritCLCache.exist[id]
+ gerritCLCache.Unlock()
+ if ok {
+ return true, nil
+ }
+
+ // Query the Gerrit API Get Change endpoint, as documented at
+ // https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#get-change.
+ ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
+ defer cancel()
+ resp, err := ctxhttp.Get(ctx, nil, fmt.Sprintf("https://go-review.googlesource.com/changes/%d", id))
+ if err != nil {
+ return false, err
+ }
+ resp.Body.Close()
+ switch resp.StatusCode {
+ case http.StatusOK:
+ // A Gerrit CL with this ID exists. Add it to cache.
+ gerritCLCache.Lock()
+ gerritCLCache.exist[id] = true
+ gerritCLCache.Unlock()
+ return true, nil
+ case http.StatusNotFound:
+ // A Gerrit CL with this ID doesn't exist. It may get created in the future.
+ return false, nil
+ default:
+ return false, fmt.Errorf("unexpected status code: %v", resp.Status)
+ }
+}
+
+var gerritCLCache = struct {
+ sync.Mutex
+ exist map[int]bool // exist is a set of Gerrit CL IDs that are known to exist.
+}{exist: make(map[int]bool)}
+
+var changeMap *hashMap
+
+// LoadChangeMap loads the specified map of Mercurial to Git revisions,
+// which is used by the /change/ handler to intelligently map old hg
+// revisions to their new git equivalents.
+// It should be called before calling Register.
+// The file should remain open as long as the process is running.
+// See the implementation of this package for details.
+func LoadChangeMap(filename string) error {
+ f, err := os.Open(filename)
+ if err != nil {
+ return err
+ }
+ m, err := newHashMap(f)
+ if err != nil {
+ return err
+ }
+ changeMap = m
+ return nil
+}
+
+func changeHandler(w http.ResponseWriter, r *http.Request) {
+ const prefix = "/change/"
+ if p := r.URL.Path; p == prefix {
+ // redirect /prefix/ to /prefix
+ http.Redirect(w, r, p[:len(p)-1], http.StatusFound)
+ return
+ }
+ hash := r.URL.Path[len(prefix):]
+ target := "https://go.googlesource.com/go/+/" + hash
+ if git := changeMap.Lookup(hash); git > 0 {
+ target = fmt.Sprintf("https://go.googlesource.com/%v/+/%v", git.Repo(), git.Hash())
+ }
+ http.Redirect(w, r, target, http.StatusFound)
+}
+
+func designHandler(w http.ResponseWriter, r *http.Request) {
+ const prefix = "/design/"
+ if p := r.URL.Path; p == prefix {
+ // redirect /prefix/ to /prefix
+ http.Redirect(w, r, p[:len(p)-1], http.StatusFound)
+ return
+ }
+ name := r.URL.Path[len(prefix):]
+ target := "https://go.googlesource.com/proposal/+/master/design/" + name + ".md"
+ http.Redirect(w, r, target, http.StatusFound)
+}
diff --git a/internal/redirect/redirect_test.go b/internal/redirect/redirect_test.go
new file mode 100644
index 0000000..1c9ad64
--- /dev/null
+++ b/internal/redirect/redirect_test.go
@@ -0,0 +1,113 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package redirect
+
+import (
+ "net/http"
+ "net/http/httptest"
+ "testing"
+)
+
+type redirectResult struct {
+ status int
+ path string
+}
+
+func errorResult(status int) redirectResult {
+ return redirectResult{status, ""}
+}
+
+func TestRedirects(t *testing.T) {
+ var tests = map[string]redirectResult{
+ "/build": {301, "http://build.golang.org"},
+ "/ref": {301, "/doc/#references"},
+ "/doc/mem": {301, "/ref/mem"},
+ "/doc/spec": {301, "/ref/spec"},
+ "/tour": {301, "http://tour.golang.org"},
+ "/foo": errorResult(404),
+
+ "/pkg/asn1": {301, "/pkg/encoding/asn1/"},
+ "/pkg/template/parse": {301, "/pkg/text/template/parse/"},
+
+ "/src/pkg/foo": {301, "/src/foo"},
+
+ "/cmd/gofix": {301, "/cmd/fix/"},
+
+ // git commits (/change)
+ // TODO: mercurial tags and LoadChangeMap.
+ "/change": {301, "https://go.googlesource.com/go"},
+ "/change/a": {302, "https://go.googlesource.com/go/+/a"},
+
+ "/issue": {301, "https://github.com/golang/go/issues"},
+ "/issue?": {301, "https://github.com/golang/go/issues"},
+ "/issue/1": {302, "https://github.com/golang/go/issues/1"},
+ "/issue/new": {301, "https://github.com/golang/go/issues/new"},
+ "/issue/new?a=b&c=d%20&e=f": {301, "https://github.com/golang/go/issues/new?a=b&c=d%20&e=f"},
+ "/issues": {301, "https://github.com/golang/go/issues"},
+ "/issues/1": {302, "https://github.com/golang/go/issues/1"},
+ "/issues/new": {301, "https://github.com/golang/go/issues/new"},
+ "/issues/1/2/3": errorResult(404),
+
+ "/wiki/foo": {302, "https://github.com/golang/go/wiki/foo"},
+ "/wiki/foo/": {302, "https://github.com/golang/go/wiki/foo/"},
+
+ "/design": {301, "https://go.googlesource.com/proposal/+/master/design"},
+ "/design/": {302, "/design"},
+ "/design/123-foo": {302, "https://go.googlesource.com/proposal/+/master/design/123-foo.md"},
+ "/design/text/123-foo": {302, "https://go.googlesource.com/proposal/+/master/design/text/123-foo.md"},
+
+ "/cl/1": {302, "https://go-review.googlesource.com/1"},
+ "/cl/1/": {302, "https://go-review.googlesource.com/1"},
+ "/cl/267120043": {302, "https://codereview.appspot.com/267120043"},
+ "/cl/267120043/": {302, "https://codereview.appspot.com/267120043"},
+
+ // Verify that we're using the Rietveld CL table:
+ "/cl/152046": {302, "https://codereview.appspot.com/152046"},
+ "/cl/152047": {302, "https://go-review.googlesource.com/152047"},
+ "/cl/152048": {302, "https://codereview.appspot.com/152048"},
+
+ // And verify we're using the "bigEnoughAssumeRietveld" value:
+ "/cl/3999999": {302, "https://go-review.googlesource.com/3999999"},
+ "/cl/4000000": {302, "https://codereview.appspot.com/4000000"},
+ }
+
+ mux := http.NewServeMux()
+ Register(mux)
+ ts := httptest.NewServer(mux)
+ defer ts.Close()
+
+ for path, want := range tests {
+ if want.path != "" && want.path[0] == '/' {
+ // All redirects are absolute.
+ want.path = ts.URL + want.path
+ }
+
+ req, err := http.NewRequest("GET", ts.URL+path, nil)
+ if err != nil {
+ t.Errorf("(path: %q) unexpected error: %v", path, err)
+ continue
+ }
+
+ resp, err := http.DefaultTransport.RoundTrip(req)
+ if err != nil {
+ t.Errorf("(path: %q) unexpected error: %v", path, err)
+ continue
+ }
+
+ if resp.StatusCode != want.status {
+ t.Errorf("(path: %q) got status %d, want %d", path, resp.StatusCode, want.status)
+ }
+
+ if want.status != 301 && want.status != 302 {
+ // Not a redirect. Just check status.
+ continue
+ }
+
+ out, _ := resp.Location()
+ if got := out.String(); got != want.path {
+ t.Errorf("(path: %q) got %s, want %s", path, got, want.path)
+ }
+ }
+}
diff --git a/internal/redirect/rietveld.go b/internal/redirect/rietveld.go
new file mode 100644
index 0000000..2a5c6a7
--- /dev/null
+++ b/internal/redirect/rietveld.go
@@ -0,0 +1,3269 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package redirect
+
+// bigEnoughAssumeRietveld is the value where CLs equal or great are
+// assumed to be on Rietveld. By including this threshold we shrink
+// the size of the table below. When Go amasses more CLs, we'll need
+// to bump this number, regenerate the list below, and handle subrepos
+// (see below).
+const bigEnoughAssumeRietveld = 4000000
+
+// isRietveldCL reports whether cl was a Rietveld CL number.
+func isRietveldCL(cl int) bool {
+ return cl >= bigEnoughAssumeRietveld || lowRietveldCL[cl]
+}
+
+// lowRietveldCLs are the old CL numbers assigned by Rietveld code
+// review system as used by Go prior to Gerrit which are less than
+// bigEnoughAssumeRietveld.
+//
+// This list of numbers is registered with the /cl/NNNN redirect
+// handler to disambiguate which code review system a particular
+// number corresponds to. In some rare cases there may be duplicates,
+// in which case we might render an HTML choice for the user.
+//
+// To re-generate this list, run:
+//
+// $ cd $GOROOT
+// $ git log 7d7c6a9..94151eb | grep "^ https://golang.org/cl/" | perl -ne 's,^\s+https://golang.org/cl/(\d+).*$,$1,; chomp; print "$_: true,\n" if $_ < 4000000' | sort -n | uniq
+//
+// Note that we ignore the x/* repos because we didn't start using
+// "subrepos" until the Rietveld CLs numbers were already 4,000,000+,
+// above bigEnoughAssumeRietveld.
+var lowRietveldCL = map[int]bool{
+ 152046: true,
+ 152048: true,
+ 152049: true,
+ 152050: true,
+ 152051: true,
+ 152052: true,
+ 152055: true,
+ 152056: true,
+ 152057: true,
+ 152072: true,
+ 152073: true,
+ 152075: true,
+ 152076: true,
+ 152077: true,
+ 152078: true,
+ 152079: true,
+ 152080: true,
+ 152082: true,
+ 152084: true,
+ 152085: true,
+ 152086: true,
+ 152088: true,
+ 152089: true,
+ 152091: true,
+ 152098: true,
+ 152101: true,
+ 152102: true,
+ 152105: true,
+ 152106: true,
+ 152107: true,
+ 152108: true,
+ 152109: true,
+ 152110: true,
+ 152114: true,
+ 152117: true,
+ 152118: true,
+ 152120: true,
+ 152123: true,
+ 152124: true,
+ 152128: true,
+ 152130: true,
+ 152131: true,
+ 152138: true,
+ 152141: true,
+ 152142: true,
+ 153048: true,
+ 153049: true,
+ 153050: true,
+ 153051: true,
+ 153055: true,
+ 153056: true,
+ 153057: true,
+ 154043: true,
+ 154044: true,
+ 154045: true,
+ 154049: true,
+ 154055: true,
+ 154057: true,
+ 154058: true,
+ 154059: true,
+ 154061: true,
+ 154064: true,
+ 154065: true,
+ 154067: true,
+ 154068: true,
+ 154069: true,
+ 154071: true,
+ 154072: true,
+ 154073: true,
+ 154076: true,
+ 154079: true,
+ 154096: true,
+ 154097: true,
+ 154099: true,
+ 154100: true,
+ 154101: true,
+ 154102: true,
+ 154108: true,
+ 154118: true,
+ 154121: true,
+ 154122: true,
+ 154123: true,
+ 154125: true,
+ 154126: true,
+ 154128: true,
+ 154136: true,
+ 154138: true,
+ 154139: true,
+ 154140: true,
+ 154141: true,
+ 154142: true,
+ 154143: true,
+ 154144: true,
+ 154145: true,
+ 154146: true,
+ 154152: true,
+ 154153: true,
+ 154156: true,
+ 154159: true,
+ 154161: true,
+ 154166: true,
+ 154167: true,
+ 154169: true,
+ 154171: true,
+ 154172: true,
+ 154173: true,
+ 154174: true,
+ 154175: true,
+ 154176: true,
+ 154177: true,
+ 154178: true,
+ 154179: true,
+ 154180: true,
+ 155041: true,
+ 155042: true,
+ 155045: true,
+ 155047: true,
+ 155048: true,
+ 155049: true,
+ 155050: true,
+ 155054: true,
+ 155055: true,
+ 155056: true,
+ 155057: true,
+ 155058: true,
+ 155059: true,
+ 155061: true,
+ 155062: true,
+ 155063: true,
+ 155065: true,
+ 155067: true,
+ 155069: true,
+ 155072: true,
+ 155074: true,
+ 155075: true,
+ 155077: true,
+ 155078: true,
+ 155079: true,
+ 156041: true,
+ 156044: true,
+ 156045: true,
+ 156046: true,
+ 156047: true,
+ 156051: true,
+ 156052: true,
+ 156054: true,
+ 156055: true,
+ 156056: true,
+ 156058: true,
+ 156059: true,
+ 156060: true,
+ 156061: true,
+ 156062: true,
+ 156063: true,
+ 156066: true,
+ 156067: true,
+ 156070: true,
+ 156071: true,
+ 156073: true,
+ 156075: true,
+ 156077: true,
+ 156079: true,
+ 156080: true,
+ 156081: true,
+ 156083: true,
+ 156084: true,
+ 156085: true,
+ 156086: true,
+ 156089: true,
+ 156091: true,
+ 156092: true,
+ 156093: true,
+ 156094: true,
+ 156097: true,
+ 156099: true,
+ 156100: true,
+ 156102: true,
+ 156103: true,
+ 156104: true,
+ 156106: true,
+ 156107: true,
+ 156108: true,
+ 156109: true,
+ 156110: true,
+ 156113: true,
+ 156115: true,
+ 156116: true,
+ 157041: true,
+ 157042: true,
+ 157043: true,
+ 157044: true,
+ 157046: true,
+ 157053: true,
+ 157055: true,
+ 157056: true,
+ 157058: true,
+ 157060: true,
+ 157061: true,
+ 157062: true,
+ 157065: true,
+ 157066: true,
+ 157067: true,
+ 157068: true,
+ 157069: true,
+ 157071: true,
+ 157072: true,
+ 157073: true,
+ 157074: true,
+ 157075: true,
+ 157076: true,
+ 157077: true,
+ 157082: true,
+ 157084: true,
+ 157085: true,
+ 157087: true,
+ 157088: true,
+ 157091: true,
+ 157095: true,
+ 157096: true,
+ 157099: true,
+ 157100: true,
+ 157101: true,
+ 157102: true,
+ 157103: true,
+ 157104: true,
+ 157106: true,
+ 157110: true,
+ 157111: true,
+ 157112: true,
+ 157114: true,
+ 157116: true,
+ 157119: true,
+ 157140: true,
+ 157142: true,
+ 157143: true,
+ 157144: true,
+ 157146: true,
+ 157147: true,
+ 157149: true,
+ 157151: true,
+ 157152: true,
+ 157153: true,
+ 157154: true,
+ 157156: true,
+ 157157: true,
+ 157158: true,
+ 157159: true,
+ 157160: true,
+ 157162: true,
+ 157166: true,
+ 157167: true,
+ 157168: true,
+ 157170: true,
+ 158041: true,
+ 159044: true,
+ 159049: true,
+ 159050: true,
+ 159051: true,
+ 160043: true,
+ 160044: true,
+ 160045: true,
+ 160046: true,
+ 160047: true,
+ 160054: true,
+ 160056: true,
+ 160057: true,
+ 160059: true,
+ 160060: true,
+ 160061: true,
+ 160064: true,
+ 160065: true,
+ 160069: true,
+ 160070: true,
+ 161049: true,
+ 161050: true,
+ 161056: true,
+ 161058: true,
+ 161060: true,
+ 161061: true,
+ 161069: true,
+ 161070: true,
+ 161073: true,
+ 161075: true,
+ 162041: true,
+ 162044: true,
+ 162046: true,
+ 162053: true,
+ 162054: true,
+ 162055: true,
+ 162056: true,
+ 162057: true,
+ 162058: true,
+ 162059: true,
+ 162061: true,
+ 162062: true,
+ 163042: true,
+ 163044: true,
+ 163049: true,
+ 163050: true,
+ 163051: true,
+ 163052: true,
+ 163053: true,
+ 163055: true,
+ 163058: true,
+ 163061: true,
+ 163062: true,
+ 163064: true,
+ 163067: true,
+ 163068: true,
+ 163069: true,
+ 163070: true,
+ 163071: true,
+ 163072: true,
+ 163082: true,
+ 163083: true,
+ 163085: true,
+ 163088: true,
+ 163091: true,
+ 163092: true,
+ 163097: true,
+ 163098: true,
+ 164043: true,
+ 164047: true,
+ 164049: true,
+ 164052: true,
+ 164053: true,
+ 164056: true,
+ 164059: true,
+ 164060: true,
+ 164062: true,
+ 164068: true,
+ 164069: true,
+ 164071: true,
+ 164073: true,
+ 164074: true,
+ 164075: true,
+ 164078: true,
+ 164079: true,
+ 164081: true,
+ 164082: true,
+ 164083: true,
+ 164085: true,
+ 164086: true,
+ 164088: true,
+ 164090: true,
+ 164091: true,
+ 164092: true,
+ 164093: true,
+ 164094: true,
+ 164095: true,
+ 165042: true,
+ 165044: true,
+ 165045: true,
+ 165048: true,
+ 165049: true,
+ 165050: true,
+ 165051: true,
+ 165055: true,
+ 165057: true,
+ 165058: true,
+ 165059: true,
+ 165061: true,
+ 165062: true,
+ 165063: true,
+ 165064: true,
+ 165065: true,
+ 165068: true,
+ 165070: true,
+ 165076: true,
+ 165078: true,
+ 165080: true,
+ 165083: true,
+ 165086: true,
+ 165097: true,
+ 165100: true,
+ 165101: true,
+ 166041: true,
+ 166043: true,
+ 166044: true,
+ 166047: true,
+ 166049: true,
+ 166052: true,
+ 166053: true,
+ 166055: true,
+ 166058: true,
+ 166059: true,
+ 166060: true,
+ 166064: true,
+ 166066: true,
+ 166067: true,
+ 166068: true,
+ 166070: true,
+ 166071: true,
+ 166072: true,
+ 166073: true,
+ 166074: true,
+ 166076: true,
+ 166077: true,
+ 166078: true,
+ 166080: true,
+ 167043: true,
+ 167044: true,
+ 167047: true,
+ 167050: true,
+ 167055: true,
+ 167057: true,
+ 167058: true,
+ 168041: true,
+ 168045: true,
+ 170042: true,
+ 170043: true,
+ 170044: true,
+ 170046: true,
+ 170047: true,
+ 170048: true,
+ 170049: true,
+ 171044: true,
+ 171046: true,
+ 171047: true,
+ 171048: true,
+ 171051: true,
+ 172041: true,
+ 172042: true,
+ 172043: true,
+ 172045: true,
+ 172049: true,
+ 173041: true,
+ 173044: true,
+ 173045: true,
+ 174042: true,
+ 174047: true,
+ 174048: true,
+ 174050: true,
+ 174051: true,
+ 174052: true,
+ 174053: true,
+ 174063: true,
+ 174064: true,
+ 174072: true,
+ 174076: true,
+ 174077: true,
+ 174078: true,
+ 174082: true,
+ 174083: true,
+ 174087: true,
+ 175045: true,
+ 175046: true,
+ 175047: true,
+ 175048: true,
+ 176056: true,
+ 176057: true,
+ 176058: true,
+ 176061: true,
+ 176062: true,
+ 176063: true,
+ 176064: true,
+ 176066: true,
+ 176067: true,
+ 176070: true,
+ 176071: true,
+ 176076: true,
+ 178043: true,
+ 178044: true,
+ 178046: true,
+ 178048: true,
+ 179047: true,
+ 179055: true,
+ 179061: true,
+ 179062: true,
+ 179063: true,
+ 179067: true,
+ 179069: true,
+ 179070: true,
+ 179072: true,
+ 179079: true,
+ 179088: true,
+ 179095: true,
+ 179096: true,
+ 179097: true,
+ 179099: true,
+ 179105: true,
+ 179106: true,
+ 179108: true,
+ 179118: true,
+ 179120: true,
+ 179125: true,
+ 179126: true,
+ 179128: true,
+ 179129: true,
+ 179130: true,
+ 180044: true,
+ 180045: true,
+ 180046: true,
+ 180047: true,
+ 180048: true,
+ 180049: true,
+ 180050: true,
+ 180052: true,
+ 180053: true,
+ 180054: true,
+ 180055: true,
+ 180056: true,
+ 180057: true,
+ 180059: true,
+ 180061: true,
+ 180064: true,
+ 180065: true,
+ 180068: true,
+ 180069: true,
+ 180070: true,
+ 180074: true,
+ 180075: true,
+ 180081: true,
+ 180082: true,
+ 180085: true,
+ 180092: true,
+ 180099: true,
+ 180105: true,
+ 180108: true,
+ 180112: true,
+ 180118: true,
+ 181041: true,
+ 181043: true,
+ 181044: true,
+ 181045: true,
+ 181049: true,
+ 181050: true,
+ 181055: true,
+ 181057: true,
+ 181058: true,
+ 181059: true,
+ 181063: true,
+ 181071: true,
+ 181073: true,
+ 181075: true,
+ 181077: true,
+ 181080: true,
+ 181083: true,
+ 181084: true,
+ 181085: true,
+ 181086: true,
+ 181087: true,
+ 181089: true,
+ 181097: true,
+ 181099: true,
+ 181102: true,
+ 181111: true,
+ 181130: true,
+ 181135: true,
+ 181137: true,
+ 181138: true,
+ 181139: true,
+ 181151: true,
+ 181152: true,
+ 181153: true,
+ 181155: true,
+ 181156: true,
+ 181157: true,
+ 181158: true,
+ 181160: true,
+ 181161: true,
+ 181163: true,
+ 181164: true,
+ 181171: true,
+ 181179: true,
+ 181183: true,
+ 181184: true,
+ 181186: true,
+ 182041: true,
+ 182043: true,
+ 182044: true,
+ 183042: true,
+ 183043: true,
+ 183044: true,
+ 183047: true,
+ 183049: true,
+ 183065: true,
+ 183066: true,
+ 183073: true,
+ 183074: true,
+ 183075: true,
+ 183083: true,
+ 183084: true,
+ 183087: true,
+ 183088: true,
+ 183090: true,
+ 183095: true,
+ 183104: true,
+ 183107: true,
+ 183109: true,
+ 183111: true,
+ 183112: true,
+ 183113: true,
+ 183116: true,
+ 183123: true,
+ 183124: true,
+ 183125: true,
+ 183126: true,
+ 183132: true,
+ 183133: true,
+ 183135: true,
+ 183136: true,
+ 183137: true,
+ 183138: true,
+ 183139: true,
+ 183140: true,
+ 183141: true,
+ 183142: true,
+ 183153: true,
+ 183155: true,
+ 183156: true,
+ 183157: true,
+ 183160: true,
+ 184043: true,
+ 184055: true,
+ 184058: true,
+ 184059: true,
+ 184068: true,
+ 184069: true,
+ 184079: true,
+ 184080: true,
+ 184081: true,
+ 185043: true,
+ 185045: true,
+ 186042: true,
+ 186043: true,
+ 186073: true,
+ 186076: true,
+ 186077: true,
+ 186078: true,
+ 186079: true,
+ 186081: true,
+ 186095: true,
+ 186108: true,
+ 186113: true,
+ 186115: true,
+ 186116: true,
+ 186118: true,
+ 186119: true,
+ 186132: true,
+ 186137: true,
+ 186138: true,
+ 186139: true,
+ 186143: true,
+ 186144: true,
+ 186145: true,
+ 186146: true,
+ 186147: true,
+ 186148: true,
+ 186159: true,
+ 186160: true,
+ 186161: true,
+ 186165: true,
+ 186169: true,
+ 186173: true,
+ 186180: true,
+ 186210: true,
+ 186211: true,
+ 186212: true,
+ 186213: true,
+ 186214: true,
+ 186215: true,
+ 186216: true,
+ 186228: true,
+ 186229: true,
+ 186230: true,
+ 186232: true,
+ 186234: true,
+ 186255: true,
+ 186263: true,
+ 186276: true,
+ 186279: true,
+ 186282: true,
+ 186283: true,
+ 188043: true,
+ 189042: true,
+ 189057: true,
+ 189059: true,
+ 189062: true,
+ 189078: true,
+ 189080: true,
+ 189083: true,
+ 189088: true,
+ 189093: true,
+ 189095: true,
+ 189096: true,
+ 189098: true,
+ 189100: true,
+ 190041: true,
+ 190042: true,
+ 190043: true,
+ 190044: true,
+ 190059: true,
+ 190062: true,
+ 190068: true,
+ 190074: true,
+ 190076: true,
+ 190077: true,
+ 190079: true,
+ 190085: true,
+ 190088: true,
+ 190103: true,
+ 190104: true,
+ 193055: true,
+ 193066: true,
+ 193067: true,
+ 193070: true,
+ 193075: true,
+ 193079: true,
+ 193080: true,
+ 193081: true,
+ 193091: true,
+ 193092: true,
+ 193095: true,
+ 193101: true,
+ 193104: true,
+ 194043: true,
+ 194045: true,
+ 194046: true,
+ 194050: true,
+ 194051: true,
+ 194052: true,
+ 194053: true,
+ 194064: true,
+ 194066: true,
+ 194069: true,
+ 194071: true,
+ 194072: true,
+ 194073: true,
+ 194074: true,
+ 194076: true,
+ 194077: true,
+ 194078: true,
+ 194082: true,
+ 194084: true,
+ 194085: true,
+ 194090: true,
+ 194091: true,
+ 194092: true,
+ 194094: true,
+ 194097: true,
+ 194098: true,
+ 194099: true,
+ 194100: true,
+ 194114: true,
+ 194116: true,
+ 194118: true,
+ 194119: true,
+ 194120: true,
+ 194121: true,
+ 194122: true,
+ 194126: true,
+ 194129: true,
+ 194131: true,
+ 194132: true,
+ 194133: true,
+ 194134: true,
+ 194146: true,
+ 194151: true,
+ 194156: true,
+ 194157: true,
+ 194159: true,
+ 194161: true,
+ 194165: true,
+ 195041: true,
+ 195044: true,
+ 195050: true,
+ 195051: true,
+ 195052: true,
+ 195068: true,
+ 195075: true,
+ 195076: true,
+ 195079: true,
+ 195080: true,
+ 195081: true,
+ 196042: true,
+ 196044: true,
+ 196050: true,
+ 196051: true,
+ 196055: true,
+ 196056: true,
+ 196061: true,
+ 196063: true,
+ 196065: true,
+ 196070: true,
+ 196071: true,
+ 196075: true,
+ 196077: true,
+ 196079: true,
+ 196087: true,
+ 196088: true,
+ 196090: true,
+ 196091: true,
+ 197041: true,
+ 197042: true,
+ 197043: true,
+ 197044: true,
+ 198044: true,
+ 198045: true,
+ 198046: true,
+ 198048: true,
+ 198049: true,
+ 198050: true,
+ 198053: true,
+ 198057: true,
+ 198058: true,
+ 198066: true,
+ 198071: true,
+ 198074: true,
+ 198081: true,
+ 198084: true,
+ 198085: true,
+ 198102: true,
+ 199042: true,
+ 199044: true,
+ 199045: true,
+ 199046: true,
+ 199047: true,
+ 199052: true,
+ 199054: true,
+ 199057: true,
+ 199066: true,
+ 199070: true,
+ 199082: true,
+ 199091: true,
+ 199094: true,
+ 199096: true,
+ 201041: true,
+ 201042: true,
+ 201043: true,
+ 201047: true,
+ 201048: true,
+ 201049: true,
+ 201058: true,
+ 201061: true,
+ 201064: true,
+ 201065: true,
+ 201068: true,
+ 202042: true,
+ 202043: true,
+ 202044: true,
+ 202051: true,
+ 202054: true,
+ 202055: true,
+ 203043: true,
+ 203050: true,
+ 203051: true,
+ 203053: true,
+ 203060: true,
+ 203062: true,
+ 204042: true,
+ 204044: true,
+ 204048: true,
+ 204052: true,
+ 204053: true,
+ 204061: true,
+ 204062: true,
+ 204064: true,
+ 204065: true,
+ 204067: true,
+ 204068: true,
+ 204069: true,
+ 205042: true,
+ 205044: true,
+ 206043: true,
+ 206044: true,
+ 206047: true,
+ 206050: true,
+ 206051: true,
+ 206052: true,
+ 206053: true,
+ 206054: true,
+ 206055: true,
+ 206058: true,
+ 206059: true,
+ 206060: true,
+ 206067: true,
+ 206069: true,
+ 206077: true,
+ 206078: true,
+ 206079: true,
+ 206084: true,
+ 206089: true,
+ 206101: true,
+ 206107: true,
+ 206109: true,
+ 207043: true,
+ 207044: true,
+ 207049: true,
+ 207050: true,
+ 207051: true,
+ 207052: true,
+ 207053: true,
+ 207054: true,
+ 207055: true,
+ 207061: true,
+ 207062: true,
+ 207069: true,
+ 207071: true,
+ 207085: true,
+ 207086: true,
+ 207087: true,
+ 207088: true,
+ 207095: true,
+ 207096: true,
+ 207102: true,
+ 207103: true,
+ 207106: true,
+ 207108: true,
+ 207110: true,
+ 207111: true,
+ 207112: true,
+ 209041: true,
+ 209042: true,
+ 209043: true,
+ 209044: true,
+ 210042: true,
+ 210043: true,
+ 210044: true,
+ 210047: true,
+ 211041: true,
+ 212041: true,
+ 212045: true,
+ 212046: true,
+ 212047: true,
+ 213041: true,
+ 213042: true,
+ 214042: true,
+ 214046: true,
+ 214049: true,
+ 214050: true,
+ 215042: true,
+ 215048: true,
+ 215050: true,
+ 216043: true,
+ 216046: true,
+ 216047: true,
+ 216052: true,
+ 216053: true,
+ 216054: true,
+ 216059: true,
+ 216068: true,
+ 217041: true,
+ 217044: true,
+ 217047: true,
+ 217048: true,
+ 217049: true,
+ 217056: true,
+ 217058: true,
+ 217059: true,
+ 217060: true,
+ 217061: true,
+ 217064: true,
+ 217066: true,
+ 217069: true,
+ 217071: true,
+ 217085: true,
+ 217086: true,
+ 217088: true,
+ 217093: true,
+ 217094: true,
+ 217108: true,
+ 217109: true,
+ 217111: true,
+ 217115: true,
+ 217116: true,
+ 218042: true,
+ 218044: true,
+ 218046: true,
+ 218050: true,
+ 218060: true,
+ 218061: true,
+ 218063: true,
+ 218064: true,
+ 218065: true,
+ 218070: true,
+ 218071: true,
+ 218072: true,
+ 218074: true,
+ 218076: true,
+ 222041: true,
+ 223041: true,
+ 223043: true,
+ 223044: true,
+ 223050: true,
+ 223052: true,
+ 223054: true,
+ 223058: true,
+ 223059: true,
+ 223061: true,
+ 223068: true,
+ 223069: true,
+ 223070: true,
+ 223071: true,
+ 223073: true,
+ 223075: true,
+ 223076: true,
+ 223083: true,
+ 223087: true,
+ 223094: true,
+ 223096: true,
+ 223101: true,
+ 223106: true,
+ 223108: true,
+ 224041: true,
+ 224042: true,
+ 224043: true,
+ 224045: true,
+ 224051: true,
+ 224053: true,
+ 224057: true,
+ 224060: true,
+ 224061: true,
+ 224062: true,
+ 224063: true,
+ 224068: true,
+ 224069: true,
+ 224081: true,
+ 224084: true,
+ 224087: true,
+ 224090: true,
+ 224096: true,
+ 224105: true,
+ 225042: true,
+ 227041: true,
+ 229045: true,
+ 229046: true,
+ 229048: true,
+ 229049: true,
+ 229050: true,
+ 231042: true,
+ 236041: true,
+ 237041: true,
+ 238041: true,
+ 238042: true,
+ 240041: true,
+ 240042: true,
+ 240043: true,
+ 241041: true,
+ 243041: true,
+ 244041: true,
+ 245041: true,
+ 247041: true,
+ 250041: true,
+ 252041: true,
+ 253041: true,
+ 253045: true,
+ 254043: true,
+ 255042: true,
+ 255043: true,
+ 257041: true,
+ 257042: true,
+ 258041: true,
+ 261041: true,
+ 264041: true,
+ 294042: true,
+ 296042: true,
+ 302042: true,
+ 310041: true,
+ 311041: true,
+ 313041: true,
+ 317041: true,
+ 357043: true,
+ 360043: true,
+ 362041: true,
+ 367041: true,
+ 369041: true,
+ 370041: true,
+ 376041: true,
+ 382045: true,
+ 384041: true,
+ 384043: true,
+ 384044: true,
+ 391041: true,
+ 417042: true,
+ 419042: true,
+ 424041: true,
+ 438042: true,
+ 444041: true,
+ 444043: true,
+ 445042: true,
+ 460042: true,
+ 461041: true,
+ 462043: true,
+ 466042: true,
+ 476043: true,
+ 484041: true,
+ 554043: true,
+ 556041: true,
+ 562041: true,
+ 569044: true,
+ 570041: true,
+ 576041: true,
+ 576042: true,
+ 578042: true,
+ 579041: true,
+ 581041: true,
+ 582041: true,
+ 582043: true,
+ 583041: true,
+ 586043: true,
+ 589043: true,
+ 593043: true,
+ 595041: true,
+ 597041: true,
+ 600041: true,
+ 601042: true,
+ 604043: true,
+ 606041: true,
+ 607041: true,
+ 608041: true,
+ 609042: true,
+ 610043: true,
+ 611042: true,
+ 614042: true,
+ 621041: true,
+ 622041: true,
+ 624041: true,
+ 624042: true,
+ 626042: true,
+ 627045: true,
+ 630043: true,
+ 634042: true,
+ 634044: true,
+ 634045: true,
+ 642041: true,
+ 642042: true,
+ 643042: true,
+ 645044: true,
+ 648041: true,
+ 649041: true,
+ 650042: true,
+ 651041: true,
+ 656043: true,
+ 657042: true,
+ 660041: true,
+ 661041: true,
+ 661043: true,
+ 661044: true,
+ 662041: true,
+ 664041: true,
+ 669041: true,
+ 673042: true,
+ 680042: true,
+ 682041: true,
+ 684041: true,
+ 691041: true,
+ 692041: true,
+ 695041: true,
+ 699041: true,
+ 700041: true,
+ 702042: true,
+ 703041: true,
+ 704041: true,
+ 705043: true,
+ 708041: true,
+ 711041: true,
+ 713041: true,
+ 714041: true,
+ 715042: true,
+ 719041: true,
+ 720041: true,
+ 725042: true,
+ 731041: true,
+ 733041: true,
+ 734041: true,
+ 738041: true,
+ 739042: true,
+ 740041: true,
+ 741041: true,
+ 743041: true,
+ 744042: true,
+ 747041: true,
+ 748041: true,
+ 749041: true,
+ 751041: true,
+ 755041: true,
+ 758041: true,
+ 759041: true,
+ 760042: true,
+ 762041: true,
+ 763041: true,
+ 763042: true,
+ 769041: true,
+ 770041: true,
+ 773041: true,
+ 778041: true,
+ 781041: true,
+ 782041: true,
+ 783041: true,
+ 784041: true,
+ 785041: true,
+ 786041: true,
+ 787041: true,
+ 788041: true,
+ 790041: true,
+ 791041: true,
+ 793041: true,
+ 799048: true,
+ 800041: true,
+ 800042: true,
+ 802043: true,
+ 802044: true,
+ 802051: true,
+ 804042: true,
+ 805043: true,
+ 808041: true,
+ 809041: true,
+ 810043: true,
+ 811042: true,
+ 811044: true,
+ 811046: true,
+ 812041: true,
+ 812043: true,
+ 812044: true,
+ 813043: true,
+ 813047: true,
+ 815041: true,
+ 815044: true,
+ 816042: true,
+ 816047: true,
+ 819042: true,
+ 820045: true,
+ 821044: true,
+ 821045: true,
+ 821046: true,
+ 821048: true,
+ 822044: true,
+ 822045: true,
+ 822047: true,
+ 823041: true,
+ 823045: true,
+ 823048: true,
+ 824041: true,
+ 824043: true,
+ 824045: true,
+ 824046: true,
+ 824049: true,
+ 824051: true,
+ 825043: true,
+ 826042: true,
+ 827042: true,
+ 829044: true,
+ 831042: true,
+ 831045: true,
+ 833042: true,
+ 833044: true,
+ 833045: true,
+ 834045: true,
+ 834046: true,
+ 836043: true,
+ 836046: true,
+ 837041: true,
+ 837042: true,
+ 838046: true,
+ 839041: true,
+ 840043: true,
+ 840045: true,
+ 842041: true,
+ 842042: true,
+ 843041: true,
+ 844041: true,
+ 844044: true,
+ 844048: true,
+ 845041: true,
+ 846043: true,
+ 846050: true,
+ 848041: true,
+ 848042: true,
+ 849041: true,
+ 849044: true,
+ 849045: true,
+ 849049: true,
+ 850041: true,
+ 851041: true,
+ 851045: true,
+ 853042: true,
+ 854045: true,
+ 854046: true,
+ 854048: true,
+ 855043: true,
+ 855044: true,
+ 855046: true,
+ 857045: true,
+ 857048: true,
+ 859042: true,
+ 860041: true,
+ 862042: true,
+ 864041: true,
+ 864042: true,
+ 864044: true,
+ 867044: true,
+ 867046: true,
+ 869041: true,
+ 869045: true,
+ 870041: true,
+ 870044: true,
+ 871042: true,
+ 872041: true,
+ 872043: true,
+ 872045: true,
+ 872048: true,
+ 874041: true,
+ 874043: true,
+ 875041: true,
+ 875043: true,
+ 875045: true,
+ 875048: true,
+ 876045: true,
+ 878046: true,
+ 878047: true,
+ 879041: true,
+ 880043: true,
+ 880046: true,
+ 881042: true,
+ 881043: true,
+ 881044: true,
+ 881047: true,
+ 881050: true,
+ 882043: true,
+ 882047: true,
+ 882049: true,
+ 883045: true,
+ 883046: true,
+ 883049: true,
+ 883051: true,
+ 884041: true,
+ 886043: true,
+ 887042: true,
+ 887043: true,
+ 887045: true,
+ 888045: true,
+ 889041: true,
+ 890044: true,
+ 890048: true,
+ 891048: true,
+ 891049: true,
+ 891050: true,
+ 893041: true,
+ 895043: true,
+ 896041: true,
+ 896045: true,
+ 897041: true,
+ 897042: true,
+ 901042: true,
+ 902041: true,
+ 902042: true,
+ 902044: true,
+ 902045: true,
+ 903043: true,
+ 903044: true,
+ 904046: true,
+ 906041: true,
+ 906042: true,
+ 907041: true,
+ 908041: true,
+ 908044: true,
+ 909041: true,
+ 912041: true,
+ 915041: true,
+ 917042: true,
+ 919045: true,
+ 920041: true,
+ 921041: true,
+ 929041: true,
+ 937042: true,
+ 940041: true,
+ 943043: true,
+ 943046: true,
+ 943047: true,
+ 944043: true,
+ 944044: true,
+ 946043: true,
+ 946045: true,
+ 946046: true,
+ 947042: true,
+ 949043: true,
+ 952041: true,
+ 953041: true,
+ 953042: true,
+ 954041: true,
+ 955041: true,
+ 956050: true,
+ 957041: true,
+ 957042: true,
+ 957045: true,
+ 958041: true,
+ 961041: true,
+ 961042: true,
+ 961044: true,
+ 961046: true,
+ 961047: true,
+ 962043: true,
+ 962045: true,
+ 962046: true,
+ 963042: true,
+ 963043: true,
+ 963044: true,
+ 964045: true,
+ 965044: true,
+ 965045: true,
+ 965047: true,
+ 967041: true,
+ 968041: true,
+ 968042: true,
+ 968043: true,
+ 969047: true,
+ 970041: true,
+ 970042: true,
+ 971041: true,
+ 972044: true,
+ 972045: true,
+ 972046: true,
+ 974043: true,
+ 975042: true,
+ 976041: true,
+ 978042: true,
+ 978043: true,
+ 979043: true,
+ 979044: true,
+ 980043: true,
+ 982043: true,
+ 986044: true,
+ 987041: true,
+ 988042: true,
+ 988043: true,
+ 989042: true,
+ 989044: true,
+ 989045: true,
+ 993042: true,
+ 994043: true,
+ 994044: true,
+ 1004042: true,
+ 1004043: true,
+ 1004045: true,
+ 1006041: true,
+ 1006044: true,
+ 1006045: true,
+ 1007041: true,
+ 1008041: true,
+ 1008042: true,
+ 1008045: true,
+ 1009041: true,
+ 1010041: true,
+ 1010042: true,
+ 1013041: true,
+ 1013042: true,
+ 1014041: true,
+ 1014043: true,
+ 1015043: true,
+ 1016041: true,
+ 1018042: true,
+ 1019042: true,
+ 1019043: true,
+ 1021041: true,
+ 1021043: true,
+ 1032041: true,
+ 1032043: true,
+ 1032044: true,
+ 1037041: true,
+ 1040041: true,
+ 1040042: true,
+ 1043042: true,
+ 1044041: true,
+ 1046042: true,
+ 1048041: true,
+ 1052042: true,
+ 1054041: true,
+ 1063042: true,
+ 1064041: true,
+ 1065041: true,
+ 1067042: true,
+ 1072041: true,
+ 1073041: true,
+ 1077041: true,
+ 1078041: true,
+ 1079041: true,
+ 1080041: true,
+ 1081041: true,
+ 1081042: true,
+ 1083041: true,
+ 1084041: true,
+ 1090041: true,
+ 1091041: true,
+ 1092041: true,
+ 1094041: true,
+ 1094043: true,
+ 1098041: true,
+ 1103041: true,
+ 1112041: true,
+ 1113041: true,
+ 1118041: true,
+ 1120042: true,
+ 1121041: true,
+ 1121042: true,
+ 1122043: true,
+ 1123043: true,
+ 1127041: true,
+ 1132042: true,
+ 1133043: true,
+ 1134041: true,
+ 1138041: true,
+ 1139042: true,
+ 1140041: true,
+ 1140043: true,
+ 1145044: true,
+ 1146041: true,
+ 1148041: true,
+ 1149041: true,
+ 1154042: true,
+ 1164041: true,
+ 1166041: true,
+ 1170041: true,
+ 1171041: true,
+ 1172042: true,
+ 1173041: true,
+ 1179041: true,
+ 1180042: true,
+ 1186041: true,
+ 1193046: true,
+ 1195041: true,
+ 1195042: true,
+ 1196043: true,
+ 1198044: true,
+ 1198046: true,
+ 1202042: true,
+ 1206043: true,
+ 1207041: true,
+ 1207043: true,
+ 1207044: true,
+ 1209047: true,
+ 1209048: true,
+ 1211047: true,
+ 1216042: true,
+ 1217046: true,
+ 1218042: true,
+ 1220041: true,
+ 1220046: true,
+ 1221042: true,
+ 1221043: true,
+ 1223044: true,
+ 1224044: true,
+ 1224045: true,
+ 1227042: true,
+ 1228041: true,
+ 1228044: true,
+ 1229047: true,
+ 1230042: true,
+ 1231041: true,
+ 1231044: true,
+ 1233041: true,
+ 1235041: true,
+ 1236043: true,
+ 1238044: true,
+ 1239043: true,
+ 1240044: true,
+ 1240046: true,
+ 1242045: true,
+ 1243041: true,
+ 1243044: true,
+ 1244044: true,
+ 1244045: true,
+ 1249043: true,
+ 1250043: true,
+ 1252045: true,
+ 1253043: true,
+ 1253046: true,
+ 1254044: true,
+ 1256042: true,
+ 1257041: true,
+ 1257043: true,
+ 1258042: true,
+ 1258044: true,
+ 1259042: true,
+ 1260041: true,
+ 1262042: true,
+ 1265042: true,
+ 1266042: true,
+ 1267041: true,
+ 1267042: true,
+ 1268041: true,
+ 1270041: true,
+ 1270042: true,
+ 1271041: true,
+ 1273042: true,
+ 1274042: true,
+ 1275042: true,
+ 1278041: true,
+ 1278042: true,
+ 1279041: true,
+ 1280041: true,
+ 1281041: true,
+ 1281042: true,
+ 1282041: true,
+ 1283041: true,
+ 1284041: true,
+ 1290041: true,
+ 1301043: true,
+ 1303041: true,
+ 1303042: true,
+ 1309045: true,
+ 1315042: true,
+ 1316042: true,
+ 1319042: true,
+ 1326042: true,
+ 1331041: true,
+ 1354041: true,
+ 1363041: true,
+ 1365041: true,
+ 1372042: true,
+ 1376042: true,
+ 1381041: true,
+ 1382041: true,
+ 1383041: true,
+ 1388041: true,
+ 1390041: true,
+ 1395041: true,
+ 1399041: true,
+ 1400041: true,
+ 1404041: true,
+ 1417041: true,
+ 1418041: true,
+ 1421041: true,
+ 1426042: true,
+ 1432041: true,
+ 1433041: true,
+ 1433042: true,
+ 1434041: true,
+ 1435041: true,
+ 1436041: true,
+ 1442042: true,
+ 1444041: true,
+ 1451044: true,
+ 1452041: true,
+ 1453041: true,
+ 1454041: true,
+ 1458041: true,
+ 1462041: true,
+ 1465041: true,
+ 1472042: true,
+ 1473042: true,
+ 1475041: true,
+ 1476041: true,
+ 1480041: true,
+ 1486041: true,
+ 1495041: true,
+ 1496042: true,
+ 1499041: true,
+ 1502041: true,
+ 1503041: true,
+ 1514041: true,
+ 1518042: true,
+ 1521042: true,
+ 1522041: true,
+ 1532041: true,
+ 1533041: true,
+ 1535041: true,
+ 1536041: true,
+ 1539042: true,
+ 1548042: true,
+ 1555042: true,
+ 1559041: true,
+ 1563041: true,
+ 1567041: true,
+ 1578041: true,
+ 1581041: true,
+ 1585041: true,
+ 1590041: true,
+ 1592041: true,
+ 1592045: true,
+ 1593041: true,
+ 1593042: true,
+ 1594041: true,
+ 1597043: true,
+ 1597044: true,
+ 1599043: true,
+ 1600041: true,
+ 1610042: true,
+ 1612041: true,
+ 1613041: true,
+ 1613045: true,
+ 1614041: true,
+ 1615042: true,
+ 1615043: true,
+ 1616041: true,
+ 1616042: true,
+ 1619042: true,
+ 1620042: true,
+ 1621041: true,
+ 1623041: true,
+ 1626043: true,
+ 1627042: true,
+ 1631041: true,
+ 1632041: true,
+ 1633042: true,
+ 1636043: true,
+ 1641043: true,
+ 1644041: true,
+ 1644042: true,
+ 1647042: true,
+ 1648043: true,
+ 1649041: true,
+ 1650041: true,
+ 1652041: true,
+ 1662041: true,
+ 1663041: true,
+ 1664043: true,
+ 1664051: true,
+ 1664053: true,
+ 1664056: true,
+ 1665043: true,
+ 1665047: true,
+ 1665051: true,
+ 1666048: true,
+ 1667048: true,
+ 1667051: true,
+ 1669055: true,
+ 1669056: true,
+ 1670046: true,
+ 1670052: true,
+ 1673049: true,
+ 1674045: true,
+ 1674049: true,
+ 1675047: true,
+ 1675048: true,
+ 1675050: true,
+ 1676054: true,
+ 1677042: true,
+ 1677043: true,
+ 1677047: true,
+ 1677049: true,
+ 1677053: true,
+ 1678046: true,
+ 1678047: true,
+ 1678048: true,
+ 1678054: true,
+ 1678063: true,
+ 1679045: true,
+ 1680042: true,
+ 1680044: true,
+ 1680045: true,
+ 1680048: true,
+ 1681049: true,
+ 1682043: true,
+ 1682048: true,
+ 1682050: true,
+ 1682052: true,
+ 1684046: true,
+ 1684051: true,
+ 1684055: true,
+ 1686044: true,
+ 1686047: true,
+ 1686054: true,
+ 1687045: true,
+ 1687047: true,
+ 1689042: true,
+ 1689046: true,
+ 1689061: true,
+ 1690043: true,
+ 1690053: true,
+ 1691045: true,
+ 1692055: true,
+ 1692057: true,
+ 1693043: true,
+ 1693046: true,
+ 1693047: true,
+ 1694044: true,
+ 1695046: true,
+ 1695049: true,
+ 1696044: true,
+ 1696051: true,
+ 1696062: true,
+ 1697048: true,
+ 1697053: true,
+ 1697057: true,
+ 1698041: true,
+ 1698043: true,
+ 1698045: true,
+ 1698046: true,
+ 1698051: true,
+ 1699045: true,
+ 1699046: true,
+ 1699050: true,
+ 1700043: true,
+ 1700048: true,
+ 1701041: true,
+ 1701045: true,
+ 1701048: true,
+ 1701051: true,
+ 1702045: true,
+ 1702050: true,
+ 1703041: true,
+ 1704041: true,
+ 1704044: true,
+ 1704046: true,
+ 1705041: true,
+ 1706043: true,
+ 1706044: true,
+ 1706053: true,
+ 1707042: true,
+ 1707043: true,
+ 1707047: true,
+ 1708046: true,
+ 1708048: true,
+ 1712042: true,
+ 1712048: true,
+ 1714044: true,
+ 1715043: true,
+ 1715046: true,
+ 1715054: true,
+ 1715060: true,
+ 1717046: true,
+ 1718042: true,
+ 1720043: true,
+ 1722046: true,
+ 1723044: true,
+ 1724042: true,
+ 1727043: true,
+ 1729045: true,
+ 1729046: true,
+ 1729051: true,
+ 1729052: true,
+ 1731043: true,
+ 1731047: true,
+ 1731048: true,
+ 1731057: true,
+ 1732043: true,
+ 1733045: true,
+ 1733046: true,
+ 1734042: true,
+ 1734046: true,
+ 1734047: true,
+ 1736041: true,
+ 1736042: true,
+ 1737044: true,
+ 1738047: true,
+ 1738048: true,
+ 1739042: true,
+ 1739043: true,
+ 1740043: true,
+ 1740044: true,
+ 1741041: true,
+ 1741045: true,
+ 1741047: true,
+ 1741053: true,
+ 1741058: true,
+ 1741059: true,
+ 1742044: true,
+ 1742045: true,
+ 1742048: true,
+ 1742050: true,
+ 1742055: true,
+ 1742057: true,
+ 1743053: true,
+ 1743059: true,
+ 1745041: true,
+ 1745042: true,
+ 1746047: true,
+ 1747041: true,
+ 1748041: true,
+ 1748042: true,
+ 1749041: true,
+ 1750042: true,
+ 1752043: true,
+ 1752044: true,
+ 1756042: true,
+ 1760043: true,
+ 1761042: true,
+ 1762042: true,
+ 1762044: true,
+ 1764043: true,
+ 1766042: true,
+ 1771043: true,
+ 1772043: true,
+ 1773041: true,
+ 1774044: true,
+ 1774047: true,
+ 1777041: true,
+ 1778041: true,
+ 1780042: true,
+ 1784042: true,
+ 1790041: true,
+ 1791041: true,
+ 1792042: true,
+ 1803043: true,
+ 1804041: true,
+ 1805041: true,
+ 1806043: true,
+ 1812043: true,
+ 1813042: true,
+ 1814043: true,
+ 1814044: true,
+ 1815042: true,
+ 1817041: true,
+ 1819041: true,
+ 1821041: true,
+ 1823041: true,
+ 1824042: true,
+ 1825043: true,
+ 1830041: true,
+ 1835041: true,
+ 1838041: true,
+ 1841042: true,
+ 1841044: true,
+ 1842042: true,
+ 1843044: true,
+ 1843046: true,
+ 1844041: true,
+ 1846042: true,
+ 1846043: true,
+ 1846047: true,
+ 1846051: true,
+ 1847041: true,
+ 1847042: true,
+ 1847043: true,
+ 1847047: true,
+ 1847050: true,
+ 1847051: true,
+ 1848045: true,
+ 1848047: true,
+ 1848049: true,
+ 1848056: true,
+ 1849041: true,
+ 1849054: true,
+ 1849055: true,
+ 1850052: true,
+ 1853041: true,
+ 1854042: true,
+ 1855043: true,
+ 1855051: true,
+ 1856042: true,
+ 1856047: true,
+ 1856052: true,
+ 1856054: true,
+ 1857043: true,
+ 1857048: true,
+ 1857049: true,
+ 1859044: true,
+ 1860045: true,
+ 1860046: true,
+ 1862042: true,
+ 1862043: true,
+ 1862044: true,
+ 1862045: true,
+ 1862046: true,
+ 1863042: true,
+ 1863046: true,
+ 1863051: true,
+ 1864042: true,
+ 1864046: true,
+ 1864051: true,
+ 1866044: true,
+ 1867042: true,
+ 1868041: true,
+ 1868043: true,
+ 1868047: true,
+ 1869042: true,
+ 1869043: true,
+ 1870042: true,
+ 1870047: true,
+ 1871049: true,
+ 1871054: true,
+ 1871055: true,
+ 1871057: true,
+ 1872041: true,
+ 1872042: true,
+ 1872045: true,
+ 1873047: true,
+ 1874045: true,
+ 1874046: true,
+ 1875043: true,
+ 1875049: true,
+ 1876045: true,
+ 1879043: true,
+ 1880047: true,
+ 1882043: true,
+ 1882046: true,
+ 1883049: true,
+ 1886042: true,
+ 1886043: true,
+ 1886046: true,
+ 1888041: true,
+ 1889041: true,
+ 1890043: true,
+ 1890045: true,
+ 1892049: true,
+ 1892050: true,
+ 1892052: true,
+ 1893042: true,
+ 1893045: true,
+ 1894043: true,
+ 1894047: true,
+ 1895049: true,
+ 1896044: true,
+ 1897043: true,
+ 1897046: true,
+ 1897049: true,
+ 1897050: true,
+ 1899041: true,
+ 1899042: true,
+ 1899044: true,
+ 1900044: true,
+ 1902042: true,
+ 1902043: true,
+ 1902049: true,
+ 1903043: true,
+ 1903049: true,
+ 1904041: true,
+ 1904044: true,
+ 1904045: true,
+ 1905050: true,
+ 1906042: true,
+ 1907041: true,
+ 1907045: true,
+ 1907046: true,
+ 1910041: true,
+ 1910045: true,
+ 1912042: true,
+ 1913041: true,
+ 1913042: true,
+ 1913047: true,
+ 1914041: true,
+ 1914046: true,
+ 1915042: true,
+ 1915043: true,
+ 1917044: true,
+ 1917048: true,
+ 1918047: true,
+ 1919042: true,
+ 1923041: true,
+ 1923043: true,
+ 1933043: true,
+ 1933044: true,
+ 1933045: true,
+ 1935041: true,
+ 1936044: true,
+ 1938041: true,
+ 1938044: true,
+ 1939042: true,
+ 1940042: true,
+ 1941041: true,
+ 1941042: true,
+ 1941052: true,
+ 1942043: true,
+ 1942044: true,
+ 1943042: true,
+ 1943045: true,
+ 1943049: true,
+ 1944043: true,
+ 1946041: true,
+ 1947041: true,
+ 1947042: true,
+ 1949042: true,
+ 1950041: true,
+ 1950045: true,
+ 1951041: true,
+ 1951043: true,
+ 1952041: true,
+ 1952045: true,
+ 1952046: true,
+ 1952047: true,
+ 1953044: true,
+ 1953048: true,
+ 1954044: true,
+ 1954049: true,
+ 1955049: true,
+ 1956044: true,
+ 1956046: true,
+ 1957041: true,
+ 1957045: true,
+ 1958047: true,
+ 1958048: true,
+ 1959042: true,
+ 1959043: true,
+ 1959044: true,
+ 1960042: true,
+ 1960044: true,
+ 1960050: true,
+ 1961042: true,
+ 1962041: true,
+ 1962042: true,
+ 1962046: true,
+ 1962048: true,
+ 1963044: true,
+ 1964043: true,
+ 1965042: true,
+ 1966048: true,
+ 1967045: true,
+ 1967047: true,
+ 1967048: true,
+ 1967049: true,
+ 1968041: true,
+ 1968042: true,
+ 1968043: true,
+ 1969042: true,
+ 1969046: true,
+ 1971042: true,
+ 1972044: true,
+ 1972046: true,
+ 1973043: true,
+ 1974046: true,
+ 1975042: true,
+ 1975043: true,
+ 1975044: true,
+ 1976044: true,
+ 1976045: true,
+ 1976049: true,
+ 1981041: true,
+ 1981044: true,
+ 1981047: true,
+ 1982041: true,
+ 1982042: true,
+ 1982045: true,
+ 1982049: true,
+ 1983041: true,
+ 1983042: true,
+ 1983043: true,
+ 1983045: true,
+ 1983050: true,
+ 1983051: true,
+ 1984043: true,
+ 1985042: true,
+ 1986044: true,
+ 1987041: true,
+ 1987042: true,
+ 1991047: true,
+ 1993043: true,
+ 1994041: true,
+ 1995041: true,
+ 1995043: true,
+ 1995050: true,
+ 1995051: true,
+ 1997044: true,
+ 1997045: true,
+ 1998041: true,
+ 1998042: true,
+ 1998045: true,
+ 1998046: true,
+ 1999044: true,
+ 2000041: true,
+ 2004044: true,
+ 2004046: true,
+ 2005042: true,
+ 2007042: true,
+ 2007043: true,
+ 2007047: true,
+ 2009041: true,
+ 2009043: true,
+ 2009044: true,
+ 2009045: true,
+ 2009046: true,
+ 2010041: true,
+ 2011046: true,
+ 2012041: true,
+ 2013043: true,
+ 2015043: true,
+ 2017042: true,
+ 2018041: true,
+ 2020043: true,
+ 2020045: true,
+ 2021041: true,
+ 2023042: true,
+ 2023044: true,
+ 2024043: true,
+ 2025041: true,
+ 2025042: true,
+ 2026045: true,
+ 2029042: true,
+ 2033041: true,
+ 2033043: true,
+ 2036045: true,
+ 2039043: true,
+ 2039044: true,
+ 2040041: true,
+ 2040042: true,
+ 2040043: true,
+ 2041041: true,
+ 2042044: true,
+ 2043041: true,
+ 2043042: true,
+ 2048043: true,
+ 2049043: true,
+ 2050042: true,
+ 2050043: true,
+ 2051041: true,
+ 2052041: true,
+ 2052042: true,
+ 2053041: true,
+ 2055041: true,
+ 2061042: true,
+ 2066042: true,
+ 2068041: true,
+ 2072041: true,
+ 2073041: true,
+ 2075041: true,
+ 2078041: true,
+ 2083041: true,
+ 2083042: true,
+ 2084041: true,
+ 2084042: true,
+ 2091042: true,
+ 2094041: true,
+ 2095041: true,
+ 2098044: true,
+ 2098047: true,
+ 2098048: true,
+ 2099041: true,
+ 2100041: true,
+ 2100044: true,
+ 2102043: true,
+ 2103046: true,
+ 2103048: true,
+ 2104042: true,
+ 2104048: true,
+ 2105043: true,
+ 2106047: true,
+ 2106049: true,
+ 2107047: true,
+ 2107048: true,
+ 2110044: true,
+ 2110046: true,
+ 2111045: true,
+ 2111046: true,
+ 2112041: true,
+ 2112042: true,
+ 2112046: true,
+ 2113041: true,
+ 2114042: true,
+ 2115042: true,
+ 2115043: true,
+ 2115045: true,
+ 2116043: true,
+ 2116047: true,
+ 2118050: true,
+ 2119042: true,
+ 2119044: true,
+ 2119048: true,
+ 2121041: true,
+ 2121042: true,
+ 2121045: true,
+ 2121048: true,
+ 2122042: true,
+ 2122049: true,
+ 2123044: true,
+ 2124041: true,
+ 2124044: true,
+ 2124045: true,
+ 2124046: true,
+ 2125042: true,
+ 2126042: true,
+ 2127045: true,
+ 2127046: true,
+ 2128041: true,
+ 2128045: true,
+ 2128047: true,
+ 2129041: true,
+ 2132045: true,
+ 2132046: true,
+ 2132047: true,
+ 2134045: true,
+ 2135045: true,
+ 2136041: true,
+ 2136043: true,
+ 2136047: true,
+ 2137041: true,
+ 2137048: true,
+ 2138045: true,
+ 2138047: true,
+ 2139044: true,
+ 2139045: true,
+ 2140043: true,
+ 2140045: true,
+ 2140046: true,
+ 2140048: true,
+ 2141041: true,
+ 2141042: true,
+ 2141043: true,
+ 2143041: true,
+ 2144042: true,
+ 2144043: true,
+ 2145043: true,
+ 2145045: true,
+ 2146044: true,
+ 2147042: true,
+ 2147047: true,
+ 2148042: true,
+ 2149045: true,
+ 2149046: true,
+ 2149047: true,
+ 2150042: true,
+ 2150044: true,
+ 2151042: true,
+ 2151044: true,
+ 2151046: true,
+ 2152045: true,
+ 2154041: true,
+ 2156045: true,
+ 2156046: true,
+ 2156047: true,
+ 2157041: true,
+ 2157042: true,
+ 2157043: true,
+ 2158043: true,
+ 2158044: true,
+ 2160041: true,
+ 2161043: true,
+ 2162043: true,
+ 2163042: true,
+ 2163044: true,
+ 2165042: true,
+ 2165044: true,
+ 2165046: true,
+ 2166041: true,
+ 2166042: true,
+ 2167045: true,
+ 2168043: true,
+ 2169043: true,
+ 2171044: true,
+ 2172041: true,
+ 2172043: true,
+ 2174043: true,
+ 2175041: true,
+ 2178041: true,
+ 2182041: true,
+ 2182042: true,
+ 2182043: true,
+ 2184042: true,
+ 2184044: true,
+ 2186041: true,
+ 2187042: true,
+ 2188041: true,
+ 2190044: true,
+ 2191043: true,
+ 2192041: true,
+ 2192043: true,
+ 2192048: true,
+ 2192049: true,
+ 2192050: true,
+ 2193048: true,
+ 2194041: true,
+ 2194046: true,
+ 2194047: true,
+ 2197047: true,
+ 2197050: true,
+ 2198042: true,
+ 2198044: true,
+ 2198046: true,
+ 2198047: true,
+ 2199043: true,
+ 2201041: true,
+ 2201044: true,
+ 2204045: true,
+ 2204047: true,
+ 2204048: true,
+ 2204050: true,
+ 2205042: true,
+ 2206041: true,
+ 2206042: true,
+ 2206044: true,
+ 2207044: true,
+ 2207045: true,
+ 2208046: true,
+ 2208047: true,
+ 2208049: true,
+ 2208050: true,
+ 2208053: true,
+ 2209042: true,
+ 2211041: true,
+ 2211044: true,
+ 2211045: true,
+ 2212041: true,
+ 2212042: true,
+ 2212043: true,
+ 2212044: true,
+ 2213042: true,
+ 2213044: true,
+ 2213045: true,
+ 2213048: true,
+ 2214042: true,
+ 2214043: true,
+ 2214044: true,
+ 2215044: true,
+ 2215045: true,
+ 2215046: true,
+ 2216043: true,
+ 2216047: true,
+ 2216051: true,
+ 2216053: true,
+ 2216054: true,
+ 2218043: true,
+ 2218044: true,
+ 2218046: true,
+ 2220048: true,
+ 2221042: true,
+ 2221044: true,
+ 2223041: true,
+ 2224041: true,
+ 2225041: true,
+ 2225042: true,
+ 2225044: true,
+ 2225045: true,
+ 2225046: true,
+ 2225048: true,
+ 2226046: true,
+ 2226047: true,
+ 2227041: true,
+ 2228041: true,
+ 2229041: true,
+ 2229044: true,
+ 2229047: true,
+ 2233043: true,
+ 2233044: true,
+ 2234044: true,
+ 2237042: true,
+ 2237043: true,
+ 2237044: true,
+ 2240043: true,
+ 2241043: true,
+ 2241045: true,
+ 2244041: true,
+ 2244044: true,
+ 2245041: true,
+ 2246041: true,
+ 2246042: true,
+ 2246046: true,
+ 2246049: true,
+ 2247044: true,
+ 2248041: true,
+ 2248043: true,
+ 2248045: true,
+ 2248046: true,
+ 2249041: true,
+ 2249042: true,
+ 2249045: true,
+ 2250041: true,
+ 2250042: true,
+ 2253042: true,
+ 2254041: true,
+ 2254044: true,
+ 2254047: true,
+ 2255042: true,
+ 2256041: true,
+ 2256042: true,
+ 2257042: true,
+ 2258045: true,
+ 2261042: true,
+ 2264043: true,
+ 2265041: true,
+ 2265042: true,
+ 2265044: true,
+ 2266043: true,
+ 2267042: true,
+ 2267044: true,
+ 2267046: true,
+ 2270041: true,
+ 2270042: true,
+ 2271041: true,
+ 2272041: true,
+ 2273041: true,
+ 2273042: true,
+ 2275041: true,
+ 2278041: true,
+ 2279041: true,
+ 2279042: true,
+ 2288041: true,
+ 2289041: true,
+ 2290041: true,
+ 2290044: true,
+ 2290045: true,
+ 2294041: true,
+ 2295041: true,
+ 2296041: true,
+ 2297041: true,
+ 2297042: true,
+ 2298041: true,
+ 2300041: true,
+ 2301041: true,
+ 2301045: true,
+ 2302041: true,
+ 2302042: true,
+ 2303041: true,
+ 2303043: true,
+ 2305043: true,
+ 2308042: true,
+ 2308043: true,
+ 2309043: true,
+ 2310041: true,
+ 2312041: true,
+ 2312042: true,
+ 2313041: true,
+ 2314043: true,
+ 2315042: true,
+ 2315045: true,
+ 2316044: true,
+ 2317044: true,
+ 2319041: true,
+ 2321043: true,
+ 2323042: true,
+ 2326041: true,
+ 2329041: true,
+ 2329042: true,
+ 2330041: true,
+ 2330042: true,
+ 2331044: true,
+ 2331045: true,
+ 2332042: true,
+ 2333043: true,
+ 2333045: true,
+ 2335043: true,
+ 2336042: true,
+ 2336044: true,
+ 2337044: true,
+ 2338041: true,
+ 2338042: true,
+ 2339042: true,
+ 2341042: true,
+ 2341049: true,
+ 2342045: true,
+ 2343043: true,
+ 2344041: true,
+ 2344042: true,
+ 2345041: true,
+ 2345043: true,
+ 2346044: true,
+ 2350041: true,
+ 2352043: true,
+ 2353043: true,
+ 2355043: true,
+ 2356042: true,
+ 2358041: true,
+ 2362043: true,
+ 2365044: true,
+ 2367041: true,
+ 2369043: true,
+ 2370043: true,
+ 2372042: true,
+ 2373043: true,
+ 2380042: true,
+ 2383041: true,
+ 2384042: true,
+ 2385041: true,
+ 2385042: true,
+ 2387042: true,
+ 2390041: true,
+ 2390042: true,
+ 2400041: true,
+ 2404043: true,
+ 2414041: true,
+ 2416042: true,
+ 2417042: true,
+ 2419042: true,
+ 2420041: true,
+ 2421042: true,
+ 2427042: true,
+ 2431042: true,
+ 2433042: true,
+ 2436041: true,
+ 2437041: true,
+ 2438041: true,
+ 2439041: true,
+ 2443041: true,
+ 2444041: true,
+ 2447042: true,
+ 2448041: true,
+ 2449041: true,
+ 2456041: true,
+ 2465041: true,
+ 2468041: true,
+ 2469041: true,
+ 2469043: true,
+ 2470045: true,
+ 2471042: true,
+ 2471043: true,
+ 2472041: true,
+ 2473041: true,
+ 2473042: true,
+ 2475042: true,
+ 2476041: true,
+ 2479043: true,
+ 2481042: true,
+ 2485041: true,
+ 2486043: true,
+ 2487042: true,
+ 2490041: true,
+ 2490043: true,
+ 2491041: true,
+ 2493043: true,
+ 2494042: true,
+ 2496041: true,
+ 2498041: true,
+ 2499041: true,
+ 2504043: true,
+ 2506042: true,
+ 2506045: true,
+ 2512041: true,
+ 2512042: true,
+ 2514041: true,
+ 2515042: true,
+ 2515043: true,
+ 2519042: true,
+ 2519043: true,
+ 2519044: true,
+ 2520042: true,
+ 2521042: true,
+ 2525041: true,
+ 2525042: true,
+ 2526041: true,
+ 2530041: true,
+ 2532041: true,
+ 2533041: true,
+ 2537041: true,
+ 2540042: true,
+ 2542042: true,
+ 2543042: true,
+ 2543043: true,
+ 2543044: true,
+ 2550041: true,
+ 2554042: true,
+ 2555041: true,
+ 2556041: true,
+ 2566042: true,
+ 2585043: true,
+ 2587041: true,
+ 2588041: true,
+ 2592041: true,
+ 2595041: true,
+ 2596041: true,
+ 2596043: true,
+ 2597041: true,
+ 2598041: true,
+ 2606041: true,
+ 2608041: true,
+ 2609041: true,
+ 2612041: true,
+ 2613042: true,
+ 2614041: true,
+ 2615041: true,
+ 2616041: true,
+ 2618042: true,
+ 2620041: true,
+ 2621042: true,
+ 2622041: true,
+ 2623043: true,
+ 2624042: true,
+ 2627043: true,
+ 2629041: true,
+ 2631041: true,
+ 2634041: true,
+ 2635041: true,
+ 2637041: true,
+ 2638041: true,
+ 2639041: true,
+ 2645042: true,
+ 2649041: true,
+ 2650041: true,
+ 2652042: true,
+ 2654041: true,
+ 2658042: true,
+ 2660042: true,
+ 2661041: true,
+ 2662041: true,
+ 2663041: true,
+ 2664041: true,
+ 2666041: true,
+ 2670042: true,
+ 2674041: true,
+ 2678041: true,
+ 2683041: true,
+ 2685042: true,
+ 2687042: true,
+ 2695042: true,
+ 2696041: true,
+ 2700041: true,
+ 2701041: true,
+ 2701042: true,
+ 2704042: true,
+ 2710044: true,
+ 2711043: true,
+ 2713042: true,
+ 2713043: true,
+ 2716041: true,
+ 2717043: true,
+ 2720042: true,
+ 2723041: true,
+ 2726041: true,
+ 2727041: true,
+ 2728043: true,
+ 2729041: true,
+ 2731041: true,
+ 2732041: true,
+ 2732042: true,
+ 2733041: true,
+ 2733042: true,
+ 2735041: true,
+ 2735042: true,
+ 2735043: true,
+ 2736041: true,
+ 2736044: true,
+ 2737041: true,
+ 2738041: true,
+ 2740041: true,
+ 2741041: true,
+ 2741042: true,
+ 2743041: true,
+ 2743042: true,
+ 2747044: true,
+ 2748041: true,
+ 2749041: true,
+ 2750041: true,
+ 2751042: true,
+ 2753043: true,
+ 2753045: true,
+ 2754043: true,
+ 2757042: true,
+ 2759041: true,
+ 2761041: true,
+ 2761043: true,
+ 2762041: true,
+ 2762042: true,
+ 2763041: true,
+ 2768042: true,
+ 2770044: true,
+ 2774041: true,
+ 2777041: true,
+ 2778042: true,
+ 2781042: true,
+ 2782041: true,
+ 2789043: true,
+ 2791042: true,
+ 2792041: true,
+ 2793041: true,
+ 2795041: true,
+ 2798041: true,
+ 2799041: true,
+ 2801042: true,
+ 2804041: true,
+ 2806041: true,
+ 2807041: true,
+ 2813041: true,
+ 2814041: true,
+ 2816041: true,
+ 2817041: true,
+ 2818041: true,
+ 2819041: true,
+ 2820041: true,
+ 2821041: true,
+ 2823042: true,
+ 2825041: true,
+ 2831041: true,
+ 2831042: true,
+ 2833041: true,
+ 2834041: true,
+ 2836041: true,
+ 2841041: true,
+ 2846041: true,
+ 2848041: true,
+ 2853042: true,
+ 2859041: true,
+ 2865041: true,
+ 2880041: true,
+ 2881042: true,
+ 2886041: true,
+ 2888041: true,
+ 2889042: true,
+ 2890041: true,
+ 2894042: true,
+ 2899041: true,
+ 2900041: true,
+ 2904041: true,
+ 2906041: true,
+ 2907041: true,
+ 2908041: true,
+ 2916041: true,
+ 2918042: true,
+ 2922041: true,
+ 2923041: true,
+ 2925041: true,
+ 2932041: true,
+ 2934041: true,
+ 2936041: true,
+ 2937041: true,
+ 2938041: true,
+ 2939041: true,
+ 2942042: true,
+ 2943041: true,
+ 2967041: true,
+ 2970042: true,
+ 2984041: true,
+ 2985041: true,
+ 2985042: true,
+ 2985043: true,
+ 2986042: true,
+ 2988041: true,
+ 2990041: true,
+ 2991041: true,
+ 2993041: true,
+ 2994041: true,
+ 2997041: true,
+ 3000041: true,
+ 3002041: true,
+ 3003043: true,
+ 3008041: true,
+ 3015042: true,
+ 3016041: true,
+ 3016043: true,
+ 3022041: true,
+ 3024041: true,
+ 3025042: true,
+ 3026041: true,
+ 3042041: true,
+ 3044041: true,
+ 3048041: true,
+ 3050041: true,
+ 3051041: true,
+ 3052041: true,
+ 3053041: true,
+ 3057041: true,
+ 3065041: true,
+ 3069041: true,
+ 3071041: true,
+ 3072041: true,
+ 3074041: true,
+ 3075041: true,
+ 3076041: true,
+ 3079041: true,
+ 3095042: true,
+ 3103042: true,
+ 3136042: true,
+ 3146041: true,
+ 3150041: true,
+ 3152041: true,
+ 3159041: true,
+ 3182043: true,
+ 3183041: true,
+ 3183043: true,
+ 3195042: true,
+ 3200041: true,
+ 3205041: true,
+ 3206041: true,
+ 3207041: true,
+ 3208041: true,
+ 3209041: true,
+ 3210041: true,
+ 3213041: true,
+ 3217042: true,
+ 3225042: true,
+ 3231041: true,
+ 3231042: true,
+ 3245041: true,
+ 3259043: true,
+ 3266042: true,
+ 3268042: true,
+ 3271041: true,
+ 3280044: true,
+ 3280045: true,
+ 3283042: true,
+ 3287042: true,
+ 3288042: true,
+ 3293041: true,
+ 3294041: true,
+ 3299041: true,
+ 3300042: true,
+ 3302042: true,
+ 3306042: true,
+ 3308041: true,
+ 3309041: true,
+ 3311043: true,
+ 3315041: true,
+ 3316041: true,
+ 3319042: true,
+ 3332043: true,
+ 3334041: true,
+ 3344044: true,
+ 3352041: true,
+ 3355041: true,
+ 3359041: true,
+ 3359042: true,
+ 3361041: true,
+ 3364041: true,
+ 3366041: true,
+ 3373041: true,
+ 3378041: true,
+ 3385041: true,
+ 3391042: true,
+ 3391043: true,
+ 3391044: true,
+ 3395041: true,
+ 3395042: true,
+ 3399042: true,
+ 3411043: true,
+ 3415042: true,
+ 3416042: true,
+ 3416043: true,
+ 3417041: true,
+ 3417042: true,
+ 3418043: true,
+ 3419043: true,
+ 3420041: true,
+ 3420043: true,
+ 3421041: true,
+ 3421042: true,
+ 3423041: true,
+ 3423043: true,
+ 3425044: true,
+ 3426042: true,
+ 3427043: true,
+ 3430042: true,
+ 3431045: true,
+ 3431046: true,
+ 3433041: true,
+ 3433042: true,
+ 3434041: true,
+ 3434046: true,
+ 3435042: true,
+ 3437041: true,
+ 3439043: true,
+ 3440046: true,
+ 3442041: true,
+ 3442042: true,
+ 3444043: true,
+ 3445041: true,
+ 3448042: true,
+ 3448043: true,
+ 3449044: true,
+ 3453042: true,
+ 3459043: true,
+ 3460042: true,
+ 3460043: true,
+ 3463043: true,
+ 3466044: true,
+ 3469044: true,
+ 3470044: true,
+ 3473041: true,
+ 3473044: true,
+ 3477041: true,
+ 3481041: true,
+ 3481042: true,
+ 3481043: true,
+ 3483041: true,
+ 3485044: true,
+ 3485046: true,
+ 3488041: true,
+ 3491042: true,
+ 3497042: true,
+ 3499041: true,
+ 3502041: true,
+ 3503041: true,
+ 3504041: true,
+ 3504042: true,
+ 3505041: true,
+ 3506041: true,
+ 3507041: true,
+ 3508041: true,
+ 3510041: true,
+ 3511043: true,
+ 3514041: true,
+ 3515041: true,
+ 3516042: true,
+ 3521041: true,
+ 3522041: true,
+ 3523041: true,
+ 3524041: true,
+ 3527042: true,
+ 3529041: true,
+ 3529042: true,
+ 3532042: true,
+ 3533041: true,
+ 3536041: true,
+ 3536043: true,
+ 3540042: true,
+ 3541044: true,
+ 3545042: true,
+ 3545044: true,
+ 3547041: true,
+ 3547042: true,
+ 3549041: true,
+ 3553041: true,
+ 3555041: true,
+ 3556041: true,
+ 3559041: true,
+ 3561041: true,
+ 3562042: true,
+ 3563042: true,
+ 3564041: true,
+ 3565041: true,
+ 3571043: true,
+ 3572042: true,
+ 3573043: true,
+ 3573044: true,
+ 3574044: true,
+ 3575042: true,
+ 3576043: true,
+ 3578041: true,
+ 3579042: true,
+ 3580041: true,
+ 3580042: true,
+ 3582042: true,
+ 3584042: true,
+ 3585041: true,
+ 3592041: true,
+ 3595043: true,
+ 3601041: true,
+ 3606043: true,
+ 3608042: true,
+ 3609042: true,
+ 3617041: true,
+ 3618041: true,
+ 3619041: true,
+ 3619042: true,
+ 3620041: true,
+ 3621041: true,
+ 3627041: true,
+ 3628041: true,
+ 3631041: true,
+ 3634042: true,
+ 3637041: true,
+ 3641041: true,
+ 3641042: true,
+ 3642041: true,
+ 3646043: true,
+ 3650042: true,
+ 3652041: true,
+ 3659041: true,
+ 3661042: true,
+ 3666042: true,
+ 3668042: true,
+ 3671042: true,
+ 3674043: true,
+ 3676041: true,
+ 3680041: true,
+ 3683042: true,
+ 3685041: true,
+ 3685043: true,
+ 3687041: true,
+ 3690042: true,
+ 3691042: true,
+ 3699041: true,
+ 3701041: true,
+ 3702041: true,
+ 3705041: true,
+ 3707041: true,
+ 3708041: true,
+ 3709041: true,
+ 3710042: true,
+ 3712041: true,
+ 3719042: true,
+ 3720042: true,
+ 3723041: true,
+ 3728041: true,
+ 3730041: true,
+ 3731041: true,
+ 3731046: true,
+ 3731048: true,
+ 3733046: true,
+ 3739042: true,
+ 3746041: true,
+ 3746044: true,
+ 3746047: true,
+ 3749041: true,
+ 3749043: true,
+ 3749044: true,
+ 3750041: true,
+ 3751041: true,
+ 3752041: true,
+ 3752044: true,
+ 3753041: true,
+ 3759042: true,
+ 3760049: true,
+ 3763043: true,
+ 3766042: true,
+ 3766045: true,
+ 3769042: true,
+ 3770045: true,
+ 3772043: true,
+ 3775047: true,
+ 3775048: true,
+ 3775050: true,
+ 3779043: true,
+ 3782044: true,
+ 3786043: true,
+ 3787044: true,
+ 3787046: true,
+ 3789045: true,
+ 3790044: true,
+ 3794041: true,
+ 3794043: true,
+ 3795044: true,
+ 3797041: true,
+ 3797045: true,
+ 3799045: true,
+ 3802044: true,
+ 3802045: true,
+ 3804042: true,
+ 3809041: true,
+ 3809042: true,
+ 3811042: true,
+ 3813045: true,
+ 3814041: true,
+ 3816043: true,
+ 3818044: true,
+ 3821042: true,
+ 3821044: true,
+ 3824043: true,
+ 3827042: true,
+ 3827043: true,
+ 3829043: true,
+ 3831041: true,
+ 3832045: true,
+ 3834042: true,
+ 3835043: true,
+ 3837042: true,
+ 3849043: true,
+ 3849044: true,
+ 3851041: true,
+ 3851042: true,
+ 3852041: true,
+ 3858042: true,
+ 3861044: true,
+ 3862041: true,
+ 3867041: true,
+ 3867044: true,
+ 3867045: true,
+ 3868041: true,
+ 3869042: true,
+ 3869043: true,
+ 3879041: true,
+ 3880041: true,
+ 3881041: true,
+ 3882042: true,
+ 3885041: true,
+ 3886041: true,
+ 3887042: true,
+ 3889043: true,
+ 3890042: true,
+ 3891042: true,
+ 3892041: true,
+ 3896042: true,
+ 3898042: true,
+ 3900044: true,
+ 3901043: true,
+ 3902042: true,
+ 3902044: true,
+ 3903043: true,
+ 3905041: true,
+ 3906041: true,
+ 3907042: true,
+ 3909041: true,
+ 3910042: true,
+ 3912041: true,
+ 3912043: true,
+ 3913041: true,
+ 3913043: true,
+ 3918041: true,
+ 3919043: true,
+ 3920042: true,
+ 3921041: true,
+ 3921043: true,
+ 3923043: true,
+ 3926041: true,
+ 3926044: true,
+ 3937041: true,
+ 3937043: true,
+ 3939042: true,
+ 3941041: true,
+ 3946041: true,
+ 3948043: true,
+ 3949042: true,
+ 3952041: true,
+ 3956042: true,
+ 3959041: true,
+ 3967041: true,
+ 3969042: true,
+ 3970041: true,
+ 3970045: true,
+ 3971041: true,
+ 3971044: true,
+ 3972041: true,
+ 3972047: true,
+ 3973041: true,
+ 3973050: true,
+ 3973051: true,
+ 3973052: true,
+ 3973054: true,
+ 3974044: true,
+ 3975046: true,
+ 3978042: true,
+ 3978043: true,
+ 3979044: true,
+ 3979045: true,
+ 3980042: true,
+ 3980043: true,
+ 3981043: true,
+ 3981049: true,
+ 3981052: true,
+ 3981054: true,
+ 3982045: true,
+ 3982051: true,
+ 3984042: true,
+ 3985046: true,
+ 3985047: true,
+ 3986042: true,
+ 3987043: true,
+ 3987045: true,
+ 3988045: true,
+ 3989042: true,
+ 3989052: true,
+ 3989056: true,
+ 3989058: true,
+ 3989059: true,
+ 3989061: true,
+ 3989062: true,
+ 3989065: true,
+ 3990043: true,
+ 3990045: true,
+ 3991043: true,
+ 3991045: true,
+ 3991047: true,
+ 3992041: true,
+ 3992044: true,
+ 3992047: true,
+ 3993041: true,
+ 3993044: true,
+ 3994041: true,
+ 3994042: true,
+ 3994043: true,
+ 3996047: true,
+ 3998041: true,
+ 3998045: true,
+ 3998053: true,
+ 3999041: true,
+ 3999046: true,
+ 3999047: true,
+}
diff --git a/internal/short/short.go b/internal/short/short.go
new file mode 100644
index 0000000..a7a1507
--- /dev/null
+++ b/internal/short/short.go
@@ -0,0 +1,206 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package short implements a simple URL shortener, serving shortened urls
+// from /s/key. An administrative handler is provided for other services to use.
+package short
+
+// TODO(adg): collect statistics on URL visits
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "html/template"
+ "log"
+ "net/http"
+ "net/url"
+ "regexp"
+ "strings"
+
+ "cloud.google.com/go/datastore"
+ "golang.org/x/website/internal/memcache"
+)
+
+const (
+ prefix = "/s"
+ kind = "Link"
+ baseURL = "https://golang.org" + prefix
+)
+
+// Link represents a short link.
+type Link struct {
+ Key, Target string
+}
+
+var validKey = regexp.MustCompile(`^[a-zA-Z0-9-_.]+$`)
+
+type server struct {
+ datastore *datastore.Client
+ memcache *memcache.CodecClient
+}
+
+func newServer(dc *datastore.Client, mc *memcache.Client) *server {
+ return &server{
+ datastore: dc,
+ memcache: mc.WithCodec(memcache.JSON),
+ }
+}
+
+func RegisterHandlers(mux *http.ServeMux, dc *datastore.Client, mc *memcache.Client) {
+ s := newServer(dc, mc)
+ mux.HandleFunc(prefix+"/", s.linkHandler)
+}
+
+// linkHandler services requests to short URLs.
+// http://golang.org/s/key[/remaining/path]
+// It consults memcache and datastore for the Link for key.
+// It then sends a redirects or an error message.
+// If the remaining path part is not empty, the redirects
+// will be the relative path from the resolved Link.
+func (h server) linkHandler(w http.ResponseWriter, r *http.Request) {
+ ctx := r.Context()
+
+ key, remainingPath, err := extractKey(r)
+ if err != nil { // invalid key or url
+ http.Error(w, "not found", http.StatusNotFound)
+ return
+ }
+
+ var link Link
+ if err := h.memcache.Get(ctx, cacheKey(key), &link); err != nil {
+ k := datastore.NameKey(kind, key, nil)
+ err = h.datastore.Get(ctx, k, &link)
+ switch err {
+ case datastore.ErrNoSuchEntity:
+ http.Error(w, "not found", http.StatusNotFound)
+ return
+ default: // != nil
+ log.Printf("ERROR %q: %v", key, err)
+ http.Error(w, "internal server error", http.StatusInternalServerError)
+ return
+ case nil:
+ item := &memcache.Item{
+ Key: cacheKey(key),
+ Object: &link,
+ }
+ if err := h.memcache.Set(ctx, item); err != nil {
+ log.Printf("WARNING %q: %v", key, err)
+ }
+ }
+ }
+
+ target := link.Target
+ if remainingPath != "" {
+ target += remainingPath
+ }
+ http.Redirect(w, r, target, http.StatusFound)
+}
+
+func extractKey(r *http.Request) (key, remainingPath string, err error) {
+ path := r.URL.Path
+ if !strings.HasPrefix(path, prefix+"/") {
+ return "", "", errors.New("invalid path")
+ }
+
+ key, remainingPath = path[len(prefix)+1:], ""
+ if slash := strings.Index(key, "/"); slash > 0 {
+ key, remainingPath = key[:slash], key[slash:]
+ }
+
+ if !validKey.MatchString(key) {
+ return "", "", errors.New("invalid key")
+ }
+ return key, remainingPath, nil
+}
+
+// AdminHandler serves an administrative interface for managing shortener entries.
+// Be careful. It is the caller’s responsibility to ensure that the handler is
+// only exposed to authorized users.
+func AdminHandler(dc *datastore.Client, mc *memcache.Client) http.HandlerFunc {
+ s := newServer(dc, mc)
+ return s.adminHandler
+}
+
+var adminTemplate = template.Must(template.New("admin").Parse(templateHTML))
+
+// adminHandler serves an administrative interface.
+// Be careful. Ensure that this handler is only be exposed to authorized users.
+func (h server) adminHandler(w http.ResponseWriter, r *http.Request) {
+ ctx := r.Context()
+
+ var newLink *Link
+ var doErr error
+ if r.Method == "POST" {
+ key := r.FormValue("key")
+ switch r.FormValue("do") {
+ case "Add":
+ newLink = &Link{key, r.FormValue("target")}
+ doErr = h.putLink(ctx, newLink)
+ case "Delete":
+ k := datastore.NameKey(kind, key, nil)
+ doErr = h.datastore.Delete(ctx, k)
+ default:
+ http.Error(w, "unknown action", http.StatusBadRequest)
+ }
+ err := h.memcache.Delete(ctx, cacheKey(key))
+ if err != nil && err != memcache.ErrCacheMiss {
+ log.Printf("WARNING %q: %v", key, err)
+ }
+ }
+
+ var links []*Link
+ q := datastore.NewQuery(kind).Order("Key")
+ if _, err := h.datastore.GetAll(ctx, q, &links); err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ log.Printf("ERROR %v", err)
+ return
+ }
+
+ // Put the new link in the list if it's not there already.
+ // (Eventual consistency means that it might not show up
+ // immediately, which might be confusing for the user.)
+ if newLink != nil && doErr == nil {
+ found := false
+ for i := range links {
+ if links[i].Key == newLink.Key {
+ found = true
+ break
+ }
+ }
+ if !found {
+ links = append([]*Link{newLink}, links...)
+ }
+ newLink = nil
+ }
+
+ var data = struct {
+ BaseURL string
+ Prefix string
+ Links []*Link
+ New *Link
+ Error error
+ }{baseURL, prefix, links, newLink, doErr}
+ if err := adminTemplate.Execute(w, &data); err != nil {
+ log.Printf("ERROR adminTemplate: %v", err)
+ }
+}
+
+// putLink validates the provided link and puts it into the datastore.
+func (h server) putLink(ctx context.Context, link *Link) error {
+ if !validKey.MatchString(link.Key) {
+ return errors.New("invalid key; must match " + validKey.String())
+ }
+ if _, err := url.Parse(link.Target); err != nil {
+ return fmt.Errorf("bad target: %v", err)
+ }
+ k := datastore.NameKey(kind, link.Key, nil)
+ _, err := h.datastore.Put(ctx, k, link)
+ return err
+}
+
+// cacheKey returns a short URL key as a memcache key.
+func cacheKey(key string) string {
+ return "link-" + key
+}
diff --git a/internal/short/short_test.go b/internal/short/short_test.go
new file mode 100644
index 0000000..f0ed0dc
--- /dev/null
+++ b/internal/short/short_test.go
@@ -0,0 +1,37 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package short
+
+import (
+ "net/http/httptest"
+ "testing"
+)
+
+func TestExtractKey(t *testing.T) {
+ testCases := []struct {
+ in string
+ wantKey, wantRemaining string
+ wantErr bool
+ }{
+ {in: "/s/foo", wantKey: "foo", wantRemaining: ""},
+ {in: "/s/foo/", wantKey: "foo", wantRemaining: "/"},
+ {in: "/s/foo/bar/", wantKey: "foo", wantRemaining: "/bar/"},
+ {in: "/s/foo.bar/baz", wantKey: "foo.bar", wantRemaining: "/baz"},
+ {in: "/s/s/s/s", wantKey: "s", wantRemaining: "/s/s"},
+ {in: "/", wantErr: true},
+ {in: "/s/", wantErr: true},
+ {in: "/s", wantErr: true},
+ {in: "/t/foo", wantErr: true},
+ {in: "/s/foo*", wantErr: true},
+ }
+
+ for _, tc := range testCases {
+ req := httptest.NewRequest("GET", tc.in, nil)
+ gotKey, gotRemaining, gotErr := extractKey(req)
+ if gotKey != tc.wantKey || gotRemaining != tc.wantRemaining || (gotErr != nil) != tc.wantErr {
+ t.Errorf("extractKey(%q) = (%q, %q, %v), want (%q, %q, err=%v)", tc.in, gotKey, gotRemaining, gotErr, tc.wantKey, tc.wantRemaining, tc.wantErr)
+ }
+ }
+}
diff --git a/internal/short/tmpl.go b/internal/short/tmpl.go
new file mode 100644
index 0000000..ba16298
--- /dev/null
+++ b/internal/short/tmpl.go
@@ -0,0 +1,110 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package short
+
+const templateHTML = `
+<!doctype HTML>
+<html lang="en">
+<title>golang.org URL shortener</title>
+<style>
+* {
+ box-sizing: border-box;
+}
+body {
+ font-family: system-ui, sans-serif;
+}
+input {
+ border: 1px solid #ccc;
+}
+input[type=text],
+input[type=url] {
+ width: 400px;
+}
+input, td, th {
+ color: #333;
+}
+input, td {
+ font-size: 14pt;
+}
+th {
+ font-size: 16pt;
+ text-align: left;
+ padding-top: 10px;
+}
+.autoselect {
+ border: none;
+}
+.error {
+ color: #900;
+}
+table {
+ margin-left: auto;
+ margin-right: auto;
+}
+</style>
+<table>
+
+{{with .Error}}
+ <tr>
+ <th colspan="3">Error</th>
+ </tr>
+ <tr>
+ <td class="error" colspan="3">{{.}}</td>
+ </tr>
+{{end}}
+
+<tr>
+ <th>Key</th>
+ <th>Target</th>
+ <th></th>
+</tr>
+
+<form method="POST">
+<tr>
+ <td><input type="text" name="key"{{with .New}} value="{{.Key}}"{{end}} required></td>
+ <td><input type="url" name="target"{{with .New}} value="{{.Target}}"{{end}} required></td>
+ <td><input type="submit" name="do" value="Add">
+</tr>
+</form>
+
+{{with .Links}}
+ <tr>
+ <th>Short Link</th>
+ <th> </th>
+ <th> </th>
+ </tr>
+ {{range .}}
+ <tr>
+ <td><input class="autoselect" type="text" value="{{$.BaseURL}}/{{.Key}}" readonly></td>
+ <td><input class="autoselect" type="text" value="{{.Target}}" readonly></td>
+ <td>
+ <form method="POST">
+ <input type="hidden" name="key" value="{{.Key}}">
+ <input type="submit" name="do" value="Delete" class="delete">
+ </form>
+ </td>
+ </tr>
+ {{end}}
+{{end}}
+</table>
+<script>
+document.querySelectorAll('.autoselect').forEach(el => {
+ el.addEventListener('click', e => {
+ e.target.select();
+ });
+});
+
+const baseURL = '{{$.BaseURL}}';
+document.querySelectorAll('.delete').forEach(el => {
+ el.addEventListener('click', e => {
+ const key = e.target.form.elements['key'].value;
+ if (!confirm('Delete this link?\n' + baseURL + '/' + key)) {
+ e.preventDefault();
+ return;
+ }
+ })
+});
+</script>
+`
diff --git a/internal/spec/spec.go b/internal/spec/spec.go
new file mode 100644
index 0000000..abff27f
--- /dev/null
+++ b/internal/spec/spec.go
@@ -0,0 +1,177 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package spec implements hyperlinking of the Go language specification.
+package spec
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "text/scanner"
+)
+
+// Linkify adds links to HTML source text containing EBNF sections,
+// as found in go_spec.html, linking identifiers to their definitions.
+// It writes the modified HTML to out.
+func Linkify(out io.Writer, src []byte) {
+ for len(src) > 0 {
+ // i: beginning of EBNF text (or end of source)
+ i := bytes.Index(src, openTag)
+ if i < 0 {
+ i = len(src) - len(openTag)
+ }
+ i += len(openTag)
+
+ // j: end of EBNF text (or end of source)
+ j := bytes.Index(src[i:], closeTag) // close marker
+ if j < 0 {
+ j = len(src) - i
+ }
+ j += i
+
+ // write text before EBNF
+ out.Write(src[0:i])
+ // process EBNF
+ var p ebnfParser
+ p.parse(out, src[i:j])
+
+ // advance
+ src = src[j:]
+ }
+}
+
+// Markers around EBNF sections
+var (
+ openTag = []byte(`<pre class="ebnf">`)
+ closeTag = []byte(`</pre>`)
+)
+
+type ebnfParser struct {
+ out io.Writer // parser output
+ src []byte // parser input
+ scanner scanner.Scanner
+ prev int // offset of previous token
+ pos int // offset of current token
+ tok rune // one token look-ahead
+ lit string // token literal
+}
+
+func (p *ebnfParser) flush() {
+ p.out.Write(p.src[p.prev:p.pos])
+ p.prev = p.pos
+}
+
+func (p *ebnfParser) next() {
+ p.tok = p.scanner.Scan()
+ p.pos = p.scanner.Position.Offset
+ p.lit = p.scanner.TokenText()
+}
+
+func (p *ebnfParser) printf(format string, args ...interface{}) {
+ p.flush()
+ fmt.Fprintf(p.out, format, args...)
+}
+
+func (p *ebnfParser) errorExpected(msg string) {
+ p.printf(`<span class="highlight">error: expected %s, found %s</span>`, msg, scanner.TokenString(p.tok))
+}
+
+func (p *ebnfParser) expect(tok rune) {
+ if p.tok != tok {
+ p.errorExpected(scanner.TokenString(tok))
+ }
+ p.next() // make progress in any case
+}
+
+func (p *ebnfParser) parseIdentifier(def bool) {
+ if p.tok == scanner.Ident {
+ name := p.lit
+ if def {
+ p.printf(`<a id="%s">%s</a>`, name, name)
+ } else {
+ p.printf(`<a href="#%s" class="noline">%s</a>`, name, name)
+ }
+ p.prev += len(name) // skip identifier when printing next time
+ p.next()
+ } else {
+ p.expect(scanner.Ident)
+ }
+}
+
+func (p *ebnfParser) parseTerm() bool {
+ switch p.tok {
+ case scanner.Ident:
+ p.parseIdentifier(false)
+
+ case scanner.String, scanner.RawString:
+ p.next()
+ const ellipsis = '…' // U+2026, the horizontal ellipsis character
+ if p.tok == ellipsis {
+ p.next()
+ p.expect(scanner.String)
+ }
+
+ case '(':
+ p.next()
+ p.parseExpression()
+ p.expect(')')
+
+ case '[':
+ p.next()
+ p.parseExpression()
+ p.expect(']')
+
+ case '{':
+ p.next()
+ p.parseExpression()
+ p.expect('}')
+
+ default:
+ return false // no term found
+ }
+
+ return true
+}
+
+func (p *ebnfParser) parseSequence() {
+ if !p.parseTerm() {
+ p.errorExpected("term")
+ }
+ for p.parseTerm() {
+ }
+}
+
+func (p *ebnfParser) parseExpression() {
+ for {
+ p.parseSequence()
+ if p.tok != '|' {
+ break
+ }
+ p.next()
+ }
+}
+
+func (p *ebnfParser) parseProduction() {
+ p.parseIdentifier(true)
+ p.expect('=')
+ if p.tok != '.' {
+ p.parseExpression()
+ }
+ p.expect('.')
+}
+
+func (p *ebnfParser) parse(out io.Writer, src []byte) {
+ // initialize ebnfParser
+ p.out = out
+ p.src = src
+ p.scanner.Init(bytes.NewBuffer(src))
+ p.next() // initializes pos, tok, lit
+
+ // process source
+ for p.tok != scanner.EOF {
+ p.parseProduction()
+ }
+ p.flush()
+}
diff --git a/internal/spec/spec_test.go b/internal/spec/spec_test.go
new file mode 100644
index 0000000..20eb9a8
--- /dev/null
+++ b/internal/spec/spec_test.go
@@ -0,0 +1,22 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package spec
+
+import (
+ "bytes"
+ "strings"
+ "testing"
+)
+
+func TestParseEBNFString(t *testing.T) {
+ var p ebnfParser
+ var buf bytes.Buffer
+ src := []byte("octal_byte_value = `\\` octal_digit octal_digit octal_digit .")
+ p.parse(&buf, src)
+
+ if strings.Contains(buf.String(), "error") {
+ t.Error(buf.String())
+ }
+}
diff --git a/internal/texthtml/ast.go b/internal/texthtml/ast.go
new file mode 100644
index 0000000..76bd4bb
--- /dev/null
+++ b/internal/texthtml/ast.go
@@ -0,0 +1,298 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package texthtml
+
+import (
+ "bytes"
+ "fmt"
+ "go/ast"
+ "go/doc"
+ "go/token"
+ "strconv"
+ "unicode"
+ "unicode/utf8"
+)
+
+// A goLink describes the (HTML) link information for a Go identifier.
+// The zero value of a link represents "no link".
+type goLink struct {
+ path, name string // package path, identifier name
+ isVal bool // identifier is defined in a const or var declaration
+}
+
+func (l *goLink) tags() (start, end string) {
+ switch {
+ case l.path != "" && l.name == "":
+ // package path
+ return `<a href="/pkg/` + l.path + `/">`, `</a>`
+ case l.path != "" && l.name != "":
+ // qualified identifier
+ return `<a href="/pkg/` + l.path + `/#` + l.name + `">`, `</a>`
+ case l.path == "" && l.name != "":
+ // local identifier
+ if l.isVal {
+ return `<span id="` + l.name + `">`, `</span>`
+ }
+ if ast.IsExported(l.name) {
+ return `<a href="#` + l.name + `">`, `</a>`
+ }
+ }
+ return "", ""
+}
+
+// goLinksFor returns the list of links for the identifiers used
+// by node in the same order as they appear in the source.
+func goLinksFor(node ast.Node) (links []goLink) {
+ // linkMap tracks link information for each ast.Ident node. Entries may
+ // be created out of source order (for example, when we visit a parent
+ // definition node). These links are appended to the returned slice when
+ // their ast.Ident nodes are visited.
+ linkMap := make(map[*ast.Ident]goLink)
+
+ ast.Inspect(node, func(node ast.Node) bool {
+ switch n := node.(type) {
+ case *ast.Field:
+ for _, n := range n.Names {
+ linkMap[n] = goLink{}
+ }
+ case *ast.ImportSpec:
+ if name := n.Name; name != nil {
+ linkMap[name] = goLink{}
+ }
+ case *ast.ValueSpec:
+ for _, n := range n.Names {
+ linkMap[n] = goLink{name: n.Name, isVal: true}
+ }
+ case *ast.FuncDecl:
+ linkMap[n.Name] = goLink{}
+ case *ast.TypeSpec:
+ linkMap[n.Name] = goLink{}
+ case *ast.AssignStmt:
+ // Short variable declarations only show up if we apply
+ // this code to all source code (as opposed to exported
+ // declarations only).
+ if n.Tok == token.DEFINE {
+ // Some of the lhs variables may be re-declared,
+ // so technically they are not defs. We don't
+ // care for now.
+ for _, x := range n.Lhs {
+ // Each lhs expression should be an
+ // ident, but we are conservative and check.
+ if n, _ := x.(*ast.Ident); n != nil {
+ linkMap[n] = goLink{isVal: true}
+ }
+ }
+ }
+ case *ast.SelectorExpr:
+ // Detect qualified identifiers of the form pkg.ident.
+ // If anything fails we return true and collect individual
+ // identifiers instead.
+ if x, _ := n.X.(*ast.Ident); x != nil {
+ // Create links only if x is a qualified identifier.
+ if obj := x.Obj; obj != nil && obj.Kind == ast.Pkg {
+ if spec, _ := obj.Decl.(*ast.ImportSpec); spec != nil {
+ // spec.Path.Value is the import path
+ if path, err := strconv.Unquote(spec.Path.Value); err == nil {
+ // Register two links, one for the package
+ // and one for the qualified identifier.
+ linkMap[x] = goLink{path: path}
+ linkMap[n.Sel] = goLink{path: path, name: n.Sel.Name}
+ }
+ }
+ }
+ }
+ case *ast.CompositeLit:
+ // Detect field names within composite literals. These links should
+ // be prefixed by the type name.
+ fieldPath := ""
+ prefix := ""
+ switch typ := n.Type.(type) {
+ case *ast.Ident:
+ prefix = typ.Name + "."
+ case *ast.SelectorExpr:
+ if x, _ := typ.X.(*ast.Ident); x != nil {
+ // Create links only if x is a qualified identifier.
+ if obj := x.Obj; obj != nil && obj.Kind == ast.Pkg {
+ if spec, _ := obj.Decl.(*ast.ImportSpec); spec != nil {
+ // spec.Path.Value is the import path
+ if path, err := strconv.Unquote(spec.Path.Value); err == nil {
+ // Register two links, one for the package
+ // and one for the qualified identifier.
+ linkMap[x] = goLink{path: path}
+ linkMap[typ.Sel] = goLink{path: path, name: typ.Sel.Name}
+ fieldPath = path
+ prefix = typ.Sel.Name + "."
+ }
+ }
+ }
+ }
+ }
+ for _, e := range n.Elts {
+ if kv, ok := e.(*ast.KeyValueExpr); ok {
+ if k, ok := kv.Key.(*ast.Ident); ok {
+ // Note: there is some syntactic ambiguity here. We cannot determine
+ // if this is a struct literal or a map literal without type
+ // information. We assume struct literal.
+ name := prefix + k.Name
+ linkMap[k] = goLink{path: fieldPath, name: name}
+ }
+ }
+ }
+ case *ast.Ident:
+ if l, ok := linkMap[n]; ok {
+ links = append(links, l)
+ } else {
+ l := goLink{name: n.Name}
+ if n.Obj == nil && doc.IsPredeclared(n.Name) {
+ l.path = "builtin"
+ }
+ links = append(links, l)
+ }
+ }
+ return true
+ })
+ return
+}
+
+// postFormatAST makes any appropriate changes to the formatting of node in buf.
+// Specifically, it adds span links to each struct field, so they can be linked properly.
+// TODO(rsc): Why not do this as part of the linking above?
+func postFormatAST(buf *bytes.Buffer, node ast.Node) {
+ if st, name := isStructTypeDecl(node); st != nil {
+ addStructFieldIDAttributes(buf, name, st)
+ }
+}
+
+// isStructTypeDecl checks whether n is a struct declaration.
+// It either returns a non-nil StructType and its name, or zero values.
+func isStructTypeDecl(n ast.Node) (st *ast.StructType, name string) {
+ gd, ok := n.(*ast.GenDecl)
+ if !ok || gd.Tok != token.TYPE {
+ return nil, ""
+ }
+ if gd.Lparen > 0 {
+ // Parenthesized type. Who does that, anyway?
+ // TODO: Reportedly gri does. Fix this to handle that too.
+ return nil, ""
+ }
+ if len(gd.Specs) != 1 {
+ return nil, ""
+ }
+ ts, ok := gd.Specs[0].(*ast.TypeSpec)
+ if !ok {
+ return nil, ""
+ }
+ st, ok = ts.Type.(*ast.StructType)
+ if !ok {
+ return nil, ""
+ }
+ return st, ts.Name.Name
+}
+
+// addStructFieldIDAttributes modifies the contents of buf such that
+// all struct fields of the named struct have <span id='name.Field'>
+// in them, so people can link to /#Struct.Field.
+func addStructFieldIDAttributes(buf *bytes.Buffer, name string, st *ast.StructType) {
+ if st.Fields == nil {
+ return
+ }
+ // needsLink is a set of identifiers that still need to be
+ // linked, where value == key, to avoid an allocation in func
+ // linkedField.
+ needsLink := make(map[string]string)
+
+ for _, f := range st.Fields.List {
+ if len(f.Names) == 0 {
+ continue
+ }
+ fieldName := f.Names[0].Name
+ needsLink[fieldName] = fieldName
+ }
+ var newBuf bytes.Buffer
+ foreachLine(buf.Bytes(), func(line []byte) {
+ if fieldName := linkedField(line, needsLink); fieldName != "" {
+ fmt.Fprintf(&newBuf, `<span id="%s.%s"></span>`, name, fieldName)
+ delete(needsLink, fieldName)
+ }
+ newBuf.Write(line)
+ })
+ buf.Reset()
+ buf.Write(newBuf.Bytes())
+}
+
+// foreachLine calls fn for each line of in, where a line includes
+// the trailing "\n", except on the last line, if it doesn't exist.
+func foreachLine(in []byte, fn func(line []byte)) {
+ for len(in) > 0 {
+ nl := bytes.IndexByte(in, '\n')
+ if nl == -1 {
+ fn(in)
+ return
+ }
+ fn(in[:nl+1])
+ in = in[nl+1:]
+ }
+}
+
+// commentPrefix is the line prefix for comments after they've been HTMLified.
+var commentPrefix = []byte(`<span class="comment">// `)
+
+// linkedField determines whether the given line starts with an
+// identifier in the provided ids map (mapping from identifier to the
+// same identifier). The line can start with either an identifier or
+// an identifier in a comment. If one matches, it returns the
+// identifier that matched. Otherwise it returns the empty string.
+func linkedField(line []byte, ids map[string]string) string {
+ line = bytes.TrimSpace(line)
+
+ // For fields with a doc string of the
+ // conventional form, we put the new span into
+ // the comment instead of the field.
+ // The "conventional" form is a complete sentence
+ // per https://golang.org/s/style#comment-sentences like:
+ //
+ // // Foo is an optional Fooer to foo the foos.
+ // Foo Fooer
+ //
+ // In this case, we want the #StructName.Foo
+ // link to make the browser go to the comment
+ // line "Foo is an optional Fooer" instead of
+ // the "Foo Fooer" line, which could otherwise
+ // obscure the docs above the browser's "fold".
+ //
+ // TODO: do this better, so it works for all
+ // comments, including unconventional ones.
+ line = bytes.TrimPrefix(line, commentPrefix)
+ id := scanIdentifier(line)
+ if len(id) == 0 {
+ // No leading identifier. Avoid map lookup for
+ // somewhat common case.
+ return ""
+ }
+ return ids[string(id)]
+}
+
+// scanIdentifier scans a valid Go identifier off the front of v and
+// either returns a subslice of v if there's a valid identifier, or
+// returns a zero-length slice.
+func scanIdentifier(v []byte) []byte {
+ var n int // number of leading bytes of v belonging to an identifier
+ for {
+ r, width := utf8.DecodeRune(v[n:])
+ if !(isLetter(r) || n > 0 && isDigit(r)) {
+ break
+ }
+ n += width
+ }
+ return v[:n]
+}
+
+func isLetter(ch rune) bool {
+ return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_' || ch >= utf8.RuneSelf && unicode.IsLetter(ch)
+}
+
+func isDigit(ch rune) bool {
+ return '0' <= ch && ch <= '9' || ch >= utf8.RuneSelf && unicode.IsDigit(ch)
+}
diff --git a/internal/texthtml/texthtml.go b/internal/texthtml/texthtml.go
new file mode 100644
index 0000000..1175fe1
--- /dev/null
+++ b/internal/texthtml/texthtml.go
@@ -0,0 +1,355 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package texthtml formats text files to HTML.
+package texthtml
+
+import (
+ "bytes"
+ "fmt"
+ "go/ast"
+ "go/scanner"
+ "go/token"
+ "io"
+ "regexp"
+ "text/template"
+)
+
+// A Span describes a text span [start, end).
+// The zero value of a Span is an empty span.
+type Span struct {
+ Start, End int
+}
+
+func (s *Span) isEmpty() bool { return s.Start >= s.End }
+
+// A Selection is an "iterator" function returning a text span.
+// Repeated calls to a selection return consecutive, non-overlapping,
+// non-empty spans, followed by an infinite sequence of empty
+// spans. The first empty span marks the end of the selection.
+type Selection func() Span
+
+// A Config configures how to format text as HTML.
+type Config struct {
+ Line int // if >= 1, number lines beginning with number Line, with <span class="ln">
+ GoComments bool // mark comments in Go text with <span class="comment">
+ Highlight string // highlight matches for this regexp with <span class="highlight">
+ Selection Selection // mark selected spans with <span class="selection">
+ AST ast.Node // link uses to declarations, assuming text is formatting of AST
+}
+
+// Format formats text to HTML according to the configuration cfg.
+func Format(text []byte, cfg Config) (html []byte) {
+ var comments, highlights Selection
+ if cfg.GoComments {
+ comments = tokenSelection(text, token.COMMENT)
+ }
+ if cfg.Highlight != "" {
+ highlights = regexpSelection(text, cfg.Highlight)
+ }
+
+ var buf bytes.Buffer
+ var idents Selection = Spans()
+ var goLinks []goLink
+ if cfg.AST != nil {
+ idents = tokenSelection(text, token.IDENT)
+ goLinks = goLinksFor(cfg.AST)
+ }
+
+ formatSelections(&buf, text, goLinks, comments, highlights, cfg.Selection, idents)
+
+ if cfg.AST != nil {
+ postFormatAST(&buf, cfg.AST)
+ }
+
+ if cfg.Line > 0 {
+ // Add line numbers in a separate pass.
+ old := buf.Bytes()
+ buf = bytes.Buffer{}
+ n := cfg.Line
+ for _, line := range bytes.Split(old, []byte("\n")) {
+ // The line numbers are inserted into the document via a CSS ::before
+ // pseudo-element. This prevents them from being copied when users
+ // highlight and copy text.
+ // ::before is supported in 98% of browsers: https://caniuse.com/#feat=css-gencontent
+ // This is also the trick Github uses to hide line numbers.
+ //
+ // The first tab for the code snippet needs to start in column 9, so
+ // it indents a full 8 spaces, hence the two nbsp's. Otherwise the tab
+ // character only indents a short amount.
+ //
+ // Due to rounding and font width Firefox might not treat 8 rendered
+ // characters as 8 characters wide, and subsequently may treat the tab
+ // character in the 9th position as moving the width from (7.5 or so) up
+ // to 8. See
+ // https://github.com/webcompat/web-bugs/issues/17530#issuecomment-402675091
+ // for a fuller explanation. The solution is to add a CSS class to
+ // explicitly declare the width to be 8 characters.
+ fmt.Fprintf(&buf, `<span id="L%d" class="ln">%6d </span>`, n, n)
+ n++
+ buf.Write(line)
+ buf.WriteByte('\n')
+ }
+ }
+ return buf.Bytes()
+}
+
+// formatSelections takes a text and writes it to w using link and span
+// writers lw and sw as follows: lw is invoked for consecutive span starts
+// and ends as specified through the links selection, and sw is invoked for
+// consecutive spans of text overlapped by the same selections as specified
+// by selections.
+func formatSelections(w io.Writer, text []byte, goLinks []goLink, selections ...Selection) {
+ // compute the sequence of consecutive span changes
+ changes := newMerger(selections)
+
+ // The i'th bit in bitset indicates that the text
+ // at the current offset is covered by selections[i].
+ bitset := 0
+ lastOffs := 0
+
+ // Text spans are written in a delayed fashion
+ // such that consecutive spans belonging to the
+ // same selection can be combined (peephole optimization).
+ // last describes the last span which has not yet been written.
+ var last struct {
+ begin, end int // valid if begin < end
+ bitset int
+ }
+
+ // flush writes the last delayed text span
+ flush := func() {
+ if last.begin < last.end {
+ selectionTag(w, text[last.begin:last.end], last.bitset)
+ }
+ last.begin = last.end // invalidate last
+ }
+
+ // span runs the span [lastOffs, end) with the selection
+ // indicated by bitset through the span peephole optimizer.
+ span := func(end int) {
+ if lastOffs < end { // ignore empty spans
+ if last.end != lastOffs || last.bitset != bitset {
+ // the last span is not adjacent to or
+ // differs from the new one
+ flush()
+ // start a new span
+ last.begin = lastOffs
+ }
+ last.end = end
+ last.bitset = bitset
+ }
+ }
+
+ linkEnd := ""
+ for {
+ // get the next span change
+ index, offs, start := changes.next()
+ if index < 0 || offs > len(text) {
+ // no more span changes or the next change
+ // is past the end of the text - we're done
+ break
+ }
+
+ // format the previous selection span, determine
+ // the new selection bitset and start a new span
+ span(offs)
+ if index == 3 { // Go link
+ flush()
+ if start {
+ if len(goLinks) > 0 {
+ start, end := goLinks[0].tags()
+ io.WriteString(w, start)
+ linkEnd = end
+ goLinks = goLinks[1:]
+ }
+ } else {
+ if linkEnd != "" {
+ io.WriteString(w, linkEnd)
+ linkEnd = ""
+ }
+ }
+ } else {
+ mask := 1 << uint(index)
+ if start {
+ bitset |= mask
+ } else {
+ bitset &^= mask
+ }
+ }
+ lastOffs = offs
+ }
+ span(len(text))
+ flush()
+}
+
+// A merger merges a slice of Selections and produces a sequence of
+// consecutive span change events through repeated next() calls.
+type merger struct {
+ selections []Selection
+ spans []Span // spans[i] is the next span of selections[i]
+}
+
+const infinity int = 2e9
+
+func newMerger(selections []Selection) *merger {
+ spans := make([]Span, len(selections))
+ for i, sel := range selections {
+ spans[i] = Span{infinity, infinity}
+ if sel != nil {
+ if seg := sel(); !seg.isEmpty() {
+ spans[i] = seg
+ }
+ }
+ }
+ return &merger{selections, spans}
+}
+
+// next returns the next span change: index specifies the Selection
+// to which the span belongs, offs is the span start or end offset
+// as determined by the start value. If there are no more span changes,
+// next returns an index value < 0.
+func (m *merger) next() (index, offs int, start bool) {
+ // find the next smallest offset where a span starts or ends
+ offs = infinity
+ index = -1
+ for i, seg := range m.spans {
+ switch {
+ case seg.Start < offs:
+ offs = seg.Start
+ index = i
+ start = true
+ case seg.End < offs:
+ offs = seg.End
+ index = i
+ start = false
+ }
+ }
+ if index < 0 {
+ // no offset found => all selections merged
+ return
+ }
+ // offset found - it's either the start or end offset but
+ // either way it is ok to consume the start offset: set it
+ // to infinity so it won't be considered in the following
+ // next call
+ m.spans[index].Start = infinity
+ if start {
+ return
+ }
+ // end offset found - consume it
+ m.spans[index].End = infinity
+ // advance to the next span for that selection
+ seg := m.selections[index]()
+ if !seg.isEmpty() {
+ m.spans[index] = seg
+ }
+ return
+}
+
+// lineSelection returns the line spans for text as a Selection.
+func lineSelection(text []byte) Selection {
+ i, j := 0, 0
+ return func() (seg Span) {
+ // find next newline, if any
+ for j < len(text) {
+ j++
+ if text[j-1] == '\n' {
+ break
+ }
+ }
+ if i < j {
+ // text[i:j] constitutes a line
+ seg = Span{i, j}
+ i = j
+ }
+ return
+ }
+}
+
+// tokenSelection returns, as a selection, the sequence of
+// consecutive occurrences of token sel in the Go src text.
+func tokenSelection(src []byte, sel token.Token) Selection {
+ var s scanner.Scanner
+ fset := token.NewFileSet()
+ file := fset.AddFile("", fset.Base(), len(src))
+ s.Init(file, src, nil, scanner.ScanComments)
+ return func() (seg Span) {
+ for {
+ pos, tok, lit := s.Scan()
+ if tok == token.EOF {
+ break
+ }
+ offs := file.Offset(pos)
+ if tok == sel {
+ seg = Span{offs, offs + len(lit)}
+ break
+ }
+ }
+ return
+ }
+}
+
+// Spans is a helper function to make a Selection from a slice of spans.
+// Empty spans are discarded.
+func Spans(spans ...Span) Selection {
+ i := 0
+ return func() Span {
+ for i < len(spans) {
+ s := spans[i]
+ i++
+ if s.Start < s.End {
+ // non-empty
+ return s
+ }
+ }
+ return Span{}
+ }
+}
+
+// regexpSelection computes the Selection for the regular expression expr in text.
+func regexpSelection(text []byte, expr string) Selection {
+ var matches [][]int
+ if rx, err := regexp.Compile(expr); err == nil {
+ matches = rx.FindAllIndex(text, -1)
+ }
+ var spans []Span
+ for _, m := range matches {
+ spans = append(spans, Span{m[0], m[1]})
+ }
+ return Spans(spans...)
+}
+
+// Span tags for all the possible selection combinations that may
+// be generated by FormatText. Selections are indicated by a bitset,
+// and the value of the bitset specifies the tag to be used.
+//
+// bit 0: comments
+// bit 1: highlights
+// bit 2: selections
+//
+var startTags = [][]byte{
+ /* 000 */ []byte(``),
+ /* 001 */ []byte(`<span class="comment">`),
+ /* 010 */ []byte(`<span class="highlight">`),
+ /* 011 */ []byte(`<span class="highlight-comment">`),
+ /* 100 */ []byte(`<span class="selection">`),
+ /* 101 */ []byte(`<span class="selection-comment">`),
+ /* 110 */ []byte(`<span class="selection-highlight">`),
+ /* 111 */ []byte(`<span class="selection-highlight-comment">`),
+}
+
+var endTag = []byte(`</span>`)
+
+func selectionTag(w io.Writer, text []byte, selections int) {
+ if selections < len(startTags) {
+ if tag := startTags[selections]; len(tag) > 0 {
+ w.Write(tag)
+ template.HTMLEscape(w, text)
+ w.Write(endTag)
+ return
+ }
+ }
+ template.HTMLEscape(w, text)
+}
