What is new in Go 1.15?

Go 1.15 was released on August 11, 2020. It is not the kind of release that asks for a celebratory rewrite of every service; it is quieter than that. The value sits in compilation, runtime cost, and smaller details that make production Go feel more boring in the best sense.1Note 1Primary release note for Go 1.15.

—Toolchain improvements.

—Linker rewrite.

The most significant change in Go 1.15 is the rewritten linker. The release notes describe faster linking, lower memory use, and a Go implementation that gives future toolchain work a cleaner base.2Note 2Announcement context from the Go team.

The migration note I would keep in a repository is short. It records the compiler version, a baseline build time, and the one or two project-level checks that should catch drift.

go version
go test ./...
go test -race ./...
go build -trimpath ./cmd/service

—Smaller binaries.

Go 1.15 also improves dead code elimination. Typical binaries are smaller, symbol tables are handled more efficiently, and deployment artifacts get a little easier to move around.

go test ./...
go build -trimpath ./cmd/service
go version

steps:
- run: go test ./...
- run: go build -trimpath ./cmd/service

Link time

The number most teams will feel first when working on large services or generated code.

Memory pressure

The number most likely to matter on CI workers with narrow resource limits.

Artifact size

The quieter win that compounds in container registries, deploy caches, and cold starts.

—Runtime performance.

—Defer performance.

The defer statement got a practical speedup. In many common cases, Go can use open-coded defers, making cleanup-heavy code less expensive while preserving the shape that humans actually want to read.

func processFile(filename string) error {
    f, err := os.Open(filename)
    if err != nil {
        return err
    }
    defer f.Close()
 
    return process(f)
}

The practical rule is simple:

1. 01Keep defer where it communicates ownership.
2. 02Measure hot paths before hand-optimizing.
3. 03Prefer readable cleanup until a profile proves otherwise.

func BenchmarkDeferClose(b *testing.B) {
    for i := 0; i < b.N; i++ {
        closer := noopCloser{}
        defer closer.Close()
    }
}

a tiny defer benchmark skeleton

—Standard library updates.

—Embedded timezone data.

The new time/tzdata package allows a program to embed timezone data directly in the binary. That matters for small containers, restricted systems, and deployments where the host filesystem cannot be trusted to provide the same zoneinfo files everywhere.3Note 3Useful when a deployed system does not provide zoneinfo files.

package main
 
import (
    "fmt"
    "time"
    _ "time/tzdata"
)
 
func main() {
    loc, err := time.LoadLocation("Asia/Shanghai")
    if err != nil {
        panic(err)
    }
    fmt.Println(time.Now().In(loc).Format(time.RFC3339))
}

—Test temporary directories.

testing.TB.TempDir gives tests a managed temporary directory that is automatically removed when the test finishes. It is a small API, but it removes a surprising amount of cleanup ceremony.

func TestSomething(t *testing.T) {
    dir := t.TempDir()
    path := filepath.Join(dir, "sample.txt")
 
    if err := os.WriteFile(path, []byte("hello"), 0o644); err != nil {
        t.Fatal(err)
    }
}

Use Ctrl + K or / to search for follow-up notes across the site.

• Use t.TempDir() for filesystem tests.
• Keep cleanup local to the test instead of sharing global temporary paths.
• Only test the operating system behavior you actually depend on.

—Compatibility notes.

Go 1.15 is intentionally conservative, but conservative does not mean invisible. When I review an upgrade like this, I put the risk in three buckets.

—Editorial component sync.

The blocks below are intentionally dense. They are here so the article can exercise the full reading system on one page: component headings, badges, prompt boxes, lists, tables, references, copy buttons, and interactive panels.

#A short component heading.

Code

Use fenced Markdown for highlighted code, or CodeBlock when a caption is needed.

References

Use frontmatter references with inline Footnote markers and a closing References block.

Lists

Plain Markdown lists now render with the v3 list vocabulary.

package main
 
import "fmt"
 
func main() {
fmt.Println("Go 1.15 still rewards simple programs.")
}

- go 1.14
+ go 1.15

checks:
- go test ./...
- go build -trimpath ./cmd/service

• Render the full synchronized component set.
• Keep copy buttons delegated through GlobalUI.
• Use the blocks in future essays only when they make the reading flow clearer.

Review this Go upgrade note. Keep the prose calm, identify hidden operational risks, and suggest one measurement that would make the rollout easier to trust.

Plain Markdown also participates in the component system:

• —Fenced code uses the editorial code frame.
• —Lists use quiet custom markers.
• —Tables keep their hairline editorial rhythm.
• —Blockquotes are routed into the same quote component as explicit <C>Quote</C> usage.

type UpgradeNote = {
  from: "go1.14";
  to: "go1.15";
  checks: Array<"test" | "build" | "race" | "smoke">;
};

—Conclusion.

Go 1.15 is a grounded release: faster linking, lower memory use, cheaper defers, smaller binaries, and a few standard library niceties. The release is worth upgrading to because it lets existing code keep its shape while the platform underneath becomes a little calmer.