diff --git a/blog/content/4years.article b/blog/content/4years.article
index 8d49283..d6d2cad 100644
--- a/blog/content/4years.article
+++ b/blog/content/4years.article
@@ -46,7 +46,7 @@
 
 Businesses are enjoying Go, too. The [[https://golang.org/wiki/GoUsers][Go Users wiki page]] lists dozens of success stories (and if you use Go, please add yourself to it). Some examples:
 
-- [[http://blog.cloudflare.com/go-at-cloudflare][CloudFlare]] built their distributed DNS service entirely with Go, and are in the process of migrating their gigabytes-per-minute logging infrastructure to the language. Programmer John Graham-Cumming said "We've found Go to be the perfect match for our needs: the combination of familiar syntax, a powerful type system, a strong network library and built-in concurrency means that more and more projects are being built here in Go." 
+- [[https://blog.cloudflare.com/go-at-cloudflare][CloudFlare]] built their distributed DNS service entirely with Go, and are in the process of migrating their gigabytes-per-minute logging infrastructure to the language. Programmer John Graham-Cumming said "We've found Go to be the perfect match for our needs: the combination of familiar syntax, a powerful type system, a strong network library and built-in concurrency means that more and more projects are being built here in Go." 
 
 - [[http://soundcloud.com][SoundCloud]] is an audio distribution service that has "dozens of [[http://backstage.soundcloud.com/2012/07/go-at-soundcloud/][systems in Go]], touching almost every part of the site, and in many cases powering features from top to bottom." Engineer Peter Bourgon said "Go demonstrates that the cruft that burdens other languages and ecosystems—stuff that developers have learned to deal with, often in anger—is simply not a necessary part of modern programming. With Go, I have a straightforward and non-adversarial relationship with my tools, from development to production."
 
@@ -56,13 +56,13 @@
 
 - Music collaboration startup [[http://splice.com][Splice]] chose to build their service with Go. Co-founder Matt Aimonetti said "We seriously studied and considered many programming languages, but Go's simplicity, efficiency, philosophy and community won us over."
 
-- And, of course, engineering teams across Google are moving to Go. Engineer Matt Welsh recently [[http://matt-welsh.blogspot.com.au/2013/08/rewriting-large-production-system-in-go.html][shared his experience]] rewriting a large production service in Go. Other notable public examples include YouTube's [[https://github.com/youtube/vitess][vitess project]] and [[http://talks.golang.org/2013/oscon-dl.slide][dl.google.com]]. We hope to share more stories like these soon.
+- And, of course, engineering teams across Google are moving to Go. Engineer Matt Welsh recently [[http://matt-welsh.blogspot.com.au/2013/08/rewriting-large-production-system-in-go.html][shared his experience]] rewriting a large production service in Go. Other notable public examples include YouTube's [[https://github.com/youtube/vitess][vitess project]] and [[https://talks.golang.org/2013/oscon-dl.slide][dl.google.com]]. We hope to share more stories like these soon.
 
 In September 2012, [[http://apcera.com/][Apcera]] CEO Derek Collison [[https://twitter.com/derekcollison/status/245522124666716160][predicted]] that "Go will become the dominant language for systems work in [Infastructure-as-a-Service], Orchestration, and [Platform-as-a-Service] in 24 months." Looking at the list above, 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:
 
-- [[http://blog.golang.org/getthee-to-go-meetup][Join your nearest Go User Group]], 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, Berlin, Gothenburg, London, Moscow, Munich, New York City, Paris, San Francisco, Seoul, Stockholm, Sydney, Tokyo, and Warsaw; but there are [[https://golang.org/wiki/GoUserGroups][many more]]!
+- [[https://blog.golang.org/getthee-to-go-meetup][Join your nearest Go User Group]], 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, Berlin, Gothenburg, London, Moscow, Munich, New York City, Paris, San Francisco, Seoul, Stockholm, Sydney, Tokyo, and Warsaw; but there are [[https://golang.org/wiki/GoUserGroups][many more]]!
 
 - Create or contribute to an open source Go project (or [[https://golang.org/doc/contribute.html][to Go itself]]). (And if you're building something, we'd love to hear from you on the [[http://groups.google.com/group/golang-nuts][Go mailing list]].)
 
diff --git a/blog/content/5years.article b/blog/content/5years.article
index 4c86432..dcef847 100644
--- a/blog/content/5years.article
+++ b/blog/content/5years.article
@@ -27,14 +27,14 @@
 
 After the initial release, it took us a while to properly communicate the
 goals and design ethos behind Go. Rob Pike did so eloquently in his 2012 essay
-[[http://talks.golang.org/2012/splash.article][_Go_at_Google:_Language_Design_in_the_Service_of_Software_Engineering_]] and
+[[https://talks.golang.org/2012/splash.article][_Go_at_Google:_Language_Design_in_the_Service_of_Software_Engineering_]] and
 more personally in his blog post
-[[http://commandcenter.blogspot.com.au/2012/06/less-is-exponentially-more.html][_Less_is_exponentially_more_]].
+[[https://commandcenter.blogspot.com.au/2012/06/less-is-exponentially-more.html][_Less_is_exponentially_more_]].
 Andrew Gerrand's
 [[http://vimeo.com/53221560][_Code_that_grows_with_grace_]]
-([[http://talks.golang.org/2012/chat.slide][slides]]) and
+([[https://talks.golang.org/2012/chat.slide][slides]]) and
 [[https://www.youtube.com/watch?v=dKGmK_Z1Zl0][_Go_for_Gophers_]]
-([[http://talks.golang.org/2014/go4gophers.slide][slides]]) give a
+([[https://talks.golang.org/2014/go4gophers.slide][slides]]) give a
 more in-depth, technical take on Go's design philosophy.
 
 Over time, the few became many. The turning point for the project was the
@@ -47,9 +47,9 @@
 
 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 [[http://blog.golang.org/gophercon][GopherCon]] and
+the inaugural [[https://blog.golang.org/gophercon][GopherCon]] and
 [[http://www.dotgo.eu/][dotGo]] conferences in Denver and Paris, the
-[[http://blog.golang.org/fosdem14][Go DevRoom at FOSDEM]] and two more
+[[https://blog.golang.org/fosdem14][Go DevRoom at FOSDEM]] and two more
 instances of the biannual [[https://github.com/GoCon/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
diff --git a/blog/content/6years.article b/blog/content/6years.article
index 6e4730b..662ce74 100644
--- a/blog/content/6years.article
+++ b/blog/content/6years.article
@@ -11,8 +11,8 @@
 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 [[https://blog.golang.org/gophercon2015][around]]
-[[http://blog.golang.org/gouk15][the]]
-[[http://blog.golang.org/gopherchina][world]] with regularity.
+[[https://blog.golang.org/gouk15][the]]
+[[https://blog.golang.org/gopherchina][world]] with regularity.
 
 .image 6years-gopher.png
 
diff --git a/blog/content/advanced-go-concurrency-patterns.article b/blog/content/advanced-go-concurrency-patterns.article
index 68c3fda..5361a97 100644
--- a/blog/content/advanced-go-concurrency-patterns.article
+++ b/blog/content/advanced-go-concurrency-patterns.article
@@ -6,10 +6,10 @@
 
 * Introduction
 
-At Google I/O a year ago Rob Pike presented [[http://talks.golang.org/2012/concurrency.slide][_Go_Concurrency_Patterns_]], an introduction to Go's concurrency model. Last week, at I/O 2013, Go team member Sameer Ajmani continued the story with [[http://talks.golang.org/2013/advconc.slide][_Advanced_Go_Concurrency_Patterns_]], an in-depth look at a real concurrent programming problem. The talk shows how to detect and avoid deadlocks and race conditions, and demonstrates the implementation of deadlines, cancellation, and more. For those who want to take their Go programming to the next level, this is a must-see.
+At Google I/O a year ago Rob Pike presented [[https://talks.golang.org/2012/concurrency.slide][_Go_Concurrency_Patterns_]], an introduction to Go's concurrency model. Last week, at I/O 2013, Go team member Sameer Ajmani continued the story with [[http://talks.golang.org/2013/advconc.slide][_Advanced_Go_Concurrency_Patterns_]], an in-depth look at a real concurrent programming problem. The talk shows how to detect and avoid deadlocks and race conditions, and demonstrates the implementation of deadlines, cancellation, and more. For those who want to take their Go programming to the next level, this is a must-see.
 
 .iframe //www.youtube.com/embed/QDDwwePbDtw?rel=0 309 549
 
-The slides are [[http://talks.golang.org/2013/advconc.slide][available here]] (use the left and right arrows to navigate).
+The slides are [[https://talks.golang.org/2013/advconc.slide][available here]] (use the left and right arrows to navigate).
 
-The slides were produced with [[http://godoc.org/golang.org/x/tools/present][the present tool]], and the runnable code snippets are powered by the [[http://play.golang.org/][Go Playground]]. The source code for this talk is in [[https://github.com/golang/talks/blob/master/2013/advconc.slide][the go.talks sub-repository]].
+The slides were produced with [[https://godoc.org/golang.org/x/tools/present][the present tool]], and the runnable code snippets are powered by the [[http://play.golang.org/][Go Playground]]. The source code for this talk is in [[https://github.com/golang/talks/blob/master/2013/advconc.slide][the go.talks sub-repository]].
diff --git a/blog/content/appengine-dec2013.article b/blog/content/appengine-dec2013.article
index 02cee48..1e53a7d 100644
--- a/blog/content/appengine-dec2013.article
+++ b/blog/content/appengine-dec2013.article
@@ -8,7 +8,7 @@
 
 * Background
 
-When we [[http://blog.golang.org/go-and-google-app-engine][launched Go for App Engine]]
+When we [[https://blog.golang.org/go-and-google-app-engine][launched Go for 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,
@@ -16,7 +16,7 @@
 [[https://golang.org/doc/code.html][convention]] for organizing Go programs.
 
 In January 2013 we announced
-[[http://blog.golang.org/the-app-engine-sdk-and-workspaces-gopath][better integration]]
+[[https://blog.golang.org/the-app-engine-sdk-and-workspaces-gopath][better integration]]
 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/blog/content/concurrency-is-not-parallelism.article b/blog/content/concurrency-is-not-parallelism.article
index 62f7e5a..19c7cb6 100644
--- a/blog/content/concurrency-is-not-parallelism.article
+++ b/blog/content/concurrency-is-not-parallelism.article
@@ -14,6 +14,6 @@
 
 .iframe //player.vimeo.com/video/49718712?badge=0 281 500
 
-The slides are available at [[http://talks.golang.org/2012/waza.slide][talks.golang.org]] (use the left and right arrow keys to navigate).
+The slides are available at [[https://talks.golang.org/2012/waza.slide][talks.golang.org]] (use the left and right arrow keys to navigate).
 
-To learn about Go's concurrency primitives, watch [[http://www.youtube.com/watch?v=f6kdp27TYZs][Go concurrency patterns]] ([[http://talks.golang.org/2012/concurrency.slide][slides]]).
+To learn about Go's concurrency primitives, watch [[http://www.youtube.com/watch?v=f6kdp27TYZs][Go concurrency patterns]] ([[https://talks.golang.org/2012/concurrency.slide][slides]]).
diff --git a/blog/content/constants.article b/blog/content/constants.article
index 7b498df..7258aa9 100644
--- a/blog/content/constants.article
+++ b/blog/content/constants.article
@@ -398,7 +398,7 @@
 .play -edit constants/exercise6.go /START/,/STOP/
 
 Whatever the number of bits it takes to represent a `uint` in the current execution environment
-(on the [[http://blog.golang.org/playground][playground]], it's 32),
+(on the [[https://blog.golang.org/playground][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, you understand all the important points about constants in Go.
diff --git a/blog/content/context.article b/blog/content/context.article
index 42bcfc4..68c7f23 100644
--- a/blog/content/context.article
+++ b/blog/content/context.article
@@ -198,7 +198,7 @@
 specific HTTP request in the Gorilla package.
 
 Other packages have provided cancelation support similar to `Context`.
-For example, [[http://godoc.org/gopkg.in/tomb.v2][Tomb]] provides a `Kill`
+For example, [[https://godoc.org/gopkg.in/tomb.v2][Tomb]] provides a `Kill`
 method that signals cancelation by closing a `Dying` channel.
 `Tomb` also provides methods to wait for those goroutines to exit, similar to
 `sync.WaitGroup`.
diff --git a/blog/content/cover.article b/blog/content/cover.article
index c40502d..3abd67d 100644
--- a/blog/content/cover.article
+++ b/blog/content/cover.article
@@ -26,7 +26,7 @@
 * Support for tools
 
 First, some background: What does it mean for a
-[[http://talks.golang.org/2012/splash.article#TOC_17.][language to support good tooling]]?
+[[https://talks.golang.org/2012/splash.article#TOC_17.][language to support good tooling]]?
 It means that the language makes it easy to write good tools and that its ecosystem
 supports the construction of tools of all flavors.
 
@@ -50,7 +50,7 @@
 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
-[[http://blog.golang.org/the-path-to-go-1][run-up to Go 1.0]],
+[[https://blog.golang.org/the-path-to-go-1][run-up to Go 1.0]],
 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/blog/content/debugging-go-programs-with-gnu-debugger.article b/blog/content/debugging-go-programs-with-gnu-debugger.article
index 265a479..6988636 100644
--- a/blog/content/debugging-go-programs-with-gnu-debugger.article
+++ b/blog/content/debugging-go-programs-with-gnu-debugger.article
@@ -6,7 +6,7 @@
 
 * Introduction
 
-Last year we [[http://blog.golang.org/2010/11/debugging-go-code-status-report.html][reported]] that Go's [[https://golang.org/cmd/gc/][gc]]/[[https://golang.org/cmd/6l/][ld]] 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.
+Last year we [[https://blog.golang.org/2010/11/debugging-go-code-status-report.html][reported]] that Go's [[https://golang.org/cmd/gc/][gc]]/[[https://golang.org/cmd/6l/][ld]] 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.
 Among the improvements are the ability to inspect goroutines and to print native Go data types, including structs, slices, strings, maps, interfaces, and channels.
 
 To learn more about Go and GDB, see the [[https://golang.org/doc/debugging_with_gdb.html][Debugging with GDB]] article.
diff --git a/blog/content/docker.article b/blog/content/docker.article
index 38aedca..2ec5cc3 100644
--- a/blog/content/docker.article
+++ b/blog/content/docker.article
@@ -18,7 +18,7 @@
 * The demo app
 
 For our demonstration we will use the
-[[http://godoc.org/github.com/golang/example/outyet][outyet]] program from the
+[[https://godoc.org/github.com/golang/example/outyet][outyet]] program from the
 [[https://github.com/golang/example][Go examples repository]],
 a simple web server that reports whether the next version of Go has been released
 (designed to power sites like [[http://isgo1point4.outyet.org/][isgo1point4.outyet.org]]).
diff --git a/blog/content/first-go-program.article b/blog/content/first-go-program.article
index 9628965..59e46e8 100644
--- a/blog/content/first-go-program.article
+++ b/blog/content/first-go-program.article
@@ -19,7 +19,7 @@
 
 What follows is the first Go program. It was written by Rob in February 2008,
 when the team was just Rob, Robert, and Ken. They had a solid feature list
-(mentioned in [[http://commandcenter.blogspot.com.au/2012/06/less-is-exponentially-more.html][this blog post]])
+(mentioned in [[https://commandcenter.blogspot.com.au/2012/06/less-is-exponentially-more.html][this blog post]])
 and a rough language specfication. Ken had just finished the first working version of
 a Go compiler (it didn't produce native code, but rather transliterated Go code
 to C for fast prototyping) and it was time to try writing a program with it.
diff --git a/blog/content/from-zero-to-go-launching-on-google.article b/blog/content/from-zero-to-go-launching-on-google.article
index 9857096..0d95ef9 100644
--- a/blog/content/from-zero-to-go-launching-on-google.article
+++ b/blog/content/from-zero-to-go-launching-on-google.article
@@ -128,7 +128,7 @@
 Here's the code for the request handler with explanatory comments:
 
 	func handler(w http.ResponseWriter, r *http.Request) {
-	    // [[http://blog.golang.org/2010/08/defer-panic-and-recover.html][Defer]] a function to recover from any panics.
+	    // [[https://blog.golang.org/2010/08/defer-panic-and-recover.html][Defer]] a function to recover from any panics.
 	    // When recovering from a panic, log the error condition to
 	    // the App Engine dashboard and send the default image to the user.
 	    defer func() {
@@ -197,7 +197,7 @@
 
 Go's great documentation also helped me put this together fast. The docs are generated from the source code, so each function's documentation links directly to the associated source code. This not only allows the developer to understand very quickly what a particular function does but also encourages the developer to dig into the package implementation, making it easier to learn good style and conventions.
 
-In writing this application I used just three resources: App Engine's [[http://code.google.com/appengine/docs/go/gettingstarted/helloworld.html][Hello World Go example]], [[https://golang.org/pkg/][the Go packages documentation]], and [[http://blog.golang.org/2011/09/go-imagedraw-package.html][a blog post showcasing the Draw package]]. 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, production ready, doodle generator in less than 24 hours.
+In writing this application I used just three resources: App Engine's [[http://code.google.com/appengine/docs/go/gettingstarted/helloworld.html][Hello World Go example]], [[https://golang.org/pkg/][the Go packages documentation]], and [[https://blog.golang.org/2011/09/go-imagedraw-package.html][a blog post showcasing the Draw package]]. 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, production ready, doodle generator in less than 24 hours.
 
 Download the full app source code (including images) at [[http://code.google.com/p/go-thanksgiving/source/browse/][the Google Code project]].
 
diff --git a/blog/content/generate.article b/blog/content/generate.article
index c9335cc..68d7ba3 100644
--- a/blog/content/generate.article
+++ b/blog/content/generate.article
@@ -30,7 +30,7 @@
 
 Until now, that is.
 
-The [[http://blog.golang.org/go1.4][latest Go release]], 1.4,
+The [[https://blog.golang.org/go1.4][latest Go release]], 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.
@@ -94,7 +94,7 @@
 	$ go get golang.org/x/tools/cmd/stringer
 
 Here's an example from the documentation for
-[[http://godoc.org/golang.org/x/tools/cmd/stringer][`stringer`]].
+[[https://godoc.org/golang.org/x/tools/cmd/stringer][`stringer`]].
 Imagine we have some code that contains a set of integer constants defining different types of pills:
 
 	package painkiller
diff --git a/blog/content/gif-decoder-exercise-in-go-interfaces.article b/blog/content/gif-decoder-exercise-in-go-interfaces.article
index 032c17e..6e63817 100644
--- a/blog/content/gif-decoder-exercise-in-go-interfaces.article
+++ b/blog/content/gif-decoder-exercise-in-go-interfaces.article
@@ -82,7 +82,7 @@
 
 Lines 18-19 copy the data from `b.slice` to the caller's buffer. We are implementing `Read`, not `ReadFull`, so we are allowed to return fewer than the requested number of bytes.  That makes it easy: we just copy the data from `b.slice` to the caller's buffer (`p`), and the return value from copy is the number of bytes transferred.  Then we reslice `b.slice` to drop the first `n` bytes, ready for the next call.
 
-It's a nice technique in Go programming to couple a slice (`b.slice`) to an array (`b.tmp`).  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 [[http://blog.golang.org/2011/01/go-slices-usage-and-internals.html][this post from the Go Blog]].)
+It's a nice technique in Go programming to couple a slice (`b.slice`) to an array (`b.tmp`).  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 [[https://blog.golang.org/2011/01/go-slices-usage-and-internals.html][this post from the Go Blog]].)
 
 Given the `blockReader` type, we can unblock the image data stream just by wrapping the input reader, say a file, like this:
 
diff --git a/blog/content/go-at-google-io-2011-videos.article b/blog/content/go-at-google-io-2011-videos.article
index 173f40a..5e339f3 100644
--- a/blog/content/go-at-google-io-2011-videos.article
+++ b/blog/content/go-at-google-io-2011-videos.article
@@ -10,7 +10,7 @@
 
 * Writing Web Apps in Go
 
-In “[[http://www.youtube.com/watch?v=-i0hat7pdpk][Writing Web Apps in Go]]” we announce the [[http://blog.golang.org/2011/05/go-and-google-app-engine.html][Go runtime for Google App Engine]] and walk through the development and deployment of [[http://moustach-io.appspot.com/][Moustachio]], the first Go App Engine app.
+In “[[http://www.youtube.com/watch?v=-i0hat7pdpk][Writing Web Apps in Go]]” we announce the [[https://blog.golang.org/2011/05/go-and-google-app-engine.html][Go runtime for Google App Engine]] and walk through the development and deployment of [[http://moustach-io.appspot.com/][Moustachio]], the first Go App Engine app.
 
 .iframe //www.youtube.com/embed/-i0hat7pdpk 349 560
 
diff --git a/blog/content/go-at-heroku.article b/blog/content/go-at-heroku.article
index 9b415a1..b2785b7 100644
--- a/blog/content/go-at-heroku.article
+++ b/blog/content/go-at-heroku.article
@@ -14,7 +14,7 @@
 
 At Doozer's core is [[http://en.wikipedia.org/wiki/Paxos_(computer_science)][Paxos]], a family of protocols for solving consensus in an unreliable network of unreliable nodes. While Paxos is essential to running a fault-tolerant system, it is notorious for being difficult to implement. Even example implementations that can be found online are complex and hard to follow, despite being simplified for educational purposes. Existing production systems have a reputation for being worse.
 
-Fortunately, Go's concurrency primitives made the task much easier. Paxos is defined in terms of independent, 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 [[http://blog.golang.org/2010/07/share-memory-by-communicating.html][goroutines and channels]] 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 renowned for being difficult.
+Fortunately, Go's concurrency primitives made the task much easier. Paxos is defined in terms of independent, 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 [[https://blog.golang.org/2010/07/share-memory-by-communicating.html][goroutines and channels]] 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 renowned for being difficult.
 
 The standard packages in Go were another big win for Doozer. The Go team is very pragmatic about what goes into them. For instance, a package we quickly found useful was [[https://golang.org/pkg/websocket/][websocket]]. Once we had a working data store, we needed an easy way to introspect it and visualize activity. Using the websocket package, Keith was able to add the web viewer on his train ride home and without requiring external dependencies. This is a real testament to how well Go mixes systems and application programming.
 
diff --git a/blog/content/go-one-year-ago-today.article b/blog/content/go-one-year-ago-today.article
index 363bec7..041da76 100644
--- a/blog/content/go-one-year-ago-today.article
+++ b/blog/content/go-one-year-ago-today.article
@@ -18,20 +18,20 @@
 
 The standard library has grown by over 42,000 lines of code and includes 20 new [[https://golang.org/pkg/][packages]].  Among the additions are the [[https://golang.org/pkg/image/jpeg/][jpeg]], [[https://golang.org/pkg/rpc/jsonrpc/][jsonrpc]], [[https://golang.org/pkg/mime/][mime]], [[https://golang.org/pkg/netchan/][netchan]], and [[https://golang.org/pkg/smtp/][smtp]] packages, as well as a slew of new [[https://golang.org/pkg/crypto/][cryptography]] packages. More generally, the standard library has been continuously refined and revised as our understanding of Go’s idioms deepens.
 
-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 [[http://blog.golang.org/2010/11/debugging-go-code-status-report.html][ recent blog post]] for details.) 
+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 [[https://blog.golang.org/2010/11/debugging-go-code-status-report.html][ recent blog post]] for details.) 
 
 It’s now easier than ever to link against existing libraries written in languages other than Go.  Go support is in the most recent [[http://www.swig.org/][SWIG]] release, version 2.0.1, making it easier to link against C and C++ code, and our [[https://golang.org/cmd/cgo/][cgo]] tool has seen many fixes and improvements.
 
 [[https://golang.org/doc/gccgo_install.html][Gccgo]], the Go front end for the GNU C Compiler, has kept pace with the gc compiler as a parallel Go implementation. It now has a working garbage collector, and has been accepted into the GCC core.  We’re now working toward making [[http://code.google.com/p/gofrontend/][gofrontend]] available as a BSD-licensed Go compiler front end, fully decoupled from GCC.
 
-Outside the Go project itself Go is starting to be used to build real software. There are more than 200 Go programs and libraries listed on our [[http://godashboard.appspot.com/project][Project dashboard]], and hundreds more on [[http://code.google.com/hosting/search?q=label:Go][Google Code]] and [[https://github.com/search?q=language:Go][Github]]. On our mailing list and IRC channel you can find coders from around the world who use Go for their programming projects. (See our [[http://blog.golang.org/2010/10/real-go-projects-smarttwitter-and-webgo.html][guest blog post]] 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. We have also been in touch with several educators who are using Go as a teaching language.
+Outside the Go project itself Go is starting to be used to build real software. There are more than 200 Go programs and libraries listed on our [[http://godashboard.appspot.com/project][Project dashboard]], and hundreds more on [[http://code.google.com/hosting/search?q=label:Go][Google Code]] and [[https://github.com/search?q=language:Go][Github]]. On our mailing list and IRC channel you can find coders from around the world who use Go for their programming projects. (See our [[https://blog.golang.org/2010/10/real-go-projects-smarttwitter-and-webgo.html][guest blog post]] 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. We have also been in touch with several educators who are using Go as a teaching language.
 
 The language itself has grown and matured, too. In the past year we have received many feature requests. But Go is a small language, and we’ve worked hard to ensure that any new feature strikes the right compromise between simplicity and utility. Since the launch we have made a number of language changes, many of which were driven by feedback from the community.
 
 - Semicolons are now optional in almost all instances. [[https://golang.org/doc/go_spec.html#Semicolons][spec]]
 - The new built-in functions `copy` and `append` make management of slices more efficient and straightforward. [[https://golang.org/doc/go_spec.html#Appending_and_copying_slices][spec]]
 - The upper and lower bounds may be omitted when making a sub-slice. This means that `s[:]` is shorthand for `s[0:len(s)]`. [[https://golang.org/doc/go_spec.html#Slices][spec]]
-- The new built-in function `recover` complements `panic` and `defer` as an error handling mechanism.  [[http://blog.golang.org/2010/08/defer-panic-and-recover.html][blog]], [[https://golang.org/doc/go_spec.html#Handling_panics][spec]]
+- The new built-in function `recover` complements `panic` and `defer` as an error handling mechanism.  [[https://blog.golang.org/2010/08/defer-panic-and-recover.html][blog]], [[https://golang.org/doc/go_spec.html#Handling_panics][spec]]
 - The new complex number types (`complex`, `complex64`, and `complex128`) simplify certain mathematical operations. [[https://golang.org/doc/go_spec.html#Complex_numbers][spec]], [[https://golang.org/doc/go_spec.html#Imaginary_literals][spec]]
 - The composite literal syntax permits the omission of redundant type information (when specifying two-dimensional arrays, for example). [[https://golang.org/doc/devel/release.html#2010-10-27][release.2010-10-27]], [[https://golang.org/doc/go_spec.html#Composite_literals][spec]]
 - A general syntax for variable function arguments (`...T`) and their propagation (`v...`) is now specified. [[https://golang.org/doc/go_spec.html#Function_Types][spec]], [[https://golang.org/doc/go_spec.html#Passing_arguments_to_..._parameters][ spec]], [[https://golang.org/doc/devel/release.html#2010-09-29][release.2010-09-29]]
diff --git a/blog/content/go-programming-language-turns-two.article b/blog/content/go-programming-language-turns-two.article
index 888ec91..2e749bd 100644
--- a/blog/content/go-programming-language-turns-two.article
+++ b/blog/content/go-programming-language-turns-two.article
@@ -7,13 +7,13 @@
 * Introduction
 
 Two years ago a small team at Google went public with their fledgling project - the Go Programming Language. They presented a language spec, two compilers, a modest standard library, some novel tools, and plenty of accurate (albeit succinct) documentation. They watched with excitement as programmers around the world began to play with Go. The team continued to iterate and improve on what they had built, 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 [[https://golang.org/doc/docs.html][documentation]]. They celebrated a successful year in the public eye with a [[http://blog.golang.org/2010/11/go-one-year-ago-today.html][blog post]] 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 efficient in the context of high performance systems."
+The Go Authors went on to produce lots of libraries, new tools, and reams of [[https://golang.org/doc/docs.html][documentation]]. They celebrated a successful year in the public eye with a [[https://blog.golang.org/2010/11/go-one-year-ago-today.html][blog post]] 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 efficient in the context of high performance systems."
 
-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 [[http://blog.golang.org/2011/06/profiling-go-programs.html][profiling]] and [[http://blog.golang.org/2011/10/debugging-go-programs-with-gnu-debugger.html][debugging]] makes it easier to detect and remove performance issues in user code. Go is also now easier to learn with [[http://tour.golang.org/][A Tour of Go]], an interactive tutorial you can take from the comfort of your web browser.
+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 [[https://blog.golang.org/2011/06/profiling-go-programs.html][profiling]] and [[http://blog.golang.org/2011/10/debugging-go-programs-with-gnu-debugger.html][debugging]] makes it easier to detect and remove performance issues in user code. Go is also now easier to learn with [[http://tour.golang.org/][A Tour of Go]], an interactive tutorial you can take from the comfort of your web browser.
 
 This year we introduced the experimental [[http://code.google.com/appengine/docs/go/][Go runtime]] for Google's App Engine platform, and we have been steadily increasing the Go runtime's support for App Engine's APIs. Just this week we released [[http://code.google.com/appengine/downloads.html][version 1.6.0]] of the Go App Engine SDK, which includes support for [[http://code.google.com/appengine/docs/go/backends/overview.html][backends]] (long-running processes), finer control over datastore indexes, and various other improvements. Today, the Go runtime is near feature parity with - and is a viable alternative to - the Python and Java runtimes. In fact, we now serve [[https://golang.org/][golang.org]] by running a version of [[https://golang.org/cmd/godoc/][godoc]] on the App Engine service.
 
-While 2010 was a year of discovery and experimentation, 2011 was a year of fine tuning and planning for the future. This year we issued several "[[https://golang.org/doc/devel/release.html][release]]" versions of Go that were more reliable and better supported than weekly snapshots. We also introduced [[https://golang.org/cmd/gofix/][gofix]] to take the pain out of migrating to newer releases. Furthermore, last month we announced a [[http://blog.golang.org/2011/10/preview-of-go-version-1.html][plan for Go version 1]] - 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 [[http://weekly.golang.org/pkg/][weekly.golang.org]].
+While 2010 was a year of discovery and experimentation, 2011 was a year of fine tuning and planning for the future. This year we issued several "[[https://golang.org/doc/devel/release.html][release]]" versions of Go that were more reliable and better supported than weekly snapshots. We also introduced [[https://golang.org/cmd/gofix/][gofix]] to take the pain out of migrating to newer releases. Furthermore, last month we announced a [[https://blog.golang.org/2011/10/preview-of-go-version-1.html][plan for Go version 1]] - 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 [[http://weekly.golang.org/pkg/][weekly.golang.org]].
 
 The plan is to launch Go 1 in early 2012. We hope to bring the Go App Engine runtime out of "experimental" status at the same time.
 
diff --git a/blog/content/go-turns-three.article b/blog/content/go-turns-three.article
index 7f75109..89ca9eb 100644
--- a/blog/content/go-turns-three.article
+++ b/blog/content/go-turns-three.article
@@ -24,13 +24,13 @@
 which eventually became the
 [[https://golang.org/cmd/go/][go command]].
 We also added
-[[http://blog.golang.org/2011/07/go-for-app-engine-is-now-generally.html][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]].
 Over the past year we've also given [[https://golang.org/doc/#talks][many talks]], created an [[http://tour.golang.org/][interactive introductory tour]]
 and recently we added support for [[https://golang.org/pkg/strings/#pkg-examples][executable examples in package documentation]].
 
 Perhaps the most important development in the past year
 was the launch of the first stable version,
-[[http://blog.golang.org/2012/03/go-version-1-is-released.html][Go 1]].
+[[https://blog.golang.org/2012/03/go-version-1-is-released.html][Go 1]].
 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.
@@ -55,7 +55,7 @@
 [[https://golang.org/][Go home page]]
 on [[https://developers.google.com/appengine/docs/go/overview][App Engine]].
 Last year's
-[[http://blog.golang.org/2011/12/from-zero-to-go-launching-on-google.html][Thanksgiving Doodle]]
+[[https://blog.golang.org/2011/12/from-zero-to-go-launching-on-google.html][Thanksgiving Doodle]]
 and the recent
 [[http://www.jamwithchrome.com/technology][Jam with Chrome]]
 site are also served by Go programs.
@@ -64,11 +64,11 @@
 [[http://www.quora.com/Go-programming-language/Is-Google-Go-ready-for-production-use/answer/Kunal-Anand][BBC Worldwide]],
 [[http://dave.cheney.net/wp-content/uploads/2012/08/august-go-meetup.pdf][Canonical]],
 [[http://blog.cloudflare.com/go-at-cloudflare][CloudFlare]],
-[[http://blog.golang.org/2011/04/go-at-heroku.html][Heroku]],
+[[https://blog.golang.org/2011/04/go-at-heroku.html][Heroku]],
 [[https://plus.google.com/114945221884326152379/posts/d1SVaqkRyTL][Novartis]],
 [[http://backstage.soundcloud.com/2012/07/go-at-soundcloud/][SoundCloud]],
 [[http://sorcery.smugmug.com/2012/04/06/deriving-json-types-in-go/][SmugMug]],
-[[http://blog.golang.org/2011/12/building-stathat-with-go.html][StatHat]],
+[[https://blog.golang.org/2011/12/building-stathat-with-go.html][StatHat]],
 [[https://tinkercad.com/about/jobs][Tinkercad]],
 and
 [[https://golang.org/wiki/GoUsers][many others]].
diff --git a/blog/content/go1.3.article b/blog/content/go1.3.article
index b02c3ad..af191aa 100644
--- a/blog/content/go1.3.article
+++ b/blog/content/go1.3.article
@@ -14,7 +14,7 @@
 [[https://golang.org/doc/go1.3][release notes]].
 What follows are some highlights.
 
-[[http://godoc.org/code.google.com/p/go.tools/cmd/godoc][Godoc]],
+[[https://godoc.org/code.google.com/p/go.tools/cmd/godoc][Godoc]],
 the Go documentation server, now performs static analysis.
 When enabled with the -analysis flag, analysis results are presented
 in both the source and package documentation views, making it easier
@@ -24,7 +24,7 @@
 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
-[[http://blog.golang.org/playground][Playground]].
+[[https://blog.golang.org/playground][Playground]].
 To set up NaCl on your system see the [[https://golang.org/wiki/NativeClient][NativeClient wiki page]].
 
 Also included in this release is experimental support for the DragonFly BSD,
diff --git a/blog/content/go12.article b/blog/content/go12.article
index 1161c15..2516a77 100644
--- a/blog/content/go12.article
+++ b/blog/content/go12.article
@@ -36,7 +36,7 @@
 A major new feature of the tool chain is the facility to compute and display
 [[https://golang.org/doc/go1.2#cover][test coverage results]].
 See the [[https://golang.org/cmd/go/#hdr-Description_of_testing_flags][`go`test`]]
-and [[http://godoc.org/code.google.com/p/go.tools/cmd/cover/][cover tool]]
+and [[https://godoc.org/code.google.com/p/go.tools/cmd/cover/][cover tool]]
 documentation for details. Later this week we will publish an article that
 discusses this new feature in detail.
 
diff --git a/blog/content/gopher.article b/blog/content/gopher.article
index a72b265..d21e32f 100644
--- a/blog/content/gopher.article
+++ b/blog/content/gopher.article
@@ -16,7 +16,7 @@
 
 .image gopher/wfmu.jpg
 
-The gopher next made an appearance at Bell Labs, as Bob Flandrena's [[http://research.swtch.com/face][avatar]] in the Bell Labs mail system. Other Renee drawings became avatars for ken, r, rsc, and others. (Of course, Peter Weinberger's was his own [[http://spinroot.com/pico/pjw.html][iconic face]].)
+The gopher next made an appearance at Bell Labs, as Bob Flandrena's [[https://research.swtch.com/face][avatar]] in the Bell Labs mail system. Other Renee drawings became avatars for ken, r, rsc, and others. (Of course, Peter Weinberger's was his own [[http://spinroot.com/pico/pjw.html][iconic face]].)
 
 .image gopher/avatars.png
 
diff --git a/blog/content/gophercon.article b/blog/content/gophercon.article
index ee1911f..4777b78 100644
--- a/blog/content/gophercon.article
+++ b/blog/content/gophercon.article
@@ -19,8 +19,8 @@
 
 Two keynotes framed the conference:
 
-- Rob Pike's opening talk [[https://www.youtube.com/watch?v=VoS7DsT1rdM]["Hello, Gophers!"]] ([[http://talks.golang.org/2014/hellogophers.slide][slides]]) discusses the history of Go by walking through two of the first Go programs.
-- Andrew Gerrand's closing talk [[https://www.youtube.com/watch?v=dKGmK_Z1Zl0]["Go for gophers"]] ([[http://talks.golang.org/2014/go4gophers.slide][slides]]) explains the Go design philosophy through the lens of his personal experience learning the language.
+- Rob Pike's opening talk [[https://www.youtube.com/watch?v=VoS7DsT1rdM]["Hello, Gophers!"]] ([[https://talks.golang.org/2014/hellogophers.slide][slides]]) discusses the history of Go by walking through two of the first Go programs.
+- Andrew Gerrand's closing talk [[https://www.youtube.com/watch?v=dKGmK_Z1Zl0]["Go for gophers"]] ([[https://talks.golang.org/2014/go4gophers.slide][slides]]) explains the Go design philosophy through the lens of his personal experience learning the language.
 
 One talk that resonated with members of the Go team was Peter Bourgon's
 [[https://www.youtube.com/watch?v=Y1-RLAl7iOI]["Best practices for Production Environments"]]
diff --git a/blog/content/gophercon2015.article b/blog/content/gophercon2015.article
index b5cf676..c25bd3b 100644
--- a/blog/content/gophercon2015.article
+++ b/blog/content/gophercon2015.article
@@ -20,12 +20,12 @@
 
 [[http://gophercon.com/schedule/8july/][Day 1]]:
 
-- Go, Open Source, Community — Russ Cox ([[https://www.youtube.com/watch?v=XvZOdpd_9tc][video]]) ([[http://blog.golang.org/open-source][text]])
+- Go, Open Source, Community — Russ Cox ([[https://www.youtube.com/watch?v=XvZOdpd_9tc][video]]) ([[https://blog.golang.org/open-source][text]])
 - Go kit: A Standard Library for Distributed Programming — Peter Bourgon ([[https://www.youtube.com/watch?v=1AjaZi4QuGo][video]]) ([[https://github.com/gophercon/2015-talks/blob/master/Go%20kit/go-kit.pdf][slides]])
 - Delve Into Go — Derek Parker ([[https://www.youtube.com/watch?v=InG72scKPd4][video]]) ([[http://go-talks.appspot.com/github.com/derekparker/talks/gophercon-2015/delve-into-go.slide][slides]])
 - How a complete beginner learned Go as her first backend language in 5 weeks — Audrey Lim ([[https://www.youtube.com/watch?v=fZh8uCInEfw][video]]) ([[https://github.com/gophercon/2015-talks/blob/master/Audrey%20Lim%20-%20How%20a%20Complete%20Beginner%20Picked%20Up%20Go%20as%20Her%20First%20Backend%20Language%20in%205%20weeks/audreylim_slides.pdf][slides]])
 - A Practical Guide to Preventing Deadlocks and Leaks in Go — Richard Fliam ([[https://www.youtube.com/watch?v=3EW1hZ8DVyw][video]])
-- Go GC: Solving the Latency Problem — Rick Hudson ([[https://www.youtube.com/watch?v=aiv1JOfMjm0][video]]) ([[http://talks.golang.org/2015/go-gc.pdf][slides]])
+- Go GC: Solving the Latency Problem — Rick Hudson ([[https://www.youtube.com/watch?v=aiv1JOfMjm0][video]]) ([[https://talks.golang.org/2015/go-gc.pdf][slides]])
 - Simplicity and Go — Katherine Cox-Buday ([[https://www.youtube.com/watch?v=S6mEo_FHZ5Y][video]]) ([[https://github.com/gophercon/2015-talks/blob/master/Katherine%20Cox-Buday:%20Simplicity%20%26%20Go/Simplicity%20%26%20Go.pdf][slides]])
 - Rebuilding Parse.com in Go - an opinionated rewrite — Abhishek Kona ([[https://www.youtube.com/watch?v=_f9LS-OWfeA][video]]) ([[https://github.com/gophercon/2015-talks/blob/master/Abhishek%20Kona%20Rewriting%20Parse%20in%20GO/myslides.pdf][slides]])
 - Prometheus: Designing and Implementing a Modern Monitoring Solution in Go — Björn Rabenstein ([[https://www.youtube.com/watch?v=1V7eJ0jN8-E][video]]) ([[https://github.com/gophercon/2015-talks/blob/master/Bj%C3%B6rn%20Rabenstein%20-%20Prometheus/slides.pdf][slides]])
@@ -34,17 +34,17 @@
 
 [[http://gophercon.com/schedule/9july/][Day 2]]:
 
-- The Evolution of Go — Robert Griesemer ([[https://www.youtube.com/watch?v=0ReKdcpNyQg][video]]) ([[http://talks.golang.org/2015/gophercon-goevolution.slide][slides]])
+- The Evolution of Go — Robert Griesemer ([[https://www.youtube.com/watch?v=0ReKdcpNyQg][video]]) ([[https://talks.golang.org/2015/gophercon-goevolution.slide][slides]])
 - Static Code Analysis Using SSA — Ben Johnson ([[https://www.youtube.com/watch?v=D2-gaMvWfQY][video]]) ([[https://speakerdeck.com/benbjohnson/static-code-analysis-using-ssa][slides]])
-- Go on Mobile — Hana Kim ([[https://www.youtube.com/watch?v=sQ6-HyPxHKg][video]]) ([[http://talks.golang.org/2015/gophercon-go-on-mobile.slide][slides]])
-- Go Dynamic Tools — Dmitry Vyukov ([[https://www.youtube.com/watch?v=a9xrxRsIbSU][video]]) ([[http://talks.golang.org/2015/dynamic-tools.slide][slides]])
+- Go on Mobile — Hana Kim ([[https://www.youtube.com/watch?v=sQ6-HyPxHKg][video]]) ([[https://talks.golang.org/2015/gophercon-go-on-mobile.slide][slides]])
+- Go Dynamic Tools — Dmitry Vyukov ([[https://www.youtube.com/watch?v=a9xrxRsIbSU][video]]) ([[https://talks.golang.org/2015/dynamic-tools.slide][slides]])
 - Embrace the Interface — Tomás Senart ([[https://www.youtube.com/watch?v=xyDkyFjzFVc][video]]) ([[https://github.com/gophercon/2015-talks/blob/master/Tom%C3%A1s%20Senart%20-%20Embrace%20the%20Interface/ETI.pdf][slides]])
 - Uptime: Building Resilient Services with Go — Blake Caldwell ([[https://www.youtube.com/watch?v=PyBJQA4clfc][video]]) ([[https://github.com/gophercon/2015-talks/blob/master/Blake%20Caldwell%20-%20Uptime:%20Building%20Resilient%20Services%20with%20Go/2015-GopherCon-Talk-Uptime.pdf][slides]])
 - Cayley: Building a Graph Database — Barak Michener ([[https://www.youtube.com/watch?v=-9kWbPmSyCI][video]]) ([[https://github.com/gophercon/2015-talks/blob/master/Barak%20Michener%20-%20Cayley:%20Building%20a%20Graph%20Database/Cayley%20-%20Building%20a%20Graph%20Database.pdf][slides]])
 - Code Generation For The Sake Of Consistency — Sarah Adams ([[https://www.youtube.com/watch?v=kGAgHwfjg1s][video]])
 - The Many Faces of Struct Tags — Sam Helman and Kyle Erf ([[https://www.youtube.com/watch?v=_SCRvMunkdA][video]]) ([[https://github.com/gophercon/2015-talks/blob/master/Sam%20Helman%20%26%20Kyle%20Erf%20-%20The%20Many%20Faces%20of%20Struct%20Tags/StructTags.pdf][slides]])
 - Betting the Company on Go and Winning — Kelsey Hightower ([[https://www.youtube.com/watch?v=wqVbLlHqAeY][video]])
-- How Go Was Made — Andrew Gerrand ([[https://www.youtube.com/watch?v=0ht89TxZZnk][video]]) ([[http://talks.golang.org/2015/how-go-was-made.slide][slides]])
+- How Go Was Made — Andrew Gerrand ([[https://www.youtube.com/watch?v=0ht89TxZZnk][video]]) ([[https://talks.golang.org/2015/how-go-was-made.slide][slides]])
 
 The [[http://gophercon.com/schedule/10july/][hack day]] was also a ton of fun,
 with hours of [[https://www.youtube.com/playlist?list=PL2ntRZ1ySWBeHqlHM8DmvS8axgbrpvF9b][lightning talks]] and a range of activities from programming robots
diff --git a/blog/content/introducing-gofix.article b/blog/content/introducing-gofix.article
index 98b7b80..5b42b5b 100644
--- a/blog/content/introducing-gofix.article
+++ b/blog/content/introducing-gofix.article
@@ -6,7 +6,7 @@
 
 * Introduction
 
-The next Go release will include significant API changes in several fundamental Go packages. Code that [[http://codereview.appspot.com/4239076][implements an HTTP server handler]], [[http://codereview.appspot.com/4244055][calls `net.Dial`]], [[http://codereview.appspot.com/4357052][calls `os.Open`]], or [[http://codereview.appspot.com/4281055][uses the reflect package]] will not build unless it is updated to use the new APIs. Now that our releases are [[http://blog.golang.org/2011/03/go-becomes-more-stable.html][more stable and less frequent]], 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; together, however, they represent a significant amount of manual effort to update existing code.
+The next Go release will include significant API changes in several fundamental Go packages. Code that [[http://codereview.appspot.com/4239076][implements an HTTP server handler]], [[http://codereview.appspot.com/4244055][calls `net.Dial`]], [[http://codereview.appspot.com/4357052][calls `os.Open`]], or [[http://codereview.appspot.com/4281055][uses the reflect package]] will not build unless it is updated to use the new APIs. Now that our releases are [[https://blog.golang.org/2011/03/go-becomes-more-stable.html][more stable and less frequent]], 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; together, however, they represent a significant amount of manual effort to update existing code.
 
 [[https://golang.org/cmd/fix/][Gofix]] is a new tool that reduces the amount of effort it takes to update existing code. It reads a program from a source file, looks for uses of old APIs, rewrites them to use the current API, and writes the program back to the file. Not all API changes preserve all the functionality of an old API, so gofix cannot always do a perfect job. When gofix cannot rewrite a use of an old API, it prints a warning giving the file name and line number of the use, so that a developer can examine and rewrite the code. Gofix takes care of the easy, repetitive, tedious changes, so that a developer can focus on the ones that truly merit attention.
 
diff --git a/blog/content/laws-of-reflection.article b/blog/content/laws-of-reflection.article
index 0b87ad8..103ae73 100644
--- a/blog/content/laws-of-reflection.article
+++ b/blog/content/laws-of-reflection.article
@@ -57,7 +57,7 @@
 
 * The representation of an interface
 
-Russ Cox has written a [[http://research.swtch.com/2009/12/go-data-structures-interfaces.html][ detailed blog post]] about the representation of interface values in Go. It's not necessary to repeat the full story here, but a simplified summary is in order.
+Russ Cox has written a [[https://research.swtch.com/2009/12/go-data-structures-interfaces.html][ detailed blog post]] about the representation of interface values in Go. It's not necessary to repeat the full story here, but a simplified summary is in order.
 
 A variable of interface type stores a pair: the concrete value assigned to the variable, and that value's type descriptor. To be more precise, the value is the underlying concrete data item that implements the interface and the type describes the full type of that item. For instance, after
 
diff --git a/blog/content/normalization.article b/blog/content/normalization.article
index 1763fcb..fd80e9c 100644
--- a/blog/content/normalization.article
+++ b/blog/content/normalization.article
@@ -6,13 +6,13 @@
 
 * Introduction
 
-An earlier [[http://blog.golang.org/strings][post]] talked about strings, bytes
+An earlier [[https://blog.golang.org/strings][post]] 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
-[[http://godoc.org/code.google.com/p/go.text/unicode/norm][go.text/unicode/norm]],
+[[https://godoc.org/code.google.com/p/go.text/unicode/norm][go.text/unicode/norm]],
 which handles normalization, a topic touched in the
-[[http://blog.golang.org/strings][strings article]] and the subject of this
+[[https://blog.golang.org/strings][strings article]] 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
@@ -51,7 +51,7 @@
 As mentioned in the strings blog post, Go does not guarantee that characters in
 a string are normalized. However, the go.text packages can compensate. For
 example, the
-[[http://godoc.org/code.google.com/p/go.text/collate][collate]] package, which
+[[https://godoc.org/code.google.com/p/go.text/collate][collate]] package, which
 can sort strings in a language-specific way, works correctly even with
 unnormalized strings. The packages in go.text do not always require normalized
 input, but in general normalization may be necessary for consistent results.
@@ -129,7 +129,7 @@
 in and output your text as NFC like the rest of the world.
 
 To write your text as NFC, use the
-[[http://godoc.org/code.google.com/p/go.text/unicode/norm][unicode/norm]] package
+[[https://godoc.org/code.google.com/p/go.text/unicode/norm][unicode/norm]] package
 to wrap your `io.Writer` of choice:
 
 	wc := norm.NFC.Writer(w)
@@ -206,7 +206,7 @@
 
 Another tool provided by the norm package that may help dealing with character
 boundaries is its iterator,
-[[http://godoc.org/code.google.com/p/go.text/unicode/norm#Iter][`norm.Iter`]].
+[[https://godoc.org/code.google.com/p/go.text/unicode/norm#Iter][`norm.Iter`]].
 It iterates over characters one at a time in the normal form of choice.
 
 * Performing magic
@@ -246,7 +246,7 @@
 to minimize the need for normalization at run time. The type `norm.Properties`
 provides access to the per-rune information needed by these packages, most
 notably the Canonical Combining Class and decomposition information. Read the
-[[http://godoc.org/code.google.com/p/go.text/unicode/norm/#Properties][documentation]]
+[[https://godoc.org/code.google.com/p/go.text/unicode/norm/#Properties][documentation]]
 for this type if you want to dig deeper.
 
 * Performance
diff --git a/blog/content/osconreport.article b/blog/content/osconreport.article
index 3937ade..70b6fab 100644
--- a/blog/content/osconreport.article
+++ b/blog/content/osconreport.article
@@ -30,7 +30,7 @@
 [[https://talks.golang.org/2014/hammers.slide#1][Gophers with hammers]],
 and [[http://twitter.com/francesc][Francesc Campoy]] talked about all the things
 that could have gone wrong and what the Go team did to prevent them
-[[http://talks.golang.org/2014/playground.slide][Inside the Go playground]].
+[[https://talks.golang.org/2014/playground.slide][Inside the Go playground]].
 
 * Workshops
 
@@ -55,7 +55,7 @@
 .image osconreport/meetup.png _ 800
 
 At the meetup Francesc Campoy talked about
-[[http://talks.golang.org/2013/bestpractices.slide][Go Best Practices]] and
+[[https://talks.golang.org/2013/bestpractices.slide][Go Best Practices]] and
 [[https://twitter.com/kelseyhightower][Kelsey Hightower]] gave a great
 introduction to [[https://github.com/GoogleCloudPlatform/kubernetes][Kubernetes]],
 a container management system for clusters written in Go by Google. If you live
diff --git a/blog/content/pipelines.article b/blog/content/pipelines.article
index 260cccf..febc0c4 100644
--- a/blog/content/pipelines.article
+++ b/blog/content/pipelines.article
@@ -307,6 +307,6 @@
 
 Further reading:
 
-- [[http://talks.golang.org/2012/concurrency.slide#1][Go Concurrency Patterns]] ([[https://www.youtube.com/watch?v=f6kdp27TYZs][video]]) presents the basics of Go's concurrency primitives and several ways to apply them.
-- [[http://blog.golang.org/advanced-go-concurrency-patterns][Advanced Go Concurrency Patterns]] ([[http://www.youtube.com/watch?v=QDDwwePbDtw][video]]) covers more complex uses of Go's primitives, especially `select`.
-- Douglas McIlroy's paper [[http://swtch.com/~rsc/thread/squint.pdf][Squinting at Power Series]] shows how Go-like concurrency provides elegant support for complex calculations.
+- [[https://talks.golang.org/2012/concurrency.slide#1][Go Concurrency Patterns]] ([[https://www.youtube.com/watch?v=f6kdp27TYZs][video]]) presents the basics of Go's concurrency primitives and several ways to apply them.
+- [[https://blog.golang.org/advanced-go-concurrency-patterns][Advanced Go Concurrency Patterns]] ([[http://www.youtube.com/watch?v=QDDwwePbDtw][video]]) covers more complex uses of Go's primitives, especially `select`.
+- Douglas McIlroy's paper [[https://swtch.com/~rsc/thread/squint.pdf][Squinting at Power Series]] shows how Go-like concurrency provides elegant support for complex calculations.
diff --git a/blog/content/share-memory-by-communicating.article b/blog/content/share-memory-by-communicating.article
index 5eaa278..2d9e77a 100644
--- a/blog/content/share-memory-by-communicating.article
+++ b/blog/content/share-memory-by-communicating.article
@@ -8,7 +8,7 @@
 
 Traditional threading models (commonly used when writing Java, C++, and Python programs, for example) require the programmer to communicate between threads using shared memory. Typically, shared data structures are protected by locks, and threads will contend over those locks to access the data. In some cases, this is made easier by the use of thread-safe data structures such as Python's Queue.
 
-Go's concurrency primitives - goroutines and channels - provide an elegant and distinct means of structuring concurrent software. (These concepts have an [[http://swtch.com/~rsc/thread/][interesting history]] that begins with C. A. R. Hoare's [[http://www.usingcsp.com/][Communicating Sequential Processes]].) Instead of explicitly using locks to mediate access to shared data, Go encourages the use of channels to pass references to data between goroutines. This approach ensures that only one goroutine has access to the data at a given time. The concept is summarized in the document [[https://golang.org/doc/effective_go.html][Effective Go]] (a must-read for any Go programmer):
+Go's concurrency primitives - goroutines and channels - provide an elegant and distinct means of structuring concurrent software. (These concepts have an [[https://swtch.com/~rsc/thread/][interesting history]] that begins with C. A. R. Hoare's [[http://www.usingcsp.com/][Communicating Sequential Processes]].) Instead of explicitly using locks to mediate access to shared data, Go encourages the use of channels to pass references to data between goroutines. This approach ensures that only one goroutine has access to the data at a given time. The concept is summarized in the document [[https://golang.org/doc/effective_go.html][Effective Go]] (a must-read for any Go programmer):
 
 _Do_not_communicate_by_sharing_memory;_instead,_share_memory_by_communicating._
 
diff --git a/blog/content/slices.article b/blog/content/slices.article
index c11ddd1..015d56f 100644
--- a/blog/content/slices.article
+++ b/blog/content/slices.article
@@ -549,7 +549,7 @@
 the benchmarks saw huge speedups as a result.
 
 There's much more to strings, of course, and a
-[[http://blog.golang.org/strings][separate blog post]] covers them in greater depth.
+[[https://blog.golang.org/strings][separate blog post]] covers them in greater depth.
 
 * Conclusion
 
@@ -569,9 +569,9 @@
 As mentioned earlier,
 the [[https://golang.org/wiki/SliceTricks]["Slice Tricks" Wiki page]]
 has many examples.
-The [[http://blog.golang.org/go-slices-usage-and-internals][Go Slices]] blog post
+The [[https://blog.golang.org/go-slices-usage-and-internals][Go Slices]] blog post
 describes the memory layout details with clear diagrams.
-Russ Cox's [[http://research.swtch.com/godata][Go Data Structures]] article includes
+Russ Cox's [[https://research.swtch.com/godata][Go Data Structures]] article includes
 a discussion of slices along with some of Go's other internal data structures.
 
 There is much more material available, but the best way to learn about slices is to use them.
diff --git a/blog/content/strings.article b/blog/content/strings.article
index 104540c..be58013 100644
--- a/blog/content/strings.article
+++ b/blog/content/strings.article
@@ -6,7 +6,7 @@
 
 * Introduction
 
-The [[http://blog.golang.org/slices][previous blog post]] explained how slices
+The [[https://blog.golang.org/slices][previous blog post]] 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.
@@ -34,7 +34,7 @@
 
 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 [[http://blog.golang.org/slices][previous blog post]];
+please read the [[https://blog.golang.org/slices][previous blog post]];
 we'll assume here that you have.
 
 It's important to state right up front that a string holds _arbitrary_ bytes.
diff --git a/blog/content/the-path-to-go-1.article b/blog/content/the-path-to-go-1.article
index 352ce24..345cf93 100644
--- a/blog/content/the-path-to-go-1.article
+++ b/blog/content/the-path-to-go-1.article
@@ -10,6 +10,6 @@
 
 .iframe //www.youtube.com/embed/bj9T2c2Xk_s 309 550
 
-The slides for the talk are [[http://talks.golang.org/2012/go1.slide][available here]].
+The slides for the talk are [[https://talks.golang.org/2012/go1.slide][available here]].
 
 It's almost a year since we cut Go 1.0 and we are now busy preparing Go 1.1. The release will include performance improvements to the gc compiler, garbage collector, and goroutine scheduler, some standard library additions, and many bug fixes and other improvements. Stay tuned, as we hope to release Go 1.1 in the coming weeks.
diff --git a/blog/content/two-recent-go-articles.article b/blog/content/two-recent-go-articles.article
index 63aeb01..c006fe8 100644
--- a/blog/content/two-recent-go-articles.article
+++ b/blog/content/two-recent-go-articles.article
@@ -10,7 +10,7 @@
 
 * Go at Google
 
-In October last year, Rob Pike presented a keynote at the ACM [[http://splashcon.org/2012/][SPLASH]] conference in Tucson. The talk, titled [[http://talks.golang.org/2012/splash.slide][Go at Google]], was a comprehensive discussion of the motivations behind Go. Rob later expanded on his talk to produce an essay titled [[http://talks.golang.org/2012/splash.article][Go at Google: Language Design in the Service of Software Engineering]]. Here is the abstract:
+In October last year, Rob Pike presented a keynote at the ACM [[http://splashcon.org/2012/][SPLASH]] conference in Tucson. The talk, titled [[https://talks.golang.org/2012/splash.slide][Go at Google]], was a comprehensive discussion of the motivations behind Go. Rob later expanded on his talk to produce an essay titled [[http://talks.golang.org/2012/splash.article][Go at Google: Language Design in the Service of Software Engineering]]. Here is the abstract:
 
 	The Go programming language was conceived in late 2007 as an
 	answer to some of the problems we were seeing developing
@@ -37,7 +37,7 @@
 
 This article explains how these issues were addressed while building an efficient, compiled programming language that feels lightweight and pleasant. Examples and explanations will be taken from the real-world problems faced at Google.
 
-If you have wondered about the design decisions behind Go, you may find your questions answered by [[http://talks.golang.org/2012/splash.article][the essay]]. It is recommended reading for both new and experienced Go programmers.
+If you have wondered about the design decisions behind Go, you may find your questions answered by [[https://talks.golang.org/2012/splash.article][the essay]]. It is recommended reading for both new and experienced Go programmers.
 
 * Go at the Google Developers Academy
 
diff --git a/blog/content/two-recent-go-talks.article b/blog/content/two-recent-go-talks.article
index bf62410..8e72336 100644
--- a/blog/content/two-recent-go-talks.article
+++ b/blog/content/two-recent-go-talks.article
@@ -18,7 +18,7 @@
 
 .iframe //player.vimeo.com/video/53221558?badge=0 281 500
 
-See the [[http://talks.golang.org/2012/simple.slide][slide deck]] (use the left and right arrows to navigate).
+See the [[https://talks.golang.org/2012/simple.slide][slide deck]] (use the left and right arrows to navigate).
 
 * Go: code that grows with grace
 
@@ -26,4 +26,4 @@
 
 .iframe //player.vimeo.com/video/53221560?badge=0 281 500
 
-See the [[http://talks.golang.org/2012/chat.slide][slide deck]] (use the left and right arrows to navigate).
+See the [[https://talks.golang.org/2012/chat.slide][slide deck]] (use the left and right arrows to navigate).
diff --git a/blog/content/writing-scalable-app-engine.article b/blog/content/writing-scalable-app-engine.article
index d260f35..cf020d2 100644
--- a/blog/content/writing-scalable-app-engine.article
+++ b/blog/content/writing-scalable-app-engine.article
@@ -6,10 +6,10 @@
 
 * Introduction
 
-Back in May, we [[http://blog.golang.org/2011/05/go-and-google-app-engine.html][announced]] the Go runtime for App Engine. Since then, we've opened it up for everyone to use, added many new APIs, and improved performance. We have been thrilled by all the interesting ways that people are using Go on App Engine.
+Back in May, we [[https://blog.golang.org/2011/05/go-and-google-app-engine.html][announced]] the Go runtime for App Engine. Since then, we've opened it up for everyone to use, added many new APIs, and improved performance. We have been thrilled by all the interesting ways that people are using Go on App Engine.
 One of the key benefits of the Go runtime, apart from working in a fantastic language, is that it has high performance. Go applications compile to native code, with no interpreter or virtual machine getting between your program and the machine.
 
-Making your web application fast is important because it is well known that a web site's latency has a measurable impact on user happiness, and [[http://googlewebmastercentral.blogspot.com/2010/04/using-site-speed-in-web-search-ranking.html][Google web search uses it as a ranking factor]]. Also announced in May was that App Engine would be [[http://googleappengine.blogspot.com/2011/05/year-ahead-for-google-app-engine.html][leaving its Preview status]] and transitioning to a [[http://www.google.com/enterprise/cloud/appengine/pricing.html][new pricing model]], providing another reason to write efficient App Engine applications.
+Making your web application fast is important because it is well known that a web site's latency has a measurable impact on user happiness, and [[https://googlewebmastercentral.blogspot.com/2010/04/using-site-speed-in-web-search-ranking.html][Google web search uses it as a ranking factor]]. Also announced in May was that App Engine would be [[http://googleappengine.blogspot.com/2011/05/year-ahead-for-google-app-engine.html][leaving its Preview status]] and transitioning to a [[https://www.google.com/enterprise/cloud/appengine/pricing.html][new pricing model]], providing another reason to write efficient App Engine applications.
 
 To make it easier for Go developers using App Engine to write highly efficient, scalable applications, we recently updated some existing App Engine articles to include snippets of Go source code and to link to relevant Go documentation.