Go is becoming pretty mainstream. Every job posting I’ve seen recently requires Go as a want-to-have or a need-to-have skill. This post serves as a guide to help you hit the ground running with Go.

Go Gopher

This is a Live Document. I will be updating it periodically.

What is Go

Go is a programming language created by Google. It started as an experiment by some engineers, to develop to address the pain points of C++ and Java without compromising performance and capability that those languages provides. Other than a well-thought design, it has some specific features for concurrency like a type of light-weight processes called goroutines.

In Tomassett’s blog article on best articles for each situation, he writes:

All its Go’s authors expressed a dislike for C++ complexity. So, in some way, it is a language designed to persuade C people to enter the new century.

Why Learn Go

It’s easy to learn.
It let’s you do concurrency without the overhead.
It’s type safe.
It’s fast.

This article discusses the business case for why learn go, including Moore’s law is failing, which drives the need for a language with built-in concurrency support. Concurrency is not parallelism.

concurrency is the composition of independently executing processes, while parallelism is the simultaneous execution of (possibly related) computations. Concurrency is about dealing with lots of things at once. Parallelism is about doing lots of things at once.

Language Features

Easy to learn - See this article
Built-in Concurrency Support
Go is that it’s a modern high performant low level language with built in concurrency support and strong type system
supports OOP but instead of class inheritance, it uses composition
Supports lambda expressions with their function literals and also supports higher order functions
The market share for Go is networking and servers but based on current trends, it seems Go will beat C, C++, Java, and Rust in the language for building infrastructure since the future is multicore processing. Go is not totally mainstream yet but is gaining a lot of traction

Go Offers Best Balance

There used to be a time when programmers have to make a tradeoff between and efficient code and clean and easy to read code when selecting a language.

Go lets you write efficient and clean code.

Go is efficient and easy to write and manage

Your First Go Program

Set up

Download Go from this link and install Go on your computer.

Set up GOPATH and GOBIN:

Add $GOPATH and $GOBIN

$ vim ~/.bash_profile

Add the following lines to .bash_profile

export GOPATH=$HOME/go
export GOBIN=$HOME/go/bin

Refresh .bash_profile for the GOPATH and GOBIN to take effect:
```
$ . ~/.bash_profile`
```
Verify paths
```
$ echo $GOPATH
/Users/xiaoyun/go
```

For more information about GOPATH, checkout the wiki.

Cat program

We will implement cat in Go. It should take at least one argument which specifies the file name and prints out the contents.

package main

import (
  "fmt"
  "io"
  "os"
)

func main() {
  if len(os.Args) < 2 {
    _, err := io.Copy(os.Stdout, os.Stdin)

    if err != nil {
      fmt.Fprintf(os.Stderr, "%v\n", err)
      os.Exit(1)
    }

    os.Exit(0)
  }

  for _, files := range os.Args[1:] {
    r, err := os.Open(files)
    if err != nil {
      fmt.Fprintf(os.Stderr, "%v\n", err)
      continue
    }

    _, cerr := io.Copy(os.Stdout, r)

    if cerr != nil {
      fmt.Fprintf(os.Stderr, "%v\n", err)
      continue
    }
    r.Close()
  }
}

Save the code to a file called cat.go. Then in the same directory, create two files:

$ echo foo! > foo
$ echo bar! > bar

Build the cat program in go:

$ go build cat.go

Then we can run our cat program as such:

$ ./cat foo bar
foo!
bar!

We don’t have to build a program to run it. Another way to run the program:

$ go run cat.go foo bar

Dependencies

To use libraries created by the Go community in your code, we can use the go get command. A pre-requisite is to have GOPATH set.

For example, let’s use SVGo:

$ go get github.com/ajstarks/svgo

The command above basically performs a git clone and download all the code from that repository into $GOPATH/src/github.com/ajstarks/svgo. After executing the command, you can use the svgo library as follows:

package main

import (
  "math/rand"
  "os"

  svg "github.com/ajstarks/svgo"
)

var (
  canvas = svg.New(os.Stdout)
  width  = 1000
  height = 500
)

func main() {
  canvas.Start(width, height)
  canvas.Gstyle("fill:#22264b")

  var color string
  radius := 90
  step := 8

  for i := 0; i < 200; i++ {
    if i%4 == 0 {
      color = "#e6cf8b"
    } else {
      color = "#b56969"
    }

    x, y := rand.Intn(width), rand.Intn(height)

    for r, nc := radius, 0; nc < 10; nc++ {
      canvas.Circle(x, y, r, "stroke:"+color)
      r -= step
    }
  }

  canvas.Gend()
  canvas.End()
}

Run the code above using go run main.go > circles.html && open circles.html generates the following image:

Go Modules

Go v.1.11 introduced Go modules, which is a dependency management solution in Go. Here’s a good introduction to go.modules:

Stuff to check out

SVGo - generates SVG and canvas elements
Athens - A Go module datastore and proxy (NPM for Go)
GopherizeMe - Make Gopher version of yourself

Get Started With Go

Table of Contents