A New Year A New Go Routine

05 Jan 2016

I want to talk about a programming language I absolutely love. I think you will too.

Golang or Go Lang: What is it?

Go is an open source programming language that makes it easy to build simple, reliable, and efficient software.

Key Value
Paradigm    compiled, concurrent, imperative, structured
Designed by    Robert Griesemer Rob Pike Ken Thompson
Designed at    Google Inc
Website    http://golang.org

Golang Introduction

Here are some of the important data structures in Golang. This isn't a comprehensive list; Just what I think is important.

Golang JSON

JSON is arguably the most important data interchange format on the web today. Here is an Golang JSON example for the people at Go By Example.

// Go offers built-in support for JSON encoding and
// decoding, including to and from built-in and custom
// data types.

package main

import "encoding/json"
import "fmt"
import "os"

// We'll use these two structs to demonstrate encoding and
// decoding of custom types below.
type Response1 struct {
    Page   int
    Fruits []string
type Response2 struct {
    Page   int      `json:"page"`
    Fruits []string `json:"fruits"`

func main() {

    // First we'll look at encoding basic data types to
    // JSON strings. Here are some examples for atomic
    // values.
    bolB, _ := json.Marshal(true)

    intB, _ := json.Marshal(1)

    fltB, _ := json.Marshal(2.34)

    strB, _ := json.Marshal("gopher")

    // And here are some for slices and maps, which encode
    // to JSON arrays and objects as you'd expect.
    slcD := []string{"apple", "peach", "pear"}
    slcB, _ := json.Marshal(slcD)

    mapD := map[string]int{"apple": 5, "lettuce": 7}
    mapB, _ := json.Marshal(mapD)

    // The JSON package can automatically encode your
    // custom data types. It will only include exported
    // fields in the encoded output and will by default
    // use those names as the JSON keys.
    res1D := &Response1{
        Page:   1,
        Fruits: []string{"apple", "peach", "pear"}}
    res1B, _ := json.Marshal(res1D)

    // You can use tags on struct field declarations
    // to customize the encoded JSON key names. Check the
    // definition of `Response2` above to see an example
    // of such tags.
    res2D := &Response2{
        Page:   1,
        Fruits: []string{"apple", "peach", "pear"}}
    res2B, _ := json.Marshal(res2D)

    // Now let's look at decoding JSON data into Go
    // values. Here's an example for a generic data
    // structure.
    byt := []byte(`{"num":6.13,"strs":["a","b"]}`)

    // We need to provide a variable where the JSON
    // package can put the decoded data. This
    // `map[string]interface{}` will hold a map of strings
    // to arbitrary data types.
    var dat map[string]interface{}

    // Here's the actual decoding, and a check for
    // associated errors.
    if err := json.Unmarshal(byt, &dat); err != nil {

    // In order to use the values in the decoded map,
    // we'll need to cast them to their appropriate type.
    // For example here we cast the value in `num` to
    // the expected `float64` type.
    num := dat["num"].(float64)

    // Accessing nested data requires a series of
    // casts.
    strs := dat["strs"].([]interface{})
    str1 := strs[0].(string)

    // We can also decode JSON into custom data types.
    // This has the advantages of adding additional
    // type-safety to our programs and eliminating the
    // need for type assertions when accessing the decoded
    // data.
    str := `{"page": 1, "fruits": ["apple", "peach"]}`
    res := Response2{}
    json.Unmarshal([]byte(str), &res)

    // In the examples above we always used bytes and
    // strings as intermediates between the data and
    // JSON representation on standard out. We can also
    // stream JSON encodings directly to `os.Writer`s like
    // `os.Stdout` or even HTTP response bodies.
    enc := json.NewEncoder(os.Stdout)
    d := map[string]int{"apple": 5, "lettuce": 7}


$ go run json.go
map[num:6.13 strs:[a b]]
{1 [apple peach]}

I'll mention the play.golang.org site where you edit and run go code. It's perfect for one-off coding, learning, and links to runnable examples.

Here is a link to this example you can edit and run. http://play.golang.org/p/WxRgpycMaH.

Golang Map

Maps (Called Hashes or Dictionaries in other programming languages) are another essential data structure.

Here is an example from Go By Example.

// _Maps_ are Go's built-in [associative data type](http://en.wikipedia.org/wiki/Associative_array)
// (sometimes called _hashes_ or _dicts_ in other languages).

package main

import "fmt"

func main() {

    // To create an empty map, use the builtin `make`:
    // `make(map[key-type]val-type)`.
    m := make(map[string]int)

    // Set key/value pairs using typical `name[key] = val`
    // syntax.
    m["k1"] = 7
    m["k2"] = 13

    // Printing a map with e.g. `Println` will show all of
    // its key/value pairs.
    fmt.Println("map:", m)

    // Get a value for a key with `name[key]`.
    v1 := m["k1"]
    fmt.Println("v1: ", v1)

    // The builtin `len` returns the number of key/value
    // pairs when called on a map.
    fmt.Println("len:", len(m))

    // The builtin `delete` removes key/value pairs from
    // a map.
    delete(m, "k2")
    fmt.Println("map:", m)

    // The optional second return value when getting a
    // value from a map indicates if the key was present
    // in the map. This can be used to disambiguate
    // between missing keys and keys with zero values
    // like `0` or `""`. Here we didn't need the value
    // itself, so we ignored it with the _blank identifier_
    // `_`.
    _, prs := m["k2"]
    fmt.Println("prs:", prs)

    // You can also declare and initialize a new map in
    // the same line with this syntax.
    n := map[string]int{"foo": 1, "bar": 2}
    fmt.Println("map:", n)


$ go run maps.go
map: map[k1:7 k2:13]
v1:  7
len: 2
map: map[k1:7]
prs: false
map: map[foo:1 bar:2]

Try it out here

Golang Interface

Golang Interfaces are named collections of method signatures.

An example from Go By Example shows their usefulness.

// _Interfaces_ are named collections of method
// signatures.

package main

import "fmt"
import "math"

// Here's a basic interface for geometric shapes.
type geometry interface {
    area() float64
    perim() float64

// For our example we'll implement this interface on
// `rect` and `circle` types.
type rect struct {
    width, height float64
type circle struct {
    radius float64

// To implement an interface in Go, we just need to
// implement all the methods in the interface. Here we
// implement `geometry` on `rect`s.
func (r rect) area() float64 {
    return r.width * r.height
func (r rect) perim() float64 {
    return 2*r.width + 2*r.height

// The implementation for `circle`s.
func (c circle) area() float64 {
    return math.Pi * c.radius * c.radius
func (c circle) perim() float64 {
    return 2 * math.Pi * c.radius

// If a variable has an interface type, then we can call
// methods that are in the named interface. Here's a
// generic `measure` function taking advantage of this
// to work on any `geometry`.
func measure(g geometry) {

func main() {
    r := rect{width: 3, height: 4}
    c := circle{radius: 5}

    // The `circle` and `rect` struct types both
    // implement the `geometry` interface so we can use
    // instances of
    // these structs as arguments to `measure`.


{3 4}

Program exited.

For this runnable example try to add a "Cube" struct and implement the "Volume" function.

Golang Nuts

Forums are a great way to keep a pulse on a programming language community. The Golang Nuts is a a general discussion list for the Go Programming Language. Here you will search for answers, ask questions, and contribute to the Golang community.

Golang Book

We've already seen an awesome mailing list. Here is a book I recommend for getting started with Golang.

According to https://www.golang-book.com/ the An Introduction to Programming in Go book is,

A short, concise introduction to computer programming using the language Go. Designed by Google, Go is a general purpose programming language with modern features, clean syntax and a robust well-documented common library, making it an ideal language to learn as your first programming language.

If you learn better by reading and coding simultaneously, this book and course is great.

I hope you enjoyed my little tour of Golang. If you found it interesting, funny, or useful, please tweet!

Content is published under this license.