_content/blog: happy 16th birthday, Go!

Change-Id: I49908cd0bff7f54a020461f3b3e6b14727668006
Reviewed-on: https://go-review.googlesource.com/c/website/+/720680
Auto-Submit: Austin Clements <austin@google.com>
Reviewed-by: Neal Patel <nealpatel@google.com>
Reviewed-by: Nicholas Husin <nsh@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

1 files changed, 202 insertions, 0 deletions

diff --git a/_content/blog/16years.md b/_content/blog/16years.md
new file mode 100644
index 00000000..bcdef106
--- /dev/null
+++ b/_content/blog/16years.md
@@ -0,0 +1,202 @@
+---
+title: Go’s Sweet 16
+date: 2025-11-14
+by:
+- Austin Clements, for the Go team
+tags:
+- community
+- birthday
+summary: Happy Birthday, Go\!
+---
+
+This past Monday, November 10th, we celebrated the 16th anniversary of Go’s
+[open source
+release](https://opensource.googleblog.com/2009/11/hey-ho-lets-go.html)\!
+
+We released [Go 1.24 in February](/blog/go1.24) and [Go 1.25 in
+August](/blog/go1.25), following our now well-established and dependable release
+cadence. Continuing our mission to build the most productive language platform
+for building production systems, these releases included new APIs for building
+robust and reliable software, significant advances in Go’s track record for
+building secure software, and some serious under-the-hood improvements.
+Meanwhile, no one can ignore the seismic shifts in our industry brought by
+generative AI. The Go team is applying its thoughtful and uncompromising mindset
+to the problems and opportunities of this dynamic space, working to bring Go’s
+production-ready approach to building robust AI integrations, products, agents,
+and infrastructure.
+
+# Core language and library improvements
+
+First released in Go 1.24 as an experiment and then graduated in Go 1.25, the
+new [`testing/synctest`](https://pkg.go.dev/testing/synctest) package
+significantly simplifies writing tests for [concurrent, asynchronous
+code](/blog/testing-time). Such code is particularly common in network services,
+and is traditionally very hard to test well. The `synctest` package works by
+virtualizing time itself. It takes tests that used to be slow, flaky, or both,
+and makes them easy to rewrite into reliable and nearly instantaneous tests,
+often with just a couple extra lines of code. It’s also a great example of Go’s
+integrated approach to software development: behind an almost trivial API, the
+`synctest` package hides a deep integration with the Go runtime and other parts
+of the standard library.
+
+This isn’t the only boost the `testing` package got over the past year. The new
+[`testing.B.Loop`](https://pkg.go.dev/testing#B.Loop) API is both easier to use
+than the original `testing.B.N` API and addresses many of the traditional—and
+often invisible\!—[pitfalls](/blog/testing-b-loop) of writing Go benchmarks. The
+`testing` package also has new APIs that [make it easy to
+cleanup](https://pkg.go.dev/testing#T.Context) in tests that use
+[`Context`](https://pkg.go.dev/context#Context), and that [make it
+easy](https://pkg.go.dev/testing#T.Output) to write to the test’s log.
+
+Go and containerization grew up together and work great with each other. Go 1.25
+launched [container-aware scheduling](/blog/container-aware-gomaxprocs), making
+this pairing even stronger. Without developers having to lift a finger, this
+transparently adjusts the parallelism of Go workloads running in containers,
+preventing CPU throttling that can impact tail latency and improving Go’s
+out-of-the-box production-readiness.
+
+Go 1.25’s new [flight recorder](/blog/flight-recorder) builds on our already
+powerful execution tracer, enabling deep insights into the dynamic behavior of
+production systems. While the execution tracer generally collected *too much*
+information to be practical in long-running production services, the flight
+recorder is like a little time machine, allowing a service to snapshot recent
+events in great detail *after* something has gone wrong.
+
+## Secure software development
+
+Go continues to strengthen its commitment to secure software development, making
+significant strides in its native cryptography packages and evolving its
+standard library for enhanced safety.
+
+Go ships with a full suite of native cryptography packages in the standard
+library, which reached two major milestones over the past year. An security
+audit conducted by independent security firm [Trail of
+Bits](https://www.trailofbits.com/) yielded [excellent
+results](/blog/tob-crypto-audit), with only a single low-severity finding.
+Furthermore, through a collaborative effort between the Go Security Team and
+[Geomys](https://geomys.org/), these packages achieved CAVP certification,
+paving the way for [full FIPS 140-3 certification](/blog/fips140). This is a
+vital development for Go users in certain regulated environments. FIPS 140
+compliance, previously a source of friction due to the need for unsupported
+solutions, will now be seamlessly integrated, addressing concerns related to
+safety, developer experience, functionality, release velocity, and compliance.
+
+The Go standard library has continued to evolve to be *safe by default* and
+*safe by design*. For example, the [`os.Root`](https://pkg.go.dev/os#Root)
+API—added in Go 1.24—enables [traversal-resistant file system
+access](/blog/osroot), effectively combating a class of vulnerabilities where an
+attacker could manipulate programs into accessing files intended to be
+inaccessible. Such vulnerabilities are notoriously challenging to address
+without underlying platform and operating system support, and the new
+[`os.Root`](https://pkg.go.dev/os#Root) API offers a straightforward,
+consistent, and portable solution.
+
+## Under-the-hood improvements
+
+In addition to user-visible changes, Go has made significant improvements under
+the hood over the past year.
+
+For Go 1.24, we completely [redesigned the `map`
+implementation](/blog/swisstable), building on the latest and greatest ideas in
+hash table design. This change is completely transparent, and brings significant
+improvements to `map` performance, lower tail latency of `map` operations, and
+in some cases even significant memory wins.
+
+Go 1.25 includes an experimental and significant advancement in Go’s garbage
+collector called [Green Tea](/blog/greenteagc). Green Tea reduces garbage
+collection overhead in many applications by at least 10% and sometimes as much
+as 40%. It uses a novel algorithm designed for the capabilities and constraints
+of today’s hardware and opens up a new design space that we’re eagerly
+exploring. For example, in the forthcoming Go 1.26 release, Green Tea will
+achieve an additional 10% reduction in garbage collector overhead on hardware
+that supports AVX-512 vector instructions—something that would have been nigh
+impossible to take advantage of in the old algorithm. Green Tea will be enabled
+by default in Go 1.26; users need only upgrade their Go version to benefit.
+
+# Furthering the software development stack
+
+Go is about far more than the language and standard library. It’s a software
+development platform, and over the past year, we’ve also made four regular
+releases of the [gopls language server](/gopls), and have formed partnerships to
+support emerging new frameworks for agentic applications.
+
+Gopls provides Go support to VS Code and other LSP-powered editors and IDEs.
+Every release sees a litany of features and improvements to the experience of
+reading and writing Go code (see the [v0.17.0](/gopls/release/v0.17.0),
+[v0.18.0](/gopls/release/v0.18.0), [v0.19.0](/gopls/release/v0.19.0), and
+[v0.20.0](/gopls/release/v0.20.0) release notes for full details, or our new
+[gopls feature documentation](/gopls/features)\!). Some highlights include many
+new and enhanced analyzers to help developers write more idiomatic and robust Go
+code; refactoring support for variable extraction, variable inlining, and JSON
+struct tags; and an [experimental built-in server](/gopls/features/mcp) for the
+Model Context Protocol (MCP) that exposes a subset of gopls’ functionality to AI
+assistants in the form of MCP tools.
+
+With gopls v0.18.0, we began exploring *automatic code modernizers*. As Go
+evolves, every release brings new capabilities and new idioms; new and better
+ways to do things that Go programmers have been finding other ways to do. Go
+stands by its [compatibility promise](/doc/go1compat)—the old way will continue
+to work in perpetuity—but nevertheless this creates a bifurcation between old
+idioms and new idioms. Modernizers are static analysis tools that recognize old
+idioms and suggest faster, more readable, more secure, more *modern*
+replacements, and do so with push-button reliability. What `gofmt` did for
+[stylistic consistency](/blog/gofmt), we hope modernizers can do for idiomatic
+consistency. We’ve integrated modernizers as IDE suggestions, where they can
+help developers not only maintain more consistent coding standards, but where we
+believe they will help developers discover new features and keep up with the
+state of the art. We believe modernizers can also help AI coding assistants keep
+up with the state of the art and combat their proclivity to reinforce outdated
+knowledge of the Go language, APIs, and idioms. The upcoming Go 1.26 release
+will include a total overhaul of the long-dormant `go fix` command to make it
+apply the full suite of modernizers in bulk, a return to its [pre-Go 1.0
+roots](/blog/introducing-gofix).
+
+At the end of September, in collaboration with
+[Anthropic](https://www.anthropic.com/) and the Go community, we released
+[v1.0.0](https://github.com/modelcontextprotocol/go-sdk/releases/tag/v1.0.0) of
+the [official Go SDK](https://github.com/modelcontextprotocol/go-sdk) for the
+[Model Context Protocol (MCP)](https://modelcontextprotocol.io/). This SDK
+supports both MCP clients and MCP servers, and underpins the new MCP
+functionality in gopls. Contributing this work in open source helps empower
+other areas of the growing open source agentic ecosystem built around Go, such
+as the recently released [Agent Development Kit (ADK) for
+Go](https://github.com/google/adk-go) from [Google](https://www.google.com/).
+ADK Go builds on the Go MCP SDK to provide an idiomatic framework for building
+modular multi-agent applications and systems. The Go MCP SDK and ADK Go
+demonstrate how Go’s unique strengths in concurrency, performance, and
+reliability differentiate Go for production AI development and we are expecting
+more AI workloads to be written in Go in the coming years.
+
+# Looking ahead
+
+Go has an exciting year ahead of it.
+
+We’re working on advancing developer productivity through the brand new `go fix`
+command, deeper support for AI coding assistants, and ongoing improvements to
+gopls and VS Code Go. General availability of the Green Tea garbage collector,
+native support for Single Instruction Multiple Data (SIMD) hardware features,
+and runtime and standard library support for writing code that scales even
+better to massive multicore hardware will continue to align Go with modern
+hardware and improve production efficiency. We’re focusing on Go’s “production
+stack” libraries and diagnostics, including a massive (and long in the making)
+[upgrade to `encoding/json`](/issue/71497), driven by Joe Tsai and people across
+the Go community; [leaked goroutine
+profiling](/design/74609-goroutine-leak-detection-gc), contributed by
+[Uber’s](https://www.uber.com/us/en/about/) Programming Systems team; and many
+other improvements to `net/http`, `unicode`, and other foundational packages.
+We’re working to provide well-lit paths for building with Go and AI, evolving
+the language platform with care for the evolving needs of today’s developers,
+and building tools and capabilities that help both human developers and AI
+assistants and systems alike.
+
+On this 16th anniversary of Go’s open source release, we’re also looking to the
+future of the Go open source project itself. From its [humble
+beginnings](https://www.youtube.com/watch?v=wwoWei-GAPo), Go has formed a
+thriving contributor community. To continue to best meet the needs of our
+ever-expanding user base, especially in a time of upheaval in the software
+industry, we’re working on ways to better scale Go's development
+processes—without losing sight of Go’s fundamental principles—and more deeply
+involve our wonderful contributor community.
+
+Go would not be where it is today without our incredible user and contributor
+communities. We wish you all the best in the coming year\!