Go on Edward Muller

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.