Go on Edward Muller

Go's Built In Go Version Manager

Fri, 11 Oct 2019 18:39:35 -0700

Go has a built in Go version manager. Well, almost.

TL;DR: Any version of go you want can be installed with:

$ go get golang.org/dl/<go version string>

If you have a working go install run the following:

$ go get golang.org/dl/go1.12.7
$ go1.12.7
go1.12.7: not downloaded. Run 'go1.12.7 download' to install to /Users/freeformz/sdk/go1.12.7
$ go1.12.7 download
Downloaded   0.0% (    15152 / 127614387 bytes) ...
Downloaded  15.8% ( 20135936 / 127614387 bytes) ...
Downloaded  33.4% ( 42631168 / 127614387 bytes) ...
Downloaded  49.3% ( 62947328 / 127614387 bytes) ...
Downloaded  65.8% ( 83918848 / 127614387 bytes) ...
Downloaded  84.4% (107659264 / 127614387 bytes) ...
Downloaded 100.0% (127614387 / 127614387 bytes)
Unpacking /Users/freeformz/sdk/go1.12.7/go1.12.7.darwin-amd64.tar.gz ...
Success. You may now run 'go1.12.7'
$ go1.12.7 env
...
GOROOT="/Users/freeformz/sdk/go1.12.7"
GOTMPDIR=""
GOTOOLDIR="/Users/freeformz/sdk/go1.12.7/pkg/tool/darwin_amd64"
...

Versions installed this way are placed in $HOME/sdk and an executable named the same as the full go version string is placed in $GOPATH/bin. As long as that is in your $PATH, you can run any of the installed versions of go by using the full go version.

dep 101

Thu, 09 Feb 2017 18:13:35 -0700

I’ve had the pleasure of working with several other gophers the last few months on a prototype dependency management tool named dep.

dep is part of the project started last year and is organized by Peter Bourgon. I was asked to join the team working on this project due to my involvement in a different tool, godep, the OG dependency management tool for Go, (inherited from Keith Rarick) and my work at Heroku serving our customers who use Go.

State of Go 2016 Survey

Wed, 08 Jun 2016 18:44:28 -0700

Update: See the raw results, a google sheet of the results and/or my Gophercon lightning talk slides.

TL;DR: If you are interested in Go please take a few minutes to fill out this survey. I’ll do a follow up with the results.

I’ve been wondering what most other gophers are up to these days, what tools are being used, what packages are popular, where are people deploying, etc.

Inspired by a slack conversation with Damian Gryski a few weeks ago I started putting together the State of Go 2016 Survey.

On Variable Declarations: Slices

Wed, 10 Feb 2016 19:00:00 +0000

There are several different ways to declare slices in Go.

IMO, there is an implied meaning to each of these different ways:

var foo []T : Declare a slice that the code is going to start appending an unknown number of items to and/or the number doesn’t matter.
var foo = []T{ ... } or foo := []T{ ... } : Where ... is a list of items of type T. Declare a slice where the code has already figured out how to fill it and it’s unlikely to change much or at all while I reference it. Prefer the later. Also seen as return []T{ ... }.
foo := make([]T, <len>, <cap>) : Declare a slice of a known capacity which I don’t expect to exceed while appending or it’s the minimum capacity slice that I’ll use. Generally the shorter form w/o capacity (ex. make([]T, <len>)), should only be used when making a slice as the target of a copy or index range manipulation loop.

I feel that these above meanings lead to easier to understand and consume code. I encourage people to consider this when declaring and using1pa slices.

Type, *Type, Receivers & Interfaces

Wed, 14 Oct 2015 15:05:14 -0700

I’ve recently seen a bit of confusion around types, pointers to types, receivers for the two and interfaces. I’m going to try to clarify that confusion a bit with some examples.

Given a simple interface named Fooer, a struct type (Bar) that implements it and a simple function (DoFoo()) that accepts a Fooer and calls the interface function like so:

When you run the code above you get Fooer: 5 for output.

Deploying Go Apps to Heroku with Docker

Tue, 18 Aug 2015 10:11:50 -0700

This post covers using the heroku docker cli plugin to deploy a Go application to Heroku. Only Linux and MAC OSX are supported until docker-compose supports MS Windows.

Prerequisites Link to heading

Docker: Installable via either the toolbox for MAC OSX or via the Linux getting started guide
Docker Compose: Included in the Docker Toolbox. Linux instructions are here
Free Heroku Account
Heroku Toolbelt
Heroku Docker CLI Plugin

Please take a look at the links above and make sure everything is installed as per the linked instructions.

Go 1.5's vendor/ experiment

Thu, 09 Jul 2015 00:00:00 +0000

Go versions before 1.5 did not provide any built in method for vendoring packages. The tools that currently exist today (godep, nut and a few others) basically exploit the implementation details of $GOPATH. Go 1.5 however includes a “vendor experiment”. With this experiment go commands will attempt to resolve dependencies in vendor/ directories.

Russ Cox explains it fairly well in his commit message:

If there is a source directory d/vendor, then, when compiling a source file within the subtree rooted at d, import “p” is interpreted as import “d/vendor/p” if that exists.

Go + Heroku : Hello World

Fri, 17 Apr 2015 00:00:00 +0000

This is a quick start guide to deploying a simple “Hello World” Go web application to Heroku. It is in no way comprehensive, but aims to provide links to supporting documentation. In many ways it is an updated version of the excellent Getting Started With Go On Heroku guide done by Mark McGranaghan.

The guide is command line centric and examples assume basic proficiency with a shell on a UNIX (OS X, Linux, etc) operating system.

Why I Like Go

Sat, 09 Feb 2013 00:00:00 +0000

I visited with PagerDuty yesterday for a little Friday beer and pizza. While there I got started talking about Go. I was asked by Alex, their CEO, why I liked it. Several other people have asked me the same question recently, so I figured it was worth posting.

Goroutines Link to heading

The first 1/2 of Go’s concurrency story. Lightweight, concurrent function execution. You can spawn tons of these if needed and the Go runtime multiplexes them onto the configured number of CPUs/Threads as needed. They start with a super small stack that can grow (and shrink) via dynamic allocation (and freeing). They are as simple as go f(x), where f() is a function.