diff --git a/blog/content/4years.article b/blog/content/4years.article
index 4c99dbb..8d49283 100644
--- a/blog/content/4years.article
+++ b/blog/content/4years.article
@@ -28,7 +28,7 @@
 
 But where is the interest coming from?
 
-The open source community has embraced Go, with our community wiki listing [[http://golang.org/wiki/Projects][hundreds of Go projects]]. Some popular ones:
+The open source community has embraced Go, with our community wiki listing [[https://golang.org/wiki/Projects][hundreds of Go projects]]. Some popular ones:
 
 - [[http://docker.io][Docker]] is a tool for packaging and running applications in lightweight containers. Docker makes it easy to isolate, package, and deploy applications, and is beloved by system administrators. Its creator Solomon Hykes cited Go's standard library, concurrency primitives, and ease of deployment as key factors, and said "To put it simply, if Docker had not been written in Go, it would not have been as successful."
 
@@ -44,7 +44,7 @@
 
 But this is just the tip of the iceberg. The number of high-quality open source Go projects is phenomenal. Prolific Go hacker [[http://xph.us/software/][Keith Rarick]] put it well: "The state of the Go ecosystem after only four years is astounding. Compare Go in 2013 to Python in 1995 or Java in 1999. Or C++ in 1987!"
 
-Businesses are enjoying Go, too. The [[http://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:
+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." 
 
@@ -64,7 +64,7 @@
 
 - [[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]]!
 
-- Create or contribute to an open source Go project (or [[http://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]].)
+- 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]].)
 
 - If you're in Europe in February 2014, come along to the [[https://code.google.com/p/go-wiki/wiki/Fosdem2014][Go Devroom]] at [[https://fosdem.org/2014/][FOSDEM 2014]].
 
diff --git a/blog/content/5years.article b/blog/content/5years.article
index 42a2fa5..4c86432 100644
--- a/blog/content/5years.article
+++ b/blog/content/5years.article
@@ -60,7 +60,7 @@
 _More_than_1,200_gophers_attended_GopherCon_in_Denver_and_dotGo_in_Paris._
 
 There are also dozens of community-run
-[[http://golang.org/wiki/GoUserGroups][Go User Groups]] spread across cities
+[[https://golang.org/wiki/GoUserGroups][Go User Groups]] 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
 [[https://blog.golang.org/getthee-to-go-meetup][start one]]?
diff --git a/blog/content/appengine-dec2013.article b/blog/content/appengine-dec2013.article
index db2e5de..02cee48 100644
--- a/blog/content/appengine-dec2013.article
+++ b/blog/content/appengine-dec2013.article
@@ -12,8 +12,8 @@
 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,
-including the [[http://golang.org/cmd/go/][go tool]] and a
-[[http://golang.org/doc/code.html][convention]] for organizing Go programs.
+including the [[https://golang.org/cmd/go/][go tool]] and a
+[[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]]
@@ -30,7 +30,7 @@
 version of the "go" tool. The new name permits users to keep both the regular
 "go" tool and the "goapp" tool in their system PATH.
 
-In addition to the existing "go" tool [[http://golang.org/cmd/go/][commands]],
+In addition to the existing "go" tool [[https://golang.org/cmd/go/][commands]],
 the "goapp" tool provides new commands for working with App Engine apps.
 The "[[https://developers.google.com/appengine/docs/go/tools/devserver][goapp serve]]"
 command starts the local development server and the
@@ -64,7 +64,7 @@
 
 The Go App Engine SDK now supports local unit testing, using Go's native
 [[https://developers.google.com/appengine/docs/go/tools/localunittesting][testing package]]
-and the "[[http://golang.org/cmd/go/#hdr-Test_packages][go test]]" command
+and the "[[https://golang.org/cmd/go/#hdr-Test_packages][go test]]" command
 (provided as "goapp test" by the SDK).
 
 Furthermore, you can now write tests that use App Engine services.
diff --git a/blog/content/building-stathat-with-go.article b/blog/content/building-stathat-with-go.article
index e9d0d25..81479ec 100644
--- a/blog/content/building-stathat-with-go.article
+++ b/blog/content/building-stathat-with-go.article
@@ -6,7 +6,7 @@
 
 * Introduction
 
-My name is Patrick Crosby and I'm the founder of a company called Numerotron. We recently released [[http://www.stathat.com][StatHat]].  This post is about why we chose to develop StatHat in [[http://golang.org][Go]], including details about how we are using Go.
+My name is Patrick Crosby and I'm the founder of a company called Numerotron. We recently released [[http://www.stathat.com][StatHat]].  This post is about why we chose to develop StatHat in [[https://golang.org][Go]], including details about how we are using Go.
 
 [[http://www.stathat.com][StatHat]] is a tool to track statistics and events in your code.  Everyone from HTML designers to backend engineers can use StatHat easily, as it supports sending stats from HTML, JavaScript, Go, and twelve other languages.
 
@@ -54,11 +54,11 @@
 
 * Runtime
 
-We use the standard Go [[http://golang.org/pkg/http/][http package]] for our API and web app servers.  All requests first go through Nginx and any non-file requests are proxied to the Go-powered http servers.  The backend servers are all written in Go and use the [[http://golang.org/pkg/rpc/][rpc package]] to communicate with the frontend.
+We use the standard Go [[https://golang.org/pkg/http/][http package]] for our API and web app servers.  All requests first go through Nginx and any non-file requests are proxied to the Go-powered http servers.  The backend servers are all written in Go and use the [[https://golang.org/pkg/rpc/][rpc package]] to communicate with the frontend.
 
 * Templating
 
-We built a template system using the standard [[http://golang.org/pkg/template/][template package]].  Our system adds layouts, some common formatting functions, and the ability to recompile templates on-the-fly during development.  We are very pleased with the performance and functionality of the Go templates.
+We built a template system using the standard [[https://golang.org/pkg/template/][template package]].  Our system adds layouts, some common formatting functions, and the ability to recompile templates on-the-fly during development.  We are very pleased with the performance and functionality of the Go templates.
 
 * Tinkering
 
@@ -68,7 +68,7 @@
 
 * RPC
 
-Since StatHat is a multi-tiered system, we wanted an RPC layer so that all communication was standard.  With Go, we are using the [[http://golang.org/pkg/rpc/][rpc package]] and the [[http://golang.org/pkg/gob/][gob package]] for encoding Go objects.  In Go, the RPC server just takes any Go object and registers its exported methods.  There is no need for an intermediary interface description language.  We've found it very easy to use and many of our core application servers are under 300 lines of code.
+Since StatHat is a multi-tiered system, we wanted an RPC layer so that all communication was standard.  With Go, we are using the [[https://golang.org/pkg/rpc/][rpc package]] and the [[https://golang.org/pkg/gob/][gob package]] for encoding Go objects.  In Go, the RPC server just takes any Go object and registers its exported methods.  There is no need for an intermediary interface description language.  We've found it very easy to use and many of our core application servers are under 300 lines of code.
 
 * Libraries
 
@@ -106,4 +106,4 @@
 
 For more information on StatHat, please visit [[http://www.stathat.com][stathat.com]]. We are releasing some of the Go code we've written. Go to [[http://www.stathat.com/src][www.stathat.com/src]] for all of the open source StatHat projects.
 
-To learn more about Go, visit [[http://golang.org/][golang.org]].
+To learn more about Go, visit [[https://golang.org/][golang.org]].
diff --git a/blog/content/c-go-cgo.article b/blog/content/c-go-cgo.article
index 71773b9..19a01f3 100644
--- a/blog/content/c-go-cgo.article
+++ b/blog/content/c-go-cgo.article
@@ -50,7 +50,7 @@
 	    C.srandom(C.uint(i))
 	}
 
-Note that cgo knows the `unsigned`int` type as `C.uint`; see the [[http://golang.org/cmd/cgo][cgo documentation]] for a complete list of these numeric type names.
+Note that cgo knows the `unsigned`int` type as `C.uint`; see the [[https://golang.org/cmd/cgo][cgo documentation]] for a complete list of these numeric type names.
 
 The one detail of this example we haven't examined yet is the comment above the `import` statement.
 
@@ -63,7 +63,7 @@
 
 There is a limitation: if your program uses any `//export` directives, then the C code in the comment may only include declarations (`extern`int`f();`), not definitions (`int`f()`{`return`1;`}`).  You can use `//export` directives to make Go functions accessible to C code.
 
-The `#cgo` and `//export` directives are documented in the [[http://golang.org/cmd/cgo/][cgo documentation]].
+The `#cgo` and `//export` directives are documented in the [[https://golang.org/cmd/cgo/][cgo documentation]].
 
 * Strings and things
 
@@ -88,7 +88,7 @@
 
 Memory allocations made by C code are not known to Go's memory manager. When you create a C string with `C.CString` (or any C memory allocation) you must remember to free the memory when you're done with it by calling `C.free`.
 
-The call to `C.CString` returns a pointer to the start of the char array, so before the function exits we convert it to an [[http://golang.org/pkg/unsafe/#Pointer][`unsafe.Pointer`]] and release the memory allocation with `C.free`. A common idiom in cgo programs is to [[http://golang.org/doc/articles/defer_panic_recover.html][`defer`]] the free immediately after allocating (especially when the code that follows is more complex than a single function call), as in this rewrite of `Print`:
+The call to `C.CString` returns a pointer to the start of the char array, so before the function exits we convert it to an [[https://golang.org/pkg/unsafe/#Pointer][`unsafe.Pointer`]] and release the memory allocation with `C.free`. A common idiom in cgo programs is to [[https://golang.org/doc/articles/defer_panic_recover.html][`defer`]] the free immediately after allocating (especially when the code that follows is more complex than a single function call), as in this rewrite of `Print`:
 
 	func Print(s string) {
 	    cs := C.CString(s)
@@ -98,10 +98,10 @@
 
 * Building cgo packages
 
-To build cgo packages, just use [[http://golang.org/cmd/go/#Compile_packages_and_dependencies][`go`build`]] or [[http://golang.org/cmd/go/#Compile_and_install_packages_and_dependencies][`go`install`]] as usual. The go tool recognizes the special `"C"` import and automatically uses cgo for those files.
+To build cgo packages, just use [[https://golang.org/cmd/go/#Compile_packages_and_dependencies][`go`build`]] or [[https://golang.org/cmd/go/#Compile_and_install_packages_and_dependencies][`go`install`]] as usual. The go tool recognizes the special `"C"` import and automatically uses cgo for those files.
 
 * More cgo resources
 
-The [[http://golang.org/cmd/cgo/][cgo command]] documentation has more detail about the C pseudo-package and the build process. The [[http://golang.org/misc/cgo/][cgo examples]] in the Go tree demonstrate more advanced concepts.
+The [[https://golang.org/cmd/cgo/][cgo command]] documentation has more detail about the C pseudo-package and the build process. The [[https://golang.org/misc/cgo/][cgo examples]] in the Go tree demonstrate more advanced concepts.
 
 Finally, if you're curious as to how all this works internally, take a look at the introductory comment of the runtime package's [[https://golang.org/src/runtime/cgocall.go][cgocall.go]].
diff --git a/blog/content/constants.article b/blog/content/constants.article
index 3a0538f..7b498df 100644
--- a/blog/content/constants.article
+++ b/blog/content/constants.article
@@ -190,7 +190,7 @@
 
 The default type of an untyped constant is determined by its syntax.
 For string constants, the only possible implicit type is `string`.
-For [[http://golang.org/ref/spec#Numeric_types][numeric constants]], the implicit type has more variety.
+For [[https://golang.org/ref/spec#Numeric_types][numeric constants]], the implicit type has more variety.
 Integer constants default to `int`, floating-point constants `float64`, rune constants to `rune` (an alias for `int32`), and imaginary constants to `complex128`.
 Here's our canonical print statement used repeatedly to show the default types in action:
 
@@ -300,7 +300,7 @@
 * Integers
 
 At last we come to integers.
-They have more moving parts—[[http://golang.org/ref/spec#Numeric_types][many sizes, signed or unsigned, and more]]—but they play by the same rules.
+They have more moving parts—[[https://golang.org/ref/spec#Numeric_types][many sizes, signed or unsigned, and more]]—but they play by the same rules.
 For the last time, here is our familiar example, using just `int` this time:
 
 .play -edit constants/int1.go /START/,/STOP/
@@ -368,7 +368,7 @@
 .play -edit constants/exercise2.go /const/
 
 Even though at run-time a value of -1 can be converted to an unsigned integer, the rules
-for constant [[http://golang.org/ref/spec#Conversions][conversions]] forbid this kind of coercion at compile time.
+for constant [[https://golang.org/ref/spec#Conversions][conversions]] forbid this kind of coercion at compile time.
 That is to say, this works:
 
 .play -edit constants/exercise3.go /START/,/STOP/
diff --git a/blog/content/cover.article b/blog/content/cover.article
index 4e6bcdb..c40502d 100644
--- a/blog/content/cover.article
+++ b/blog/content/cover.article
@@ -9,13 +9,13 @@
 From the beginning of the project, Go was designed with tools in mind.
 Those tools include some of the most iconic pieces of Go technology such as
 the documentation presentation tool
-[[http://golang.org/cmd/godoc][godoc]],
+[[https://golang.org/cmd/godoc][godoc]],
 the code formatting tool
-[[http://golang.org/cmd/gofmt][gofmt]],
+[[https://golang.org/cmd/gofmt][gofmt]],
 and the API rewriter
-[[http://golang.org/cmd/fix][gofix]].
+[[https://golang.org/cmd/fix][gofix]].
 Perhaps most important of all is the
-[[http://golang.org/cmd/go][`go` command]],
+[[https://golang.org/cmd/go][`go` command]],
 the program that automatically installs, builds, and tests Go programs
 using nothing more than the source code as the build specification.
 
@@ -194,7 +194,7 @@
 The default is 'set', which we've already seen.
 The `atomic` setting is needed only when accurate counts are required
 when running parallel algorithms. It uses atomic operations from the
-[[http://golang.org/pkg/sync/atomic/][sync/atomic]] package,
+[[https://golang.org/pkg/sync/atomic/][sync/atomic]] package,
 which can be quite expensive.
 For most purposes, though, the `count` mode works fine and, like
 the default `set` mode, is very cheap.
diff --git a/blog/content/debugging-go-programs-with-gnu-debugger.article b/blog/content/debugging-go-programs-with-gnu-debugger.article
index 1ff9b27..265a479 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 [[http://golang.org/cmd/gc/][gc]]/[[http://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 [[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.
 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 [[http://golang.org/doc/debugging_with_gdb.html][Debugging with GDB]] article.
+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/defer-panic-and-recover.article b/blog/content/defer-panic-and-recover.article
index f43383a..6a05f7c 100644
--- a/blog/content/defer-panic-and-recover.article
+++ b/blog/content/defer-panic-and-recover.article
@@ -171,7 +171,7 @@
 
  
 
-For a real-world example of *panic* and *recover*, see the [[http://golang.org/pkg/encoding/json/][json package]] from the Go standard library. It decodes JSON-encoded data with a set of recursive functions. When malformed JSON is encountered, the parser calls panic to unwind the stack to the top-level function call, which recovers from the panic and returns an appropriate error value (see the 'error' and 'unmarshal' methods of the decodeState type in [[http://golang.org/src/pkg/encoding/json/decode.go][decode.go]]).
+For a real-world example of *panic* and *recover*, see the [[https://golang.org/pkg/encoding/json/][json package]] from the Go standard library. It decodes JSON-encoded data with a set of recursive functions. When malformed JSON is encountered, the parser calls panic to unwind the stack to the top-level function call, which recovers from the panic and returns an appropriate error value (see the 'error' and 'unmarshal' methods of the decodeState type in [[https://golang.org/src/pkg/encoding/json/decode.go][decode.go]]).
 
 The convention in the Go libraries is that even when a package uses panic internally, its external API still presents explicit error return values.
 
diff --git a/blog/content/docker.article b/blog/content/docker.article
index 522690c..38aedca 100644
--- a/blog/content/docker.article
+++ b/blog/content/docker.article
@@ -26,7 +26,7 @@
 data files at run time; for a web server, it's about as simple as it gets.
 
 Use "go get" to fetch and install outyet in your
-[[http://golang.org/doc/code.html#Workspaces][workspace]]:
+[[https://golang.org/doc/code.html#Workspaces][workspace]]:
 
 	$ go get github.com/golang/example/outyet
 
diff --git a/blog/content/error-handling-and-go.article b/blog/content/error-handling-and-go.article
index 6535c0b..95aed00 100644
--- a/blog/content/error-handling-and-go.article
+++ b/blog/content/error-handling-and-go.article
@@ -28,9 +28,9 @@
 	    Error() string
 	}
 
-The `error` type, as with all built in types, is [[http://golang.org/doc/go_spec.html#Predeclared_identifiers][predeclared]] in the [[http://golang.org/doc/go_spec.html#Blocks][universe block]].
+The `error` type, as with all built in types, is [[https://golang.org/doc/go_spec.html#Predeclared_identifiers][predeclared]] in the [[https://golang.org/doc/go_spec.html#Blocks][universe block]].
 
-The most commonly-used `error` implementation is the [[http://golang.org/pkg/errors/][errors]] package's unexported `errorString` type.
+The most commonly-used `error` implementation is the [[https://golang.org/pkg/errors/][errors]] package's unexported `errorString` type.
 
 	// errorString is a trivial implementation of error.
 	type errorString struct {
@@ -64,7 +64,7 @@
 	        fmt.Println(err)
 	    }
 
-The [[http://golang.org/pkg/fmt/][fmt]] package formats an `error` value by calling its `Error()`string` method.
+The [[https://golang.org/pkg/fmt/][fmt]] package formats an `error` value by calling its `Error()`string` method.
 
 It is the error implementation's responsibility to summarize the context. The error returned by `os.Open` formats as "open /etc/passwd: permission denied," not just "permission denied."  The error returned by our `Sqrt` is missing information about the invalid argument.
 
@@ -84,9 +84,9 @@
 	    return fmt.Sprintf("math: square root of negative number %g", float64(f))
 	}
 
-A sophisticated caller can then use a [[http://golang.org/doc/go_spec.html#Type_assertions][type assertion]] to check for a `NegativeSqrtError` and handle it specially, while callers that just pass the error to `fmt.Println` or `log.Fatal` will see no change in behavior.
+A sophisticated caller can then use a [[https://golang.org/doc/go_spec.html#Type_assertions][type assertion]] to check for a `NegativeSqrtError` and handle it specially, while callers that just pass the error to `fmt.Println` or `log.Fatal` will see no change in behavior.
 
-As another example, the [[http://golang.org/pkg/encoding/json/][json]] package specifies a `SyntaxError` type that the `json.Decode` function returns when it encounters a syntax error parsing a JSON blob.
+As another example, the [[https://golang.org/pkg/encoding/json/][json]] package specifies a `SyntaxError` type that the `json.Decode` function returns when it encounters a syntax error parsing a JSON blob.
 
 	type SyntaxError struct {
 	    msg    string // description of error
@@ -107,7 +107,7 @@
 
 (This is a slightly simplified version of some [[https://github.com/camlistore/go4/blob/03efcb870d84809319ea509714dd6d19a1498483/jsonconfig/eval.go#L123-L135][actual code]] from the [[http://camlistore.org][Camlistore]] project.)
 
-The `error` interface requires only a `Error` method; specific error implementations might have additional methods. For instance, the [[http://golang.org/pkg/net/][net]] package returns errors of type `error`, following the usual convention, but some of the error implementations have additional methods defined by the `net.Error` interface:
+The `error` interface requires only a `Error` method; specific error implementations might have additional methods. For instance, the [[https://golang.org/pkg/net/][net]] package returns errors of type `error`, following the usual convention, but some of the error implementations have additional methods defined by the `net.Error` interface:
 
 	package net
 
@@ -168,7 +168,7 @@
 	    return viewTemplate.Execute(w, record)
 	}
 
-This is simpler than the original version, but the [[http://golang.org/pkg/net/http/][http]] package doesn't understand functions that return `error`. To fix this we can implement the `http.Handler` interface's `ServeHTTP` method on `appHandler`:
+This is simpler than the original version, but the [[https://golang.org/pkg/net/http/][http]] package doesn't understand functions that return `error`. To fix this we can implement the `http.Handler` interface's `ServeHTTP` method on `appHandler`:
 
 	func (fn appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	    if err := fn(w, r); err != nil {
@@ -198,7 +198,7 @@
 
 	type appHandler func(http.ResponseWriter, *http.Request) *appError
 
-(It's usually a mistake to pass back the concrete type of an error rather than `error`, for reasons discussed in [[http://golang.org/doc/go_faq.html#nil_error][the Go FAQ]], but it's the right thing to do here because `ServeHTTP` is the only place that sees the value and uses its contents.)
+(It's usually a mistake to pass back the concrete type of an error rather than `error`, for reasons discussed in [[https://golang.org/doc/go_faq.html#nil_error][the Go FAQ]], but it's the right thing to do here because `ServeHTTP` is the only place that sees the value and uses its contents.)
 
 And make `appHandler`'s `ServeHTTP` method display the `appError`'s `Message` to the user with the correct HTTP status `Code` and log the full `Error` to the developer console:
 
@@ -235,7 +235,7 @@
 
 - write a constructor function for `appError` that stores the stack trace for easier debugging,
 
-- recover from panics inside the `appHandler`, logging the error to the console as "Critical," while telling the user "a serious error has occurred." This is a nice touch to avoid exposing the user to inscrutable error messages caused by programming errors. See the [[http://golang.org/doc/articles/defer_panic_recover.html][Defer, Panic, and Recover]] article for more details.
+- recover from panics inside the `appHandler`, logging the error to the console as "Critical," while telling the user "a serious error has occurred." This is a nice touch to avoid exposing the user to inscrutable error messages caused by programming errors. See the [[https://golang.org/doc/articles/defer_panic_recover.html][Defer, Panic, and Recover]] article for more details.
 
 * Conclusion
 
diff --git a/blog/content/errors-are-values.article b/blog/content/errors-are-values.article
index 95a7d3f..0876d7a 100644
--- a/blog/content/errors-are-values.article
+++ b/blog/content/errors-are-values.article
@@ -43,8 +43,8 @@
 eliminating much of the boilerplate that arises if every error is checked with a rote if statement.
 
 Here's a simple example from the `bufio` package's
-[[http://golang.org/pkg/bufio/#Scanner][`Scanner`]] type.
-Its [[http://golang.org/pkg/bufio/#Scanner.Scan][`Scan`]] method performs the underlying I/O,
+[[https://golang.org/pkg/bufio/#Scanner][`Scanner`]] type.
+Its [[https://golang.org/pkg/bufio/#Scanner.Scan][`Scan`]] method performs the underlying I/O,
 which can of course lead to an error.
 Yet the `Scan` method does not expose an error at all.
 Instead, it returns a boolean, and a separate method, to be run at the end of the scan,
@@ -86,7 +86,7 @@
 
 Under the covers what's happening, of course,
 is that as soon as `Scan` encounters an I/O error, it records it and returns `false`.
-A separate method, [[http://golang.org/pkg/bufio/#Scanner.Err][`Err`]],
+A separate method, [[https://golang.org/pkg/bufio/#Scanner.Err][`Err`]],
 reports the error value when the client asks.
 Trivial though this is, it's not the same as putting
 
@@ -198,12 +198,12 @@
 And much more.
 
 In fact, this pattern appears often in the standard library.
-The [[http://golang.org/pkg/archive/zip/][`archive/zip`]] and
-[[http://golang.org/pkg/net/http/][`net/http`]] packages use it.
-More salient to this discussion, the [[http://golang.org/pkg/bufio/][`bufio` package's `Writer`]]
+The [[https://golang.org/pkg/archive/zip/][`archive/zip`]] and
+[[https://golang.org/pkg/net/http/][`net/http`]] packages use it.
+More salient to this discussion, the [[https://golang.org/pkg/bufio/][`bufio` package's `Writer`]]
 is actually an implementation of the `errWriter` idea.
 Although `bufio.Writer.Write` returns an error,
-that is mostly about honoring the [[http://golang.org/pkg/io/#Writer][`io.Writer`]] interface.
+that is mostly about honoring the [[https://golang.org/pkg/io/#Writer][`io.Writer`]] interface.
 The `Write` method of `bufio.Writer` behaves just like our `errWriter.write`
 method above, with `Flush` reporting the error, so our example could be written like this:
 
diff --git a/blog/content/examples.article b/blog/content/examples.article
index aa0dd28..a8d5aba 100644
--- a/blog/content/examples.article
+++ b/blog/content/examples.article
@@ -6,7 +6,7 @@
 
 * Introduction
 
-Godoc [[http://golang.org/pkg/testing/#hdr-Examples][examples]] are snippets of
+Godoc [[https://golang.org/pkg/testing/#hdr-Examples][examples]] are snippets of
 Go code that are displayed as package documentation and that are verified by
 running them as tests.
 They can also be run by a user visiting the godoc web page for the package
@@ -16,7 +16,7 @@
 will not go out of date as the API changes.
 
 The standard library includes many such examples
-(see the [[http://golang.org/pkg/strings/#Contains][`strings` package]],
+(see the [[https://golang.org/pkg/strings/#Contains][`strings` package]],
 for instance).
 
 This article explains how to write your own example functions.
diff --git a/blog/content/first-class-functions-in-go-and-new-go.article b/blog/content/first-class-functions-in-go-and-new-go.article
index 998ccb3..1458b83 100644
--- a/blog/content/first-class-functions-in-go-and-new-go.article
+++ b/blog/content/first-class-functions-in-go-and-new-go.article
@@ -6,6 +6,6 @@
 
 * Introduction
 
-Programmers new to Go are often surprised by its support for function types, functions as values, and closures. The [[http://golang.org/doc/codewalk/functions/][First Class Functions in Go]] code walk demonstrates these features with a simulation of the dice game [[http://en.wikipedia.org/wiki/Pig_(dice)][Pig]]. It is a pretty program that uses the language to great effect, and a fun read for Go beginners and veterans alike.
+Programmers new to Go are often surprised by its support for function types, functions as values, and closures. The [[https://golang.org/doc/codewalk/functions/][First Class Functions in Go]] code walk demonstrates these features with a simulation of the dice game [[http://en.wikipedia.org/wiki/Pig_(dice)][Pig]]. It is a pretty program that uses the language to great effect, and a fun read for Go beginners and veterans alike.
 
-More resources are available at [[http://golang.org/doc/docs.html][golang.org]].
+More resources are available at [[https://golang.org/doc/docs.html][golang.org]].
diff --git a/blog/content/first-go-program.article b/blog/content/first-go-program.article
index 3e31585..9628965 100644
--- a/blog/content/first-go-program.article
+++ b/blog/content/first-go-program.article
@@ -7,7 +7,7 @@
 * Introduction
 
 Brad Fitzpatrick and I (Andrew Gerrand) recently started restructuring
-[[http://golang.org/cmd/godoc/][godoc]], and it occurred to me that it is one
+[[https://golang.org/cmd/godoc/][godoc]], and it occurred to me that it is one
 of the oldest Go programs.
 Robert Griesemer started writing it back in early 2009,
 and we're still using it today.
@@ -52,7 +52,7 @@
 It takes no user input and has no imports, relying only on the built-in
 `print` facility for output. 
 It was written literally the first day there was a
-[[http://golang.org/change/8b8615138da3][working but rudimentary compiler]].
+[[https://golang.org/change/8b8615138da3][working but rudimentary compiler]].
 Much of the language wasn't implemented and some of it wasn't even specified.
 
 Still, the basic flavor of the language today is recognizable in this program.
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 42e033e..9857096 100644
--- a/blog/content/from-zero-to-go-launching-on-google.article
+++ b/blog/content/from-zero-to-go-launching-on-google.article
@@ -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]], [[http://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 [[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.
 
 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/gccgo-in-gcc-471.article b/blog/content/gccgo-in-gcc-471.article
index 4aa51c7..d239f4b 100644
--- a/blog/content/gccgo-in-gcc-471.article
+++ b/blog/content/gccgo-in-gcc-471.article
@@ -6,7 +6,7 @@
 
 * Introduction
 
-The Go language has always been defined by a [[http://golang.org/ref/spec][spec]], not an implementation.  The Go team has written two different compilers that implement that spec: gc and gccgo.  Having two different implementations helps ensure that the spec is complete and correct: when the compilers disagree, we fix the spec, and change one or both compilers accordingly.  Gc is the original compiler, and the go tool uses it by default.  Gccgo is a different implementation with a different focus, and in this post we’ll take a closer look at it.
+The Go language has always been defined by a [[https://golang.org/ref/spec][spec]], not an implementation.  The Go team has written two different compilers that implement that spec: gc and gccgo.  Having two different implementations helps ensure that the spec is complete and correct: when the compilers disagree, we fix the spec, and change one or both compilers accordingly.  Gc is the original compiler, and the go tool uses it by default.  Gccgo is a different implementation with a different focus, and in this post we’ll take a closer look at it.
 
 Gccgo is distributed as part of GCC, the GNU Compiler Collection.  GCC supports several different frontends for different languages; gccgo is a Go frontend connected to the GCC backend.  The Go frontend is separate from the GCC project and is designed to be able to connect to other compiler backends, but currently only supports GCC.
 
diff --git a/blog/content/generate.article b/blog/content/generate.article
index a95c2c5..c9335cc 100644
--- a/blog/content/generate.article
+++ b/blog/content/generate.article
@@ -75,7 +75,7 @@
 Every time `gopher.y` is modified, just rerun `go` `generate` to regenerate the parser.
 
 For more details about how `go` `generate` works, including options, environment variables,
-and so on, see the [[http://golang.org/s/go1.4-generate][design document]].
+and so on, see the [[https://golang.org/s/go1.4-generate][design document]].
 
 Go generate does nothing that couldn't be done with Make or some other build mechanism,
 but it comes with the `go` tool—no extra installation required—and fits nicely into the Go ecosystem.
diff --git a/blog/content/gif-decoder-exercise-in-go-interfaces.article b/blog/content/gif-decoder-exercise-in-go-interfaces.article
index 3496ea6..032c17e 100644
--- a/blog/content/gif-decoder-exercise-in-go-interfaces.article
+++ b/blog/content/gif-decoder-exercise-in-go-interfaces.article
@@ -32,7 +32,7 @@
 
 * Deblocking the pixel data
 
-To decode GIF pixel data in Go, we can use the LZW decompressor from the `compress/lzw` package. It has a NewReader function that returns an object that, as [[http://golang.org/pkg/compress/lzw/#NewReader][the documentation]] says, "satisfies reads by decompressing the data read from r":
+To decode GIF pixel data in Go, we can use the LZW decompressor from the `compress/lzw` package. It has a NewReader function that returns an object that, as [[https://golang.org/pkg/compress/lzw/#NewReader][the documentation]] says, "satisfies reads by decompressing the data read from r":
 
 	func NewReader(r io.Reader, order Order, litWidth int) io.ReadCloser
 
diff --git a/blog/content/go-11-is-released.article b/blog/content/go-11-is-released.article
index 1245c30..18e2839 100644
--- a/blog/content/go-11-is-released.article
+++ b/blog/content/go-11-is-released.article
@@ -16,16 +16,16 @@
 
 The most significant improvements are performance-related. We have made optimizations in the compiler and linker, garbage collector, goroutine scheduler, map implementation, and parts of the standard library. It is likely that your Go code will run noticeably faster when built with Go 1.1.
 
-There are some minor changes to the language itself, two of which are worth singling out here: the [[http://golang.org/doc/go1.1#return][changes to return requirements]] will lead to more succinct and correct programs, and the introduction of [[http://golang.org/doc/go1.1#method_values][method values]] provides an expressive way to bind a method to its receiver as a function value.
+There are some minor changes to the language itself, two of which are worth singling out here: the [[https://golang.org/doc/go1.1#return][changes to return requirements]] will lead to more succinct and correct programs, and the introduction of [[https://golang.org/doc/go1.1#method_values][method values]] provides an expressive way to bind a method to its receiver as a function value.
 
-Concurrent programming is safer in Go 1.1 with the addition of a race detector for finding memory synchronization errors in your programs. We will discuss the race detector more in an upcoming article, but for now [[http://golang.org/doc/articles/race_detector.html][the manual]] is a great place to get started.
+Concurrent programming is safer in Go 1.1 with the addition of a race detector for finding memory synchronization errors in your programs. We will discuss the race detector more in an upcoming article, but for now [[https://golang.org/doc/articles/race_detector.html][the manual]] is a great place to get started.
 
-The tools and standard library have been improved and expanded. You can read the full story in the [[http://golang.org/doc/go1.1][release notes]].
+The tools and standard library have been improved and expanded. You can read the full story in the [[https://golang.org/doc/go1.1][release notes]].
 
-As per our [[http://golang.org/doc/go1compat.html][compatibility guidelines]], Go 1.1 remains compatible with Go 1.0 and we recommend all Go users upgrade to the new release.
+As per our [[https://golang.org/doc/go1compat.html][compatibility guidelines]], Go 1.1 remains compatible with Go 1.0 and we recommend all Go users upgrade to the new release.
 
 All this would not have been possible without the help of our contributors from the open source community. Since Go 1.0, the core received more than 2600 commits from 161 people outside Google. Thank you everyone for your time and effort. In particular, we would like to thank Shenghou Ma, Rémy Oudompheng, Dave Cheney, Mikio Hara, Alex Brainman, Jan Ziak, and Daniel Morsing for their outstanding contributions.
 
-To grab the new release, follow the usual [[http://golang.org/doc/install][installation instructions]]. Happy hacking!
+To grab the new release, follow the usual [[https://golang.org/doc/install][installation instructions]]. Happy hacking!
 
 _Thanks_to_Renée_French_for_the_gopher!_
diff --git a/blog/content/go-and-google-app-engine.article b/blog/content/go-and-google-app-engine.article
index e12feb4..a2f32ef 100644
--- a/blog/content/go-and-google-app-engine.article
+++ b/blog/content/go-and-google-app-engine.article
@@ -16,7 +16,7 @@
 
 One of the cool but less obvious things about this news is that it provides a very easy way to play with Go. You don’t even need to have Go installed beforehand because the SDK is fully self-contained. Just download the SDK, unzip it, and start coding. Moreover, the SDK’s “dev app server” means you don’t even need to run the compiler yourself; everything is delightfully automatic.
 
-What you’ll find in the SDK is many of the standard App Engine APIs, custom designed in good Go style, including Datastore, Blobstore, URL Fetch, Mail, Users, and so on. More APIs will be added as the environment develops. The runtime provides the full Go language and almost all the standard libraries, except for a few things that don’t make sense in the App Engine environment. For instance, there is no `unsafe` package and the `syscall` package is trimmed. (The implementation uses an expanded version of the setup in the [[http://golang.org/doc/play/][Go Playground]] on [[http://golang.org/][golang.org]].)
+What you’ll find in the SDK is many of the standard App Engine APIs, custom designed in good Go style, including Datastore, Blobstore, URL Fetch, Mail, Users, and so on. More APIs will be added as the environment develops. The runtime provides the full Go language and almost all the standard libraries, except for a few things that don’t make sense in the App Engine environment. For instance, there is no `unsafe` package and the `syscall` package is trimmed. (The implementation uses an expanded version of the setup in the [[https://golang.org/doc/play/][Go Playground]] on [[https://golang.org/][golang.org]].)
 
 Also, although goroutines and channels are present, when a Go app runs on App Engine only one thread is run in a given instance.  That is, all goroutines run in a single operating system thread, so there is no CPU parallelism available for a given client request.  We expect this restriction will be lifted at some point.
 
diff --git a/blog/content/go-app-engine-sdk-155-released.article b/blog/content/go-app-engine-sdk-155-released.article
index 0249ba0..e468199 100644
--- a/blog/content/go-app-engine-sdk-155-released.article
+++ b/blog/content/go-app-engine-sdk-155-released.article
@@ -8,7 +8,7 @@
 
 Today we released version 1.5.5 the Go App Engine SDK. You can download it from the [[http://code.google.com/appengine/downloads.html][App Engine downloads page]].
 
-This release includes changes and improvements to the App Engine APIs and brings the supporting Go tool chain to [[http://golang.org/doc/devel/release.html#r60][release.r60.2]] (the current stable release). Also included in this release are the [[http://golang.org/cmd/godoc/][godoc]], [[http://golang.org/cmd/gofmt/][gofmt]], and [[http://golang.org/cmd/gofix/][gofix]] tools from the Go tool chain. They can be found in the root directory of the SDK.
+This release includes changes and improvements to the App Engine APIs and brings the supporting Go tool chain to [[https://golang.org/doc/devel/release.html#r60][release.r60.2]] (the current stable release). Also included in this release are the [[https://golang.org/cmd/godoc/][godoc]], [[https://golang.org/cmd/gofmt/][gofmt]], and [[https://golang.org/cmd/gofix/][gofix]] tools from the Go tool chain. They can be found in the root directory of the SDK.
 
 Some changes made in this release are backwards-incompatible, so we have incremented the SDK `api_version` to 3. Existing apps will require code changes when migrating to `api_version` 3.
 
diff --git a/blog/content/go-at-google-io-2011-videos.article b/blog/content/go-at-google-io-2011-videos.article
index 29d6222..173f40a 100644
--- a/blog/content/go-at-google-io-2011-videos.article
+++ b/blog/content/go-at-google-io-2011-videos.article
@@ -14,7 +14,7 @@
 
 .iframe //www.youtube.com/embed/-i0hat7pdpk 349 560
 
-(See the [[http://golang.org/doc/talks/io2011/Writing_Web_Apps_in_Go.pdf][presentation slides]].)
+(See the [[https://golang.org/doc/talks/io2011/Writing_Web_Apps_in_Go.pdf][presentation slides]].)
 
 The [[https://code.google.com/p/appengine-go/source/browse/example/moustachio][source code]] for Moustachio is available as part of [[http://code.google.com/appengine/downloads.html#Google_App_Engine_SDK_for_Go][the SDK]] along with some other examples, such as this [[http://mandelbrot-tiles.appspot.com/][Mandelbrot demo]].
 
@@ -37,6 +37,6 @@
 
 .iframe //www.youtube.com/embed/7QDVRowyUQA 349 560
 
-(See the [[http://golang.org/doc/talks/io2011/Real_World_Go.pdf ][presentation slides]].)
+(See the [[https://golang.org/doc/talks/io2011/Real_World_Go.pdf ][presentation slides]].)
 
 Thanks to everyone who attended our talks and workshops. We look forward to seeing you again soon!
diff --git a/blog/content/go-at-heroku.article b/blog/content/go-at-heroku.article
index 8f0892d..9b415a1 100644
--- a/blog/content/go-at-heroku.article
+++ b/blog/content/go-at-heroku.article
@@ -16,9 +16,9 @@
 
 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.
 
-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 [[http://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.
+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.
 
-One of our favorite productivity gains was provided by Go's source formatter: [[http://golang.org/cmd/gofmt/][gofmt]]. We never argued over where to put a curly-brace, tabs vs. spaces, or if we should align assignments. We simply agreed that the buck stopped at the default output from gofmt.
+One of our favorite productivity gains was provided by Go's source formatter: [[https://golang.org/cmd/gofmt/][gofmt]]. We never argued over where to put a curly-brace, tabs vs. spaces, or if we should align assignments. We simply agreed that the buck stopped at the default output from gofmt.
 
 Deploying Doozer was satisfyingly simple. Go builds statically linked binaries which means Doozer has no external dependencies; it's a single file that can be copied to any machine and immediately launched to join a cluster of running Doozers.
 
diff --git a/blog/content/go-becomes-more-stable.article b/blog/content/go-becomes-more-stable.article
index e33d2c5..17325e4 100644
--- a/blog/content/go-becomes-more-stable.article
+++ b/blog/content/go-becomes-more-stable.article
@@ -8,7 +8,7 @@
 
 The Go project is moving fast. As we learn more about Go we are compelled to change our tools, libraries, and occasionally even the language itself. We permit backward-incompatible changes so that we can learn from, rather than immortalize, our mistakes. We believe flexibility at this stage of Go’s development is essential to the project’s development and, ultimately, its longevity.
 
-Since Go's launch we have been making releases approximately once a week. Accompanying each release are [[http://golang.org/doc/devel/release.html][notes describing what changed]], with any backwards-incompatible changes signposted. Questions I hear often are "Is Go stable? How can I be sure that I won’t have to update my Go code every week?" The answer to those questions are now "Yes," and "You won't."
+Since Go's launch we have been making releases approximately once a week. Accompanying each release are [[https://golang.org/doc/devel/release.html][notes describing what changed]], with any backwards-incompatible changes signposted. Questions I hear often are "Is Go stable? How can I be sure that I won’t have to update my Go code every week?" The answer to those questions are now "Yes," and "You won't."
 
 With this week’s release we’re introducing a new release tagging scheme. We intend to continue with our weekly releases, but have renamed the existing tags from `release` to `weekly`. The `release` tag will now be applied to one hand-picked stable release each month or two. This more relaxed release schedule should make life easier for the average Go programmer.
 
diff --git a/blog/content/go-concurrency-patterns-timing-out-and.article b/blog/content/go-concurrency-patterns-timing-out-and.article
index fa81a2c..93411fd 100644
--- a/blog/content/go-concurrency-patterns-timing-out-and.article
+++ b/blog/content/go-concurrency-patterns-timing-out-and.article
@@ -25,7 +25,7 @@
 
 The `timeout` channel is buffered with space for 1 value, allowing the timeout goroutine to send to the channel and then exit. The goroutine doesn't know (or care) whether the value is received. This means the goroutine won't hang around forever if the `ch` receive happens before the timeout is reached. The `timeout` channel will eventually be deallocated by the garbage collector.
 
-(In this example we used `time.Sleep` to demonstrate the mechanics of goroutines and channels. In real programs you should use ` [[http://golang.org/pkg/time/#After][time.After]]`, a function that returns a channel and sends on that channel after the specified duration.)
+(In this example we used `time.Sleep` to demonstrate the mechanics of goroutines and channels. In real programs you should use ` [[https://golang.org/pkg/time/#After][time.After]]`, a function that returns a channel and sends on that channel after the specified duration.)
 
 Let's look at another variation of this pattern. In this example we have a program that reads from multiple replicated databases simultaneously. The program needs only one of the answers, and it should accept the answer that arrives first.
 
@@ -46,6 +46,6 @@
 
 In this example, the closure does a non-blocking send, which it achieves by using the send operation in `select` statement with a `default` case. If the send cannot go through immediately the default case will be selected. Making the send non-blocking guarantees that none of the goroutines launched in the loop will hang around. However, if the result arrives before the main function has made it to the receive, the send could fail since no one is ready.
 
-This problem is a textbook example of what is known as a [[https://en.wikipedia.org/wiki/Race_condition][race condition]], but the fix is trivial. We just make sure to buffer the channel `ch` (by adding the buffer length as the second argument to [[http://golang.org/pkg/builtin/#make][make]]), guaranteeing that the first send has a place to put the value. This ensures the send will always succeed, and the first value to arrive will be retrieved regardless of the order of execution.
+This problem is a textbook example of what is known as a [[https://en.wikipedia.org/wiki/Race_condition][race condition]], but the fix is trivial. We just make sure to buffer the channel `ch` (by adding the buffer length as the second argument to [[https://golang.org/pkg/builtin/#make][make]]), guaranteeing that the first send has a place to put the value. This ensures the send will always succeed, and the first value to arrive will be retrieved regardless of the order of execution.
 
 These two examples demonstrate the simplicity with which Go can express complex interactions between goroutines.
diff --git a/blog/content/go-fmt-your-code.article b/blog/content/go-fmt-your-code.article
index e95dd6e..a60fe8c 100644
--- a/blog/content/go-fmt-your-code.article
+++ b/blog/content/go-fmt-your-code.article
@@ -6,7 +6,7 @@
 
 * Introduction
 
-[[http://golang.org/cmd/gofmt/][Gofmt]] is a tool that automatically formats Go source code.
+[[https://golang.org/cmd/gofmt/][Gofmt]] is a tool that automatically formats Go source code.
 
 Gofmt'd code is:
 
@@ -26,7 +26,7 @@
 
 	 gofmt -w yourcode.go
 
-Or you can use the "[[http://golang.org/cmd/go/#hdr-Run_gofmt_on_package_sources][go fmt]]" command:
+Or you can use the "[[https://golang.org/cmd/go/#hdr-Run_gofmt_on_package_sources][go fmt]]" command:
 
 	 go fmt path/to/your/package
 
@@ -52,11 +52,11 @@
 
 where both pattern and replacement are valid Go expressions. In the pattern, single-character lowercase identifiers serve as wildcards matching arbitrary sub-expressions, and those expressions are substituted for the same identifiers in the replacement.
 
-For example, this[[https://golang.org/cl/7038051][ recent change]] to the Go core rewrote some uses of [[http://golang.org/pkg/bytes/#Compare][bytes.Compare]] to use the more efficient [[http://golang.org/pkg/bytes/#Equal][bytes.Equal]]. The contributor made the change using just two gofmt invocations:
+For example, this[[https://golang.org/cl/7038051][ recent change]] to the Go core rewrote some uses of [[https://golang.org/pkg/bytes/#Compare][bytes.Compare]] to use the more efficient [[https://golang.org/pkg/bytes/#Equal][bytes.Equal]]. The contributor made the change using just two gofmt invocations:
 
 	 gofmt -r 'bytes.Compare(a, b) == 0 -> bytes.Equal(a, b)'
 	 gofmt -r 'bytes.Compare(a, b) != 0 -> !bytes.Equal(a, b)'
 
-Gofmt also enables [[http://golang.org/cmd/fix/][gofix]], which can make arbitrarily complex source transformations. Gofix was an invaluable tool during the early days when we regularly made breaking changes to the language and libraries. For example, before Go 1 the built-in error interface didn't exist and the convention was to use the os.Error type. When we [[http://golang.org/doc/go1.html#errors][introduced error]], we provided a gofix module that rewrote all references to os.Error and its associated helper functions to use error and the new [[http://golang.org/pkg/errors/][errors package]]. 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.
+Gofmt also enables [[https://golang.org/cmd/fix/][gofix]], which can make arbitrarily complex source transformations. Gofix was an invaluable tool during the early days when we regularly made breaking changes to the language and libraries. For example, before Go 1 the built-in error interface didn't exist and the convention was to use the os.Error type. When we [[https://golang.org/doc/go1.html#errors][introduced error]], we provided a gofix module that rewrote all references to os.Error and its associated helper functions to use error and the new [[https://golang.org/pkg/errors/][errors package]]. 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 [[https://blog.golang.org/introducing-gofix][this article]].
diff --git a/blog/content/go-for-app-engine-is-now-generally.article b/blog/content/go-for-app-engine-is-now-generally.article
index 21d1c59..1674722 100644
--- a/blog/content/go-for-app-engine-is-now-generally.article
+++ b/blog/content/go-for-app-engine-is-now-generally.article
@@ -10,7 +10,7 @@
 
 Since we announced the Go runtime at Google I/O we have continued to [[http://code.google.com/p/googleappengine/wiki/SdkForGoReleaseNotes][improve and extend]] Go support for the App Engine APIs and have added the Channels API. The Go Datastore API now supports transactions and ancestor queries, too. See the [[https://code.google.com/appengine/docs/go/][Go App Engine documentation]] for all the details.
 
-For those who have been using the Go SDK already, please note that the 1.5.2 release introduces `api_version` 2. This is because the new SDK is based on Go `release.r58.1` (the current stable version of Go) and is not backwards compatible with the previous release. Existing apps may require changes as per the [[http://golang.org/doc/devel/release.html#r58][r58 release notes]]. Once you've updated your code, you should redeploy your app with the line `api_version:`2` in its `app.yaml` file. Apps written against `api_version` 1 will stop working after the 18th of August.
+For those who have been using the Go SDK already, please note that the 1.5.2 release introduces `api_version` 2. This is because the new SDK is based on Go `release.r58.1` (the current stable version of Go) and is not backwards compatible with the previous release. Existing apps may require changes as per the [[https://golang.org/doc/devel/release.html#r58][r58 release notes]]. Once you've updated your code, you should redeploy your app with the line `api_version:`2` in its `app.yaml` file. Apps written against `api_version` 1 will stop working after the 18th of August.
 
 Finally, we owe a huge thanks to our trusted testers and their many bug reports. Their help was invaluable in reaching this important milestone.
 
diff --git a/blog/content/go-image-package.article b/blog/content/go-image-package.article
index 6734e8b..347c597 100644
--- a/blog/content/go-image-package.article
+++ b/blog/content/go-image-package.article
@@ -6,11 +6,11 @@
 
 * Introduction
 
-The [[http://golang.org/pkg/image/][image]] and [[http://golang.org/pkg/image/color/][image/color]] packages define a number of types: `color.Color` and `color.Model` describe colors, `image.Point` and `image.Rectangle` describe basic 2-D geometry, and `image.Image` brings the two concepts together to represent a rectangular grid of colors. A [[http://golang.org/doc/articles/image_draw.html][separate article]] covers image composition with the [[http://golang.org/pkg/image/draw/][image/draw]] package.
+The [[https://golang.org/pkg/image/][image]] and [[https://golang.org/pkg/image/color/][image/color]] packages define a number of types: `color.Color` and `color.Model` describe colors, `image.Point` and `image.Rectangle` describe basic 2-D geometry, and `image.Image` brings the two concepts together to represent a rectangular grid of colors. A [[https://golang.org/doc/articles/image_draw.html][separate article]] covers image composition with the [[https://golang.org/pkg/image/draw/][image/draw]] package.
 
 * Colors and Color Models
 
-[[http://golang.org/pkg/image/color/#Color][Color]] is an interface that defines the minimal method set of any type that can be considered a color: one that can be converted to red, green, blue and alpha values. The conversion may be lossy, such as converting from CMYK or YCbCr color spaces.
+[[https://golang.org/pkg/image/color/#Color][Color]] is an interface that defines the minimal method set of any type that can be considered a color: one that can be converted to red, green, blue and alpha values. The conversion may be lossy, such as converting from CMYK or YCbCr color spaces.
 
 	type Color interface {
 	    // RGBA returns the alpha-premultiplied red, green, blue and alpha values
@@ -32,15 +32,15 @@
 
 The last line of that code snippet would have been more complicated if we worked with non-alpha-premultiplied colors, which is why `Color` uses alpha-premultiplied values.
 
-The image/color package also defines a number of concrete types that implement the `Color` interface. For example, [[http://golang.org/pkg/image/color/#RGBA][`RGBA`]] is a struct that represents the classic "8 bits per channel" color.
+The image/color package also defines a number of concrete types that implement the `Color` interface. For example, [[https://golang.org/pkg/image/color/#RGBA][`RGBA`]] is a struct that represents the classic "8 bits per channel" color.
 
 	type RGBA struct {
 	    R, G, B, A uint8
 	}
 
-Note that the `R` field of an `RGBA` is an 8-bit alpha-premultiplied color in the range [0, 255]. `RGBA` satisfies the `Color` interface by multiplying that value by 0x101 to generate a 16-bit alpha-premultiplied color in the range [0, 65535]. Similarly, the [[http://golang.org/pkg/image/color/#NRGBA][`NRGBA`]] struct type represents an 8-bit non-alpha-premultiplied color, as used by the PNG image format. When manipulating an `NRGBA`'s fields directly, the values are non-alpha-premultiplied, but when calling the `RGBA` method, the return values are alpha-premultiplied.
+Note that the `R` field of an `RGBA` is an 8-bit alpha-premultiplied color in the range [0, 255]. `RGBA` satisfies the `Color` interface by multiplying that value by 0x101 to generate a 16-bit alpha-premultiplied color in the range [0, 65535]. Similarly, the [[https://golang.org/pkg/image/color/#NRGBA][`NRGBA`]] struct type represents an 8-bit non-alpha-premultiplied color, as used by the PNG image format. When manipulating an `NRGBA`'s fields directly, the values are non-alpha-premultiplied, but when calling the `RGBA` method, the return values are alpha-premultiplied.
 
-A [[http://golang.org/pkg/image/color/#Model][`Model`]] is simply something that can convert `Color`s to other `Color`s, possibly lossily. For example, the `GrayModel` can convert any `Color` to a desaturated [[http://golang.org/pkg/image/color/#Gray][`Gray`]]. A `Palette` can convert any `Color` to one from a limited palette.
+A [[https://golang.org/pkg/image/color/#Model][`Model`]] is simply something that can convert `Color`s to other `Color`s, possibly lossily. For example, the `GrayModel` can convert any `Color` to a desaturated [[https://golang.org/pkg/image/color/#Gray][`Gray`]]. A `Palette` can convert any `Color` to one from a limited palette.
 
 	type Model interface {
 	    Convert(c Color) Color
@@ -50,7 +50,7 @@
 
 * Points and Rectangles
 
-A [[http://golang.org/pkg/image/#Point][`Point`]] is an (x, y) co-ordinate on the integer grid, with axes increasing right and down. It is neither a pixel nor a grid square. A `Point` has no intrinsic width, height or color, but the visualizations below use a small colored square.
+A [[https://golang.org/pkg/image/#Point][`Point`]] is an (x, y) co-ordinate on the integer grid, with axes increasing right and down. It is neither a pixel nor a grid square. A `Point` has no intrinsic width, height or color, but the visualizations below use a small colored square.
 
 	type Point struct {
 	    X, Y int
@@ -60,7 +60,7 @@
 
 	    p := image.Point{2, 1}
 
-A [[http://golang.org/pkg/image/#Rectangle][`Rectangle`]] is an axis-aligned rectangle on the integer grid, defined by its top-left and bottom-right `Point`.  A `Rectangle` also has no intrinsic color, but the visualizations below outline rectangles with a thin colored line, and call out their `Min` and `Max` `Point`s.
+A [[https://golang.org/pkg/image/#Rectangle][`Rectangle`]] is an axis-aligned rectangle on the integer grid, defined by its top-left and bottom-right `Point`.  A `Rectangle` also has no intrinsic color, but the visualizations below outline rectangles with a thin colored line, and call out their `Min` and `Max` `Point`s.
 
 	type Rectangle struct {
 	    Min, Max Point
@@ -95,7 +95,7 @@
 
 * Images
 
-An [[http://golang.org/pkg/image/#Image][Image]] maps every grid square in a `Rectangle` to a `Color` from a `Model`. "The pixel at (x, y)" refers to the color of the grid square defined by the points (x, y), (x+1, y), (x+1, y+1) and (x, y+1).
+An [[https://golang.org/pkg/image/#Image][Image]] maps every grid square in a `Rectangle` to a `Color` from a `Model`. "The pixel at (x, y)" refers to the color of the grid square defined by the points (x, y), (x+1, y), (x+1, y+1) and (x, y+1).
 
 	type Image interface {
 	    // ColorModel returns the Image's color model.
@@ -118,13 +118,13 @@
 	 }
 	}
 
-`Image` implementations do not have to be based on an in-memory slice of pixel data. For example, a [[http://golang.org/pkg/image/#Uniform][`Uniform`]] is an `Image` of enormous bounds and uniform color, whose in-memory representation is simply that color.
+`Image` implementations do not have to be based on an in-memory slice of pixel data. For example, a [[https://golang.org/pkg/image/#Uniform][`Uniform`]] is an `Image` of enormous bounds and uniform color, whose in-memory representation is simply that color.
 
 	type Uniform struct {
 	    C color.Color
 	}
 
-Typically, though, programs will want an image based on a slice. Struct types like [[http://golang.org/pkg/image/#RGBA][`RGBA`]] and [[http://golang.org/pkg/image/#Gray][`Gray`]] (which other packages refer to as `image.RGBA` and `image.Gray`) hold slices of pixel data and implement the `Image` interface.
+Typically, though, programs will want an image based on a slice. Struct types like [[https://golang.org/pkg/image/#RGBA][`RGBA`]] and [[https://golang.org/pkg/image/#Gray][`Gray`]] (which other packages refer to as `image.RGBA` and `image.Gray`) hold slices of pixel data and implement the `Image` interface.
 
 	type RGBA struct {
 	    // Pix holds the image's pixels, in R, G, B, A order. The pixel at
@@ -152,11 +152,11 @@
 	    fmt.Println(m0.Bounds().Dx(), m1.Bounds().Dx()) // prints 8, 4
 	    fmt.Println(m0.Stride == m1.Stride)             // prints true
 
-For low-level code that works on an image's `Pix` field, be aware that ranging over `Pix` can affect pixels outside an image's bounds. In the example above, the pixels covered by `m1.Pix` are shaded in blue. Higher-level code, such as the `At` and `Set` methods or the [[http://golang.org/pkg/image/draw/][image/draw package]], will clip their operations to the image's bounds.
+For low-level code that works on an image's `Pix` field, be aware that ranging over `Pix` can affect pixels outside an image's bounds. In the example above, the pixels covered by `m1.Pix` are shaded in blue. Higher-level code, such as the `At` and `Set` methods or the [[https://golang.org/pkg/image/draw/][image/draw package]], will clip their operations to the image's bounds.
 
 * Image Formats
 
-The standard package library supports a number of common image formats, such as GIF, JPEG and PNG. If you know the format of a source image file, you can decode from an [[http://golang.org/pkg/io/#Reader][`io.Reader`]] directly.
+The standard package library supports a number of common image formats, such as GIF, JPEG and PNG. If you know the format of a source image file, you can decode from an [[https://golang.org/pkg/io/#Reader][`io.Reader`]] directly.
 
 	import (
 	 "image/jpeg"
@@ -173,7 +173,7 @@
 	 return png.Encode(w, img)
 	}
 
-If you have image data of unknown format, the [[http://golang.org/pkg/image/#Decode][`image.Decode`]] function can detect the format. The set of recognized formats is constructed at run time and is not limited to those in the standard package library. An image format package typically registers its format in an init function, and the main package will "underscore import" such a package solely for the side effect of format registration.
+If you have image data of unknown format, the [[https://golang.org/pkg/image/#Decode][`image.Decode`]] function can detect the format. The set of recognized formats is constructed at run time and is not limited to those in the standard package library. An image format package typically registers its format in an init function, and the main package will "underscore import" such a package solely for the side effect of format registration.
 
 	import (
 	 "image"
diff --git a/blog/content/go-imagedraw-package.article b/blog/content/go-imagedraw-package.article
index 0c98560..a7a864e 100644
--- a/blog/content/go-imagedraw-package.article
+++ b/blog/content/go-imagedraw-package.article
@@ -6,7 +6,7 @@
 
 * Introduction
 
-[[http://golang.org/pkg/image/draw/][Package image/draw]] defines only one operation: drawing a source image onto a destination image, through an optional mask image. This one operation is surprisingly versatile and can perform a number of common image manipulation tasks elegantly and efficiently.
+[[https://golang.org/pkg/image/draw/][Package image/draw]] defines only one operation: drawing a source image onto a destination image, through an optional mask image. This one operation is surprisingly versatile and can perform a number of common image manipulation tasks elegantly and efficiently.
 
 Composition is performed pixel by pixel in the style of the Plan 9 graphics library and the X Render extension. The model is based on the classic "Compositing Digital Images" paper by Porter and Duff, with an additional mask parameter: `dst`=`(src`IN`mask)`OP`dst`. For a fully opaque mask, this reduces to the original Porter-Duff formula: `dst`=`src`OP`dst`. In Go, a nil mask image is equivalent to an infinitely sized, fully opaque mask image.
 
@@ -18,14 +18,14 @@
 
 .image go-imagedraw-package_20.png
 
-The [[http://golang.org/pkg/image/draw/#DrawMask][`DrawMask`]] function takes seven arguments, but an explicit mask and mask-point are usually unnecessary, so the [[http://golang.org/pkg/image/draw/#Draw][`Draw`]] function takes five:
+The [[https://golang.org/pkg/image/draw/#DrawMask][`DrawMask`]] function takes seven arguments, but an explicit mask and mask-point are usually unnecessary, so the [[https://golang.org/pkg/image/draw/#Draw][`Draw`]] function takes five:
 
 	// Draw calls DrawMask with a nil mask.
 	func Draw(dst Image, r image.Rectangle, src image.Image, sp image.Point, op Op)
 	func DrawMask(dst Image, r image.Rectangle, src image.Image, sp image.Point,
 	 mask image.Image, mp image.Point, op Op)
 
-The destination image must be mutable, so the image/draw package defines a [[http://golang.org/pkg/image/draw/#Image][`draw.Image`]] interface which has a `Set` method.
+The destination image must be mutable, so the image/draw package defines a [[https://golang.org/pkg/image/draw/#Image][`draw.Image`]] interface which has a `Set` method.
 
 	type Image interface {
 	    image.Image
diff --git a/blog/content/go-maps-in-action.article b/blog/content/go-maps-in-action.article
index 80c1477..e57edc6 100644
--- a/blog/content/go-maps-in-action.article
+++ b/blog/content/go-maps-in-action.article
@@ -14,7 +14,7 @@
 
 	map[KeyType]ValueType
 
-where `KeyType` may be any type that is [[http://golang.org/ref/spec#Comparison_operators][comparable]] (more on this later), and `ValueType` may be any type at all, including another map!
+where `KeyType` may be any type that is [[https://golang.org/ref/spec#Comparison_operators][comparable]] (more on this later), and `ValueType` may be any type at all, including another map!
 
 This variable `m` is a map of string keys to int values:
 
@@ -106,7 +106,7 @@
 
 * Key types
 
-As mentioned earlier, map keys may be of any type that is comparable. The [[http://golang.org/ref/spec#Comparison_operators][language spec]] defines this precisely, but in short, comparable types are boolean, numeric, string, pointer, channel, and interface types, and structs or arrays that contain only those types. Notably absent from the list are slices, maps, and functions; these types cannot be compared using `==`, and may not be used as map keys.
+As mentioned earlier, map keys may be of any type that is comparable. The [[https://golang.org/ref/spec#Comparison_operators][language spec]] defines this precisely, but in short, comparable types are boolean, numeric, string, pointer, channel, and interface types, and structs or arrays that contain only those types. Notably absent from the list are slices, maps, and functions; these types cannot be compared using `==`, and may not be used as map keys.
 
 It's obvious that strings, ints, and other basic types should be available as map keys, but perhaps unexpected are struct keys. Struct can be used to key data by multiple dimensions. For example, this map of maps could be used to tally web page hits by country:
 
@@ -145,7 +145,7 @@
 
 * Concurrency
 
-[[http://golang.org/doc/faq#atomic_maps][Maps are not safe for concurrent use]]: it's not defined what happens when you read and write to them simultaneously. If you need to read from and write to a map from concurrently executing goroutines, the accesses must be mediated by some kind of synchronization mechanism. One common way to protect maps is with [[http://golang.org/pkg/sync/#RWMutex][sync.RWMutex]].
+[[https://golang.org/doc/faq#atomic_maps][Maps are not safe for concurrent use]]: it's not defined what happens when you read and write to them simultaneously. If you need to read from and write to a map from concurrently executing goroutines, the accesses must be mediated by some kind of synchronization mechanism. One common way to protect maps is with [[https://golang.org/pkg/sync/#RWMutex][sync.RWMutex]].
 
 This statement declares a `counter` variable that is an anonymous struct containing a map and an embedded `sync.RWMutex`.
 
diff --git a/blog/content/go-one-year-ago-today.article b/blog/content/go-one-year-ago-today.article
index f471c54..363bec7 100644
--- a/blog/content/go-one-year-ago-today.article
+++ b/blog/content/go-one-year-ago-today.article
@@ -10,32 +10,32 @@
 
 We set out to build a language for systems programming - the kinds of programs one might typically write in C or C++ - and we were surprised by Go’s utility as a general purpose language. We had anticipated interest from C, C++, and Java programmers, but the flurry of interest from users of dynamically-typed languages like Python and JavaScript was unexpected.  Go’s combination of native compilation, static typing, memory management, and lightweight syntax seemed to strike a chord with a broad cross-section of the programming community.
 
-That cross-section grew to become a dedicated community of enthusiastic Go coders. Our [[http://groups.google.com/group/golang-nuts][mailing list]] has over 3,800 members, with around 1,500 posts each month. The project has over 130 [[http://golang.org/CONTRIBUTORS][contributors]] (people who have submitted code or documentation), and of the 2,800 commits since launch almost one third were contributed by programmers outside the core team. To get all that code into shape, nearly 14,000 emails were exchanged on our [[http://groups.google.com/group/golang-dev][development mailing list]].
+That cross-section grew to become a dedicated community of enthusiastic Go coders. Our [[http://groups.google.com/group/golang-nuts][mailing list]] has over 3,800 members, with around 1,500 posts each month. The project has over 130 [[https://golang.org/CONTRIBUTORS][contributors]] (people who have submitted code or documentation), and of the 2,800 commits since launch almost one third were contributed by programmers outside the core team. To get all that code into shape, nearly 14,000 emails were exchanged on our [[http://groups.google.com/group/golang-dev][development mailing list]].
 
 Those numbers reflect a labor whose fruits are evident in the project’s code base. The compilers have improved substantially, with faster and more efficient code generation, more than one hundred reported bugs fixed, and support for a widening range of operating systems and architectures. The Windows port is approaching completion thanks to a dedicated group of contributors (one of whom became our first non-Google committer to the project). The ARM port has also made great progress, recently reaching the milestone of passing all tests.
 
-The Go tool set has been expanded and improved. The Go documentation tool, [[http://golang.org/cmd/godoc/][godoc]], now supports the documentation of other source trees (you can browse and search your own code) and provides a [[http://golang.org/doc/codewalk/]["code walk"]] interface for presenting tutorial materials (among many more improvements). [[http://golang.org/cmd/goinstall/][Goinstall]] , a new package management tool, allows users to install and update external packages with a single command. [[http://golang.org/cmd/gofmt/][Gofmt]], the Go pretty-printer, now makes syntactic simplifications where possible. [[http://golang.org/misc/goplay/][Goplay]], a web-based “compile-as-you-type” tool, is a convenient way to experiment with Go for those times when you don’t have access to the [[http://golang.org/doc/play/][Go Playground]].
+The Go tool set has been expanded and improved. The Go documentation tool, [[https://golang.org/cmd/godoc/][godoc]], now supports the documentation of other source trees (you can browse and search your own code) and provides a [[https://golang.org/doc/codewalk/]["code walk"]] interface for presenting tutorial materials (among many more improvements). [[https://golang.org/cmd/goinstall/][Goinstall]] , a new package management tool, allows users to install and update external packages with a single command. [[https://golang.org/cmd/gofmt/][Gofmt]], the Go pretty-printer, now makes syntactic simplifications where possible. [[https://golang.org/misc/goplay/][Goplay]], a web-based “compile-as-you-type” tool, is a convenient way to experiment with Go for those times when you don’t have access to the [[https://golang.org/doc/play/][Go Playground]].
 
-The standard library has grown by over 42,000 lines of code and includes 20 new [[http://golang.org/pkg/][packages]].  Among the additions are the [[http://golang.org/pkg/image/jpeg/][jpeg]], [[http://golang.org/pkg/rpc/jsonrpc/][jsonrpc]], [[http://golang.org/pkg/mime/][mime]], [[http://golang.org/pkg/netchan/][netchan]], and [[http://golang.org/pkg/smtp/][smtp]] packages, as well as a slew of new [[http://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 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.) 
 
-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 [[http://golang.org/cmd/cgo/][cgo]] tool has seen many fixes and improvements.
+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.
 
-[[http://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.
+[[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.
 
 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. [[http://golang.org/doc/go_spec.html#Semicolons][spec]]
-- The new built-in functions `copy` and `append` make management of slices more efficient and straightforward. [[http://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)]`. [[http://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]], [[http://golang.org/doc/go_spec.html#Handling_panics][spec]]
-- The new complex number types (`complex`, `complex64`, and `complex128`) simplify certain mathematical operations. [[http://golang.org/doc/go_spec.html#Complex_numbers][spec]], [[http://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). [[http://golang.org/doc/devel/release.html#2010-10-27][release.2010-10-27]], [[http://golang.org/doc/go_spec.html#Composite_literals][spec]]
-- A general syntax for variable function arguments (`...T`) and their propagation (`v...`) is now specified. [[http://golang.org/doc/go_spec.html#Function_Types][spec]], [[http://golang.org/doc/go_spec.html#Passing_arguments_to_..._parameters][ spec]], [[http://golang.org/doc/devel/release.html#2010-09-29][release.2010-09-29]]
+- 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 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]]
  
 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. This means improving the garbage collector, optimizing generated code, and improving the core libraries. We’re also exploring some further additions to the type system to make generic programming easier. A lot has happened in a year; it’s been both thrilling and satisfying.  We hope that this coming year will be even more fruitful than the last.
 
-_If_you’ve_been_meaning_to_get_[back]_into_Go,_now_is_a_great_time_to_do_so!_Check_out_the_ [[http://golang.org/doc/docs.html][_Documentation_]] _and_ [[http://golang.org/doc/install.html][_Getting_Started_]] _pages_for_more_information,_or_just_go_nuts_in_the_ [[http://golang.org/doc/play/][_Go_Playground_]].
+_If_you’ve_been_meaning_to_get_[back]_into_Go,_now_is_a_great_time_to_do_so!_Check_out_the_ [[https://golang.org/doc/docs.html][_Documentation_]] _and_ [[https://golang.org/doc/install.html][_Getting_Started_]] _pages_for_more_information,_or_just_go_nuts_in_the_ [[https://golang.org/doc/play/][_Go_Playground_]].
diff --git a/blog/content/go-programming-language-turns-two.article b/blog/content/go-programming-language-turns-two.article
index c835ec1..888ec91 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 [[http://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 [[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."
 
 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.
 
-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 [[http://golang.org/][golang.org]] by running a version of [[http://golang.org/cmd/godoc/][godoc]] on the App Engine service.
+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 "[[http://golang.org/doc/devel/release.html][release]]" versions of Go that were more reliable and better supported than weekly snapshots. We also introduced [[http://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 [[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]].
 
 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-slices-usage-and-internals.article b/blog/content/go-slices-usage-and-internals.article
index 4ba1365..d4c8dc5 100644
--- a/blog/content/go-slices-usage-and-internals.article
+++ b/blog/content/go-slices-usage-and-internals.article
@@ -230,4 +230,4 @@
 
 * Further Reading
 
-[[http://golang.org/doc/effective_go.html][Effective Go]] contains an in-depth treatment of [[http://golang.org/doc/effective_go.html#slices][slices]] and [[http://golang.org/doc/effective_go.html#arrays][arrays]], and the Go [[http://golang.org/doc/go_spec.html][language specification]] defines [[http://golang.org/doc/go_spec.html#Slice_types][slices]] and their [[http://golang.org/doc/go_spec.html#Length_and_capacity][associated]] [[http://golang.org/doc/go_spec.html#Making_slices_maps_and_channels][helper]] [[http://golang.org/doc/go_spec.html#Appending_and_copying_slices][functions]].
+[[https://golang.org/doc/effective_go.html][Effective Go]] contains an in-depth treatment of [[https://golang.org/doc/effective_go.html#slices][slices]] and [[https://golang.org/doc/effective_go.html#arrays][arrays]], and the Go [[https://golang.org/doc/go_spec.html][language specification]] defines [[https://golang.org/doc/go_spec.html#Slice_types][slices]] and their [[https://golang.org/doc/go_spec.html#Length_and_capacity][associated]] [[https://golang.org/doc/go_spec.html#Making_slices_maps_and_channels][helper]] [[https://golang.org/doc/go_spec.html#Appending_and_copying_slices][functions]].
diff --git a/blog/content/go-turns-three.article b/blog/content/go-turns-three.article
index bc86875..7f75109 100644
--- a/blog/content/go-turns-three.article
+++ b/blog/content/go-turns-three.article
@@ -22,11 +22,11 @@
 We added a package management system
 [[https://groups.google.com/d/msg/golang-nuts/8JFwR3ESjjI/cy7qZzN7Lw4J][goinstall]],
 which eventually became the
-[[http://golang.org/cmd/go/][go command]].
+[[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]].
-Over the past year we've also given [[http://golang.org/doc/#talks][many talks]], created an [[http://tour.golang.org/][interactive introductory tour]]
-and recently we added support for [[http://golang.org/pkg/strings/#pkg-examples][executable examples in package documentation]].
+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,
@@ -35,7 +35,7 @@
 continue to compile and run without change, in many environments,
 on a time scale of years.
 As part of the Go 1 launch we spent months cleaning up the
-[[http://golang.org/doc/go1.html][language and libraries]]
+[[https://golang.org/doc/go1.html][language and libraries]]
 to make it something that will age well.
 
 We're working now toward the release of Go 1.1 in 2013. There will be some
@@ -52,7 +52,7 @@
 [[https://groups.google.com/d/msg/golang-nuts/BNUNbKSypE0/E4qSfpx9qI8J][serving Chrome and other downloads]],
 [[http://code.google.com/p/vitess/][scaling MySQL database at YouTube]],
 and of course running the
-[[http://golang.org/][Go home page]]
+[[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]]
diff --git a/blog/content/go-updates-in-app-engine-171.article b/blog/content/go-updates-in-app-engine-171.article
index 24482e2..a1b0b69 100644
--- a/blog/content/go-updates-in-app-engine-171.article
+++ b/blog/content/go-updates-in-app-engine-171.article
@@ -12,7 +12,7 @@
 
 The [[https://developers.google.com/appengine/docs/go/tools/uploadingdata][bulkloader tool]] can now be used with Go apps, allowing users to upload and download datastore records in bulk. This is useful for backups and offline processing, and a great help when migrating Python or Java apps to the Go runtime.
 
-The [[https://developers.google.com/appengine/docs/go/images/overview][Images Service]] is now available to Go users. The new [[https://developers.google.com/appengine/docs/go/images/reference][appengine/image package]] supports serving images directly from Blobstore and resizing or cropping those images on the fly. Note that this is not the full image service as provided by the Python and Java SDKs, as much of the equivalent functionality is available in the [[http://golang.org/pkg/image/][standard Go image package]] and external packages such as [[http://code.google.com/p/graphics-go/][graphics-go]].
+The [[https://developers.google.com/appengine/docs/go/images/overview][Images Service]] is now available to Go users. The new [[https://developers.google.com/appengine/docs/go/images/reference][appengine/image package]] supports serving images directly from Blobstore and resizing or cropping those images on the fly. Note that this is not the full image service as provided by the Python and Java SDKs, as much of the equivalent functionality is available in the [[https://golang.org/pkg/image/][standard Go image package]] and external packages such as [[http://code.google.com/p/graphics-go/][graphics-go]].
 
 The new [[https://developers.google.com/appengine/docs/go/backends/runtime#RunInBackground][runtime.RunInBackground]] function allows backend requests to spawn a new request independent of the initial request. These can run in the background as long as the backend stays alive.
 
diff --git a/blog/content/go-version-1-is-released.article b/blog/content/go-version-1-is-released.article
index acf6a31..c7bd526 100644
--- a/blog/content/go-version-1-is-released.article
+++ b/blog/content/go-version-1-is-released.article
@@ -13,16 +13,16 @@
 
 The driving motivation for Go 1 is stability for its users. People who write Go 1 programs can be confident that those programs will continue to compile and run without change, in many environments, on a time scale of years. Similarly, authors who write books about Go 1 can be sure that their examples and explanations will be helpful to readers today and into the future.
 
-Forward compatibility is part of stability. Code that compiles in Go 1 should, with few exceptions, continue to compile and run throughout the lifetime of that version, even as we issue updates and bug fixes such as Go version 1.1, 1.2, and so on. The [[http://golang.org/doc/go1compat.html][Go 1 compatibility document]] explains the compatibility guidelines in more detail.
+Forward compatibility is part of stability. Code that compiles in Go 1 should, with few exceptions, continue to compile and run throughout the lifetime of that version, even as we issue updates and bug fixes such as Go version 1.1, 1.2, and so on. The [[https://golang.org/doc/go1compat.html][Go 1 compatibility document]] explains the compatibility guidelines in more detail.
 
-Go 1 is a representation of Go as it is used today, not a major redesign. In its planning, we focused on cleaning up problems and inconsistencies and improving portability. There had long been many changes to Go that we had designed and prototyped but not released because they were backwards-incompatible. Go 1 incorporates these changes, which provide significant improvements to the language and libraries but sometimes introduce incompatibilities for old programs. Fortunately, the [[http://golang.org/cmd/go/#Run_go_tool_fix_on_packages][go fix]] tool can automate much of the work needed to bring programs up to the Go 1 standard.
+Go 1 is a representation of Go as it is used today, not a major redesign. In its planning, we focused on cleaning up problems and inconsistencies and improving portability. There had long been many changes to Go that we had designed and prototyped but not released because they were backwards-incompatible. Go 1 incorporates these changes, which provide significant improvements to the language and libraries but sometimes introduce incompatibilities for old programs. Fortunately, the [[https://golang.org/cmd/go/#Run_go_tool_fix_on_packages][go fix]] tool can automate much of the work needed to bring programs up to the Go 1 standard.
 
-Go 1 introduces changes to the language (such as new types for [[http://golang.org/doc/go1.html#rune][Unicode characters]] and [[http://golang.org/doc/go1.html#errors][errors]]) and the standard library (such as the new [[http://golang.org/doc/go1.html#time][time package]] and renamings in the [[http://golang.org/doc/go1.html#strconv][strconv package]]). Also, the package hierarchy has been rearranged to group related items together, such as moving the networking facilities, for instance the [[http://golang.org/pkg/net/rpc/][rpc package]], into subdirectories of net. A complete list of changes is documented in the [[http://golang.org/doc/go1.html][Go 1 release notes]]. That document is an essential reference for programmers migrating code from earlier versions of Go.
+Go 1 introduces changes to the language (such as new types for [[https://golang.org/doc/go1.html#rune][Unicode characters]] and [[https://golang.org/doc/go1.html#errors][errors]]) and the standard library (such as the new [[https://golang.org/doc/go1.html#time][time package]] and renamings in the [[https://golang.org/doc/go1.html#strconv][strconv package]]). Also, the package hierarchy has been rearranged to group related items together, such as moving the networking facilities, for instance the [[https://golang.org/pkg/net/rpc/][rpc package]], into subdirectories of net. A complete list of changes is documented in the [[https://golang.org/doc/go1.html][Go 1 release notes]]. That document is an essential reference for programmers migrating code from earlier versions of Go.
 
-We also restructured the Go tool suite around the new [[http://golang.org/doc/go1.html#cmd_go][go command]], a program for fetching, building, installing and maintaining Go code. The go command eliminates the need for Makefiles to write Go code because it uses the Go program source itself to derive the build instructions. No more build scripts! 
+We also restructured the Go tool suite around the new [[https://golang.org/doc/go1.html#cmd_go][go command]], a program for fetching, building, installing and maintaining Go code. The go command eliminates the need for Makefiles to write Go code because it uses the Go program source itself to derive the build instructions. No more build scripts! 
 
 Finally, the release of Go 1 triggers a new release of the [[https://developers.google.com/appengine/docs/go][Google App Engine SDK]]. A similar process of revision and stabilization has been applied to the App Engine libraries, providing a base for developers to build programs for App Engine that will run for years.
 
 Go 1 is the result of a major effort by the core Go team and our many contributors from the open source community. We thank everyone who helped make this happen.
 
-There has never been a better time to be a Go programmer. Everything you need to get started is at [[http://golang.org/][golang.org]].
+There has never been a better time to be a Go programmer. Everything you need to get started is at [[https://golang.org/][golang.org]].
diff --git a/blog/content/go-whats-new-in-march-2010.article b/blog/content/go-whats-new-in-march-2010.article
index 858660d..0f5df7b 100644
--- a/blog/content/go-whats-new-in-march-2010.article
+++ b/blog/content/go-whats-new-in-march-2010.article
@@ -11,13 +11,13 @@
  
 The core team at Google has continued to develop the language, compilers, packages, tools, and documentation.  The compilers now produce code that is in some cases between 2x and an order of magnitude faster than at release. We have put together some graphs of a selection of [[http://godashboard.appspot.com/benchmarks][Benchmarks]], and the the [[http://godashboard.appspot.com/][Build Status]] page tracks the reliability of each changeset submitted to the repository.
  
-We have made syntax changes to make the language more concise, regular, and flexible. Semicolons have been [[http://groups.google.com/group/golang-nuts/t/5ee32b588d10f2e9][almost entirely removed]] from the language.  The [[http://golang.org/doc/go_spec.html#Function_types][...T syntax]] makes it simpler to handle an arbitrary number of typed function parameters.  The syntax x[lo:] is now shorthand for x[lo:len(x)]. Go also now natively supports complex numbers. See the [[http://golang.org/doc/devel/release.html][release notes]] for more. 
+We have made syntax changes to make the language more concise, regular, and flexible. Semicolons have been [[http://groups.google.com/group/golang-nuts/t/5ee32b588d10f2e9][almost entirely removed]] from the language.  The [[https://golang.org/doc/go_spec.html#Function_types][...T syntax]] makes it simpler to handle an arbitrary number of typed function parameters.  The syntax x[lo:] is now shorthand for x[lo:len(x)]. Go also now natively supports complex numbers. See the [[https://golang.org/doc/devel/release.html][release notes]] for more. 
  
-[[http://golang.org/cmd/godoc/][Godoc]] now provides better support for third-party libraries, and a new tool - [[http://golang.org/cmd/goinstall][goinstall]] - has been released to make it easy to install them. Additionally, we've started working on a package tracking system to make it easier to find what you need. You can view the beginnings of this on the [[http://godashboard.appspot.com/package][Packages page]].
+[[https://golang.org/cmd/godoc/][Godoc]] now provides better support for third-party libraries, and a new tool - [[https://golang.org/cmd/goinstall][goinstall]] - has been released to make it easy to install them. Additionally, we've started working on a package tracking system to make it easier to find what you need. You can view the beginnings of this on the [[http://godashboard.appspot.com/package][Packages page]].
  
-More than 40,000 lines of code have been added to [[http://golang.org/pkg/][the standard library]], including many entirely new packages, a sizable portion written by external contributors.
+More than 40,000 lines of code have been added to [[https://golang.org/pkg/][the standard library]], including many entirely new packages, a sizable portion written by external contributors.
  
-Speaking of third parties, since launch a vibrant community has flourished on our [[http://groups.google.com/group/golang-nuts/][mailing list]] and irc channel (#go-nuts on freenode). We have officially added [[http://golang.org/CONTRIBUTORS][more than 50 people]] to the project. Their contributions range from bug fixes and documentation corrections to core packages and support for additional operating systems (Go is now supported under FreeBSD, and a [[http://code.google.com/p/go/wiki/WindowsPort][Windows port]] is underway). We regard these community contributions our greatest success so far.
+Speaking of third parties, since launch a vibrant community has flourished on our [[http://groups.google.com/group/golang-nuts/][mailing list]] and irc channel (#go-nuts on freenode). We have officially added [[https://golang.org/CONTRIBUTORS][more than 50 people]] to the project. Their contributions range from bug fixes and documentation corrections to core packages and support for additional operating systems (Go is now supported under FreeBSD, and a [[http://code.google.com/p/go/wiki/WindowsPort][Windows port]] is underway). We regard these community contributions our greatest success so far.
  
 We've received some good reviews, too.  This [[http://www.pcworld.idg.com.au/article/337773/google_go_captures_developers_imaginations/][recent article in PC World]] summarized the enthusiasm surrounding the project.  Several bloggers have begun documenting their experiences in the language (see [[http://golang.tumblr.com/][here]], [[http://www.infi.nl/blog/view/id/47][here]], and [[http://freecella.blogspot.com/2010/01/gospecify-basic-setup-of-projects.html][here]] for example)  The general reaction of our users has been very positive; one first-timer remarked [[https://groups.google.com/group/golang-nuts/browse_thread/thread/5fabdd59f8562ed2]["I came away extremely impressed. Go walks an elegant line between simplicity and power."]]
  
diff --git a/blog/content/go1.3.article b/blog/content/go1.3.article
index 17dc7b7..b02c3ad 100644
--- a/blog/content/go1.3.article
+++ b/blog/content/go1.3.article
@@ -5,13 +5,13 @@
 
 * Go 1.3 is released
 
-Today we are happy to announce the release of [[http://golang.org/doc/go1.3][Go 1.3]].
+Today we are happy to announce the release of [[https://golang.org/doc/go1.3][Go 1.3]].
 This release comes six months after our last major release and provides better
 performance, improved tools, support for running Go in new environments, and more.
 All Go users should upgrade to Go 1.3.
-You can grab the release from our [[http://golang.org/dl/][downloads page]] and
+You can grab the release from our [[https://golang.org/dl/][downloads page]] and
 find the full list of improvements and fixes in the
-[[http://golang.org/doc/go1.3][release notes]].
+[[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]],
@@ -19,39 +19,39 @@
 When enabled with the -analysis flag, analysis results are presented
 in both the source and package documentation views, making it easier
 than ever to navigate and understand Go programs.
-See [[http://golang.org/lib/godoc/analysis/help.html][the documentation]] for the details.
+See [[https://golang.org/lib/godoc/analysis/help.html][the documentation]] 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
 [[http://blog.golang.org/playground][Playground]].
-To set up NaCl on your system see the [[http://golang.org/wiki/NativeClient][NativeClient wiki page]].
+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,
 Plan 9, and Solaris operating systems. To use Go on these systems you must
-[[http://golang.org/doc/install/source][install from source]].
+[[https://golang.org/doc/install/source][install from source]].
 
 Changes to the runtime have improved the
-[[http://golang.org/doc/go1.3#performance][performance]] of Go binaries,
+[[https://golang.org/doc/go1.3#performance][performance]] of Go binaries,
 with an improved garbage collector, a new
-[[http://golang.org/s/contigstacks]["contiguous" goroutine stack management strategy]],
+[[https://golang.org/s/contigstacks]["contiguous" goroutine stack management strategy]],
 a faster race detector, and improvements to the regular expression engine.
 
-As part of the general [[http://golang.org/s/go13linker][overhaul]] of the Go
+As part of the general [[https://golang.org/s/go13linker][overhaul]] of the Go
 linker, the compilers and linkers have been refactored. The instruction
 selection phase that was part of the linker has been moved to the compiler.
 This can speed up incremental builds for large projects.
 
-The [[http://golang.org/doc/go1.3#garbage_collector][garbage collector]] is now
+The [[https://golang.org/doc/go1.3#garbage_collector][garbage collector]] is now
 precise when examining stacks (collection of the heap has been precise since Go
 1.1), meaning that a non-pointer value such as an integer will never be
 mistaken for a pointer and prevent unused memory from being reclaimed. This
 change affects code that uses package unsafe; if you have unsafe code you
-should read the [[http://golang.org/doc/go1.3#garbage_collector][release notes]]
+should read the [[https://golang.org/doc/go1.3#garbage_collector][release notes]]
 carefully to see if your code needs updating.
 
 We would like to thank the many people who contributed to this release;
 it would not have been possible without your help.
 
 So, what are you waiting for?
-Head on over to the [[http://golang.org/dl/][downloads page]] and start hacking.
+Head on over to the [[https://golang.org/dl/][downloads page]] and start hacking.
diff --git a/blog/content/go12.article b/blog/content/go12.article
index eb99788..1161c15 100644
--- a/blog/content/go12.article
+++ b/blog/content/go12.article
@@ -10,37 +10,37 @@
 the Go Programming Language.
 
 Binary distributions may be downloaded from the
-[[http://golang.org/doc/install][usual place]] or if you prefer to
-[[http://golang.org/doc/install/source][compile from source]] you should use
+[[https://golang.org/doc/install][usual place]] or if you prefer to
+[[https://golang.org/doc/install/source][compile from source]] you should use
 the `release` or `go1.2` tags.
 
 This new release comes nearly seven months after the release of Go 1.1 in May,
 a much shorter period than the 14 months between 1.1 and 1.0.
 We anticipate a comparable interval between future major releases.
 
-[[http://golang.org/doc/go1.2][Go 1.2]] includes a couple of minor
+[[https://golang.org/doc/go1.2][Go 1.2]] includes a couple of minor
 language changes, several improvements to the language implementation and
 tools, some performance improvements, and many additions and
 (backward-compatible) changes to the standard library.
 
-Please read the [[http://golang.org/doc/go1.2][release notes]] for all
+Please read the [[https://golang.org/doc/go1.2][release notes]] for all
 the details, as some changes may affect the behavior of existing (buggy) programs.
 What follows is the highlights of the release.
 
-A new [[http://golang.org/doc/go1.2#three_index][three-index slice syntax]]
+A new [[https://golang.org/doc/go1.2#three_index][three-index slice syntax]]
 adds the ability to specify capacity as well as length. This allows the
 programmer to pass a slice value that can only access a limited portion of the
 underlying array, a technique that previously required the use of the unsafe
 package.
 
 A major new feature of the tool chain is the facility to compute and display
-[[http://golang.org/doc/go1.2#cover][test coverage results]].
-See the [[http://golang.org/cmd/go/#hdr-Description_of_testing_flags][`go`test`]]
+[[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]]
 documentation for details. Later this week we will publish an article that
 discusses this new feature in detail.
 
-Goroutines are now [[http://golang.org/doc/go1.2#preemption][pre-emptively scheduled]],
+Goroutines are now [[https://golang.org/doc/go1.2#preemption][pre-emptively scheduled]],
 in that the scheduler is invoked occasionally upon entry to a function.
 This can prevent busy goroutines from starving other goroutines on the same
 thread.
@@ -49,17 +49,17 @@
 performance of some programs. (The old size had a tendency to introduce
 expensive stack-segment switching in performance-critical sections.)
 On the other end, new restrictions on
-[[http://golang.org/doc/go1.2#stack_size][stack sizes]] and
-[[http://golang.org/doc/go1.2#thread_limit][the number of operating system threads]]
+[[https://golang.org/doc/go1.2#stack_size][stack sizes]] and
+[[https://golang.org/doc/go1.2#thread_limit][the number of operating system threads]]
 should prevent misbehaving programs from consuming all the resources of a
 machine. (These limits may be adjusted using new functions in the
-[[http://golang.org/pkg/runtime/debug][`runtime/debug` package]].)
+[[https://golang.org/pkg/runtime/debug][`runtime/debug` package]].)
 
-Finally, among the [[http://golang.org/doc/go1.2#library][many changes to the standard library]],
+Finally, among the [[https://golang.org/doc/go1.2#library][many changes to the standard library]],
 significant changes include
-the new [[http://golang.org/doc/go1.2#encoding][`encoding` package]],
-[[http://golang.org/doc/go1.2#fmt_indexed_arguments][indexed arguments]] in `Printf` format strings, and
-some [[http://golang.org/doc/go1.2#text_template][convenient additions]] to the template packages.
+the new [[https://golang.org/doc/go1.2#encoding][`encoding` package]],
+[[https://golang.org/doc/go1.2#fmt_indexed_arguments][indexed arguments]] in `Printf` format strings, and
+some [[https://golang.org/doc/go1.2#text_template][convenient additions]] to the template packages.
 
 As part of the release, the [[http://play.golang.org/][Go Playground]] has been
 updated to Go 1.2. This also affects services that use the Playground, such as
diff --git a/blog/content/gobs-of-data.article b/blog/content/gobs-of-data.article
index 95dfa67..fc82bbf 100644
--- a/blog/content/gobs-of-data.article
+++ b/blog/content/gobs-of-data.article
@@ -6,9 +6,9 @@
 
 * Introduction
 
-To transmit a data structure across a network or to store it in a file, it must be encoded and then decoded again. There are many encodings available, of course: [[http://www.json.org/][JSON]], [[http://www.w3.org/XML/][XML]], Google's [[http://code.google.com/p/protobuf][protocol buffers]], and more. And now there's another, provided by Go's [[http://golang.org/pkg/encoding/gob/][gob]] package.
+To transmit a data structure across a network or to store it in a file, it must be encoded and then decoded again. There are many encodings available, of course: [[http://www.json.org/][JSON]], [[http://www.w3.org/XML/][XML]], Google's [[http://code.google.com/p/protobuf][protocol buffers]], and more. And now there's another, provided by Go's [[https://golang.org/pkg/encoding/gob/][gob]] package.
 
-Why define a new encoding? It's a lot of work and redundant at that. Why not just use one of the existing formats? Well, for one thing, we do! Go has [[http://golang.org/pkg/][packages]] supporting all the encodings just mentioned (the [[http://github.com/golang/protobuf][protocol buffer package]] is in a separate repository but it's one of the most frequently downloaded). And for many purposes, including communicating with tools and systems written in other languages, they're the right choice.
+Why define a new encoding? It's a lot of work and redundant at that. Why not just use one of the existing formats? Well, for one thing, we do! Go has [[https://golang.org/pkg/][packages]] supporting all the encodings just mentioned (the [[http://github.com/golang/protobuf][protocol buffer package]] is in a separate repository but it's one of the most frequently downloaded). And for many purposes, including communicating with tools and systems written in other languages, they're the right choice.
 
 But for a Go-specific environment, such as communicating between two servers written in Go, there's an opportunity to build something much easier to use and possibly more efficient.
 
@@ -60,7 +60,7 @@
 
 From integers we can build all the other types: bytes, strings, arrays, slices, maps, even floats. Floating-point values are represented by their IEEE 754 floating-point bit pattern, stored as an integer, which works fine as long as you know their type, which we always do. By the way, that integer is sent in byte-reversed order because common values of floating-point numbers, such as small integers, have a lot of zeros at the low end that we can avoid transmitting.
 
-One nice feature of gobs that Go makes possible is that they allow you to define your own encoding by having your type satisfy the [[http://golang.org/pkg/encoding/gob/#GobEncoder][GobEncoder]] and [[http://golang.org/pkg/encoding/gob/#GobDecoder][GobDecoder]] interfaces, in a manner analogous to the [[http://golang.org/pkg/encoding/json/][JSON]] package's [[http://golang.org/pkg/encoding/json/#Marshaler][Marshaler]] and [[http://golang.org/pkg/encoding/json/#Unmarshaler][Unmarshaler]] and also to the [[http://golang.org/pkg/fmt/#Stringer][Stringer]] interface from [[http://golang.org/pkg/fmt/][package fmt]]. This facility makes it possible to represent special features, enforce constraints, or hide secrets when you transmit data. See the [[http://golang.org/pkg/encoding/gob/][documentation]] for details.
+One nice feature of gobs that Go makes possible is that they allow you to define your own encoding by having your type satisfy the [[https://golang.org/pkg/encoding/gob/#GobEncoder][GobEncoder]] and [[https://golang.org/pkg/encoding/gob/#GobDecoder][GobDecoder]] interfaces, in a manner analogous to the [[https://golang.org/pkg/encoding/json/][JSON]] package's [[https://golang.org/pkg/encoding/json/#Marshaler][Marshaler]] and [[https://golang.org/pkg/encoding/json/#Unmarshaler][Unmarshaler]] and also to the [[https://golang.org/pkg/fmt/#Stringer][Stringer]] interface from [[https://golang.org/pkg/fmt/][package fmt]]. This facility makes it possible to represent special features, enforce constraints, or hide secrets when you transmit data. See the [[https://golang.org/pkg/encoding/gob/][documentation]] for details.
 
 * Types on the wire
 
@@ -91,7 +91,7 @@
 
 * Use
 
-There's a lot going on under the hood, but the result is an efficient, easy-to-use encoding system for transmitting data. Here's a complete example showing differing encoded and decoded types. Note how easy it is to send and receive values; all you need to do is present values and variables to the [[http://golang.org/pkg/encoding/gob/][gob package]] and it does all the work.
+There's a lot going on under the hood, but the result is an efficient, easy-to-use encoding system for transmitting data. Here's a complete example showing differing encoded and decoded types. Note how easy it is to send and receive values; all you need to do is present values and variables to the [[https://golang.org/pkg/encoding/gob/][gob package]] and it does all the work.
 
 	package main
 
@@ -135,8 +135,8 @@
 
 You can compile and run this example code in the [[http://play.golang.org/p/_-OJV-rwMq][Go Playground]].
 
-The [[http://golang.org/pkg/net/rpc/][rpc package]] builds on gobs to turn this encode/decode automation into transport for method calls across the network. That's a subject for another article.
+The [[https://golang.org/pkg/net/rpc/][rpc package]] builds on gobs to turn this encode/decode automation into transport for method calls across the network. That's a subject for another article.
 
 * Details
 
-The [[http://golang.org/pkg/encoding/gob/][gob package documentation]], especially the file [[http://golang.org/src/pkg/encoding/gob/doc.go][doc.go]], expands on many of the details described here and includes a full worked example showing how the encoding represents data. If you are interested in the innards of the gob implementation, that's a good place to start.
+The [[https://golang.org/pkg/encoding/gob/][gob package documentation]], especially the file [[https://golang.org/src/pkg/encoding/gob/doc.go][doc.go]], expands on many of the details described here and includes a full worked example showing how the encoding represents data. If you are interested in the innards of the gob implementation, that's a good place to start.
diff --git a/blog/content/godoc-documenting-go-code.article b/blog/content/godoc-documenting-go-code.article
index 30d5dab..e9ad9ff 100644
--- a/blog/content/godoc-documenting-go-code.article
+++ b/blog/content/godoc-documenting-go-code.article
@@ -8,13 +8,13 @@
 
 The Go project takes documentation seriously. Documentation is a huge part of making software accessible and maintainable. Of course it must be well-written and accurate, but it also must be easy to write and to maintain. Ideally, it should be coupled to the code itself so the documentation evolves along with the code. The easier it is for programmers to produce good documentation, the better for everyone.
 
-To that end, we have developed the [[http://golang.org/cmd/godoc/][godoc]] documentation tool. This article describes godoc's approach to documentation, and explains how you can use our conventions and tools to write good documentation for your own projects.
+To that end, we have developed the [[https://golang.org/cmd/godoc/][godoc]] documentation tool. This article describes godoc's approach to documentation, and explains how you can use our conventions and tools to write good documentation for your own projects.
 
-Godoc parses Go source code - including comments - and produces documentation as HTML or plain text. The end result is documentation tightly coupled with the code it documents. For example, through godoc's web interface you can navigate from a function's [[http://golang.org/pkg/strings/#HasPrefix][documentation]] to its [[http://golang.org/src/pkg/strings/strings.go#L493][implementation]] with one click.
+Godoc parses Go source code - including comments - and produces documentation as HTML or plain text. The end result is documentation tightly coupled with the code it documents. For example, through godoc's web interface you can navigate from a function's [[https://golang.org/pkg/strings/#HasPrefix][documentation]] to its [[https://golang.org/src/pkg/strings/strings.go#L493][implementation]] with one click.
 
 Godoc is conceptually related to Python's [[http://www.python.org/dev/peps/pep-0257/][Docstring]] and Java's [[http://www.oracle.com/technetwork/java/javase/documentation/index-jsp-135444.html][Javadoc]], but its design is simpler. The comments read by godoc are not language constructs (as with Docstring) nor must they have their own machine-readable syntax (as with Javadoc). Godoc comments are just good comments, the sort you would want to read even if godoc didn't exist.
 
-The convention is simple: to document a type, variable, constant, function, or even a package, write a regular comment directly preceding its declaration, with no intervening blank line. Godoc will then present that comment as text alongside the item it documents. For example, this is the documentation for the `fmt` package's [[http://golang.org/pkg/fmt/#Fprint][`Fprint`]] function:
+The convention is simple: to document a type, variable, constant, function, or even a package, write a regular comment directly preceding its declaration, with no intervening blank line. Godoc will then present that comment as text alongside the item it documents. For example, this is the documentation for the `fmt` package's [[https://golang.org/pkg/fmt/#Fprint][`Fprint`]] function:
 
 	// Fprint formats using the default formats for its operands and writes to w.
 	// Spaces are added between operands when neither is a string.
@@ -23,17 +23,17 @@
 
 Notice this comment is a complete sentence that begins with the name of the element it describes. This important convention allows us to generate documentation in a variety of formats, from plain text to HTML to UNIX man pages, and makes it read better when tools truncate it for brevity, such as when they extract the first line or sentence.
 
-Comments on package declarations should provide general package documentation. These comments can be short, like the [[http://golang.org/pkg/sort/][`sort`]] package's brief description:
+Comments on package declarations should provide general package documentation. These comments can be short, like the [[https://golang.org/pkg/sort/][`sort`]] package's brief description:
 
 	// Package sort provides primitives for sorting slices and user-defined
 	// collections.
 	package sort
 
-They can also be detailed like the [[http://golang.org/pkg/encoding/gob/][gob package]]'s overview. That package uses another convention for packages that need large amounts of introductory documentation: the package comment is placed in its own file, [[http://golang.org/src/pkg/encoding/gob/doc.go][doc.go]], which contains only those comments and a package clause.
+They can also be detailed like the [[https://golang.org/pkg/encoding/gob/][gob package]]'s overview. That package uses another convention for packages that need large amounts of introductory documentation: the package comment is placed in its own file, [[https://golang.org/src/pkg/encoding/gob/doc.go][doc.go]], which contains only those comments and a package clause.
 
-When writing package comments of any size, keep in mind that their first sentence will appear in godoc's [[http://golang.org/pkg/][package list]].
+When writing package comments of any size, keep in mind that their first sentence will appear in godoc's [[https://golang.org/pkg/][package list]].
 
-Comments that are not adjacent to a top-level declaration are omitted from godoc's output, with one notable exception. Top-level comments that begin with the word `"BUG(who)”` are recognized as known bugs, and included in the "Bugs” section of the package documentation. The "who” part should be the user name of someone who could provide more information. For example, this is a known issue from the [[http://golang.org/pkg/bytes/#pkg-note-BUG][bytes package]]:
+Comments that are not adjacent to a top-level declaration are omitted from godoc's output, with one notable exception. Top-level comments that begin with the word `"BUG(who)”` are recognized as known bugs, and included in the "Bugs” section of the package documentation. The "who” part should be the user name of someone who could provide more information. For example, this is a known issue from the [[https://golang.org/pkg/bytes/#pkg-note-BUG][bytes package]]:
 
 	// BUG(r): The rule Title uses for word boundaries does not handle Unicode punctuation properly.
 
@@ -49,7 +49,7 @@
 
 - Subsequent lines of text are considered part of the same paragraph; you must leave a blank line to separate paragraphs.
 
-- Pre-formatted text must be indented relative to the surrounding comment text (see gob's [[http://golang.org/src/pkg/encoding/gob/doc.go][doc.go]] for an example).
+- Pre-formatted text must be indented relative to the surrounding comment text (see gob's [[https://golang.org/src/pkg/encoding/gob/doc.go][doc.go]] for an example).
 
 - URLs will be converted to HTML links; no special markup is necessary.
 
@@ -57,4 +57,4 @@
 
 In fact, the best thing about godoc's minimal approach is how easy it is to use. As a result, a lot of Go code, including all of the standard library, already follows the conventions.
 
-Your own code can present good documentation just by having comments as described above. Any Go packages installed inside `$GOROOT/src/pkg` and any `GOPATH` work spaces will already be accessible via godoc's command-line and HTTP interfaces, and you can specify additional paths for indexing via the `-path` flag or just by running `"godoc`."` in the source directory. See the [[http://golang.org/cmd/godoc/][godoc documentation]] for more details.
+Your own code can present good documentation just by having comments as described above. Any Go packages installed inside `$GOROOT/src/pkg` and any `GOPATH` work spaces will already be accessible via godoc's command-line and HTTP interfaces, and you can specify additional paths for indexing via the `-path` flag or just by running `"godoc`."` in the source directory. See the [[https://golang.org/cmd/godoc/][godoc documentation]] for more details.
diff --git a/blog/content/gopher.article b/blog/content/gopher.article
index 27b7985..a72b265 100644
--- a/blog/content/gopher.article
+++ b/blog/content/gopher.article
@@ -50,7 +50,7 @@
 
 The Go gopher is a character; a unique creation. Not any old gopher, just as Snoopy is not any old cartoon dog.
 
-The [[http://golang.org/doc/gopher/][gopher images]] are Creative Commons Attributions 3.0 licensed. That means you can play with the images but you must give credit to their creator (Renee French) wherever they are used.
+The [[https://golang.org/doc/gopher/][gopher images]] are Creative Commons Attributions 3.0 licensed. That means you can play with the images but you must give credit to their creator (Renee French) wherever they are used.
 
 Here are a few gopher adaptations that people have used as mascots for user group mascots and similar organizations.
 
diff --git a/blog/content/introducing-go-playground.article b/blog/content/introducing-go-playground.article
index cee1484..5fed8ae 100644
--- a/blog/content/introducing-go-playground.article
+++ b/blog/content/introducing-go-playground.article
@@ -6,11 +6,11 @@
 
 * Introduction
 
-If you visit [[http://golang.org/][golang.org]] today you'll see our new look. We have given the site a new coat of paint and reorganized its content to make it easier to find. These changes are also reflected in the web interface of [[http://golang.org/cmd/godoc/][godoc]], the Go documentation tool.
-But the real news is a prominent new feature: the [[http://golang.org/][Go Playground]].
+If you visit [[https://golang.org/][golang.org]] today you'll see our new look. We have given the site a new coat of paint and reorganized its content to make it easier to find. These changes are also reflected in the web interface of [[https://golang.org/cmd/godoc/][godoc]], the Go documentation tool.
+But the real news is a prominent new feature: the [[https://golang.org/][Go Playground]].
 .image introducing-go-playground_Untitled.png
 
-The Playground allows anyone with a web browser to write Go code that we immediately compile, link, and run on our servers. There are a few example programs to get you started (see the "Examples" drop-down). We hope that this will give curious programmers an opportunity to try the language before [[http://golang.org/doc/install.html][installing it]], and experienced Go users a convenient place in which to experiment. Beyond the front page, this functionality has the potential to make our reference and tutorial materials more engaging. We hope to extend its use in the near future.
+The Playground allows anyone with a web browser to write Go code that we immediately compile, link, and run on our servers. There are a few example programs to get you started (see the "Examples" drop-down). We hope that this will give curious programmers an opportunity to try the language before [[https://golang.org/doc/install.html][installing it]], and experienced Go users a convenient place in which to experiment. Beyond the front page, this functionality has the potential to make our reference and tutorial materials more engaging. We hope to extend its use in the near future.
 
-Of course, there are some limitations to the kinds of programs you can run in the Playground. We can't simply accept arbitrary code and run it on our servers without restrictions. The programs build and run in a sandbox with a reduced standard library; the only communication your program has to the outside world is via standard output, and there are limits to CPU and memory use. As such, consider this just a taste of the wonderful world of Go; to have the full experience you'll need to [[http://golang.org/doc/install.html][download it yourself]].
-If you've been meaning to try Go but never got around to it, why not visit [[http://golang.org/][golang.org]] to try it right now?
+Of course, there are some limitations to the kinds of programs you can run in the Playground. We can't simply accept arbitrary code and run it on our servers without restrictions. The programs build and run in a sandbox with a reduced standard library; the only communication your program has to the outside world is via standard output, and there are limits to CPU and memory use. As such, consider this just a taste of the wonderful world of Go; to have the full experience you'll need to [[https://golang.org/doc/install.html][download it yourself]].
+If you've been meaning to try Go but never got around to it, why not visit [[https://golang.org/][golang.org]] to try it right now?
diff --git a/blog/content/introducing-gofix.article b/blog/content/introducing-gofix.article
index 3b93379..98b7b80 100644
--- a/blog/content/introducing-gofix.article
+++ b/blog/content/introducing-gofix.article
@@ -8,7 +8,7 @@
 
 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.
 
-[[http://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.
+[[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.
 
 Each time we make a significant API change we’ll add code to gofix to take care of the conversion, as much as mechanically possible.  When you update to a new Go release and your code no longer builds, just run gofix on your source directory.
 
@@ -50,6 +50,6 @@
 
 Nearly every line above changed in some small way. The changes involved in the rewrite are extensive but nearly entirely mechanical, just the kind of thing that computers are great at doing.  
 
-Gofix is possible because Go has support in its standard libraries for [[http://golang.org/pkg/go/parser][parsing Go source files into syntax trees]] and also for [[http://golang.org/pkg/go/printer][printing those syntax trees back to Go source code]]. Importantly, the Go printing library prints a program in the official format (typically enforced via the gofmt tool), allowing gofix to make mechanical changes to Go programs without causing spurious formatting changes. In fact, one of the key motivations for creating gofmt—perhaps second only to avoiding debates about where a particular brace belongs—was to simplify the creation of tools that rewrite Go programs, as gofix does.
+Gofix is possible because Go has support in its standard libraries for [[https://golang.org/pkg/go/parser][parsing Go source files into syntax trees]] and also for [[https://golang.org/pkg/go/printer][printing those syntax trees back to Go source code]]. Importantly, the Go printing library prints a program in the official format (typically enforced via the gofmt tool), allowing gofix to make mechanical changes to Go programs without causing spurious formatting changes. In fact, one of the key motivations for creating gofmt—perhaps second only to avoiding debates about where a particular brace belongs—was to simplify the creation of tools that rewrite Go programs, as gofix does.
 
 Gofix has already made itself indispensable. In particular, the recent reflect changes would have been unpalatable without automated conversion, and the reflect API badly needed to be redone. Gofix gives us the ability to fix mistakes or completely rethink package APIs without worrying about the cost of converting existing code. We hope you find gofix as useful and convenient as we have.
diff --git a/blog/content/json-and-go.article b/blog/content/json-and-go.article
index 4a9f55a..95ab377 100644
--- a/blog/content/json-and-go.article
+++ b/blog/content/json-and-go.article
@@ -8,11 +8,11 @@
 
 JSON (JavaScript Object Notation) is a simple data interchange format. Syntactically it resembles the objects and lists of JavaScript. It is most commonly used for communication between web back-ends and JavaScript programs running in the browser, but it is used in many other places, too. Its home page, [[http://json.org][json.org]], provides a wonderfully clear and concise definition of the standard.
 
-With the [[http://golang.org/pkg/encoding/json/][json package]] it's a snap to read and write JSON data from your Go programs.
+With the [[https://golang.org/pkg/encoding/json/][json package]] it's a snap to read and write JSON data from your Go programs.
 
 * Encoding
 
-To encode JSON data we use the [[http://golang.org/pkg/encoding/json/#Marshal][`Marshal`]] function.
+To encode JSON data we use the [[https://golang.org/pkg/encoding/json/#Marshal][`Marshal`]] function.
 
 	func Marshal(v interface{}) ([]byte, error)
 
@@ -50,7 +50,7 @@
 
 * Decoding
 
-To decode JSON data we use the [[http://golang.org/pkg/encoding/json/#Unmarshal][`Unmarshal`]] function.
+To decode JSON data we use the [[https://golang.org/pkg/encoding/json/#Unmarshal][`Unmarshal`]] function.
 
 	func Unmarshal(data []byte, v interface{}) error
 
@@ -72,7 +72,7 @@
 
 How does `Unmarshal` identify the fields in which to store the decoded data? For a given JSON key `"Foo"`, `Unmarshal` will look through the destination struct's fields to find (in order of preference):
 
-- An exported field with a tag of `"Foo"` (see the [[http://golang.org/ref/spec#Struct_types][Go spec]] for more on struct tags),
+- An exported field with a tag of `"Foo"` (see the [[https://golang.org/ref/spec#Struct_types][Go spec]] for more on struct tags),
 
 - An exported field named `"Foo"`, or
 
@@ -211,7 +211,7 @@
 
 * Streaming Encoders and Decoders
 
-The json package provides `Decoder` and `Encoder` types to support the common operation of reading and writing streams of JSON data. The `NewDecoder` and `NewEncoder` functions wrap the [[http://golang.org/pkg/io/#Reader][`io.Reader`]] and [[http://golang.org/pkg/io/#Writer][`io.Writer`]] interface types.
+The json package provides `Decoder` and `Encoder` types to support the common operation of reading and writing streams of JSON data. The `NewDecoder` and `NewEncoder` functions wrap the [[https://golang.org/pkg/io/#Reader][`io.Reader`]] and [[https://golang.org/pkg/io/#Writer][`io.Writer`]] interface types.
 
 	func NewDecoder(r io.Reader) *Decoder
 	func NewEncoder(w io.Writer) *Encoder
@@ -250,4 +250,4 @@
 
 * References
 
-For more information see the [[http://golang.org/pkg/encoding/json/][json package documentation]]. For an example usage of json see the source files of the [[http://golang.org/pkg/net/rpc/jsonrpc/][jsonrpc package]].
+For more information see the [[https://golang.org/pkg/encoding/json/][json package documentation]]. For an example usage of json see the source files of the [[https://golang.org/pkg/net/rpc/jsonrpc/][jsonrpc package]].
diff --git a/blog/content/json-rpc-tale-of-interfaces.article b/blog/content/json-rpc-tale-of-interfaces.article
index e301e75..2bc3c28 100644
--- a/blog/content/json-rpc-tale-of-interfaces.article
+++ b/blog/content/json-rpc-tale-of-interfaces.article
@@ -6,7 +6,7 @@
 
 * Introduction
 
-Here we present an example where Go's [[http://golang.org/doc/effective_go.html#interfaces_and_types][interfaces]] made it easy to refactor some existing code to make it more flexible and extensible. Originally, the standard library's [[http://golang.org/pkg/net/rpc/][RPC package]] used a custom wire format called [[http://golang.org/pkg/encoding/gob/][gob]]. For a particular application, we wanted to use [[http://golang.org/pkg/encoding/json/][JSON]] as an alternate wire format.
+Here we present an example where Go's [[https://golang.org/doc/effective_go.html#interfaces_and_types][interfaces]] made it easy to refactor some existing code to make it more flexible and extensible. Originally, the standard library's [[https://golang.org/pkg/net/rpc/][RPC package]] used a custom wire format called [[https://golang.org/pkg/encoding/gob/][gob]]. For a particular application, we wanted to use [[https://golang.org/pkg/encoding/json/][JSON]] as an alternate wire format.
 
 We first defined a pair of interfaces to describe the functionality of the existing wire format, one for the client, and one for the server (depicted below).
 
diff --git a/blog/content/laws-of-reflection.article b/blog/content/laws-of-reflection.article
index fc704f2..0b87ad8 100644
--- a/blog/content/laws-of-reflection.article
+++ b/blog/content/laws-of-reflection.article
@@ -23,7 +23,7 @@
 
 then `i` has type `int` and `j` has type `MyInt`. The variables `i` and `j` have distinct static types and, although they have the same underlying type, they cannot be assigned to one another without a conversion.
 
-One important category of type is interface types, which represent fixed sets of methods. An interface variable can store any concrete (non-interface) value as long as that value implements the interface's methods. A well-known pair of examples is `io.Reader` and `io.Writer`, the types `Reader` and `Writer` from the [[http://golang.org/pkg/io/][io package]]:
+One important category of type is interface types, which represent fixed sets of methods. An interface variable can store any concrete (non-interface) value as long as that value implements the interface's methods. A well-known pair of examples is `io.Reader` and `io.Writer`, the types `Reader` and `Writer` from the [[https://golang.org/pkg/io/][io package]]:
 
 	// Reader is the interface that wraps the basic Read method.
 	type Reader interface {
@@ -92,7 +92,7 @@
 
 * 1. Reflection goes from interface value to reflection object.
 
-At the basic level, reflection is just a mechanism to examine the type and value pair stored inside an interface variable. To get started, there are two types we need to know about in [[http://golang.org/pkg/reflect/][package reflect]]: [[http://golang.org/pkg/reflect/#Type][Type]] and [[http://golang.org/pkg/reflect/#Value][Value]]. Those two types give access to the contents of an interface variable, and two simple functions, called `reflect.TypeOf` and `reflect.ValueOf`, retrieve `reflect.Type` and `reflect.Value` pieces out of an interface value. (Also, from the `reflect.Value` it's easy to get to the `reflect.Type`, but let's keep the `Value` and `Type` concepts separate for now.)
+At the basic level, reflection is just a mechanism to examine the type and value pair stored inside an interface variable. To get started, there are two types we need to know about in [[https://golang.org/pkg/reflect/][package reflect]]: [[https://golang.org/pkg/reflect/#Type][Type]] and [[https://golang.org/pkg/reflect/#Value][Value]]. Those two types give access to the contents of an interface variable, and two simple functions, called `reflect.TypeOf` and `reflect.ValueOf`, retrieve `reflect.Type` and `reflect.Value` pieces out of an interface value. (Also, from the `reflect.Value` it's easy to get to the `reflect.Type`, but let's keep the `Value` and `Type` concepts separate for now.)
 
 Let's start with `TypeOf`:
 
@@ -112,7 +112,7 @@
 
 	type: float64
 
-You might be wondering where the interface is here, since the program looks like it's passing the `float64` variable `x`, not an interface value, to `reflect.TypeOf`. But it's there; as [[http://golang.org/pkg/reflect/#TypeOf][godoc reports]], the signature of `reflect.TypeOf` includes an empty interface:
+You might be wondering where the interface is here, since the program looks like it's passing the `float64` variable `x`, not an interface value, to `reflect.TypeOf`. But it's there; as [[https://golang.org/pkg/reflect/#TypeOf][godoc reports]], the signature of `reflect.TypeOf` includes an empty interface:
 
 	// TypeOf returns the reflection Type of the value in the interface{}.
 	func TypeOf(i interface{}) Type
@@ -288,7 +288,7 @@
 
 In our previous example `v` wasn't a pointer itself, it was just derived from one. A common way for this situation to arise is when using reflection to modify the fields of a structure. As long as we have the address of the structure, we can modify its fields.
 
-Here's a simple example that analyzes a struct value, `t`. We create the reflection object with the address of the struct because we'll want to modify it later. Then we set `typeOfT` to its type and iterate over the fields using straightforward method calls (see [[http://golang.org/pkg/reflect/][package reflect]] for details). Note that we extract the names of the fields from the struct type, but the fields themselves are regular `reflect.Value` objects.
+Here's a simple example that analyzes a struct value, `t`. We create the reflection object with the address of the struct because we'll want to modify it later. Then we set `typeOfT` to its type and iterate over the fields using straightforward method calls (see [[https://golang.org/pkg/reflect/][package reflect]] for details). Note that we extract the names of the fields from the struct type, but the fields themselves are regular `reflect.Value` objects.
 
 	    type T struct {
 	        A int
diff --git a/blog/content/learn-go-from-your-browser.article b/blog/content/learn-go-from-your-browser.article
index e068eb5..595e6fe 100644
--- a/blog/content/learn-go-from-your-browser.article
+++ b/blog/content/learn-go-from-your-browser.article
@@ -8,7 +8,7 @@
 
 We are excited to announce [[http://go-tour.appspot.com/][A Tour of Go]], a guided tour of the Go programming language you can run from your browser.
 
-The tour is hands-on, demonstrating the language through code samples that you can modify, compile, and run from the tour itself. (The technology behind the [[http://golang.org/doc/play/][Go Playground]] does the work.)
+The tour is hands-on, demonstrating the language through code samples that you can modify, compile, and run from the tour itself. (The technology behind the [[https://golang.org/doc/play/][Go Playground]] does the work.)
 
 The tour has three sections. The first section covers basic syntax and data structures; the second discusses methods and interfaces; and the third introduces Go's concurrency primitives. Each section concludes with a few exercises so you can practice what you've learned.
 
diff --git a/blog/content/matchlang.article b/blog/content/matchlang.article
index 8e7ebbf..47473ea 100644
--- a/blog/content/matchlang.article
+++ b/blog/content/matchlang.article
@@ -108,7 +108,7 @@
 _Using_a_“parent”_of_a_language_as_fallback_is_non-trivial_
 
 Suppose your application supports Angolan Portuguese (“pt-AO”).
-Packages in [[http://golang.org/x/text]], like collation and display, may not
+Packages in [[https://golang.org/x/text]], like collation and display, may not
 have specific support for this dialect.
 The correct course of action in such cases is to match the closest parent dialect.
 Languages are arranged in a hierarchy, with each specific language having a more
@@ -129,7 +129,7 @@
 
 * Language Matching in Go
 
-The Go package [[http://golang.org/x/text/language]] implements the BCP 47
+The Go package [[https://golang.org/x/text/language]] implements the BCP 47
 standard for language tags and adds support for deciding which language to use
 based on data published in the Unicode Common Locale Data Repository (CLDR).
 
@@ -266,7 +266,7 @@
 
 ** Displaying Supported Languages
 
-The [[http://golang.org/x/text/language/display]] package allows naming language
+The [[https://golang.org/x/text/language/display]] package allows naming language
 tags in many languages.
 It also contains a “Self” namer for displaying a tag in its own language.
 
@@ -297,5 +297,5 @@
 language tags.
 As described above, this can produce awful results.
 
-Go's [[http://golang.org/x/text/language]] package solves this complex problem
+Go's [[https://golang.org/x/text/language]] package solves this complex problem
 while still presenting a simple, easy-to-use API. Enjoy.
diff --git a/blog/content/new-talk-and-tutorials.article b/blog/content/new-talk-and-tutorials.article
index b54d865..d7cbc4f 100644
--- a/blog/content/new-talk-and-tutorials.article
+++ b/blog/content/new-talk-and-tutorials.article
@@ -7,6 +7,6 @@
 
 Rob Pike recently gave a talk at Stanford's [[http://www.stanford.edu/class/ee380/][Computer Systems Colloquium]] (EE380). Titled [[http://www.stanford.edu/class/ee380/Abstracts/100428.html][_Another_Go_at_Language_Design_]], the presentation gives an overview of the itches Go was built to scratch, and how Go addresses those problems. You can view [[https://www.youtube.com/watch?v=7VcArS4Wpqk][a video stream of the talk]], and [[http://www.stanford.edu/class/ee380/Abstracts/100428-pike-stanford.pdf][download the slides]].
 
-Last week's release included a code lab, [[http://golang.org/doc/codelab/wiki/][Writing Web Applications]], that details the construction of a simple wiki program. It is a practical introduction to some fundamental Go concepts, and the first of a series of Go code labs.
+Last week's release included a code lab, [[https://golang.org/doc/codelab/wiki/][Writing Web Applications]], that details the construction of a simple wiki program. It is a practical introduction to some fundamental Go concepts, and the first of a series of Go code labs.
 
 Lastly, we are often asked "How do Go packages work?" It's easier to show than to explain, so I put together a [[http://www.youtube.com/watch?v=jDWBJOXs_iI][Go Packages screen cast]] that demonstrates the process of writing, building, installing, and redistributing Go packages. I hope to post more of these covering a variety of Go programming topics to the [[http://youtube.com/gocoding][gocoding YouTube channel]] in the near future.
diff --git a/blog/content/organizing-go-code.article b/blog/content/organizing-go-code.article
index 147bee2..49fd728 100644
--- a/blog/content/organizing-go-code.article
+++ b/blog/content/organizing-go-code.article
@@ -12,9 +12,9 @@
 
 The names you choose affect how you think about your code, so take care when naming your package and its exported identifiers.
 
-A package's name provides context for its contents. For instance, the [[http://golang.org/pkg/bytes/][bytes package]] from the standard library exports the `Buffer` type. On its own, the name `Buffer` isn't very descriptive, but when combined with its package name its meaning becomes clear: `bytes.Buffer`. If the package had a less descriptive name, like `util`, the buffer would likely acquire the longer and clumsier name `util.BytesBuffer`. 
+A package's name provides context for its contents. For instance, the [[https://golang.org/pkg/bytes/][bytes package]] from the standard library exports the `Buffer` type. On its own, the name `Buffer` isn't very descriptive, but when combined with its package name its meaning becomes clear: `bytes.Buffer`. If the package had a less descriptive name, like `util`, the buffer would likely acquire the longer and clumsier name `util.BytesBuffer`. 
 
-Don't be shy about renaming things as you work. As you spend time with your program you will better understand how its pieces fit together and, therefore, what their names should be. There's no need to lock yourself into early decisions. (The [[http://golang.org/cmd/gofmt/][gofmt command]] has a `-r` flag that provides a syntax-aware search and replace, making large-scale refactoring easier.)
+Don't be shy about renaming things as you work. As you spend time with your program you will better understand how its pieces fit together and, therefore, what their names should be. There's no need to lock yourself into early decisions. (The [[https://golang.org/cmd/gofmt/][gofmt command]] has a `-r` flag that provides a syntax-aware search and replace, making large-scale refactoring easier.)
 
 A good name is the most important part of a software interface: the name is the first thing every client of the code will see. A well-chosen name is therefore the starting point for good documentation. Many of the following practices result organically from good naming. 
 
@@ -44,10 +44,10 @@
 
 On the other hand, it is also easy to go overboard in splitting your code into small packages, in which case you will likely becomes bogged down in interface design, rather than just getting the job done.
 
-Look to the Go standard libraries as a guide. Some of its packages are large and some are small. For instance, the [[http://golang.org/pkg/net/http/][http package]] comprises 17 go source files (excluding tests) and exports 109 identifiers, and the [[http://golang.org/pkg/hash/][hash package]] consists of one file that exports just three declarations. There is no hard and fast rule; both approaches are appropriate given their context.
+Look to the Go standard libraries as a guide. Some of its packages are large and some are small. For instance, the [[https://golang.org/pkg/net/http/][http package]] comprises 17 go source files (excluding tests) and exports 109 identifiers, and the [[https://golang.org/pkg/hash/][hash package]] consists of one file that exports just three declarations. There is no hard and fast rule; both approaches are appropriate given their context.
 
-With that said, package main is often larger than other packages. Complex commands contain a lot of code that is of little use outside the context of the executable, and often it's simpler to just keep it all in the one place. For instance, the go tool is more than 12000 lines spread across [[http://golang.org/src/cmd/go/][34 files]].
+With that said, package main is often larger than other packages. Complex commands contain a lot of code that is of little use outside the context of the executable, and often it's simpler to just keep it all in the one place. For instance, the go tool is more than 12000 lines spread across [[https://golang.org/src/cmd/go/][34 files]].
 
 * Document your code
 
-Good documentation is an essential quality of usable and maintainable code. Read the [[http://golang.org/doc/articles/godoc_documenting_go_code.html][Godoc: documenting Go code]] article to learn how to write good doc comments.
+Good documentation is an essential quality of usable and maintainable code. Read the [[https://golang.org/doc/articles/godoc_documenting_go_code.html][Godoc: documenting Go code]] article to learn how to write good doc comments.
diff --git a/blog/content/pipelines.article b/blog/content/pipelines.article
index a0fcb2c..260cccf 100644
--- a/blog/content/pipelines.article
+++ b/blog/content/pipelines.article
@@ -83,7 +83,7 @@
 
 Sends on a closed channel panic, so it's important to ensure all sends
 are done before calling close.  The
-[[http://golang.org/pkg/sync/#WaitGroup][`sync.WaitGroup`]] type
+[[https://golang.org/pkg/sync/#WaitGroup][`sync.WaitGroup`]] type
 provides a simple way to arrange this synchronization:
 
 .code pipelines/sqfan.go /func merge/,/^}/
@@ -174,7 +174,7 @@
 We need a way to tell an unknown and unbounded number of goroutines to
 stop sending their values downstream.  In Go, we can do this by
 closing a channel, because
-[[http://golang.org/ref/spec#Receive_operator][a receive operation on a closed channel can always proceed immediately, yielding the element type's zero value.]]
+[[https://golang.org/ref/spec#Receive_operator][a receive operation on a closed channel can always proceed immediately, yielding the element type's zero value.]]
 
 This means that `main` can unblock all the senders simply by closing
 the `done` channel.  This close is effectively a broadcast signal to
diff --git a/blog/content/profiling-go-programs.article b/blog/content/profiling-go-programs.article
index 9f533d1..e7c90a7 100644
--- a/blog/content/profiling-go-programs.article
+++ b/blog/content/profiling-go-programs.article
@@ -84,7 +84,7 @@
 results from the paper.)
 
 To start tuning the Go program, we have to enable profiling.
-If the code used the [[http://golang.org/pkg/testing/][Go testing package]]'s
+If the code used the [[https://golang.org/pkg/testing/][Go testing package]]'s
 benchmarking support, we could use gotest's standard `-cpuprofile` and `-memprofile`
 flags.
 In a standalone program like this one, we have to import `runtime/pprof` and add a few
@@ -105,12 +105,12 @@
 	    ...
 
 The new code defines a flag named `cpuprofile`, calls the
-[[http://golang.org/pkg/flag/][Go flag library]] to parse the command line flags,
+[[https://golang.org/pkg/flag/][Go flag library]] to parse the command line flags,
 and then, if the `cpuprofile` flag has been set on the command line,
-[[http://golang.org/pkg/runtime/pprof/#StartCPUProfile][starts CPU profiling]]
+[[https://golang.org/pkg/runtime/pprof/#StartCPUProfile][starts CPU profiling]]
 redirected to that file.
 The profiler requires a final call to
-[[http://golang.org/pkg/runtime/pprof/#StopCPUProfile][`StopCPUProfile`]] to
+[[https://golang.org/pkg/runtime/pprof/#StopCPUProfile][`StopCPUProfile`]] to
 flush any pending writes to the file before the program exits; we use `defer`
 to make sure this happens as `main` returns.
 
@@ -633,9 +633,9 @@
 The program sources, Linux x86-64 binaries, and profiles used to write this post
 are available in the [[https://github.com/rsc/benchgraffiti/][benchgraffiti project on GitHub]].
 
-As mentioned above, [[http://golang.org/cmd/go/#Test_packages][`go test`]] includes
+As mentioned above, [[https://golang.org/cmd/go/#Test_packages][`go test`]] includes
 these profiling flags already: define a
-[[http://golang.org/pkg/testing/][benchmark function]] and you're all set.
+[[https://golang.org/pkg/testing/][benchmark function]] and you're all set.
 There is also a standard HTTP interface to profiling data. In an HTTP server, adding
 
 	import _ "net/http/pprof"
diff --git a/blog/content/qihoo.article b/blog/content/qihoo.article
index 69aaaa8..57994da 100644
--- a/blog/content/qihoo.article
+++ b/blog/content/qihoo.article
@@ -55,7 +55,7 @@
 
 - Monitor and control goroutine numbers in the program. The lack of control can cause unbearable burden on the GC, imposed by surges in goroutines due to uninhibited acceptance of external requests, as RPC invocations sent to inner servers may block goroutines recently created.
 
-- Remember to add [[http://golang.org/pkg/net/#Conn][read and write deadlines]] to connections when under a mobile network; otherwise, it may lead to goroutine blockage. Apply it properly and with caution when under a LAN network, otherwise your RPC communication efficiency will be hurt.
+- Remember to add [[https://golang.org/pkg/net/#Conn][read and write deadlines]] to connections when under a mobile network; otherwise, it may lead to goroutine blockage. Apply it properly and with caution when under a LAN network, otherwise your RPC communication efficiency will be hurt.
 
 - Use Pipeline (under Full Duplex feature of TCP) to enhance the communication efficiency of RPC framework.
 
diff --git a/blog/content/race-detector.article b/blog/content/race-detector.article
index bf3ce20..ef61a5c 100644
--- a/blog/content/race-detector.article
+++ b/blog/content/race-detector.article
@@ -16,7 +16,7 @@
 And tools can help.
 
 We're happy to announce that Go 1.1 includes a
-[[http://golang.org/doc/articles/race_detector.html][race detector]],
+[[https://golang.org/doc/articles/race_detector.html][race detector]],
 a new tool for finding race conditions in Go code.
 It is currently available for Linux, OS X, and Windows systems
 with 64-bit x86 processors.
@@ -76,9 +76,9 @@
 The first example is a simplified version of an actual bug found by the race
 detector. It uses a timer to print a message after a random duration between 0
 and 1 second. It does so repeatedly for five seconds.
-It uses [[http://golang.org/pkg/time/#AfterFunc][`time.AfterFunc`]] to create a
-[[http://golang.org/pkg/time/#Timer][`Timer`]] for the first message and then
-uses the [[http://golang.org/pkg/time/#Timer.Reset][`Reset`]] method to
+It uses [[https://golang.org/pkg/time/#AfterFunc][`time.AfterFunc`]] to create a
+[[https://golang.org/pkg/time/#Timer][`Timer`]] for the first message and then
+uses the [[https://golang.org/pkg/time/#Timer.Reset][`Reset`]] method to
 schedule the next message, re-using the `Timer` each time.
 
 .play -numbers race-detector/timer.go /func main/,$
@@ -139,12 +139,12 @@
 The second example is more subtle.
 
 The `ioutil` package's
-[[http://golang.org/pkg/io/ioutil/#Discard][`Discard`]] object implements 
-[[http://golang.org/pkg/io/#Writer][`io.Writer`]],
+[[https://golang.org/pkg/io/ioutil/#Discard][`Discard`]] object implements 
+[[https://golang.org/pkg/io/#Writer][`io.Writer`]],
 but discards all the data written to it.
 Think of it like `/dev/null`: a place to send data that you need to read but
 don't want to store.
-It is commonly used with [[http://golang.org/pkg/io/#Copy][`io.Copy`]]
+It is commonly used with [[https://golang.org/pkg/io/#Copy][`io.Copy`]]
 to drain a reader, like this:
 
 	io.Copy(ioutil.Discard, reader)
diff --git a/blog/content/real-go-projects-smarttwitter-and-webgo.article b/blog/content/real-go-projects-smarttwitter-and-webgo.article
index 3643296..912cf7e 100644
--- a/blog/content/real-go-projects-smarttwitter-and-webgo.article
+++ b/blog/content/real-go-projects-smarttwitter-and-webgo.article
@@ -8,7 +8,7 @@
 
 _This_week's_article_is_written_by_ [[http://www.hoisie.com/][_Michael_Hoisie_]]. _A_programmer_based_in_San_Francisco,_he_is_one_of_Go's_early_adopters_and_the_author_of_several_popular_Go_libraries._He_describes_his_experiences_using_Go:_
 
-I was introduced to Go by a post on [[http://news.ycombinator.com/][Hacker News]]. About an hour later I was hooked. At the time I was working at a web start-up, and had been developing internal testing apps in Python. Go offered speed, better concurrency support, and sane Unicode handling, so I was keen to port my programs to the language. At that time there wasn't an easy way to write web apps in Go, so I decided to build a simple web framework, [[http://github.com/hoisie/web.go][web.go]]. It was modeled after a popular Python framework, [[http://webpy.org/][web.py]], which I had worked with previously. While working on web.go I got involved in the Go community, submitted a bunch of bug reports, and hacked on some standard library packages (mainly [[http://golang.org/pkg/http/][http]] and [[http://golang.org/pkg/json/][json]]).
+I was introduced to Go by a post on [[http://news.ycombinator.com/][Hacker News]]. About an hour later I was hooked. At the time I was working at a web start-up, and had been developing internal testing apps in Python. Go offered speed, better concurrency support, and sane Unicode handling, so I was keen to port my programs to the language. At that time there wasn't an easy way to write web apps in Go, so I decided to build a simple web framework, [[http://github.com/hoisie/web.go][web.go]]. It was modeled after a popular Python framework, [[http://webpy.org/][web.py]], which I had worked with previously. While working on web.go I got involved in the Go community, submitted a bunch of bug reports, and hacked on some standard library packages (mainly [[https://golang.org/pkg/http/][http]] and [[https://golang.org/pkg/json/][json]]).
 
 After a few weeks I noticed that web.go was getting attention at Github. This was surprising because I'd never really promoted the project. I think there's a niche for simple, fast web applications, and I think Go can fill it.
 
diff --git a/blog/content/share-memory-by-communicating.article b/blog/content/share-memory-by-communicating.article
index 144e6c3..5eaa278 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 [[http://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 [[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):
 
 _Do_not_communicate_by_sharing_memory;_instead,_share_memory_by_communicating._
 
@@ -76,4 +76,4 @@
 
 The delicate logic from the previous example is conspicuously absent, and our Resource data structure no longer contains bookkeeping data. In fact, all that's left are the important parts. This should give you an inkling as to the power of these simple language features.
 
-There are many omissions from the above code snippets. For a walkthrough of a complete, idiomatic Go program that uses these ides, see the Codewalk [[http://golang.org/doc/codewalk/sharemem/][_Share_Memory_By_Communicating_]].
+There are many omissions from the above code snippets. For a walkthrough of a complete, idiomatic Go program that uses these ides, see the Codewalk [[https://golang.org/doc/codewalk/sharemem/][_Share_Memory_By_Communicating_]].
diff --git a/blog/content/slices.article b/blog/content/slices.article
index 4e14265..c11ddd1 100644
--- a/blog/content/slices.article
+++ b/blog/content/slices.article
@@ -153,7 +153,7 @@
 You'll often hear experienced Go programmers talk about the "slice header"
 because that really is what's stored in a slice variable.
 For instance, when you call a function that takes a slice as an argument, such as
-[[http://golang.org/pkg/bytes/#IndexRune][bytes.IndexRune]], that header is
+[[https://golang.org/pkg/bytes/#IndexRune][bytes.IndexRune]], that header is
 what gets passed to the function.
 In this call,
 
diff --git a/blog/content/spotlight-on-external-go-libraries.article b/blog/content/spotlight-on-external-go-libraries.article
index 6daf4cd..8747a1d 100644
--- a/blog/content/spotlight-on-external-go-libraries.article
+++ b/blog/content/spotlight-on-external-go-libraries.article
@@ -16,7 +16,7 @@
  
 [[https://github.com/madari/go-socket.io][Go-socket.io]] is a Go implementation of [[http://socket.io/][Socket.IO]], a client/server API that allows web servers to push messages to web browsers. Depending on the capabilities of the user's browser, Socket.IO uses the best transport for the connection, be it modern websockets, AJAX long polling, or some [[http://socket.io/#transports][other mechanism]]. Go-socket.io bridges the gap between Go servers and rich JavaScript clients for a wide range of browsers. To get a feel for go-socket.io see the [[https://github.com/madari/go-socket.io/blob/master/example/example.go][chat server example]].
  
-It's worth mentioning that these packages are [[http://golang.org/cmd/goinstall/][goinstallable]]. With an up-to-date Go [[http://golang.org/doc/install.html][installation]] you can install them all with a single command:
+It's worth mentioning that these packages are [[https://golang.org/cmd/goinstall/][goinstallable]]. With an up-to-date Go [[https://golang.org/doc/install.html][installation]] you can install them all with a single command:
 	 
 	goinstall launchpad.net/mgo \
 	    github.com/dchest/authcookie \
@@ -34,7 +34,7 @@
 	)
 
  
-Also, as they are now a part of the local Go system, we can inspect their documentation with [[http://golang.org/cmd/godoc/][godoc]]:
+Also, as they are now a part of the local Go system, we can inspect their documentation with [[https://golang.org/cmd/godoc/][godoc]]:
 	 
 	godoc launchpad.net/mgo Database # see docs for Database type
  
diff --git a/blog/content/strings.article b/blog/content/strings.article
index 377945d..104540c 100644
--- a/blog/content/strings.article
+++ b/blog/content/strings.article
@@ -295,7 +295,7 @@
 chances are the facility you need is provided by a package in the library.
 
 The most important such package is
-[[http://golang.org/pkg/unicode/utf8/][`unicode/utf8`]],
+[[https://golang.org/pkg/unicode/utf8/][`unicode/utf8`]],
 which contains
 helper routines to validate, disassemble, and reassemble UTF-8 strings.
 Here is a program equivalent to the `for` `range` example above,
@@ -311,7 +311,7 @@
 exactly the same iteration sequence.
 
 Look at the
-[[http://golang.org/pkg/unicode/utf8/][documentation]]
+[[https://golang.org/pkg/unicode/utf8/][documentation]]
 for the `unicode/utf8` package to see what
 other facilities it provides.
 
diff --git a/blog/content/the-app-engine-sdk-and-workspaces-gopath.article b/blog/content/the-app-engine-sdk-and-workspaces-gopath.article
index b0605d1..f2fcb40 100644
--- a/blog/content/the-app-engine-sdk-and-workspaces-gopath.article
+++ b/blog/content/the-app-engine-sdk-and-workspaces-gopath.article
@@ -6,9 +6,9 @@
 
 * Introduction
 
-When we released Go 1 we introduced the [[http://golang.org/cmd/go/][go tool]] and, with it, the concept of workspaces. Workspaces (specified by the GOPATH environment variable) are a convention for organizing code that simplifies fetching, building, and installing Go packages. If you're not familiar with workspaces, please read [[http://golang.org/doc/code.html][this article]] or watch [[http://www.youtube.com/watch?v=XCsL89YtqCs][this screencast]] before reading on.
+When we released Go 1 we introduced the [[https://golang.org/cmd/go/][go tool]] and, with it, the concept of workspaces. Workspaces (specified by the GOPATH environment variable) are a convention for organizing code that simplifies fetching, building, and installing Go packages. If you're not familiar with workspaces, please read [[https://golang.org/doc/code.html][this article]] or watch [[http://www.youtube.com/watch?v=XCsL89YtqCs][this screencast]] before reading on.
 
-Until recently, the tools in the App Engine SDK were not aware of workspaces. Without workspaces the "[[http://golang.org/cmd/go/#hdr-Download_and_install_packages_and_dependencies][go get]]" command cannot function, and so app authors had to install and update their app dependencies manually. It was a pain.
+Until recently, the tools in the App Engine SDK were not aware of workspaces. Without workspaces the "[[https://golang.org/cmd/go/#hdr-Download_and_install_packages_and_dependencies][go get]]" command cannot function, and so app authors had to install and update their app dependencies manually. It was a pain.
 
 This has all changed with version 1.7.4 of the App Engine SDK. The [[https://developers.google.com/appengine/docs/go/tools/devserver][dev_appserver]] and [[https://developers.google.com/appengine/docs/go/tools/uploadinganapp][appcfg]] tools are now workspace-aware. When running locally or uploading an app, these tools now search for dependencies in the workspaces specified by the GOPATH environment variable. This means you can now use "go get" while building App Engine apps, and switch between normal Go programs and App Engine apps without changing your environment or habits.
 
@@ -24,11 +24,11 @@
 
 * Hybrid stand-alone/App Engine apps
 
-The Go App Engine SDK builds on Go's standard [[http://golang.org/pkg/net/http/][net/http]] package to serve web requests and, as a result, many Go web servers can be run on App Engine with only a few changes. For example, [[http://golang.org/cmd/godoc/][godoc]] is included in the Go distribution as a stand-alone program, but it can also run as an App Engine app (godoc serves [[http://golang.org/][golang.org]] from App Engine).
+The Go App Engine SDK builds on Go's standard [[https://golang.org/pkg/net/http/][net/http]] package to serve web requests and, as a result, many Go web servers can be run on App Engine with only a few changes. For example, [[https://golang.org/cmd/godoc/][godoc]] is included in the Go distribution as a stand-alone program, but it can also run as an App Engine app (godoc serves [[https://golang.org/][golang.org]] from App Engine).
 
-But wouldn't it be nice if you could write a program that is both a stand-alone web server and an App Engine app? By using [[http://golang.org/pkg/go/build/#hdr-Build_Constraints][build constraints]], you can.
+But wouldn't it be nice if you could write a program that is both a stand-alone web server and an App Engine app? By using [[https://golang.org/pkg/go/build/#hdr-Build_Constraints][build constraints]], you can.
 
-Build constraints are line comments that determine whether a file should be included in a package. They are most often used in code that handles a variety of operating systems or processor architectures. For instance, the [[http://golang.org/pkg/path/filepath/][path/filepath]] package includes the file [[http://golang.org/src/pkg/path/filepath/symlink.go][symlink.go]], which specifies a build constraint to ensure that it is not built on Windows systems (which do not have symbolic links):
+Build constraints are line comments that determine whether a file should be included in a package. They are most often used in code that handles a variety of operating systems or processor architectures. For instance, the [[https://golang.org/pkg/path/filepath/][path/filepath]] package includes the file [[https://golang.org/src/pkg/path/filepath/symlink.go][symlink.go]], which specifies a build constraint to ensure that it is not built on Windows systems (which do not have symbolic links):
 
 	    // +build !windows
 
@@ -42,7 +42,7 @@
 
 are ignored by the App Engine SDK, while the go tool will happily build them.
 
-The [[http://code.google.com/p/goprotobuf/][goprotobuf]] library uses this mechanism to provide two implementations of a key part of its encode/decode machinery: [[http://code.google.com/p/goprotobuf/source/browse/proto/pointer_unsafe.go][pointer_unsafe.go]] is the faster version that cannot be used on App Engine because it uses the [[http://golang.org/pkg/unsafe/][unsafe package]], while [[http://code.google.com/p/goprotobuf/source/browse/proto/pointer_reflect.go][pointer_reflect.go]] is a slower version that avoids unsafe by using the [[http://golang.org/pkg/reflect/][reflect package]] instead.
+The [[http://code.google.com/p/goprotobuf/][goprotobuf]] library uses this mechanism to provide two implementations of a key part of its encode/decode machinery: [[http://code.google.com/p/goprotobuf/source/browse/proto/pointer_unsafe.go][pointer_unsafe.go]] is the faster version that cannot be used on App Engine because it uses the [[https://golang.org/pkg/unsafe/][unsafe package]], while [[http://code.google.com/p/goprotobuf/source/browse/proto/pointer_reflect.go][pointer_reflect.go]] is a slower version that avoids unsafe by using the [[https://golang.org/pkg/reflect/][reflect package]] instead.
 
 Let's take a simple Go web server and turn it into a hybrid app. This is main.go:
 
diff --git a/blog/content/third-party-libraries-goprotobuf-and.article b/blog/content/third-party-libraries-goprotobuf-and.article
index 70791b8..df80991 100644
--- a/blog/content/third-party-libraries-goprotobuf-and.article
+++ b/blog/content/third-party-libraries-goprotobuf-and.article
@@ -10,7 +10,7 @@
 
 The goprotobuf project consists of two parts: a 'protocol compiler plugin' that generates Go source files that, once compiled, can access and manage protocol buffers; and a Go package that implements run-time support for encoding (marshaling), decoding (unmarshaling), and accessing protocol buffers.
 
-To use goprotobuf, you first need to have both Go and [[http://code.google.com/p/protobuf/][protobuf]] installed. You can then install the 'proto' package with [[http://golang.org/cmd/goinstall/][goinstall]]:
+To use goprotobuf, you first need to have both Go and [[http://code.google.com/p/protobuf/][protobuf]] installed. You can then install the 'proto' package with [[https://golang.org/cmd/goinstall/][goinstall]]:
 
 	goinstall goprotobuf.googlecode.com/hg/proto
 
diff --git a/blog/content/two-go-talks-lexical-scanning-in-go-and.article b/blog/content/two-go-talks-lexical-scanning-in-go-and.article
index 58d4981..bbd372f 100644
--- a/blog/content/two-go-talks-lexical-scanning-in-go-and.article
+++ b/blog/content/two-go-talks-lexical-scanning-in-go-and.article
@@ -8,11 +8,11 @@
 
 On Tuesday night Rob Pike and Andrew Gerrand each presented at the [[http://www.sydney-gtug.org/][Sydney Google Technology User Group]].
 
-Rob's talk, "[[http://www.youtube.com/watch?v=HxaD_trXwRE][Lexical Scanning in Go]]", discusses the design of  a particularly interesting and idiomatic piece of Go code, the lexer component of the new [[http://golang.org/pkg/exp/template/][template package.]]
+Rob's talk, "[[http://www.youtube.com/watch?v=HxaD_trXwRE][Lexical Scanning in Go]]", discusses the design of  a particularly interesting and idiomatic piece of Go code, the lexer component of the new [[https://golang.org/pkg/exp/template/][template package.]]
 
 .iframe //www.youtube.com/embed/HxaD_trXwRE 345 560
 
-The slides are [[http://cuddle.googlecode.com/hg/talk/lex.html][available here]]. The new template package is available as [[http://golang.org/pkg/exp/template/][exp/template]] in Go release r59. In a future release it will replace the old template package.
+The slides are [[http://cuddle.googlecode.com/hg/talk/lex.html][available here]]. The new template package is available as [[https://golang.org/pkg/exp/template/][exp/template]] in Go release r59. In a future release it will replace the old template package.
 
 Andrew's talk, "[[http://www.youtube.com/watch?v=HQtLRqqB-Kk][Cuddle: an App Engine Demo]]", describes the construction of a simple real-time chat application that uses App Engine's [[http://code.google.com/appengine/docs/go/datastore/overview.html][Datastore]], [[http://code.google.com/appengine/docs/go/channel/overview.html][Channel]], and [[http://code.google.com/appengine/docs/go/datastore/memcache.html][Memcache]] APIs. It also includes a question and answer session that covers [[http://code.google.com/appengine/docs/go/gettingstarted/][Go for App Engine]] and Go more generally.