Golang: How to start

I've just started programming some DevOps tasks in Go (golang) and I like it. In this article i'm going to show how easy it is start programming in Go.

Golang Setup

Let's begin by installation. Of course there are many linux distros that provide Go as packages. In my case these packages are a bit to old and i wan't to use the current Go 1.6 version, therefore, i'm going to do it manually here:

sudo curl -O https://storage.googleapis.com/golang/go1.6.linux-amd64.tar.gz  
sudo tar -xvf go1.6.linux-amd64.tar.gz  
sudo mv go /usr/local  

Now Go binary is in place, but let's add it to path and make that configuration durable in your .bashrc

echo "export PATH=\$PATH:/usr/local/go/bin" >> ~/.bashrc  
#reload profile
source ~/.bashrc  

At this point Go should be on the path and you can check the installation with go version.

Organizing Go code

Contrary to many other languages a typical Go workspace contains many source repositories containing many packages and commands. Go was designed by Google and they have monolithic Codebase, therefore its not wondering that Go works best in this paradigm in which all Go source code and dependencies are in a single workspace.

So the official Go recommendations are:

  • Go programmers typically keep all their Go code in a single workspace.
  • A workspace contains many version control repositories (managed by Git, for example).
  • Each repository contains one or more packages.
  • Each package consists of one or more Go source files in a single directory.

Let's create a workspace and paly with it.

Workspace and $GOPATH

The GOPATH environment variable is used to specify directories outside of GOROOT that contain the source for Go projects and their binaries. Practically GOPATH defines the root of the your current Go workspace.

Let's create ws_go as workspace directory and point GOPATH variable to that.

mkdir -p $HOME/ws_go  
echo "export GOPATH=\$HOME/ws_go" >> ~/.bashrc  
echo "export PATH=\$PATH:\$GOPATH/bin" >> ~/.bashrc  
source ~/.bashrc  

We also exported $GOPATH/bin as it very convenient way to access produces binaries.
Here to say, top level of every Go workspace consist of three directories

  • src contains Go source files,
  • pkg contains package objects, and
  • bin contains executable commands.

More Details to that in the official documentation: How to Write Go Code

Hello World

Time to write first Go program

Create file ws_go/src/test/hello/hello.go with content:

package main

import "fmt"

func main() {  
    fmt.Printf("Hello, World\n")

Here we imported build in package fmt and used it's function Print to print "Hello World" to console. Interesting here is upper case first letter.

Names are as important in Go and even have semantic effect: the visibility of a name outside a package is determined by whether its first character is upper case.

Go Command line

Let's go through some important command you need from begin on.

go build

Go build compiles the packages named by the import paths1, along with their dependencies, but it does not install the results.

go build test/hello`  

The binary is created in the working directory of your shell, this is not alway what you want.

go install

Go install does a little more:

  • The executable file to $GOPATH/bin
  • Cache all non-main packages which imported to $GOPATH/pkg. the cache will be use in the next compile if it not changed yet.
go install test/hello`  

now as you build the test you could execute by typing the name of binary (last part of the Import path) hello or we could directly with go run

go run

Go run compiles and executes the binary in one command, however you need to specify the absolute path to the file (or several if more involved)

go run $GOPATH/src/test/hello/hello.go  

go fmt

Very useful command

go fmt $GOPATH/src/test/hello/hello.go  

It formats go source code as Go source code according to Go conventions, so every Go program is formatted the same. No questions, no discussions. So execute it every time before you commit your code.

go clean

Clean ups stuff that was created by go build (except $GOPATH/bin)

go get

Later you'll be needed go get to install you're dependencies in convenient way... Now let me give you just an example

 go get github.com/go-sql-driver/mysql

This will download the source code of myMql driver and install it i the right place. You can use this in your code like:

import _ "github.com/go-sql-driver/mysql"  

Next Steps

Now we can compile build and execute our program. Start playing around by reading official documentation.

Hope you liked. Feel free to comment.

  1. An import path is a string that uniquely identifies a package. The packages from the standard library are given short import paths such as "fmt" and "net/http". If you keep your code in a source repository somewhere, then you should use the root of that source repository as your base path. For instance github.com/user should be your base path.