From f74533cb3d222cb0987af4771426c45b6a8874d6 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Thu, 7 Dec 2023 15:02:17 -0500 Subject: [PATCH] _content: replace https://blog.golang.org/ links with /blog/ Global search and replace in HTML for href="https://blog.golang.org/ and in Markdown for ](https://blog.golang.org/ Change-Id: Ife69e89a42a631fa5c8babd07201ed0d7796eb0e Reviewed-on: https://go-review.googlesource.com/c/website/+/548062 Auto-Submit: Russ Cox Reviewed-by: Dmitri Shuralyov LUCI-TryBot-Result: Go LUCI Reviewed-by: Dmitri Shuralyov --- _content/blog/10years.md | 4 ++-- _content/blog/11years.md | 24 +++++++++---------- _content/blog/1year.md | 6 ++--- _content/blog/2years.md | 6 ++--- _content/blog/3years.md | 10 ++++---- _content/blog/4years.md | 2 +- _content/blog/5years.md | 6 ++--- _content/blog/6years.md | 8 +++---- _content/blog/7years.md | 6 ++--- _content/blog/8years.md | 10 ++++---- _content/blog/9years.md | 8 +++---- _content/blog/appengine-dec2013.md | 4 ++-- _content/blog/appengine-go111.md | 2 +- _content/blog/appengine-scalable.md | 2 +- _content/blog/constants.md | 6 ++--- _content/blog/context-and-structs.md | 2 +- _content/blog/contributor-workshop.md | 2 +- _content/blog/contributors-summit.md | 4 ++-- _content/blog/cover.md | 2 +- _content/blog/debug-gdb.md | 2 +- _content/blog/experiment.md | 4 ++-- _content/blog/generate.md | 2 +- _content/blog/generics-next-step.md | 2 +- _content/blog/generics-proposal.md | 4 ++-- _content/blog/gif-decoder.md | 2 +- _content/blog/go-cloud2019.md | 2 +- _content/blog/go1.13-errors.md | 4 ++-- _content/blog/go1.15-proposals.md | 4 ++-- _content/blog/go1.16.md | 2 +- _content/blog/go1.3.md | 2 +- _content/blog/go1.4.md | 2 +- _content/blog/go1.6.md | 4 ++-- _content/blog/go1.7.md | 2 +- _content/blog/go1.8.md | 2 +- _content/blog/go2-here-we-come.md | 6 ++--- _content/blog/go2-next-steps.md | 10 ++++---- _content/blog/go2draft.md | 2 +- _content/blog/godoc.org-redirect.md | 8 +++---- _content/blog/gofmt.md | 2 +- _content/blog/gophercon2015.md | 2 +- _content/blog/gopls-vscode-go.md | 2 +- _content/blog/heroku.md | 2 +- _content/blog/introducing-gofix.md | 2 +- _content/blog/io2011.md | 2 +- _content/blog/migrating-to-go-modules.md | 2 +- _content/blog/module-mirror-launch.md | 4 ++-- _content/blog/normalization.md | 4 ++-- _content/blog/package-names.md | 2 +- _content/blog/pipelines.md | 2 +- _content/blog/playground.md | 4 ++-- _content/blog/protobuf-apiv2.md | 2 +- _content/blog/publishing-go-modules.md | 4 ++-- _content/blog/slices.md | 4 ++-- _content/blog/stackoverflow.md | 2 +- _content/blog/strings.md | 4 ++-- _content/blog/survey2017-results.md | 4 ++-- _content/blog/survey2017.md | 4 ++-- _content/blog/survey2018-results.md | 4 ++-- _content/blog/survey2018.md | 8 +++---- _content/blog/survey2019-results.md | 2 +- _content/blog/survey2019.md | 10 ++++---- _content/blog/survey2020-results.md | 2 +- _content/blog/survey2020.md | 2 +- _content/blog/toward-go2.md | 14 +++++------ _content/blog/turkey-doodle.md | 2 +- _content/blog/using-go-modules.md | 2 +- _content/blog/versioning-proposal.md | 2 +- _content/blog/vscode-go.md | 2 +- _content/blog/wire.md | 2 +- _content/conduct.html | 2 +- _content/doc/database/cancel-operations.md | 2 +- _content/doc/devel/pre_go1.html | 2 +- _content/doc/diagnostics.html | 2 +- _content/doc/effective_go.html | 2 +- _content/doc/faq.html | 18 +++++++------- _content/doc/go1.14.md | 2 +- _content/doc/go1.5.md | 2 +- _content/doc/go1.6.md | 2 +- _content/doc/go1.7.md | 2 +- _content/doc/go1.8.md | 2 +- _content/doc/modules/developing.md | 2 +- _content/doc/modules/release-workflow.md | 2 +- .../tutorial/greetings-multiple-people.html | 4 ++-- _content/doc/tutorial/random-greeting.html | 2 +- _content/ref/mod.md | 4 ++-- 85 files changed, 169 insertions(+), 169 deletions(-) diff --git a/_content/blog/10years.md b/_content/blog/10years.md index ae4a6fae..a69ff4cf 100644 --- a/_content/blog/10years.md +++ b/_content/blog/10years.md @@ -17,7 +17,7 @@ and ecosystem for building modern networked software. To mark the occasion, [Renee French](https://twitter.com/reneefrench), the creator of the -[Go gopher](https://blog.golang.org/gopher), +[Go gopher](/blog/gopher), painted this delightful scene: @@ -86,7 +86,7 @@ we have evolved this idea and sketch into a productive language with fantastic tooling, a production-quality implementation, a -[state-of-the-art garbage collector](https://blog.golang.org/ismmkeynote), +[state-of-the-art garbage collector](/blog/ismmkeynote), and [ports to 12 operating systems and 10 architectures](/doc/install/source#introduction). Any programming language needs the support of a thriving ecosystem. diff --git a/_content/blog/11years.md b/_content/blog/11years.md index da5041d1..daef047f 100644 --- a/_content/blog/11years.md +++ b/_content/blog/11years.md @@ -9,16 +9,16 @@ summary: Happy Birthday, Go! Today we celebrate the eleventh birthday of the Go open source release. The parties we had for -[Go turning 10](https://blog.golang.org/10years) +[Go turning 10](/blog/10years) seem like a distant memory. It’s been a tough year, but we’ve kept Go development moving forward and accumulated quite a few highlights. -In November, we launched [go.dev and pkg.go.dev](https://blog.golang.org/go.dev) +In November, we launched [go.dev and pkg.go.dev](/blog/go.dev) shortly after Go’s 10th birthday. -In February, the [Go 1.14 release](https://blog.golang.org/go1.14) +In February, the [Go 1.14 release](/blog/go1.14) delivered the first officially “production-ready” implementation of Go modules, along with many performance improvements, including @@ -29,7 +29,7 @@ to reduce scheduling and garbage collection latency. In early March, we launched a -[new API for protocol buffers](https://blog.golang.org/protobuf-apiv2), +[new API for protocol buffers](/blog/protobuf-apiv2), [google.golang.org/protobuf](https://pkg.go.dev/google.golang.org/protobuf), with much-improved support for protocol buffer reflection and custom messages. @@ -51,15 +51,15 @@ which enables advanced [Go-aware support](https://github.com/golang/tools/blob/master/gopls/doc/user.md) in many editors. In June, the -[VSCode Go extension officially joined the Go project](https://blog.golang.org/vscode-go) +[VSCode Go extension officially joined the Go project](/blog/vscode-go) and is now maintained by the same developers who work on gopls. Also in June, thanks to your feedback, we open-sourced -[the code behind pkg.go.dev](https://blog.golang.org/pkgsite) +[the code behind pkg.go.dev](/blog/pkgsite) as part of the Go project as well. Later in June, we -[released the latest design draft for generics](https://blog.golang.org/generics-next-step), +[released the latest design draft for generics](/blog/generics-next-step), along with a prototype tool and [generics playground](https://go2goplay.golang.org/). In July, we published and discussed three new design drafts for future changes: @@ -69,13 +69,13 @@ and [build-time file embedding](/design/draft-embed). (We’ll see all of those in 2021, as noted below.) -In August, the [Go 1.15 release](https://blog.golang.org/go1.15) +In August, the [Go 1.15 release](/blog/go1.15) delivered mainly optimizations and bug fixes rather than new features. The most significant was the start of a rewrite of the linker, making it run 20% faster and use 30% less memory on average for large builds. -Last month, we ran our [annual Go user survey](https://blog.golang.org/survey2020). +Last month, we ran our [annual Go user survey](/blog/survey2020). We will post results on the blog once we’ve analyzed them. The Go community has adapted to “virtual-first” along with everyone else, @@ -164,7 +164,7 @@ From the start, the [goal for Go modules](https://research.swtch.com/vgo-intro) has been “to add the concept of package versions to the working vocabulary of both Go developers and our tools,” to enable deep support for modules and versions throughout the Go ecosystem. -The [Go module mirror, checksum database, and index](https://blog.golang.org/modules2019) +The [Go module mirror, checksum database, and index](/blog/modules2019) were made possible by this ecosystem-wide understanding of what a package version is. Over the next year, we will see rich module support added to more tools and systems. For example, we plan to investigate new tooling to help module authors publish new versions @@ -195,7 +195,7 @@ The Go package discovery site is another example of a version-aware system enabled by Go modules. We’ve been focused on getting the core functionality and user experience right, including a -[redesign launching today](https://blog.golang.org/pkgsite-redesign). +[redesign launching today](/blog/pkgsite-redesign). Over the next year, we will be unifying godoc.org into pkg.go.dev. We will also be expanding the version timeline for each package, @@ -212,7 +212,7 @@ that Go modules are enabling. The next feature on everyone’s minds is of course generics. As we mentioned above, we published the -[latest design draft for generics](https://blog.golang.org/generics-next-step) +[latest design draft for generics](/blog/generics-next-step) back in June. Since then, we’ve continued to refine rough edges and have turned our attention to the details of implementing a production-ready version. diff --git a/_content/blog/1year.md b/_content/blog/1year.md index 65138481..dcf08e24 100644 --- a/_content/blog/1year.md +++ b/_content/blog/1year.md @@ -73,7 +73,7 @@ The debugging story has gotten better, too. Recent improvements to the DWARF output of the gc compilers make the GNU debugger, GDB, useful for Go binaries, and we’re actively working on making that debugging information more complete. -(See the [ recent blog post](https://blog.golang.org/2010/11/debugging-go-code-status-report.html) for details.) +(See the [ recent blog post](/blog/2010/11/debugging-go-code-status-report.html) for details.) It’s now easier than ever to link against existing libraries written in languages other than Go. @@ -95,7 +95,7 @@ and hundreds more on [Google Code](http://code.google.com/hosting/search?q=label and [GitHub](https://github.com/search?q=language:Go). On our mailing list and IRC channel you can find coders from around the world who use Go for their programming projects. -(See our [guest blog post](https://blog.golang.org/2010/10/real-go-projects-smarttwitter-and-webgo.html) +(See our [guest blog post](/blog/2010/10/real-go-projects-smarttwitter-and-webgo.html) from last month for a real-world example.) Internally at Google there are several teams that choose Go for building production software, and we have received reports from other companies that are developing sizable systems in Go. @@ -117,7 +117,7 @@ many of which were driven by feedback from the community. [spec](/doc/go_spec.html#Slices) - The new built-in function `recover` complements `panic` and `defer` as an error handling mechanism. - [blog](https://blog.golang.org/2010/08/defer-panic-and-recover.html), + [blog](/blog/2010/08/defer-panic-and-recover.html), [spec](/doc/go_spec.html#Handling_panics) - The new complex number types (`complex`, `complex64`, and `complex128`) simplify certain mathematical operations. diff --git a/_content/blog/2years.md b/_content/blog/2years.md index f0a0182c..a7d5fb2e 100644 --- a/_content/blog/2years.md +++ b/_content/blog/2years.md @@ -22,7 +22,7 @@ and were gradually joined by dozens - and then hundreds - of programmers from the open source community. The Go Authors went on to produce lots of libraries, new tools, and reams of [documentation](/doc/docs.html). -They celebrated a successful year in the public eye with a [blog post](https://blog.golang.org/2010/11/go-one-year-ago-today.html) +They celebrated a successful year in the public eye with a [blog post](/blog/2010/11/go-one-year-ago-today.html) last November that concluded "Go is certainly ready for production use, but there is still room for improvement. Our focus for the immediate future is making Go programs faster and more @@ -32,7 +32,7 @@ Today is the second anniversary of Go's release, and Go is faster and more stable than ever. Careful tuning of Go's code generators, concurrency primitives, garbage collector, and core libraries have increased the performance of Go programs, -and native support for [profiling](https://blog.golang.org/2011/06/profiling-go-programs.html) +and native support for [profiling](/blog/2011/06/profiling-go-programs.html) and [debugging](http://blog.golang.org/2011/10/debugging-go-programs-with-gnu-debugger.html) makes it easier to detect and remove performance issues in user code. Go is also now easier to learn with [A Tour of Go](/tour/), @@ -57,7 +57,7 @@ This year we issued several "[release](/doc/devel/release.html)" versions of Go that were more reliable and better supported than weekly snapshots. We also introduced [gofix](/cmd/gofix/) to take the pain out of migrating to newer releases. -Furthermore, last month we announced a [plan for Go version 1](https://blog.golang.org/2011/10/preview-of-go-version-1.html) - +Furthermore, last month we announced a [plan for Go version 1](/blog/2011/10/preview-of-go-version-1.html) - a release that will be supported for years to come. Work toward Go 1 is already underway and you can observe our progress by the latest weekly snapshot at [weekly.golang.org](http://weekly.golang.org/pkg/). diff --git a/_content/blog/3years.md b/_content/blog/3years.md index 0ebb7ab9..ac077ee6 100644 --- a/_content/blog/3years.md +++ b/_content/blog/3years.md @@ -28,13 +28,13 @@ We added a package management system which eventually became the [go command](/cmd/go/). We also added -[support for Go on App Engine](https://blog.golang.org/2011/07/go-for-app-engine-is-now-generally.html). +[support for Go on App Engine](/blog/2011/07/go-for-app-engine-is-now-generally.html). Over the past year we've also given [many talks](/doc/#talks), created an [interactive introductory tour](/tour/) and recently we added support for [executable examples in package documentation](/pkg/strings/#pkg-examples). Perhaps the most important development in the past year was the launch of the first stable version, -[Go 1](https://blog.golang.org/2012/03/go-version-1-is-released.html). +[Go 1](/blog/2012/03/go-version-1-is-released.html). People who write Go 1 programs can now be confident that their programs will continue to compile and run without change, in many environments, on a time scale of years. @@ -59,7 +59,7 @@ and of course running the [Go home page](/) on [App Engine](https://developers.google.com/appengine/docs/go/overview). Last year's -[Thanksgiving Doodle](https://blog.golang.org/2011/12/from-zero-to-go-launching-on-google.html) +[Thanksgiving Doodle](/blog/2011/12/from-zero-to-go-launching-on-google.html) and the recent [Jam with Chrome](http://www.jamwithchrome.com/technology) site are also served by Go programs. @@ -68,11 +68,11 @@ Other companies and projects are using Go too, including [BBC Worldwide](http://www.quora.com/Go-programming-language/Is-Google-Go-ready-for-production-use/answer/Kunal-Anand), [Canonical](http://dave.cheney.net/wp-content/uploads/2012/08/august-go-meetup.pdf), [CloudFlare](http://blog.cloudflare.com/go-at-cloudflare), -[Heroku](https://blog.golang.org/2011/04/go-at-heroku.html), +[Heroku](/blog/2011/04/go-at-heroku.html), [Novartis](https://plus.google.com/114945221884326152379/posts/d1SVaqkRyTL), [SoundCloud](http://backstage.soundcloud.com/2012/07/go-at-soundcloud/), [SmugMug](http://sorcery.smugmug.com/2012/04/06/deriving-json-types-in-go/), -[StatHat](https://blog.golang.org/2011/12/building-stathat-with-go.html), +[StatHat](/blog/2011/12/building-stathat-with-go.html), [Tinkercad](https://tinkercad.com/about/jobs), and [many others](/wiki/GoUsers). diff --git a/_content/blog/4years.md b/_content/blog/4years.md index 847e6d89..2e821719 100644 --- a/_content/blog/4years.md +++ b/_content/blog/4years.md @@ -138,7 +138,7 @@ it's easy to believe that prediction. So how can you get involved? Whether you're a seasoned Go programmer or just Go-curious, there are many ways to get started in the Go community: - - [Join your nearest Go User Group](https://blog.golang.org/getthee-to-go-meetup), + - [Join your nearest Go User Group](/blog/getthee-to-go-meetup), where your local gophers meet to share their knowledge and experience. These groups are popping up all over the world. I have personally spoken at Go groups in Amsterdam, diff --git a/_content/blog/5years.md b/_content/blog/5years.md index 83e65df1..0b453ecd 100644 --- a/_content/blog/5years.md +++ b/_content/blog/5years.md @@ -48,9 +48,9 @@ metrics, the Go community is growing faster than we believed possible. Where can those gophers be found? They are at the many Go events that are popping up around the world. This year we saw several dedicated Go conferences: -the inaugural [GopherCon](https://blog.golang.org/gophercon) and +the inaugural [GopherCon](/blog/gophercon) and [dotGo](http://www.dotgo.eu/) conferences in Denver and Paris, the -[Go DevRoom at FOSDEM](https://blog.golang.org/fosdem14) and two more +[Go DevRoom at FOSDEM](/blog/fosdem14) and two more instances of the biannual [GoCon](https://github.com/GoCon/GoCon) conference in Tokyo. At each event, gophers from around the globe eagerly presented their Go projects. For the Go team, it is very satisfying to meet so many programmers @@ -64,7 +64,7 @@ There are also dozens of community-run [Go User Groups](/wiki/GoUserGroups) spread across cities worldwide. If you haven't visited your local group, consider going along. And if there isn't a group in your area, maybe you should -[start one](https://blog.golang.org/getthee-to-go-meetup)? +[start one](/blog/getthee-to-go-meetup)? Today, Go has found a home in the cloud. Go arrived as the industry underwent a tectonic shift toward cloud computing, and we were thrilled to see it quickly diff --git a/_content/blog/6years.md b/_content/blog/6years.md index e77ccc29..f49bbcfa 100644 --- a/_content/blog/6years.md +++ b/_content/blog/6years.md @@ -11,13 +11,13 @@ Six years ago today the Go language was released as an open source project. Since then, more than 780 contributors have made over 30,000 commits to the project's 22 repositories. The ecosystem continues to grow, with GitHub reporting more than 90,000 Go repositories. And, offline, we see new Go events -and user groups pop up [around](https://blog.golang.org/gophercon2015) -[the](https://blog.golang.org/gouk15) -[world](https://blog.golang.org/gopherchina) with regularity. +and user groups pop up [around](/blog/gophercon2015) +[the](/blog/gouk15) +[world](/blog/gopherchina) with regularity. {{image "6years/6years-gopher.png"}} -In August we [released Go 1.5](https://blog.golang.org/go1.5), the most +In August we [released Go 1.5](/blog/go1.5), the most significant release since Go 1. It features a completely [redesigned garbage collector](/doc/go1.5#gc) that makes the language more suitable for latency-sensitive applications; it marks the diff --git a/_content/blog/7years.md b/_content/blog/7years.md index b3ab6dff..72fd3545 100644 --- a/_content/blog/7years.md +++ b/_content/blog/7years.md @@ -18,7 +18,7 @@ The most significant user-facing changes to Go over the past year are the addition of built-in support for [HTTP/2](https://www.youtube.com/watch?v=FARQMJndUn0#t=0m0s) in [Go 1.6](/doc/go1.6) and the integration of the -[context package](https://blog.golang.org/context) into the standard library in [Go 1.7](/doc/go1.7). +[context package](/blog/context) into the standard library in [Go 1.7](/doc/go1.7). But we’ve been making many less visible improvements. Go 1.7 changed the x86-64 compiler to use a new SSA-based back end, improving the performance of most Go programs by 10–20%. @@ -28,10 +28,10 @@ We’ve also added new ports, to Android on 32-bit x86, Linux on 64-bit MIPS, and Linux on IBM z Systems. And we’ve developed new garbage-collection techniques that reduce typical “stop the world” pauses to [under 100 microseconds](/design/17503-eliminate-rescan). -(Contrast that with Go 1.5’s big news of [10 milliseconds or less](https://blog.golang.org/go15gc).) +(Contrast that with Go 1.5’s big news of [10 milliseconds or less](/blog/go15gc).) This year kicked off with a global Go hackathon, -the [Gopher Gala](https://blog.golang.org/gophergala), in January. +the [Gopher Gala](/blog/gophergala), in January. Then there were [Go conferences](/wiki/Conferences) in India and Dubai in February, China and Japan in April, San Francisco in May, Denver in July, London in August, Paris last month, and Brazil this past weekend. diff --git a/_content/blog/8years.md b/_content/blog/8years.md index f583f165..18e51b56 100644 --- a/_content/blog/8years.md +++ b/_content/blog/8years.md @@ -11,7 +11,7 @@ summary: Happy 8th birthday, Go! Today we celebrate 8 years since Go was released as an open source project. -During [Go’s 4th anniversary](https://blog.golang.org/4years), Andrew +During [Go’s 4th anniversary](/blog/4years), Andrew finished the post with “Here's to four more years!”. Now that we have reached that milestone, I cannot help but reflect on how much the project and ecosystem has grown since then. In our post 4 years ago we included a chart @@ -74,10 +74,10 @@ alone over 50 scholarships to conferences have been given through efforts of Go Bridge and Women Who Go. This year we had two significant firsts for the Go project. We had our first -[contributor summit](https://blog.golang.org/contributors-summit) where +[contributor summit](/blog/contributors-summit) where people from across the Go community came together to discuss the needs and future of the Go project. Shortly after, we had the -first [Go contributor workshop](https://blog.golang.org/contributor-workshop) +first [Go contributor workshop](/blog/contributor-workshop) where hundreds of people came to make their first Go contribution. {{image "8years/photo.jpg"}} @@ -148,8 +148,8 @@ enthusiasm and support of the Go community. Since Go was first open sourced we have had 10 releases of the language, libraries and tooling with more than 1680 contributors making over 50,000 commits to the project's 34 repositories; More than double the number of -contributors and nearly double the number of commits from only [two years ago](https://blog.golang.org/6years). -This year we announced that we have begun planning [Go 2](https://blog.golang.org/toward-go2), our first major +contributors and nearly double the number of commits from only [two years ago](/blog/6years). +This year we announced that we have begun planning [Go 2](/blog/toward-go2), our first major revision of the language and tooling. The Go team would like to thank everyone who has contributed to the project, diff --git a/_content/blog/9years.md b/_content/blog/9years.md index f131ea59..eb13c617 100644 --- a/_content/blog/9years.md +++ b/_content/blog/9years.md @@ -55,7 +55,7 @@ and how we can better support gophers worldwide. - [The Legacy of Go, Part 2](https://www.youtube.com/watch?v=I_KcpgxcFyU), by Carmen Andoh at GothamGo - [Growing a Community of Gophers](https://www.youtube.com/watch?v=dl1mCGKwlYY), by Cassandra Salisbury at Gopherpalooza -On that theme, this year we also [revised our code of conduct](https://blog.golang.org/conduct-2018) +On that theme, this year we also [revised our code of conduct](/blog/conduct-2018) to better support inclusivity in the Go community. The Go community is truly global. @@ -71,17 +71,17 @@ After five years of experience with Go 1, we’ve started looking at what we should change about Go to better support [programming at scale](/talks/2012/splash.article). -Last spring, we published a [draft design for Go modules](https://blog.golang.org/versioning-proposal), +Last spring, we published a [draft design for Go modules](/blog/versioning-proposal), which provide an integrated mechanism for versioning and package distribution. The most recent Go release, Go 1.11, included [preliminary support for modules](/doc/go1.11#modules). Last summer we published -[early draft designs](https://blog.golang.org/go2draft) +[early draft designs](/blog/go2draft) for how Go 2 might better support error values, error handling, and generic programming. We are excited about refining these designs with the community’s help as we work -[toward Go 2](https://blog.golang.org/toward-go2). +[toward Go 2](/blog/toward-go2). ## Go Contributors diff --git a/_content/blog/appengine-dec2013.md b/_content/blog/appengine-dec2013.md index 1e26487f..95f3b47e 100644 --- a/_content/blog/appengine-dec2013.md +++ b/_content/blog/appengine-dec2013.md @@ -11,7 +11,7 @@ summary: Announcing improvements to Go on App Engine. ## Background -When we [launched Go for App Engine](https://blog.golang.org/go-and-google-app-engine) +When we [launched Go for App Engine](/blog/go-and-google-app-engine) in May 2011 the SDK was just a modified version of the Python SDK. At the time, there was no canonical way to build or organize Go programs, so it made sense to take the Python approach. Since then Go 1.0 was released, @@ -19,7 +19,7 @@ including the [go tool](/cmd/go/) and a [convention](/doc/code.html) for organizing Go programs. In January 2013 we announced -[better integration](https://blog.golang.org/the-app-engine-sdk-and-workspaces-gopath) +[better integration](/blog/the-app-engine-sdk-and-workspaces-gopath) between the Go App Engine SDK and the go tool, promoting the use of conventional import paths in App Engine apps and making it possible to use "go get" to fetch app dependencies. diff --git a/_content/blog/appengine-go111.md b/_content/blog/appengine-go111.md index d258c752..f5c02114 100644 --- a/_content/blog/appengine-go111.md +++ b/_content/blog/appengine-go111.md @@ -11,7 +11,7 @@ summary: Google Cloud is announcing a new Go 1.11 runtime for App Engine, with f [App Engine](https://cloud.google.com/appengine/) launched -[experimental support for Go](https://blog.golang.org/go-and-google-app-engine) +[experimental support for Go](/blog/go-and-google-app-engine) in 2011. In the subsequent years, the Go community has grown significantly and has settled on idiomatic patterns for cloud-based applications. Today, Google Cloud is diff --git a/_content/blog/appengine-scalable.md b/_content/blog/appengine-scalable.md index 2172501e..16c42031 100644 --- a/_content/blog/appengine-scalable.md +++ b/_content/blog/appengine-scalable.md @@ -10,7 +10,7 @@ summary: How to build scalable web applications using Go with Google App Engine. --- -Back in May, we [announced](https://blog.golang.org/2011/05/go-and-google-app-engine.html) +Back in May, we [announced](/blog/2011/05/go-and-google-app-engine.html) the Go runtime for App Engine. Since then, we've opened it up for everyone to use, added many new APIs, and improved performance. diff --git a/_content/blog/constants.md b/_content/blog/constants.md index 8a109b1d..9219d2ae 100644 --- a/_content/blog/constants.md +++ b/_content/blog/constants.md @@ -102,7 +102,7 @@ Here is a string constant: "Hello, 世界" (For much more detail about the representation and interpretation of strings, -see [this blog post](https://blog.golang.org/strings).) +see [this blog post](/blog/strings).) What type does this string constant have? The obvious answer is `string`, but that is _wrong_. @@ -218,7 +218,7 @@ If the constant has a type, that goes into the interface, as this example shows: {{play "constants/default3.go" `/START/` `/STOP/`}} (For more information about how interface values work, -see the first sections of [this blog post](https://blog.golang.org/laws-of-reflection).) +see the first sections of [this blog post](/blog/laws-of-reflection).) In summary, a typed constant obeys all the rules of typed values in Go. On the other hand, an untyped constant does not carry a Go type in the same @@ -462,7 +462,7 @@ Here, then, is our constant: {{play "constants/exercise6.go" `/START/` `/STOP/`}} Whatever the number of bits it takes to represent a `uint` in the current execution environment -(on the [playground](https://blog.golang.org/playground), it's 32), +(on the [playground](/blog/playground), it's 32), this constant correctly represents the largest value a variable of type `uint` can hold. If you understand the analysis that got us to this result, diff --git a/_content/blog/context-and-structs.md b/_content/blog/context-and-structs.md index d9191665..fb737917 100644 --- a/_content/blog/context-and-structs.md +++ b/_content/blog/context-and-structs.md @@ -80,7 +80,7 @@ And, finally, it can be quite dangerous to design a production-grade server whos When Go 1.7 — which [introduced context.Context](/doc/go1.7) — was released, a large number of APIs had to add context support in backwards compatible ways. For example, [`net/http`'s `Client` methods](/pkg/net/http/), like `Get` and `Do`, were excellent candidates for context. Each external request sent with these methods would benefit from having the deadline, cancellation, and metadata support that came with `context.Context`. -There are two approaches for adding support for `context.Context` in backwards compatible ways: including a context in a struct, as we'll see in a moment, and duplicating functions, with duplicates accepting `context.Context` and having `Context` as their function name suffix. The duplicate approach should be preferred over the context-in-struct, and is further discussed in [Keeping your modules compatible](https://blog.golang.org/module-compatibility). However, in some cases it's impractical: for example, if your API exposes a large number of functions, then duplicating them all might be infeasible. +There are two approaches for adding support for `context.Context` in backwards compatible ways: including a context in a struct, as we'll see in a moment, and duplicating functions, with duplicates accepting `context.Context` and having `Context` as their function name suffix. The duplicate approach should be preferred over the context-in-struct, and is further discussed in [Keeping your modules compatible](/blog/module-compatibility). However, in some cases it's impractical: for example, if your API exposes a large number of functions, then duplicating them all might be infeasible. The `net/http` package chose the context-in-struct approach, which provides a useful case study. Let's look at `net/http`'s `Do`. Prior to the introduction of `context.Context`, `Do` was defined as follows: diff --git a/_content/blog/contributor-workshop.md b/_content/blog/contributor-workshop.md index 4a60a4a8..425fff05 100644 --- a/_content/blog/contributor-workshop.md +++ b/_content/blog/contributor-workshop.md @@ -62,7 +62,7 @@ the form of bug reports, of contributions. The most common type of contribution was an example function to be used in the -documentation. The [Go User survey](https://blog.golang.org/survey2016-results) +documentation. The [Go User survey](/blog/survey2016-results) identified that our documentation was significantly lacking examples. In the presentation, we asked users to find a package they loved and to add an example. In the Go project, examples are written as code in Go files diff --git a/_content/blog/contributors-summit.md b/_content/blog/contributors-summit.md index af91e874..e7bca8eb 100644 --- a/_content/blog/contributors-summit.md +++ b/_content/blog/contributors-summit.md @@ -71,7 +71,7 @@ discussion will likely continue on the mailing lists. ### The standard library The discussions we had around the future of the Go language are mostly covered -in Russ Cox's blog post: [Toward Go 2](https://blog.golang.org//toward-go2), so +in Russ Cox's blog post: [Toward Go 2](/blog//toward-go2), so let's move on to the standard library session. As a contributor to the standard library and subrepos, this session was @@ -155,7 +155,7 @@ During the breaks, Go team members dispersed themselves among the contributors for discussions both about Go and a little general socialization, which really helped to put faces to the names that review our code every day. -As Russ discussed in [Toward Go 2](https://blog.golang.org//toward-go2), +As Russ discussed in [Toward Go 2](/blog//toward-go2), communicating effectively requires knowing your audience. Having a broad sample of Go contributors in a room together helped us all to understand the Go audience better and start many productive discussions about diff --git a/_content/blog/cover.md b/_content/blog/cover.md index 42bd2f6f..97f2ffbd 100644 --- a/_content/blog/cover.md +++ b/_content/blog/cover.md @@ -56,7 +56,7 @@ correct and easy-to-read code. One example is the gofix tool, which automates the rewriting of code to use new language features or updated libraries. Gofix let us make fundamental changes to the language and libraries in the -[run-up to Go 1.0](https://blog.golang.org/the-path-to-go-1), +[run-up to Go 1.0](/blog/the-path-to-go-1), with the confidence that users could just run the tool to update their source to the newest version. Inside Google, we have used gofix to make sweeping changes in a huge code repository that would be almost diff --git a/_content/blog/debug-gdb.md b/_content/blog/debug-gdb.md index e09845cc..a98e5fef 100644 --- a/_content/blog/debug-gdb.md +++ b/_content/blog/debug-gdb.md @@ -11,7 +11,7 @@ summary: Announcing a new article about debugging Go programs with GDB. --- -Last year we [reported](https://blog.golang.org/2010/11/debugging-go-code-status-report.html) +Last year we [reported](/blog/2010/11/debugging-go-code-status-report.html) that Go's [gc](/cmd/gc/)/[ld](/cmd/6l/) toolchain produces DWARFv3 debugging information that can be read by the GNU Debugger (GDB). Since then, work has continued steadily on improving support for debugging Go code with GDB. diff --git a/_content/blog/experiment.md b/_content/blog/experiment.md index 93e6bf31..176621cb 100644 --- a/_content/blog/experiment.md +++ b/_content/blog/experiment.md @@ -322,7 +322,7 @@ Making `error` a simple interface and allowing many different implementations means we have the entire Go language available to define and inspect errors. -We like to say that [errors are values](https://blog.golang.org/errors-are-values), +We like to say that [errors are values](/blog/errors-are-values), the same as any other Go value. Here’s an example. @@ -856,7 +856,7 @@ We’ll find out. At Gophercon 2019, Ian Lance Taylor talked about why we might want to add generics to Go and briefly previewed the latest design draft. -For details, see his blog post “[Why Generics?](https://blog.golang.org/why-generics)” +For details, see his blog post “[Why Generics?](/blog/why-generics)” ## Dependencies diff --git a/_content/blog/generate.md b/_content/blog/generate.md index c40f7fbe..50c58e59 100644 --- a/_content/blog/generate.md +++ b/_content/blog/generate.md @@ -34,7 +34,7 @@ There is simply no mechanism to run Yacc from the go tool alone. Until now, that is. -The [latest Go release](https://blog.golang.org/go1.4), 1.4, +The [latest Go release](/blog/go1.4), 1.4, includes a new command that makes it easier to run such tools. It's called `go` `generate`, and it works by scanning for special comments in Go source code that identify general commands to run. diff --git a/_content/blog/generics-next-step.md b/_content/blog/generics-next-step.md index 5ea1528f..d6ee2685 100644 --- a/_content/blog/generics-next-step.md +++ b/_content/blog/generics-next-step.md @@ -14,7 +14,7 @@ summary: An updated generics design draft, and a translation tool for experiment ## Introduction It’s been almost a year since we [last wrote about the possibility of -adding generics to Go](https://blog.golang.org/why-generics). +adding generics to Go](/blog/why-generics). It’s time for an update. ## Updated design diff --git a/_content/blog/generics-proposal.md b/_content/blog/generics-proposal.md index ab40dfc6..e3598f98 100644 --- a/_content/blog/generics-proposal.md +++ b/_content/blog/generics-proposal.md @@ -33,7 +33,7 @@ instance of the data structure. Since Go was first released in 2009, support for generics has been one of the most commonly requested language features. You can read more about why generics are useful in -[an earlier blog post](https://blog.golang.org/why-generics). +[an earlier blog post](/blog/why-generics). Although generics have clear use cases, fitting them cleanly into a language like Go is a difficult task. @@ -48,7 +48,7 @@ parameters](/design/go2draft-type-parameters). This design draft has had a lot of input from the Go programming community, and many people have experimented with it using the [generics playground](https://go2goplay.golang.org) described in [an -earlier blog post](https://blog.golang.org/generics-next-step). +earlier blog post](/blog/generics-next-step). Ian Lance Taylor gave [a talk at GopherCon 2019](https://www.youtube.com/watch?v=WzgLqE-3IhY) about why to add generics and the strategy we are now following. diff --git a/_content/blog/gif-decoder.md b/_content/blog/gif-decoder.md index 92de7352..038423dc 100644 --- a/_content/blog/gif-decoder.md +++ b/_content/blog/gif-decoder.md @@ -161,7 +161,7 @@ It's a nice technique in Go programming to couple a slice (`b.slice`) to an arra In this case, it means `blockReader` type's `Read` method never does any allocations. It also means we don't need to keep a count around (it's implicit in the slice length), and the built-in `copy` function guarantees we never copy more than we should. -(For more about slices, see [this post from the Go Blog](https://blog.golang.org/2011/01/go-slices-usage-and-internals.html).) +(For more about slices, see [this post from the Go Blog](/blog/2011/01/go-slices-usage-and-internals.html).) Given the `blockReader` type, we can unblock the image data stream just by wrapping the input reader, diff --git a/_content/blog/go-cloud2019.md b/_content/blog/go-cloud2019.md index 5cd25574..4d971773 100644 --- a/_content/blog/go-cloud2019.md +++ b/_content/blog/go-cloud2019.md @@ -8,7 +8,7 @@ summary: Recent changes to the Go Cloud Development Kit (Go CDK). ## Introduction -Last July, we [introduced](https://blog.golang.org/go-cloud) the [Go Cloud Development Kit](https://gocloud.dev) +Last July, we [introduced](/blog/go-cloud) the [Go Cloud Development Kit](https://gocloud.dev) (previously referred to as simply "Go Cloud"), an open source project building libraries and tools to improve the experience of developing for the cloud with Go. diff --git a/_content/blog/go1.13-errors.md b/_content/blog/go1.13-errors.md index 10bd4cbf..a17cc778 100644 --- a/_content/blog/go1.13-errors.md +++ b/_content/blog/go1.13-errors.md @@ -11,7 +11,7 @@ summary: How to use the new Go 1.13 error interfaces and functions. ## Introduction -Go’s treatment of [errors as values](https://blog.golang.org/errors-are-values) +Go’s treatment of [errors as values](/blog/errors-are-values) has served us well over the last decade. Although the standard library’s support for errors has been minimal—just the `errors.New` and `fmt.Errorf` functions, which produce errors that contain only a message—the built-in `error` interface @@ -345,6 +345,6 @@ handled in Go programs. We expect that wrapping to provide additional context will become commonplace, helping programs to make better decisions and helping programmers to find bugs more quickly. -As Russ Cox said in his [GopherCon 2019 keynote](https://blog.golang.org/experiment), +As Russ Cox said in his [GopherCon 2019 keynote](/blog/experiment), on the path to Go 2 we experiment, simplify and ship. Now that we’ve shipped these changes, we look forward to the experiments that will follow. diff --git a/_content/blog/go1.15-proposals.md b/_content/blog/go1.15-proposals.md index 55bb8b6d..97e9373f 100644 --- a/_content/blog/go1.15-proposals.md +++ b/_content/blog/go1.15-proposals.md @@ -16,7 +16,7 @@ summary: For Go 1.15, we propose three minor language cleanup changes. We are close to the Go 1.14 release, planned for February assuming all goes well, with an RC1 candidate almost ready. Per the process outlined in the -[Go 2, here we come!](https://blog.golang.org/go2-here-we-come) blog post, +[Go 2, here we come!](/blog/go2-here-we-come) blog post, it is again the time in our development and release cycle to consider if and what language or library changes we might want to include for our next release, Go 1.15, scheduled for August of this year. @@ -91,7 +91,7 @@ always a chance that we missed something important. For that reason we plan to have the proposals implemented at the beginning of the Go 1.15 release cycle (at or shortly after the Go 1.14 release) so that there is plenty of time to gather experience and provide feedback. Per the -[proposal evaluation process](https://blog.golang.org/go2-here-we-come), +[proposal evaluation process](/blog/go2-here-we-come), the final decision will be made at the end of the development cycle, at the beginning of May, 2020. diff --git a/_content/blog/go1.16.md b/_content/blog/go1.16.md index ea4baa33..65b77ee1 100644 --- a/_content/blog/go1.16.md +++ b/_content/blog/go1.16.md @@ -25,7 +25,7 @@ Go 1.16 also adds [macOS ARM64 support](/doc/go1.16#darwin) (also known as Apple silicon). Since Apple’s announcement of their new arm64 architecture, we have been working closely with them to ensure Go is fully supported; see our blog post -“[Go on ARM and Beyond](https://blog.golang.org/ports)” +“[Go on ARM and Beyond](/blog/ports)” for more. Note that Go 1.16 diff --git a/_content/blog/go1.3.md b/_content/blog/go1.3.md index f908e88b..476b1d8d 100644 --- a/_content/blog/go1.3.md +++ b/_content/blog/go1.3.md @@ -26,7 +26,7 @@ See [the documentation](/lib/godoc/analysis/help.html) for the details. The gc toolchain now supports the Native Client (NaCl) execution sandbox on the 32- and 64-bit Intel architectures. This permits the safe execution of untrusted code, useful in environments such as the -[Playground](https://blog.golang.org/playground). +[Playground](/blog/playground). To set up NaCl on your system see the [NativeClient wiki page](/wiki/NativeClient). Also included in this release is experimental support for the DragonFly BSD, diff --git a/_content/blog/go1.4.md b/_content/blog/go1.4.md index ac6d518e..6196e0f5 100644 --- a/_content/blog/go1.4.md +++ b/_content/blog/go1.4.md @@ -8,7 +8,7 @@ summary: Go 1.4 adds support for Android, go generate, optimizations, and more. Today we announce Go 1.4, the fifth major stable release of Go, arriving six -months after our previous major release [Go 1.3](https://blog.golang.org/go1.3). +months after our previous major release [Go 1.3](/blog/go1.3). It contains a small language change, support for more operating systems and processor architectures, and improvements to the tool chain and libraries. As always, Go 1.4 keeps the promise of compatibility, and almost everything diff --git a/_content/blog/go1.6.md b/_content/blog/go1.6.md index 8e5efaf5..3763553a 100644 --- a/_content/blog/go1.6.md +++ b/_content/blog/go1.6.md @@ -10,7 +10,7 @@ summary: Go 1.6 adds HTTP/2, template blocks, and more. Today we release [Go version 1.6](/doc/go1.6), the seventh major stable release of Go. You can grab it right now from the [download page](/dl/). -Although [the release of Go 1.5](https://blog.golang.org/go1.5) six months ago +Although [the release of Go 1.5](/blog/go1.5) six months ago contained dramatic implementation changes, this release is more incremental. @@ -41,7 +41,7 @@ The runtime has added lightweight, best-effort detection of concurrent misuse of As always, if one goroutine is writing to a map, no other goroutine should be reading or writing the map concurrently. If the runtime detects this condition, it prints a diagnosis and crashes the program. The best way to find out more about the problem is to run it under the -[race detector](https://blog.golang.org/race-detector), +[race detector](/blog/race-detector), which will more reliably identify the race and give more detail. The runtime has also changed how it prints program-ending panics. diff --git a/_content/blog/go1.7.md b/_content/blog/go1.7.md index 85ee695b..29c8f610 100644 --- a/_content/blog/go1.7.md +++ b/_content/blog/go1.7.md @@ -47,7 +47,7 @@ Support for contexts has been added to the [net/http](/pkg/net/http/), and [os/exec](/pkg/os/exec/) packages. For more information about contexts, see the [package documentation](/pkg/context) -and the Go blog post [_Go Concurrency Patterns: Context_](https://blog.golang.org/context). +and the Go blog post [_Go Concurrency Patterns: Context_](/blog/context). Go 1.5 introduced experimental support for a ["vendor" directory](/cmd/go/#hdr-Vendor_Directories), enabled by the `GO15VENDOREXPERIMENT` environment variable. diff --git a/_content/blog/go1.8.md b/_content/blog/go1.8.md index fdafce7c..82d90b9a 100644 --- a/_content/blog/go1.8.md +++ b/_content/blog/go1.8.md @@ -11,7 +11,7 @@ Today the Go team is happy to announce the release of Go 1.8. You can get it from the [download page](/dl/). There are significant performance improvements and changes across the standard library. -The compiler back end introduced in [Go 1.7](https://blog.golang.org/go1.7) for 64-bit x86 is now used +The compiler back end introduced in [Go 1.7](/blog/go1.7) for 64-bit x86 is now used on all architectures, and those architectures should see significant [performance improvements](/doc/go1.8#compiler). For instance, the CPU time required by our benchmark programs was reduced by 20-30% on 32-bit ARM systems. There are also some modest performance improvements in this release for 64-bit x86 systems. diff --git a/_content/blog/go2-here-we-come.md b/_content/blog/go2-here-we-come.md index 1f16191f..0c0bf9d6 100644 --- a/_content/blog/go2-here-we-come.md +++ b/_content/blog/go2-here-we-come.md @@ -14,7 +14,7 @@ summary: How Go 2 proposals will be evaluated, selected, and shipped. At GopherCon 2017, Russ Cox officially started the thought process on the next big version of Go with his talk [The Future of Go](https://www.youtube.com/watch?v=0Zbh_vmAKvk) -([blog post](https://blog.golang.org/toward-go2)). We have +([blog post](/blog/toward-go2)). We have called this future language informally Go 2, even though we understand now that it will arrive in incremental steps rather than with a big bang and a single major release. Still, Go 2 is a useful moniker, if only to have a way @@ -56,11 +56,11 @@ seemed clearly out of the scope of Go, or were otherwise unactionable. Ideas from the remaining proposals will likely influence Go 2’s libraries and languages. Two major themes have emerged early on: support for better -error handling, and generics. [Draft designs](https://blog.golang.org/go2draft) +error handling, and generics. [Draft designs](/blog/go2draft) for these two areas have been published at this year’s GopherCon, and more exploration is needed. -But what about the rest? We are [constrained](https://blog.golang.org/toward-go2) +But what about the rest? We are [constrained](/blog/toward-go2) by the fact that we now have millions of Go programmers and a large body of Go code, and we need to bring it all along, lest we risk a split ecosystem. That means we cannot diff --git a/_content/blog/go2-next-steps.md b/_content/blog/go2-next-steps.md index 8fd37678..e7008b15 100644 --- a/_content/blog/go2-next-steps.md +++ b/_content/blog/go2-next-steps.md @@ -24,14 +24,14 @@ selected from the much larger list of [Go 2 proposals](https://github.com/golang/go/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen+label%3AGo2+label%3AProposal), per the new proposal evaluation process outlined in the -“[Go 2, here we come!](https://blog.golang.org/go2-here-we-come)” blog post. +“[Go 2, here we come!](/blog/go2-here-we-come)” blog post. We wanted our initial selection of proposals to be relatively minor and mostly uncontroversial, to have a reasonably high chance of having them make it through the process. The proposed changes had to be backward-compatible to be minimally disruptive since -[modules](https://blog.golang.org/using-go-modules), +[modules](/blog/using-go-modules), which eventually will allow module-specific language version selection, are not the default build mode quite yet. In short, this initial round of changes was more about @@ -39,7 +39,7 @@ getting the ball rolling again and gaining experience with the new process, rather than tackling big issues. Our -[original list of proposals](https://blog.golang.org/go2-here-we-come) – +[original list of proposals](/blog/go2-here-we-come) – [general Unicode identifiers](/issue/20706), [binary integer literals](/issue/19308), [separators for number literals](/issue/28493), @@ -62,7 +62,7 @@ and determine what we want to tackle next. ## Proposals for Go 1.14 The goals we have for Go today are the same as in 2007: to -[make software development scale](https://blog.golang.org/toward-go2). +[make software development scale](/blog/toward-go2). The three biggest hurdles on this path to improved scalability for Go are package and version management, better error handling support, @@ -152,7 +152,7 @@ start of the (beginning of August, 2019) so that they can be evaluated in practice. Per the -[proposal evaluation process](https://blog.golang.org/go2-here-we-come), +[proposal evaluation process](/blog/go2-here-we-come), the final decision will be made at the end of the development cycle (beginning of November, 2019). diff --git a/_content/blog/go2draft.md b/_content/blog/go2draft.md index d8386482..4bdaf0b4 100644 --- a/_content/blog/go2draft.md +++ b/_content/blog/go2draft.md @@ -11,7 +11,7 @@ summary: Announcing the draft designs for the major Go 2 changes. Yesterday, at our annual Go contributor summit, attendees got a sneak peek at preliminary _drafts_ of possible designs for changes to error handling and generics. -[The development of Go 2](https://blog.golang.org/toward-go2) was announced last year and we are excited to share updates with you today. +[The development of Go 2](/blog/toward-go2) was announced last year and we are excited to share updates with you today. For a quick overview, watch this short message we just played at Gophercon 2018: diff --git a/_content/blog/godoc.org-redirect.md b/_content/blog/godoc.org-redirect.md index eef9124a..58693257 100644 --- a/_content/blog/godoc.org-redirect.md +++ b/_content/blog/godoc.org-redirect.md @@ -9,13 +9,13 @@ summary: The plan for moving from godoc.org to pkg.go.dev. With the introduction of Go modules and the growth of the Go ecosystem, [pkg.go.dev](https://pkg.go.dev) was -[launched in 2019](https://blog.golang.org/go.dev) to provide a central place +[launched in 2019](/blog/go.dev) to provide a central place where developers can discover and evaluate Go packages and modules. Like godoc.org, pkg.go.dev serves Go documentation, but it also supports modules, better search functionality, and signals to help Go users to find the right packages. -As [we shared in January 2020](https://blog.golang.org/pkg.go.dev-2020), our +As [we shared in January 2020](/blog/pkg.go.dev-2020), our goal is to eventually redirect traffic from godoc.org to the corresponding page on pkg.go.dev. We’ve also made it possible for users to opt in to redirecting their own requests from godoc.org to pkg.go.dev. @@ -26,8 +26,8 @@ resolved through the and [pkgsite/design-2020](https://github.com/golang/go/milestone/159?closed=1) milestones on the Go issue tracker. Your feedback resulted in support for popular feature requests on pkg.go.dev, -[open sourcing pkgsite](https://blog.golang.org/pkgsite), and most recently, a -[redesign of pkg.go.dev](https://blog.golang.org/pkgsite-redesign). +[open sourcing pkgsite](/blog/pkgsite), and most recently, a +[redesign of pkg.go.dev](/blog/pkgsite-redesign). ## Next Steps diff --git a/_content/blog/gofmt.md b/_content/blog/gofmt.md index 8b3061d6..be0616b3 100644 --- a/_content/blog/gofmt.md +++ b/_content/blog/gofmt.md @@ -104,4 +104,4 @@ It would have been daunting to attempt by hand, but with the code in a standard format it was relatively easy to prepare, execute, and review this change which touched almost all Go code in existence. -For more about gofix, see [this article](https://blog.golang.org/introducing-gofix). +For more about gofix, see [this article](/blog/introducing-gofix). diff --git a/_content/blog/gophercon2015.md b/_content/blog/gophercon2015.md index 8efc796f..3e4de143 100644 --- a/_content/blog/gophercon2015.md +++ b/_content/blog/gophercon2015.md @@ -30,7 +30,7 @@ conference from afar: [Day 1](http://gophercon.com/schedule/8july/): - Go, Open Source, Community — Russ Cox ([video](https://www.youtube.com/watch?v=XvZOdpd_9tc)) - ([text](https://blog.golang.org/open-source)) + ([text](/blog/open-source)) - Go kit: A Standard Library for Distributed Programming — Peter Bourgon ([video](https://www.youtube.com/watch?v=1AjaZi4QuGo)) ([slides](https://github.com/gophercon/2015-talks/blob/master/Go%20kit/go-kit.pdf)) - Delve Into Go — Derek Parker ([video](https://www.youtube.com/watch?v=InG72scKPd4)) diff --git a/_content/blog/gopls-vscode-go.md b/_content/blog/gopls-vscode-go.md index 24005a80..264f6f54 100644 --- a/_content/blog/gopls-vscode-go.md +++ b/_content/blog/gopls-vscode-go.md @@ -35,7 +35,7 @@ collections of command-line tools. In addition to working on `gopls`, we sought other ways of creating a stable ecosystem of editor tooling. Last year, the Go team took responsibility for the -[Go extension for VS Code](https://blog.golang.org/vscode-go). As part of this +[Go extension for VS Code](/blog/vscode-go). As part of this work, we smoothed the extension’s integration with the language server—automating `gopls` updates, rearranging and clarifying `gopls` settings, improving the troubleshooting workflow, and soliciting feedback through a survey. We’ve also diff --git a/_content/blog/heroku.md b/_content/blog/heroku.md index 8f64636a..86e9abbd 100644 --- a/_content/blog/heroku.md +++ b/_content/blog/heroku.md @@ -38,7 +38,7 @@ concurrent processes that communicate via passing messages. In Doozer, these processes are implemented as goroutines, and their communications as channel operations. In the same way that garbage collectors improve upon malloc and free, -we found that [goroutines and channels](https://blog.golang.org/2010/07/share-memory-by-communicating.html) +we found that [goroutines and channels](/blog/2010/07/share-memory-by-communicating.html) improve upon the lock-based approach to concurrency. These tools let us avoid complex bookkeeping and stay focused on the problem at hand. We are still amazed at how few lines of code it took to achieve something diff --git a/_content/blog/introducing-gofix.md b/_content/blog/introducing-gofix.md index 6f46366d..6b2a77f4 100644 --- a/_content/blog/introducing-gofix.md +++ b/_content/blog/introducing-gofix.md @@ -16,7 +16,7 @@ Code that [implements an HTTP server handler](http://codereview.appspot.com/4239 [calls `os.Open`](http://codereview.appspot.com/4357052), or [uses the reflect package](http://codereview.appspot.com/4281055) will not build unless it is updated to use the new APIs. -Now that our releases are [more stable and less frequent](https://blog.golang.org/2011/03/go-becomes-more-stable.html), +Now that our releases are [more stable and less frequent](/blog/2011/03/go-becomes-more-stable.html), this will be a common situation. Each of these API changes happened in a different weekly snapshot and might have been manageable on its own; diff --git a/_content/blog/io2011.md b/_content/blog/io2011.md index 90b81bf3..ddc5c176 100644 --- a/_content/blog/io2011.md +++ b/_content/blog/io2011.md @@ -22,7 +22,7 @@ you can now watch videos of our two Go presentations on YouTube. ## Writing Web Apps in Go In “[Writing Web Apps in Go](http://www.youtube.com/watch?v=-i0hat7pdpk)” -we announce the [Go runtime for Google App Engine](https://blog.golang.org/2011/05/go-and-google-app-engine.html) +we announce the [Go runtime for Google App Engine](/blog/2011/05/go-and-google-app-engine.html) and walk through the development and deployment of [Moustachio](http://moustach-io.appspot.com/), the first Go App Engine app. diff --git a/_content/blog/migrating-to-go-modules.md b/_content/blog/migrating-to-go-modules.md index 520e9704..45868312 100644 --- a/_content/blog/migrating-to-go-modules.md +++ b/_content/blog/migrating-to-go-modules.md @@ -49,7 +49,7 @@ A project might be in one of three states when beginning the transition to Go mo - An established Go project with a non-modules dependency manager. - An established Go project without any dependency manager. -The first case is covered in [Using Go Modules](https://blog.golang.org/using-go-modules); +The first case is covered in [Using Go Modules](/blog/using-go-modules); we'll address the latter two in this post. ## With a dependency manager diff --git a/_content/blog/module-mirror-launch.md b/_content/blog/module-mirror-launch.md index 1fa1d2d9..38cc3765 100644 --- a/_content/blog/module-mirror-launch.md +++ b/_content/blog/module-mirror-launch.md @@ -29,7 +29,7 @@ See the [recording](https://youtu.be/KqTySYYhPUE) if you are interested in the f ## Module Mirror -[Modules](https://blog.golang.org/versioning-proposal) are sets of Go packages +[Modules](/blog/versioning-proposal) are sets of Go packages that are versioned together, and the contents of each version are immutable. That immutability provides new opportunities for caching and authentication. When `go get` runs in module mode, it must fetch the module containing the @@ -55,7 +55,7 @@ A module mirror is a special kind of module proxy that caches metadata and source code in its own storage system, allowing the mirror to continue to serve source code that is no longer available from the original locations. This can speed up downloads and protect you from disappearing dependencies. See -[Go Modules in 2019](https://blog.golang.org/modules2019) for more information. +[Go Modules in 2019](/blog/modules2019) for more information. The Go team maintains a module mirror, served at [proxy.golang.org](https://proxy.golang.org), which the `go` command will use by diff --git a/_content/blog/normalization.md b/_content/blog/normalization.md index 7c2a1015..20db7957 100644 --- a/_content/blog/normalization.md +++ b/_content/blog/normalization.md @@ -13,13 +13,13 @@ summary: How and why to normalize UTF-8 text in Go. ## Introduction -An earlier [post](https://blog.golang.org/strings) talked about strings, bytes +An earlier [post](/blog/strings) talked about strings, bytes and characters in Go. I've been working on various packages for multilingual text processing for the go.text repository. Several of these packages deserve a separate blog post, but today I want to focus on [go.text/unicode/norm](https://pkg.go.dev/golang.org/x/text/unicode/norm), which handles normalization, a topic touched in the -[strings article](https://blog.golang.org/strings) and the subject of this +[strings article](/blog/strings) and the subject of this post. Normalization works at a higher level of abstraction than raw bytes. To learn pretty much everything you ever wanted to know about normalization diff --git a/_content/blog/package-names.md b/_content/blog/package-names.md index b560e1b0..1aebd11d 100644 --- a/_content/blog/package-names.md +++ b/_content/blog/package-names.md @@ -252,5 +252,5 @@ grow them gracefully. - [Effective Go](/doc/effective_go.html) - [How to Write Go Code](/doc/code.html) - - [Organizing Go Code (2012 blog post)](https://blog.golang.org/organizing-go-code) + - [Organizing Go Code (2012 blog post)](/blog/organizing-go-code) - [Organizing Go Code (2014 Google I/O talk)](/talks/2014/organizeio.slide) diff --git a/_content/blog/pipelines.md b/_content/blog/pipelines.md index fcf28f3d..89963a09 100644 --- a/_content/blog/pipelines.md +++ b/_content/blog/pipelines.md @@ -318,7 +318,7 @@ Further reading: - [Go Concurrency Patterns](/talks/2012/concurrency.slide#1) ([video](https://www.youtube.com/watch?v=f6kdp27TYZs)) presents the basics of Go's concurrency primitives and several ways to apply them. - - [Advanced Go Concurrency Patterns](https://blog.golang.org/advanced-go-concurrency-patterns) + - [Advanced Go Concurrency Patterns](/blog/advanced-go-concurrency-patterns) ([video](http://www.youtube.com/watch?v=QDDwwePbDtw)) covers more complex uses of Go's primitives, especially `select`. diff --git a/_content/blog/playground.md b/_content/blog/playground.md index 4753ffc5..5c9853a7 100644 --- a/_content/blog/playground.md +++ b/_content/blog/playground.md @@ -12,7 +12,7 @@ summary: How the Go playground works. _NOTE: This article does not describe the current version of the Go Playground._ -In September 2010 we [introduced the Go Playground](https://blog.golang.org/introducing-go-playground), +In September 2010 we [introduced the Go Playground](/blog/introducing-go-playground), a web service that compiles and executes arbitrary Go code and returns the program output. @@ -25,7 +25,7 @@ from the Go documentation. You may also have used it by clicking one of the "Run" buttons in a slide deck on [go.dev/talks](/talks/) or a post on this very blog -(such as the [recent article on Strings](https://blog.golang.org/strings)). +(such as the [recent article on Strings](/blog/strings)). In this article we will take a look at how the playground is implemented and integrated with these services. diff --git a/_content/blog/protobuf-apiv2.md b/_content/blog/protobuf-apiv2.md index 63b61c11..e6b972c4 100644 --- a/_content/blog/protobuf-apiv2.md +++ b/_content/blog/protobuf-apiv2.md @@ -20,7 +20,7 @@ Google's language-neutral data interchange format. ## Motivations for a new API The first protocol buffer bindings for Go were -[announced by Rob Pike](https://blog.golang.org/third-party-libraries-goprotobuf-and) +[announced by Rob Pike](/blog/third-party-libraries-goprotobuf-and) in March of 2010. Go 1 would not be released for another two years. In the decade since that first release, the package has grown and diff --git a/_content/blog/publishing-go-modules.md b/_content/blog/publishing-go-modules.md index 96e54a01..a32c070e 100644 --- a/_content/blog/publishing-go-modules.md +++ b/_content/blog/publishing-go-modules.md @@ -36,7 +36,7 @@ This post uses [Git](https://git-scm.com/) in examples. For this post, you'll need an existing project to use as an example. So, start with the files from the end of the -[Using Go Modules](https://blog.golang.org/using-go-modules) article: +[Using Go Modules](/blog/using-go-modules) article: $ cat go.mod module example.com/hello @@ -149,7 +149,7 @@ Do not delete version tags from your repo. If you find a bug or a security issue with a version, release a new version. If people depend on a version that you have deleted, their builds may fail. Similarly, once you release a version, do not change or overwrite it. The -[module mirror and checksum database](https://blog.golang.org/module-mirror-launch) +[module mirror and checksum database](/blog/module-mirror-launch) store modules, their versions, and signed cryptographic hashes to ensure that the build of a given version remains reproducible over time. diff --git a/_content/blog/slices.md b/_content/blog/slices.md index 9f1f9bb7..1daa32b0 100644 --- a/_content/blog/slices.md +++ b/_content/blog/slices.md @@ -557,7 +557,7 @@ were added to the language, they provided a model for efficient string handling. the benchmarks saw huge speedups as a result. There's much more to strings, of course, and a -[separate blog post](https://blog.golang.org/strings) covers them in greater depth. +[separate blog post](/blog/strings) covers them in greater depth. ## Conclusion @@ -577,7 +577,7 @@ There's lots to find around the intertubes about slices in Go. As mentioned earlier, the ["Slice Tricks" Wiki page](/wiki/SliceTricks) has many examples. -The [Go Slices](https://blog.golang.org/go-slices-usage-and-internals) blog post +The [Go Slices](/blog/go-slices-usage-and-internals) blog post describes the memory layout details with clear diagrams. Russ Cox's [Go Data Structures](https://research.swtch.com/godata) article includes a discussion of slices along with some of Go's other internal data structures. diff --git a/_content/blog/stackoverflow.md b/_content/blog/stackoverflow.md index 7fefacb2..c493816e 100644 --- a/_content/blog/stackoverflow.md +++ b/_content/blog/stackoverflow.md @@ -11,7 +11,7 @@ summary: Announcing the Go Collective, a new experience for Go on Stack Overflow Since the earliest days of Go, Stack Overflow has been a significant part of the Go user experience. -For the past five years, the [Go user survey](https://blog.golang.org/survey2020-results) +For the past five years, the [Go user survey](/blog/survey2020-results) has consistently identified Stack Overflow as the #1 place users go to find answers to their Go questions. diff --git a/_content/blog/strings.md b/_content/blog/strings.md index 3e823c3d..d46e4730 100644 --- a/_content/blog/strings.md +++ b/_content/blog/strings.md @@ -13,7 +13,7 @@ summary: How strings work in Go, and how to use them. ## Introduction -The [previous blog post](https://blog.golang.org/slices) explained how slices +The [previous blog post](/blog/slices) explained how slices work in Go, using a number of examples to illustrate the mechanism behind their implementation. Building on that background, this post discusses strings in Go. @@ -41,7 +41,7 @@ Let's start with some basics. In Go, a string is in effect a read-only slice of bytes. If you're at all uncertain about what a slice of bytes is or how it works, -please read the [previous blog post](https://blog.golang.org/slices); +please read the [previous blog post](/blog/slices); we'll assume here that you have. It's important to state right up front that a string holds _arbitrary_ bytes. diff --git a/_content/blog/survey2017-results.md b/_content/blog/survey2017-results.md index df651a3b..85b00deb 100644 --- a/_content/blog/survey2017-results.md +++ b/_content/blog/survey2017-results.md @@ -16,7 +16,7 @@ and insights. It also draws key comparisons between the results of the 2016 and 2017 survey. This year we had 6,173 survey respondents, 70% more than the 3,595 we had in the -[Go 2016 User Survey](https://blog.golang.org/survey2016-results). In +[Go 2016 User Survey](/blog/survey2016-results). In addition, it also had a slightly higher completion rate (84% → 87%) and a higher response rate to most of the questions. We believe that survey length is the main cause of this improvement as the 2017 survey was shortened in response @@ -144,7 +144,7 @@ continues to be an area of focus for the project and its leadership going forward. We will continue to work to improve our understanding of user needs and approachability. -We tried some [new ways](https://blog.golang.org/8years#TOC_1.3.) to engage +We tried some [new ways](/blog/8years#TOC_1.3.) to engage with users in 2017 and while progress was made, we are still working on making these solutions scalable for our growing community. diff --git a/_content/blog/survey2017.md b/_content/blog/survey2017.md index f55d5bc7..d271f0c4 100644 --- a/_content/blog/survey2017.md +++ b/_content/blog/survey2017.md @@ -12,7 +12,7 @@ summary: Please take the 2017 Go User Survey. We want to hear from you! ## The Go project wants to hear from you (again)! Last year we conducted the first ever -[Go user survey](https://blog.golang.org/survey2016-results). Thanks to all of you, +[Go user survey](/blog/survey2016-results). Thanks to all of you, it was an overwhelming success with over 3500 responses. The survey provided key insights and helped us better plan and prioritize. @@ -34,7 +34,7 @@ and what's not, as well as help us prioritize improvements for the Go language, libraries and tools. A few weeks after the survey closes, we will publish the anonymous aggregate results to -the Go blog. See the [2016 Go user survey results](https://blog.golang.org/survey2016-results) +the Go blog. See the [2016 Go user survey results](/blog/survey2016-results) to learn what insights were gained from last year's survey. ## Spread the word! diff --git a/_content/blog/survey2018-results.md b/_content/blog/survey2018-results.md index 59ae8d47..79078aaa 100644 --- a/_content/blog/survey2018-results.md +++ b/_content/blog/survey2018-results.md @@ -19,8 +19,8 @@ summary: What we learned from the December 2018 Go User Survey. This post summarizes the results of our 2018 user survey and draws comparisons -between the results of our prior surveys from [2016](https://blog.golang.org/survey2016-results) -and [2017](https://blog.golang.org/survey2017-results). +between the results of our prior surveys from [2016](/blog/survey2016-results) +and [2017](/blog/survey2017-results). This year we had 5,883 survey respondents from 103 different countries. We are grateful to everyone who provided their feedback through this survey diff --git a/_content/blog/survey2018.md b/_content/blog/survey2018.md index 96974496..a4026e9e 100644 --- a/_content/blog/survey2018.md +++ b/_content/blog/survey2018.md @@ -11,14 +11,14 @@ summary: Please take the 2018 Go User Survey. We want to hear from you! ## The Go project wants to hear from you, the Go community! -In [2017](https://blog.golang.org/survey2017-results) & -[2016](https://blog.golang.org/survey2016-results), thousands of you helped the +In [2017](/blog/survey2017-results) & +[2016](/blog/survey2016-results), thousands of you helped the project by lending your voice via the Go user survey. In October, hundreds of companies helped us understand how enterprises are using Go by taking the Go company questionnaire. These surveys and questionnaires have played an enormous role in driving changes to our language and community, from -[our new code of conduct](https://blog.golang.org/conduct-2018), to our -[latest release Go 1.11](https://blog.golang.org/go1.11). +[our new code of conduct](/blog/conduct-2018), to our +[latest release Go 1.11](/blog/go1.11). Today we are conducting the 2018 Go user survey. We’d like to hear from **all** Go users in order to help us to create the best programming language that fits the diff --git a/_content/blog/survey2019-results.md b/_content/blog/survey2019-results.md index f64c5aee..8094c91c 100644 --- a/_content/blog/survey2019-results.md +++ b/_content/blog/survey2019-results.md @@ -13,7 +13,7 @@ summary: An analysis of the results from the 2019 Go Developer Survey. I want to start with an enormous **thank you** to the thousands of Go developers who participated in this year’s survey. -For 2019, we saw 10,975 responses, nearly [twice as many as last year](https://blog.golang.org/survey2018-results)! +For 2019, we saw 10,975 responses, nearly [twice as many as last year](/blog/survey2018-results)! On behalf of the rest of the team, I cannot adequately stress how much we appreciate you taking the time and effort to tell us about your experiences with Go. Thank you! diff --git a/_content/blog/survey2019.md b/_content/blog/survey2019.md index 7de29ac7..bd985d27 100644 --- a/_content/blog/survey2019.md +++ b/_content/blog/survey2019.md @@ -15,11 +15,11 @@ Since 2016, thousands of Gophers around the world have helped the Go project by sharing your thoughts via our annual Go Developer Survey. Your feedback has played an enormous role in driving changes to our language, ecosystem, and community, including [the gopls language server](https://about.sourcegraph.com/go/gophercon-2019-go-pls-stop-breaking-my-editor), -new [error-handling mechanics](https://blog.golang.org/go1.13-errors), -the [module mirror](https://blog.golang.org/module-mirror-launch), -and so much more from the latest [Go 1.13 release](https://blog.golang.org/go1.13). -And of course, we publicly share [each](https://blog.golang.org/survey2016-results) -[year's](https://blog.golang.org/survey2017-results) [results](https://blog.golang.org/survey2018-results), +new [error-handling mechanics](/blog/go1.13-errors), +the [module mirror](/blog/module-mirror-launch), +and so much more from the latest [Go 1.13 release](/blog/go1.13). +And of course, we publicly share [each](/blog/survey2016-results) +[year's](/blog/survey2017-results) [results](/blog/survey2018-results), so we can all benefit from the community's insights. Today we are launching the 2019 Go Developer Survey. diff --git a/_content/blog/survey2020-results.md b/_content/blog/survey2020-results.md index 5868cf22..2dbfc3d0 100644 --- a/_content/blog/survey2020-results.md +++ b/_content/blog/survey2020-results.md @@ -11,7 +11,7 @@ summary: An analysis of the results from the 2020 Go Developer Survey. ## Thank you for the amazing response! {#thanks} -In 2020, we had another great turnout with 9,648 responses, about [as many as 2019](https://blog.golang.org/survey2019-results). Thank you for putting in the time to provide the community with these insights on your experiences using Go! +In 2020, we had another great turnout with 9,648 responses, about [as many as 2019](/blog/survey2019-results). Thank you for putting in the time to provide the community with these insights on your experiences using Go! ## New modular survey design {#new} diff --git a/_content/blog/survey2020.md b/_content/blog/survey2020.md index c192715c..c9c17921 100644 --- a/_content/blog/survey2020.md +++ b/_content/blog/survey2020.md @@ -16,7 +16,7 @@ by sharing their thoughts via our annual Go Developer Survey. Your feedback has played an enormous role in driving changes to our language, ecosystem, and community, including the gopls language server, the latest generics draft, the module mirror, and so much more. -And of course, we publicly share [each year's results](https://blog.golang.org/survey2019-results), +And of course, we publicly share [each year's results](/blog/survey2019-results), so we can all benefit from the community's insights. This year we’ve streamlined the survey to shorten the time it takes to diff --git a/_content/blog/toward-go2.md b/_content/blog/toward-go2.md index 73734e60..8487376e 100644 --- a/_content/blog/toward-go2.md +++ b/_content/blog/toward-go2.md @@ -33,14 +33,14 @@ to the [open-source release](https://opensource.googleblog.com/2009/11/hey-ho-le For the next two years, with the help of the new Go open source community, we experimented with changes large and small, refining Go -and leading to the [plan for Go 1](https://blog.golang.org/preview-of-go-version-1), proposed on October 5, 2011. +and leading to the [plan for Go 1](/blog/preview-of-go-version-1), proposed on October 5, 2011.
{{image "toward-go2/go1-preview.png" 560}}
With more help from the Go community, we revised and implemented that -plan, eventually [releasing Go 1](https://blog.golang.org/go1) on March 28, 2012. +plan, eventually [releasing Go 1](/blog/go1) on March 28, 2012.
{{image "toward-go2/go1-release.png" 556}} @@ -55,7 +55,7 @@ In the years leading to Go 1, we changed Go and broke everyone's Go programs nearly every week. We understood that this was keeping Go from use in production settings, where programs could not be rewritten weekly to keep up with language changes. -As the [blog post announcing Go 1](https://blog.golang.org/go1) says, the driving motivation was to provide a stable foundation +As the [blog post announcing Go 1](/blog/go1) says, the driving motivation was to provide a stable foundation for creating reliable products, projects, and publications (blogs, tutorials, conference talks, and books), to make users confident that their programs would continue to compile and run without change for @@ -67,7 +67,7 @@ explicitly away from making language changes toward using Go in our own projects and improving the implementation: we ported Go to many new systems, we rewrote nearly every performance-critical piece to make Go run more efficiently, and we added key tools like the -[race detector](https://blog.golang.org/race-detector). +[race detector](/blog/race-detector). Now we have five years of experience using Go to build large, production-quality systems. We have developed a sense of what works @@ -104,7 +104,7 @@ scale. (For more about these goals, see Rob Pike's 2012 article “[Go at Google: Language Design in the Service of Software Engineering](/talks/2012/splash.article)” -and my GopherCon 2015 talk “[Go, Open Source, Community](https://blog.golang.org/open-source).”) +and my GopherCon 2015 talk “[Go, Open Source, Community](/blog/open-source).”) ## Constraints @@ -206,7 +206,7 @@ explained step 2 in detail, so I'd like to do that now. (For more about the development of Go 1 and the shift away from language changes, see Rob Pike and Andrew Gerrand's -OSCON 2012 talk “[The Path to Go 1](https://blog.golang.org/the-path-to-go-1).” +OSCON 2012 talk “[The Path to Go 1](/blog/the-path-to-go-1).” For more about the proposal process, see Andrew Gerrand's GopherCon 2015 talk “[How Go was Made](https://www.youtube.com/watch?v=0ht89TxZZnk)” and the [proposal process documentation](/s/proposal).) @@ -512,7 +512,7 @@ to find some way to disallow data races, to make it impossible to write or at least to compile a program with a data race. How to fit that into a language like Go is still an open question in the programming language world. Instead we added a tool to the main -distribution and made it trivial to use: that tool, the [race detector](https://blog.golang.org/race-detector), has become +distribution and made it trivial to use: that tool, the [race detector](/blog/race-detector), has become an indispensable part of the Go experience. Here the best solution was a runtime and tooling change, not a language change. diff --git a/_content/blog/turkey-doodle.md b/_content/blog/turkey-doodle.md index 45101ada..c9550654 100644 --- a/_content/blog/turkey-doodle.md +++ b/_content/blog/turkey-doodle.md @@ -273,7 +273,7 @@ making it easier to learn good style and conventions. In writing this application I used just three resources: App Engine's [Hello World Go example](http://code.google.com/appengine/docs/go/gettingstarted/helloworld.html), [the Go packages documentation](/pkg/), -and [a blog post showcasing the Draw package](https://blog.golang.org/2011/09/go-imagedraw-package.html). +and [a blog post showcasing the Draw package](/blog/2011/09/go-imagedraw-package.html). Thanks to the rapid iteration made possible by the development server and the language itself, I was able to pick up the language and build a super fast, diff --git a/_content/blog/using-go-modules.md b/_content/blog/using-go-modules.md index ca3fcd80..f104f0e5 100644 --- a/_content/blog/using-go-modules.md +++ b/_content/blog/using-go-modules.md @@ -26,7 +26,7 @@ This post is part 1 in a series. Go 1.11 and 1.12 include preliminary [support for modules](/doc/go1.11#modules), Go’s -[new dependency management system](https://blog.golang.org/versioning-proposal) +[new dependency management system](/blog/versioning-proposal) that makes dependency version information explicit and easier to manage. This blog post is an introduction to the basic operations needed diff --git a/_content/blog/versioning-proposal.md b/_content/blog/versioning-proposal.md index 3ee57e39..667e3574 100644 --- a/_content/blog/versioning-proposal.md +++ b/_content/blog/versioning-proposal.md @@ -40,7 +40,7 @@ some of the details, especially concerning backwards compatibility. ## The Impact of Compatibility The most important new feature of -[Go 1](https://blog.golang.org/preview-of-go-version-1) +[Go 1](/blog/preview-of-go-version-1) was not a language feature. It was Go 1’s emphasis on backwards compatibility. Until that point we’d issued stable release diff --git a/_content/blog/vscode-go.md b/_content/blog/vscode-go.md index e445adf3..b3d4a125 100644 --- a/_content/blog/vscode-go.md +++ b/_content/blog/vscode-go.md @@ -20,7 +20,7 @@ success can be attributed to the fantastic development tools created by the Go community. The [VS Code extension for Go](https://github.com/microsoft/vscode-go), built using many of these tools, is now used by 41 percent of Go developers -([Go developer survey](https://blog.golang.org/survey2019-results)). +([Go developer survey](/blog/survey2019-results)). As the VS Code Go extension grows in popularity and as [the ecosystem expands](https://www.youtube.com/watch?v=EFJfdWzBHwE), it diff --git a/_content/blog/wire.md b/_content/blog/wire.md index a93dc3a7..9fe28c4f 100644 --- a/_content/blog/wire.md +++ b/_content/blog/wire.md @@ -8,7 +8,7 @@ summary: How to use Wire, a dependency injection tool for Go. ## Overview -The Go team recently [announced](https://blog.golang.org/go-cloud) the +The Go team recently [announced](/blog/go-cloud) the open source project [Go Cloud](https://github.com/google/go-cloud), with portable Cloud APIs and tools for [open cloud](https://cloud.google.com/open-cloud/) development. This post goes into more detail about Wire, diff --git a/_content/conduct.html b/_content/conduct.html index 962df2e9..1cdd7a71 100644 --- a/_content/conduct.html +++ b/_content/conduct.html @@ -38,7 +38,7 @@ 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 Go, Open Source, Community.) +(See Go, Open Source, Community.)

diff --git a/_content/doc/database/cancel-operations.md b/_content/doc/database/cancel-operations.md index d01efc7a..e56beaa7 100644 --- a/_content/doc/database/cancel-operations.md +++ b/_content/doc/database/cancel-operations.md @@ -9,7 +9,7 @@ represents has been canceled and is no longer needed. By passing a `context.Context` across function calls and services in your application, those can stop working early and return an error when their processing is no longer needed. For more about `Context`, see -[Go Concurrency Patterns: Context](https://blog.golang.org/context). +[Go Concurrency Patterns: Context](/blog/context). For example, you might want to: diff --git a/_content/doc/devel/pre_go1.html b/_content/doc/devel/pre_go1.html index 645de058..43bd1e8a 100644 --- a/_content/doc/devel/pre_go1.html +++ b/_content/doc/devel/pre_go1.html @@ -316,7 +316,7 @@ future changes to the libraries. Gofix can’t handle all situations perfectly, so read and test the changes it makes before committing them. -See the gofix blog post for more +See the gofix blog post for more information.

Language

diff --git a/_content/doc/diagnostics.html b/_content/doc/diagnostics.html index c59cbdd2..da614ebf 100644 --- a/_content/doc/diagnostics.html +++ b/_content/doc/diagnostics.html @@ -128,7 +128,7 @@ so it is recommended to collect only a single profile at a time. The Go tools provide text, graph, and callgrind visualization of the profile data using go tool pprof. -Read Profiling Go programs +Read Profiling Go programs to see them in action.

diff --git a/_content/doc/effective_go.html b/_content/doc/effective_go.html index f77ff480..2e6509f2 100644 --- a/_content/doc/effective_go.html +++ b/_content/doc/effective_go.html @@ -3098,7 +3098,7 @@ 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 -this +this blog post.

A leaky buffer

diff --git a/_content/doc/faq.html b/_content/doc/faq.html index 4d8b07d2..136b325e 100644 --- a/_content/doc/faq.html +++ b/_content/doc/faq.html @@ -90,7 +90,7 @@ The mascot and logo were designed by Renée French, who also designed Glenda, the Plan 9 bunny. -A blog post +A blog post about the gopher explains how it was derived from one she used for a WFMU T-shirt design some years ago. @@ -125,7 +125,7 @@ The language's name is just plain Go, regardless.

A side note: Although the -official logo +official logo has two capital letters, the language name is written Go, not GO.

@@ -502,7 +502,7 @@ when used well, can result in clean error-handling code.

See the Defer, Panic, and Recover article for details. -Also, the Errors are values blog post +Also, the Errors are values 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.

@@ -1150,7 +1150,7 @@ to a float64 for the call to math.Sqrt.

-A blog post titled Constants +A blog post titled Constants explores this topic in more detail.

@@ -1626,7 +1626,7 @@ Do not communicate by sharing memory. Instead, share memory by communicating.

See the Share Memory By Communicating code walk -and its +and its associated article for a detailed discussion of this concept.

@@ -1665,7 +1665,7 @@ to speed it up.

For more detail on this topic see the talk entitled -Concurrency +Concurrency is not Parallelism.

@@ -2506,7 +2506,7 @@ 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 -profiling +profiling Go programs for an informative example.

Changes from C

@@ -2684,7 +2684,7 @@ in networked servers. Work continues to refine the algorithm, reduce overhead and latency further, and to explore new approaches. The 2018 -ISMM keynote +ISMM keynote by Rick Hudson of the Go team describes the progress so far and suggests some future approaches.

@@ -2695,7 +2695,7 @@ 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 -profiling +profiling Go programs for a worked example, including a demonstration of Go's profiling tools.

diff --git a/_content/doc/go1.14.md b/_content/doc/go1.14.md index 0244f4ca..4a7b0b51 100644 --- a/_content/doc/go1.14.md +++ b/_content/doc/go1.14.md @@ -23,7 +23,7 @@ We expect almost all Go programs to continue to compile and run as before. Module support in the `go` command is now ready for production use, and we encourage all users to [migrate to Go -modules for dependency management](https://blog.golang.org/migrating-to-go-modules). If you are unable to migrate due to a problem in the Go +modules for dependency management](/blog/migrating-to-go-modules). If you are unable to migrate due to a problem in the Go toolchain, please ensure that the problem has an [open issue](/issue?q=is%3Aissue+is%3Aopen+label%3Amodules) filed. (If the issue is not on the `Go1.15` milestone, please let us diff --git a/_content/doc/go1.5.md b/_content/doc/go1.5.md index f960bcfc..a9865f06 100644 --- a/_content/doc/go1.5.md +++ b/_content/doc/go1.5.md @@ -747,7 +747,7 @@ The fixes harden the implementation against incorrect and malicious inputs. `uint8(r>>8)`. Incidentally, the `image/draw` package provides better support for such conversions; see - [this blog post](https://blog.golang.org/go-imagedraw-package) + [this blog post](/blog/go-imagedraw-package) for more information. - Finally, as of Go 1.5 the closest match check in [`Index`](/pkg/image/color/#Palette.Index) diff --git a/_content/doc/go1.6.md b/_content/doc/go1.6.md index 62a6555c..f21f3ccb 100644 --- a/_content/doc/go1.6.md +++ b/_content/doc/go1.6.md @@ -227,7 +227,7 @@ 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 -[race detector](https://blog.golang.org/race-detector), +[race detector](/blog/race-detector), which will more reliably identify the race and give more detail. diff --git a/_content/doc/go1.7.md b/_content/doc/go1.7.md index 3b64ae8d..5f01bbcf 100644 --- a/_content/doc/go1.7.md +++ b/_content/doc/go1.7.md @@ -322,7 +322,7 @@ as noted below. For more information about contexts, see the [package documentation](/pkg/context/) and the Go blog post -“[Go Concurrent Patterns: Context](https://blog.golang.org/context).” +“[Go Concurrent Patterns: Context](/blog/context).” ### HTTP Tracing {#httptrace} diff --git a/_content/doc/go1.8.md b/_content/doc/go1.8.md index 6f74f7ad..1f2fc6b3 100644 --- a/_content/doc/go1.8.md +++ b/_content/doc/go1.8.md @@ -410,7 +410,7 @@ 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 -[race detector](https://blog.golang.org/race-detector), +[race detector](/blog/race-detector), which will more reliably identify the race and give more detail. diff --git a/_content/doc/modules/developing.md b/_content/doc/modules/developing.md index 1ab47707..b0d5a5c5 100644 --- a/_content/doc/modules/developing.md +++ b/_content/doc/modules/developing.md @@ -59,7 +59,7 @@ 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. +compatible](/blog/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 diff --git a/_content/doc/modules/release-workflow.md b/_content/doc/modules/release-workflow.md index 030ffbfa..3d6091ae 100644 --- a/_content/doc/modules/release-workflow.md +++ b/_content/doc/modules/release-workflow.md @@ -253,7 +253,7 @@ 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). +modules compatible](/blog/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 diff --git a/_content/doc/tutorial/greetings-multiple-people.html b/_content/doc/tutorial/greetings-multiple-people.html index be8199cf..3589f17c 100644 --- a/_content/doc/tutorial/greetings-multiple-people.html +++ b/_content/doc/tutorial/greetings-multiple-people.html @@ -109,7 +109,7 @@ func randomFormat() string { you initialize a map with the following syntax: make(map[key-type]value-type). You have the Hellos function return this map to the caller. For more - about maps, see Go maps in + about maps, see Go maps in action on the Go blog.
  • @@ -202,7 +202,7 @@ map[Darrin:Hail, Darrin! Well met! Gladys:Hi, Gladys. Welcome! Samantha:Hail, Sa 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 - Keeping your modules + Keeping your modules compatible.

    diff --git a/_content/doc/tutorial/random-greeting.html b/_content/doc/tutorial/random-greeting.html index 96d4ea5a..8cb76e19 100644 --- a/_content/doc/tutorial/random-greeting.html +++ b/_content/doc/tutorial/random-greeting.html @@ -22,7 +22,7 @@

    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 Go slices in the Go + see Go slices in the Go blog.

    diff --git a/_content/ref/mod.md b/_content/ref/mod.md index a2416315..0d586e2d 100644 --- a/_content/ref/mod.md +++ b/_content/ref/mod.md @@ -13,7 +13,7 @@ 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](/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). +with [Using Go Modules](/blog/using-go-modules). ## Modules, packages, and versions {#modules-overview} @@ -1369,7 +1369,7 @@ 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. +and Beyond](/blog/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