Learn Go

Loading slides...

    What is Go?

    Go is a new, general-purpose programming language.

    "Go is a wise, clean, insightful, fresh thinking approach to the greatest-hits subset of the well understood." — Michael T. Jones


    What is Go about?


    Small language

    Simple, concise syntax

    Orthogonal language features

    Predictable to use

    Easy to learn

    "Become competent in one day, productive in one week, and expert in one year." -me


    Structural typing: implicit interface implementation

    Encourages small, composable pieces

    No inheritance hierarchies

    Refactoring is easy

    Good design emerges naturally

    "Go makes you write good code." -me


    Goroutines are lightweight threads

    Channels provide thread-safe communication and synchronization

    "Write synchronous code, get the performance of asynchronous code." -me


    Compile to machine code

    Control memory layout

    "Write high performance code the obvious way." -me

    Compile fast

    Short write-compile-test cycle


    Garbage collected

    Pointers, but no pointer arithmetic

    No buffer overflows


    Go provides packages for reading/writing Go code

    The gofmt, godoc, and go tools use this

    Tools: gofmt

    The gofmt tool is a pretty-printer for Go source code.

    Ends all formatting discussions.

    Makes writing and reading code much easier.

    Saves a huge amount of time.

    Tools: godoc

    The godoc tool extracts and presents documentation from Go code.

    Documentation that lives with code is easy to keep up-to-date.

    // Split slices s into all substrings separated by sep and returns a slice of
    // the substrings between those separators.
    // If sep is empty, Split splits after each UTF-8 sequence.
    // It is equivalent to SplitN with a count of -1.
    func Split(s, sep string) []string {

    Tools: the go tool

    The go tool is the defacto standard for building and installing Go code.

    $ go run hello.go   # build and run hello.go
    $ go build          # build package in current directory
    $ go install        # install package in current directory

    It is a "zero configuration" tool. No Makefiles or scripts. Just Go code.

    It can also fetch Go code from remote repositories, as import paths are URLs:

    $ go get code.google.com/p/go.net/websocket
    import "code.google.com/p/go.net/websocket"
    http.Handle("/socket", websocket.Handler(socketHandler))

    This simple design leads to other cool tools:

    Tools: testing

    The testing package provides simple primitives for writing tests.

    (And benchmarks. And example code.)

    The go tool runs Go tests.

    $ go test

    Tools: etcetera



    Editor support

    The standard library

    Go has a great standard library:


    We're programmers because we love to code (right?)

    Slow, fussy development workflow makes us sad

    Go makes us happy

    Join us!



    Every Go program is made up of packages.

    Programs start running in package main.

    This program is using the packages with import paths "fmt" and "math".

    By convention, the package name is the same as the last element of the import path.

    package main import ( "fmt" "math" ) func main() { fmt.Println("Happy", math.Pi, "Day") }


    This code groups the imports into a parenthesized, "factored" import statement. You can also write multiple import statements, like:

    	import "fmt"
    	import "math"
    but it's common to use the factored form to eliminate clutter.
    package main import ( "fmt" "math" ) func main() { fmt.Printf("Now you have %g problems.", math.Nextafter(2, 3)) }

    Exported names

    After importing a package, you can refer to the names it exports.

    In Go, a name is exported if it begins with a capital letter.

    Foo is an exported name, as is FOO. The name foo is not exported.

    Run the code. Then rename math.pi to math.Pi and try it again.

    package main import ( "fmt" "math" ) func main() { fmt.Println(math.pi) }


    A function can take zero or more arguments.

    In this example, add takes two parameters of type int.

    Notice that the type comes after the variable name.

    (For more about why types look the way they do, see the article on Go's declaration syntax.)

    package main import "fmt" func add(x int, y int) int { return x + y } func main() { fmt.Println(add(42, 13)) }


    When two or more consecutive named function parameters share a type, you can omit the type from all but the last.

    In this example, we shortened

    x int, y int


    x, y int
    package main import "fmt" func add(x, y int) int { return x + y } func main() { fmt.Println(add(42, 13)) }


    A function can return any number of results.

    This function returns two strings.

    package main import "fmt" func swap(x, y string) (string, string) { return y, x } func main() { a, b := swap("hello", "world") fmt.Println(a, b) }


    Functions take parameters. In Go, functions can return multiple "result parameters", not just a single value. They can be named and act just like variables.

    If the result parameters are named, a return statement without arguments returns the current values of the results.

    package main import "fmt" func split(sum int) (x, y int) { x = sum * 4/9 y = sum - x return } func main() { fmt.Println(split(17)) }


    The var statement declares a list of variables; as in function argument lists, the type is last.

    package main import "fmt" var x, y, z int var c, python, java bool func main() { fmt.Println(x, y, z, c, python, java) }


    A var declaration can include initializers, one per variable.

    If an initializer is present, the type can be omitted; the variable will take the type of the initializer.

    package main import "fmt" var x, y, z int = 1, 2, 3 var c, python, java = true, false, "no!" func main() { fmt.Println(x, y, z, c, python, java) }


    Inside a function, the := short assignment statement can be used in place of a var declaration with implicit type.

    (Outside a function, every construct begins with a keyword and the := construct is not available.)

    package main import "fmt" func main() { var x, y, z int = 1, 2, 3 c, python, java := true, false, "no!" fmt.Println(x, y, z, c, python, java) }


    Constants are declared like variables, but with the const keyword.

    Constants can be character, string, boolean, or numeric values.

    package main import "fmt" const Pi = 3.14 func main() { const World = "世界" fmt.Println("Hello", World) fmt.Println("Happy", Pi, "Day") const Truth = true fmt.Println("Go rules?", Truth) }

    Numeric Constants

    Numeric constants are high-precision values.

    An untyped constant takes the type needed by its context.

    Try printing needInt(Big) too.

    package main import "fmt" const ( Big = 1<<100 Small = Big>>99 ) func needInt(x int) int { return x*10 + 1 } func needFloat(x float64) float64 { return x*0.1 } func main() { fmt.Println(needInt(Small)) fmt.Println(needFloat(Small)) fmt.Println(needFloat(Big)) }


    Go has only one looping construct, the for loop.

    The basic for loop looks as it does in C or Java, except that the ( ) are gone (they are not even optional) and the { } are required.

    package main import "fmt" func main() { sum := 0 for i := 0; i < 10; i++ { sum += i } fmt.Println(sum) }


    As in C or Java, you can leave the pre and post statements empty.

    package main import "fmt" func main() { sum := 1 for ; sum < 1000; { sum += sum } fmt.Println(sum) }


    At that point you can drop the semicolons: C's while is spelled for in Go.

    package main import "fmt" func main() { sum := 1 for sum < 1000 { sum += sum } fmt.Println(sum) }


    If you omit the loop condition, it loops forever.

    package main func main() { for ; ; { } }


    And with no clauses at all, the semicolons can be omitted, so an infinite loop is compactly expressed.

    package main func main() { for { } }


    The if statement looks as it does in C or Java, except that the ( ) are gone (they are not even optional) and the { } are required.

    (Sound familiar?)

    package main import ( "fmt" "math" ) func sqrt(x float64) string { if x < 0 { return sqrt(-x) + "i" } return fmt.Sprint(math.Sqrt(x)) } func main() { fmt.Println(sqrt(2), sqrt(-4)) }


    Like for, the if statement can start with a short statement to execute before the condition.

    Variables declared by the statement are only in scope until the end of the if.

    (Try using v in the last return statement.)

    package main import ( "fmt" "math" ) func pow(x, n, lim float64) float64 { if v := math.Pow(x, n); v < lim { return v } return lim } func main() { fmt.Println( pow(3, 2, 10), pow(3, 3, 20), ) }


    Variables declared inside an if's short statement are also available inside any of the else blocks.

    package main import ( "fmt" "math" ) func pow(x, n, lim float64) float64 { if v := math.Pow(x, n); v < lim { return v } else { fmt.Printf("%g >= %g\n", v, lim) } // can't use v here, though return lim } func main() { fmt.Println( pow(3, 2, 10), pow(3, 3, 20), ) }

    Basic types

    Go's basic types are

    int  int8  int16  int32  int64
    uint uint8 uint16 uint32 uint64 uintptr
    byte // alias for uint8
    rune // alias for int32
         // represents a Unicode code point
    float32 float64
    complex64 complex128
    package main import ( "math/cmplx" "fmt" ) var ( ToBe bool = false MaxInt uint64 = 1<<64 - 1 z complex128 = cmplx.Sqrt(-5+12i) ) func main() { const f = "%T(%v)\n" fmt.Printf(f, ToBe, ToBe) fmt.Printf(f, MaxInt, MaxInt) fmt.Printf(f, z, z) }


    A struct is a collection of fields.

    (And a type declaration does what you'd expect.)

    package main import "fmt" type Vertex struct { X int Y int } func main() { fmt.Println(Vertex{1, 2}) }

    Struct Fields

    Struct fields are accessed using a dot.

    package main import "fmt" type Vertex struct { X int Y int } func main() { v := Vertex{1, 2} v.X = 4 fmt.Println(v.X) }


    Go has pointers, but no pointer arithmetic.

    Struct fields can be accessed through a struct pointer. The indirection through the pointer is transparent.

    package main import "fmt" type Vertex struct { X int Y int } func main() { p := Vertex{1, 2} q := &p q.X = 1e9 fmt.Println(p) }

    Struct Literals

    A struct literal denotes a newly allocated struct value by listing the values of its fields.

    You can list just a subset of fields by using the Name: syntax. (And the order of named fields is irrelevant.)

    The special prefix & constructs a pointer to a struct literal.

    package main import "fmt" type Vertex struct { X, Y int } var ( p = Vertex{1, 2} // has type Vertex q = &Vertex{1, 2} // has type *Vertex r = Vertex{X: 1} // Y:0 is implicit s = Vertex{} // X:0 and Y:0 ) func main() { fmt.Println(p, q, r, s) }

    The new function

    The expression new(T) allocates a zeroed T value and returns a pointer to it.

    var t *T = new(T)


    t := new(T)
    package main import "fmt" type Vertex struct { X, Y int } func main() { v := new(Vertex) fmt.Println(v) v.X, v.Y = 11, 9 fmt.Println(v) }


    A map maps keys to values.

    Maps must be created with make (not new) before use; the nil map is empty and cannot be assigned to.

    package main import "fmt" type Vertex struct { Lat, Long float64 } var m map[string]Vertex func main() { m = make(map[string]Vertex) m["Bell Labs"] = Vertex{ 40.68433, 74.39967, } fmt.Println(m["Bell Labs"]) }


    Map literals are like struct literals, but the keys are required.

    package main import "fmt" type Vertex struct { Lat, Long float64 } var m = map[string]Vertex{ "Bell Labs": Vertex{ 40.68433, -74.39967, }, "Google": Vertex{ 37.42202, -122.08408, }, } func main() { fmt.Println(m) }


    If the top-level type is just a type name, you can omit it from the elements of the literal.

    package main import "fmt" type Vertex struct { Lat, Long float64 } var m = map[string]Vertex{ "Bell Labs": {40.68433, -74.39967}, "Google": {37.42202, -122.08408}, } func main() { fmt.Println(m) }

    Mutating Maps

    Insert or update an element in map m:

    m[key] = elem

    Retrieve an element:

    elem = m[key]

    Delete an element:

    delete(m, key)

    Test that a key is present with a two-value assignment:

    elem, ok = m[key]

    If key is in m, ok is true. If not, ok is false and elem is the zero value for the map's element type.

    Similarly, when reading from a map if the key is not present the result is the zero value for the map's element type.

    package main import "fmt" func main() { m := make(map[string]int) m["Answer"] = 42 fmt.Println("The value:", m["Answer"]) m["Answer"] = 48 fmt.Println("The value:", m["Answer"]) delete(m, "Answer") fmt.Println("The value:", m["Answer"]) v, ok := m["Answer"] fmt.Println("The value:", v, "Present?", ok) }


    A slice points to an array of values and also includes a length.

    []T is a slice with elements of type T.

    package main import "fmt" func main() { p := []int{2, 3, 5, 7, 11, 13} fmt.Println("p ==", p) for i := 0; i < len(p); i++ { fmt.Printf("p[%d] == %d\n", i, p[i]) } }


    Slices can be re-sliced, creating a new slice value that points to the same array.

    The expression


    evaluates to a slice of the elements from lo through hi-1, inclusive. Thus


    is empty and


    has one element.

    package main import "fmt" func main() { p := []int{2, 3, 5, 7, 11, 13} fmt.Println("p ==", p) fmt.Println("p[1:4] ==", p[1:4]) // missing low index implies 0 fmt.Println("p[:3] ==", p[:3]) // missing high index implies len(s) fmt.Println("p[4:] ==", p[4:]) }


    Slices are created with the make function. It works by allocating a zeroed array and returning a slice that refers to that array:

    a := make([]int, 5)  // len(a)=5
    Slices have length and capacity. A slice's capacity is the maximum length the slice can grow within the underlying array.

    To specify a capacity, pass a third argument to make:

    b := make([]int, 0, 5)
    // len(b)=0, cap(b)=5
    Slices can be grown by "re-slicing" (up to their capacity):

    b = b[:cap(b)] // len(b)=5, cap(b)=5
    b = b[1:]      // len(b)=4, cap(b)=4
    package main import "fmt" func main() { a := make([]int, 5) printSlice("a", a) b := make([]int, 0, 5) printSlice("b", b) c := b[:2] printSlice("c", c) d := c[2:5] printSlice("d", d) } func printSlice(s string, x []int) { fmt.Printf("%s len=%d cap=%d %v\n", s, len(x), cap(x), x) }


    The zero value of a slice is nil.

    A nil slice has a length and capacity of 0.

    (To learn more about slices, read the "Slices: usage and internals" article.)

    package main import "fmt" func main() { var z []int fmt.Println(z, len(z), cap(z)) if z == nil { fmt.Println("nil!") } }


    Functions are values too.

    package main import ( "fmt" "math" ) func main() { hypot := func(x, y float64) float64 { return math.Sqrt(x*x + y*y) } fmt.Println(hypot(3, 4)) }


    And functions are full closures.

    The adder function returns a closure. Each closure is bound to its own sum variable.

    package main import "fmt" func adder() func(int) int { sum := 0 return func(x int) int { sum += x return sum } } func main() { pos, neg := adder(), adder() for i := 0; i < 10; i++ { fmt.Println( pos(i), neg(-2*i), ) } }


    The range form of the for loop iterates over a slice or map.

    package main import "fmt" var pow = []int{1, 2, 4, 8, 16, 32, 64, 128} func main() { for i, v := range pow { fmt.Printf("2**%d = %d\n", i, v) } }


    You can skip the key or value by assigning to _.

    If you only want the index, drop the “, value” entirely.

    package main import "fmt" func main() { pow := make([]int, 10) for i := range pow { pow[i] = 1<<uint(i) } for _, value := range pow { fmt.Printf("%d\n", value) } }


    You probably knew what switch was going to look like.

    A case body breaks automatically, unless it ends with a fallthrough statement.

    package main import ( "fmt" "runtime" ) func main() { fmt.Print("Go runs on ") switch os := runtime.GOOS; os { case "darwin": fmt.Println("OS X.") case "linux": fmt.Println("Linux.") default: // freebsd, openbsd, // plan9, windows... fmt.Printf("%s.", os) } }


    Switch cases evaluate cases from top to bottom, stopping when a case succeeds.

    (For example,

    switch i {
    case 0:
    case f():

    does not call f if i==0.)

    package main import ( "fmt" "time" ) func main() { fmt.Println("When's Saturday?") today := time.Now().Weekday() switch time.Saturday { case today+0: fmt.Println("Today.") case today+1: fmt.Println("Tomorrow.") case today+2: fmt.Println("In two days.") default: fmt.Println("Too far away.") } }


    Switch without a condition is the same as switch true.

    This construct can be a clean way to write long if-then-else chains.

    package main import ( "fmt" "time" ) func main() { t := time.Now() switch { case t.Hour() < 12: fmt.Println("Good morning!") case t.Hour() < 17: fmt.Println("Good afternoon.") default: fmt.Println("Good evening.") } }

    Exercise: Loops and Functions

    As a simple way to play with functions and loops, implement the square root function using Newton's method.

    In this case, Newton's method is to approximate Sqrt(x) by picking a starting point z and then repeating:

    To begin with, just repeat that calculation 10 times and see how close you get to the answer for various values (1, 2, 3, ...).

    Next, change the loop condition to stop once the value has stopped changing (or only changes by a very small delta). See if that's more or fewer iterations. How close are you to the math.Sqrt?

    Hint: to declare and initialize a floating point value, give it floating point syntax or use a conversion:

    	z := float64(1)
    	z := 1.0
    package main import ( "fmt" ) func Sqrt(x float64) float64 { } func main() { fmt.Println(Sqrt(2)) }

    Exercise: Maps

    Implement WordCount. It should return a map of the counts of each “word” in the string s. The wc.Test function runs a test suite against the provided function and prints success or failure.

    You might find strings.Fields helpful.

    package main import ( "tourcode.google.com/p/learngo/wc" ) func WordCount(s string) map[string]int { return map[string]int{"x": 1} } func main() { wc.Test(WordCount) }

    Exercise: Slices

    Implement Pic. It should return a slice of length dy, each element of which is a slice of dx 8-bit unsigned integers. When you run the program, it will display your picture, interpreting the integers as grayscale (well, bluescale) values.

    The choice of image is up to you. Interesting functions include x^y, (x+y)/2, and x*y.

    (You need to use a loop to allocate each []uint8 inside the [][]uint8.)

    (Use uint8(intValue) to convert between types.)

    package main import "tourcode.google.com/p/learngo/pic" func Pic(dx, dy int) [][]uint8 { } func main() { pic.Show(Pic) }

    Exercise: Fibonacci closure

    Let's have some fun with functions.

    Implement a fibonacci function that returns a function (a closure) that returns successive fibonacci numbers.

    package main import "fmt" // fibonacci is a function that returns // a function that returns an int. func fibonacci() func() int { } func main() { f := fibonacci() for i := 0; i < 10; i++ { fmt.Println(f()) } }

    Advanced Exercise: Complex cube roots

    Let's explore Go's built-in support for complex numbers via the complex64 and complex128 types. For cube roots, Newton's method amounts to repeating:

    Find the cube root of 2, just to make sure the algorithm works. There is a Pow function in the math/cmplx package.

    package main import "fmt" func Cbrt(x complex128) complex128 { } func main() { fmt.Println(Cbrt(2)) }
    Set up your environment

    Set up your environment

    Installing Go

    Binary distributions are available at golang.org:

    Test your installation

    Put the code to the left in a file named hello.go.

    Then run:

    $ go run hello.go

    If you see the output "Hello!" then your Go installation is working correctly.

    package main import "fmt" func main() { fmt.Println("Hello!") }


    The go tool derives build instructions from Go source code.

    There's no need to write and maintain build scripts.

    For this to work, some prescribed directory structure, known as a workspace, is required.

        bin # executable binaries
        pkg # compiled object files
        src # source code

    Create a workspace

      $ mkdir -p $HOME/gocode/src

    (The bin and pkg sub-directories will be created by the go tool.)

    Tell the go tool where your workspace is by setting the GOPATH environment variable:

      export GOPATH=$HOME/gocode

    You may also want to add the bin sub-directory of your workspace to your PATH:

      export PATH=$PATH:$GOPATH/bin

    This lets you run your Go programs without specifying their full path.

    (You may want to put these export commands in the .bash_profile file in your home directory.)

    Choose a namespace

    Choose a special place for your Go code.

    I use "github.com/nf", the root of my GitHub account (useful with go get).

      $ mkdir -p $GOPATH/src/github.com/nf

    Create a hello directory in your namespace and copy hello.go there:

      $ mkdir $GOPATH/src/github.com/nf/hello
      $ cp hello.go $GOPATH/src/github.com/nf/hello

    Now you can build install the hello program with the go tool:

      $ go install github.com/nf/hello

    This builds an executable named hello, and installs it to the bin directory of your workspace.

      $ $GOPATH/bin/hello
      Hello, fellow gopher
    Methods and Interfaces

    Methods and Interfaces


    Go does not have classes. However, you can define methods on struct types.

    The method receiver appears in its own argument list between the func keyword and the method name.

    package main import ( "fmt" "math" ) type Vertex struct { X, Y float64 } func (v *Vertex) Abs() float64 { return math.Sqrt(v.X*v.X + v.Y*v.Y) } func main() { v := &Vertex{3, 4} fmt.Println(v.Abs()) }


    In fact, you can define a method on any type you define in your package, not just structs.

    You cannot define a method on a type from another package, or on a basic type.

    package main import ( "fmt" "math" ) type MyFloat float64 func (f MyFloat) Abs() float64 { if f < 0 { return float64(-f) } return float64(f) } func main() { f := MyFloat(-math.Sqrt2) fmt.Println(f.Abs()) }

    Methods with pointer receivers

    Methods can be associated with a named type or a pointer to a named type.

    We just saw two Abs methods. One on the *Vertex pointer type and the other on the MyFloat value type.

    There are two reasons to use a pointer receiver. First, to avoid copying the value on each method call (more efficient if the value type is a large struct). Second, so that the method can modify the value that its receiver points to.

    Try changing the declarations of the Abs and Scale methods to use Vertex as the receiver, instead of *Vertex.

    The Scale method has no effect when v is a Vertex. Scale mutates v. When v is a value (non-pointer) type, the method sees a copy of the Vertex and cannot mutate the original value.

    Abs works either way. It only reads v. It doesn't matter whether it is reading the original value (through a pointer) or a copy of that value.

    package main import ( "fmt" "math" ) type Vertex struct { X, Y float64 } func (v *Vertex) Scale(f float64) { v.X = v.X * f v.Y = v.Y * f } func (v *Vertex) Abs() float64 { return math.Sqrt(v.X*v.X + v.Y*v.Y) } func main() { v := &Vertex{3, 4} v.Scale(5) fmt.Println(v, v.Abs()) }


    An interface type is defined by a set of methods.

    A value of interface type can hold any value that implements those methods.

    package main import ( "fmt" "math" ) type Abser interface { Abs() float64 } func main() { var a Abser f := MyFloat(-math.Sqrt2) v := Vertex{3, 4} a = f // a MyFloat implements Abser a = &v // a *Vertex implements Abser a = v // a Vertex, does NOT // implement Abser fmt.Println(a.Abs()) } type MyFloat float64 func (f MyFloat) Abs() float64 { if f < 0 { return float64(-f) } return float64(f) } type Vertex struct { X, Y float64 } func (v *Vertex) Abs() float64 { return math.Sqrt(v.X*v.X + v.Y*v.Y) }


    A type implements an interface by implementing the methods.

    There is no explicit declaration of intent.

    Implicit interfaces decouple implementation packages from the packages that define the interfaces: neither depends on the other.

    It also encourages the definition of precise interfaces, because you don't have to find every implementation and tag it with the new interface name.

    Package io defines Reader and Writer; you don't have to.

    package main import ( "fmt" "os" ) type Reader interface { Read(b []byte) (n int, err error) } type Writer interface { Write(b []byte) (n int, err error) } type ReadWriter interface { Reader Writer } func main() { var w Writer // os.Stdout implements Writer w = os.Stdout fmt.Fprintf(w, "hello, writer\n") }


    An error is anything that can describe itself as an error string. The idea is captured by the predefined, built-in interface type, error, with its single method, Error, returning a string:

    type error interface {
    	Error() string

    The fmt package's various print routines automatically know to call the method when asked to print an error.

    package main import ( "fmt" "time" ) type MyError struct { When time.Time What string } func (e *MyError) Error() string { return fmt.Sprintf("at %v, %s", e.When, e.What) } func run() error { return &MyError{ time.Now(), "it didn't work", } } func main() { if err := run(); err != nil { fmt.Println(err) } }

    Web servers

    Package http serves HTTP requests using any value that implements http.Handler:

    package http
    type Handler interface {
    	ServeHTTP(w ResponseWriter,
    	          r *Request)

    In this example, the type Hello implements http.Handler.

    Visit http://localhost:4000/ to see the greeting. Note: This example won't run through the web-based tour user interface. To try writing web servers you may want to Install Go.

    package main import ( "fmt" "net/http" ) type Hello struct{} func (h Hello) ServeHTTP( w http.ResponseWriter, r *http.Request) { fmt.Fprint(w, "Hello!") } func main() { var h Hello http.ListenAndServe("localhost:4000",h) }


    Package image defines the Image interface:

    package image
    type Image interface {
    	ColorModel() color.Model
    	Bounds() Rectangle
    	At(x, y int) color.Color

    (See the documentation for all the details.)

    Also, color.Color and color.Model are interfaces, but we'll ignore that by using the predefined implementations color.RGBA and color.RGBAModel.

    package main import ( "fmt" "image" ) func main() { m := image.NewRGBA(image.Rect(0, 0, 100, 100)) fmt.Println(m.Bounds()) fmt.Println(m.At(0, 0).RGBA()) }

    Exercise: Errors

    Copy your Sqrt function from the earlier exercises and modify it to return an error value.

    Sqrt should return a non-nil error value when given a negative number, as it doesn't support complex numbers.

    Create a new type

    type ErrNegativeSqrt float64

    and make it an error by giving it a

    func (e ErrNegativeSqrt) Error() string

    method such that ErrNegativeSqrt(-2).Error() returns "cannot Sqrt negative number: -2".

    Note: a call to fmt.Print(e) inside the Error method will send the program into an infinite loop. You can avoid this by converting e first: fmt.Print(float64(e)). Why?

    Change your Sqrt function to return an ErrNegativeSqrt value when given a negative number.

    package main import ( "fmt" ) func Sqrt(f float64) (float64, error) { return 0, nil } func main() { fmt.Println(Sqrt(2)) fmt.Println(Sqrt(-2)) }

    Exercise: HTTP Handlers

    Implement the following types and define ServeHTTP methods on them. Register them to handle specific paths in your web server.

    type String string
    type Struct struct {
    	Greeting string
    	Punct    string
    	Who      string

    For example, you should be able to register handlers using:

    http.Handle("/string", String("I'm a frayed knot."))
    http.Handle("/struct", &Struct{"Hello", ":", "Gophers!"})
    package main import ( "net/http" ) func main() { // your http.Handle calls here http.ListenAndServe("localhost:4000", nil) }

    Exercise: Images

    Remember the picture generator you wrote earlier? Let's write another one, but this time it will return an implementation of image.Image instead of a slice of data.

    Define your own Image type, implement the necessary methods, and call pic.ShowImage.

    Bounds should return a image.Rectangle, like image.Rect(0, 0, w, h).

    ColorModel should return color.RGBAModel.

    At should return a color; the value v in the last picture generator corresponds to color.RGBA{v, v, 255, 255} in this one.

    package main import ( "image" "tourcode.google.com/p/learngo/pic" ) type Image struct{} func main() { m := Image{} pic.ShowImage(m) }

    Exercise: Rot13 Reader

    A common pattern is an io.Reader that wraps another io.Reader, modifying the stream in some way.

    For example, the gzip.NewReader function takes an io.Reader (a stream of gzipped data) and returns a *gzip.Reader that also implements io.Reader (a stream of the decompressed data).

    Implement a rot13Reader that implements io.Reader and reads from an io.Reader, modifying the stream by applying the ROT13 substitution cipher to all alphabetical characters.

    The rot13Reader type is provided for you. Make it an io.Reader by implementing its Read method.

    Additional exercise: implement a command-line utility that rot13-encodes standard input and writes to standard output.

    package main import ( "io" "os" "strings" ) type rot13Reader struct { r io.Reader } func main() { s := strings.NewReader( "Lbh penpxrq gur pbqr!") r := rot13Reader{s} io.Copy(os.Stdout, &r) }

    The template packages

    The Go standard library includes a text templating package, text/template.

    It uses a simple declarative language, described in detail in the package documentation.

    The text/template package has a sister package, html/template, that is identical except that it automatically escapes values in HTML, JavaScript, and CSS.

    package main import ( "log" "os" "text/template" ) var text = "{{range .}}Name: {{.Name}} Age: {{.Age}}\n{{end}}" var tmpl = template.Must(template.New("name").Parse(text)) type Person struct { Name string Age int } func main() { peeps := []Person{ {"Andrew", 28}, {"Brad", 32}, } err := tmpl.Execute(os.Stdout, peeps) if err != nil { log.Fatal(err) } }

    The encoding/json package

    Go's encoding/json package encodes and decodes JSON data from and to native Go data structures.

    Its NewDecoder and NewEncoder functions wrap io.Reader and io.Writer respectively, permitting the transcoding of JSON streams.

    package main import ( "encoding/json" "fmt" "log" "os" "strings" ) type Person struct { Name string Age int } var blob = `[ {"Name": "Andrew", "Age": 28}, {"Name": "Brad", "Age": 32} ]` func main() { var peeps []Person dec := json.NewDecoder(strings.NewReader(blob)) err := dec.Decode(&peeps) if err != nil { log.Fatal(err) } fmt.Println(peeps) enc := json.NewEncoder(os.Stdout) err = enc.Encode(&peeps) if err != nil { log.Fatal(err) } }
    Todo exercise

    Exercise: TODO 1/6

    Write a program that reads the todo.sample file and displays its contents, so that this input:

    watch a movie
    read a book
    catch a rat

    produces this output:

    0 watch a movie
    1 read a book
    2 catch a rat

    Hint: use the io/ioutil package's ReadFile function to read from a file.
    Hint: to convert a []byte b to a string use string(b).
    Hint: use the strings package's Split function.
    Hint: use the log package's Fatal function to report errors and die.
    Hint: use the fmt package's Printf function to do formatted output.

    Exercise: TODO 2/6

    Imlement an add function, so that this command line:

    $ todo buy a cat

    produces this output

    0 watch a movie
    1 read a book
    2 catch a rat
    3 buy a cat

    Hint: use the flag package to parse the command line. Look at its Parse and Args functions.
    Hint: use the strings package's Join functio to concatenate command line arguments.
    Hint: use the built-in append function to push the new item onto the list of items.
    Hint: to convert a string to a []byte use []byte(s).
    Hint: use the io/ioutil package's WriteFile function to write to a file.

    Exercise: TODO 3/6

    Implement a remove function, so that this command line removes the first item in the list:

    $ todo -rm 0

    Hint: look at flag.Int.
    Hint: use -1 as the flag default.
    Hint: to remove an item from a slice, create a new slice and add to it all but the specified item.
    Hint: (There is a more clever way of doing this with append.)

    Exercise: TODO 4/6

    Other tasks:

    Handle missing or empty todo files.

    Use $HOME/.todo as the todo file location.
    Hint: use the os package's Getenv function.

    Let the user set an environment variable to specify the todo file location.

    Exercise: TODO 5/6

    Modify your todo program to store the items in JSON format.

    Hint: use os.Open to open the file for reading.
    Hint: wrap the *os.File in a json.NewDecoder to decode the value.
    Hint: to open the file for writing, use os.OpenFile with the modes os.O_WRONLY | os.O_CREATE | os.O_TRUNC.

    Exercise: TODO 6/6

    Implement a -web flag that launches a web server that serves the todos in an HTML page.

    Hint: use flag.Bool.

    Hint: use the html/template package to generate the HTML.




    A goroutine is a lightweight thread managed by the Go runtime.

    go f(x, y, z)

    starts a new goroutine running

    f(x, y, z)

    The evaluation of f, x, y, and z happens in the current goroutine and the execution of f happens in the new goroutine.

    Goroutines run in the same address space, so access to shared memory must be synchronized. The sync package provides useful primitives, although you won't need them much in Go as there are other primitives. (See the next slide.)

    package main import ( "fmt" "runtimetime" ) func say(s string) { for i := 0; i < 5; i++ { runtime.Gosched()time.Sleep(100 * time.Millisecond) fmt.Println(s) } } func main() { go say("world") say("hello") }


    Channels are a typed conduit through which you can send and receive values with the channel operator, <-.

    ch <- v    // Send v to channel ch.
    v := <-ch  // Receive from ch, and
               // assign value to v.

    (The data flows in the direction of the arrow.)

    Like maps and slices, channels must be created before use:

    ch := make(chan int)

    By default, sends and receives block until the other side is ready. This allows goroutines to synchronize without explicit locks or condition variables.

    package main import "fmt" func sum(a []int, c chan int) { sum := 0 for _, v := range a { sum += v } c <- sum // send sum to c } func main() { a := []int{7, 2, 8, -9, 4, 0} c := make(chan int) go sum(a[:len(a)/2], c) go sum(a[len(a)/2:], c) x, y := <-c, <-c // receive from c fmt.Println(x, y, x + y) }

    Buffered Channels

    Channels can be buffered. Provide the buffer length as the second argument to make to initialize a buffered channel:

    ch := make(chan int, 100)

    Sends to a buffered channel block only when the buffer is full. Receives block when the buffer is empty.

    Modify the example to overfill the buffer and see what happens.

    package main import "fmt" func main() { c := make(chan int, 2) c <- 1 c <- 2 fmt.Println(<-c) fmt.Println(<-c) }

    Range and Close

    A sender can close a channel to indicate that no more values will be sent. Receivers can test whether a channel has been closed by assigning a second parameter to the receive expression: after

    v, ok := <-ch

    ok is false if there are no more values to receive and the channel is closed.

    The loop for i := range c receives values from the channel repeatedly until it is closed.

    Note: Only the sender should close a channel, never the receiver. Sending on a closed channel will cause a panic.

    Another note: Channels aren't like files; you don't usually need to close them. Closing is only necessary when the receiver must be told there are no more values coming, such as to terminate a range loop.

    package main import ( "fmt" ) func fibonacci(n int, c chan int) { x, y := 1, 1 for i := 0; i < n; i++ { c <- x x, y = y, x + y } close(c) } func main() { c := make(chan int, 10) go fibonacci(cap(c), c) for i := range c { fmt.Println(i) } }


    The select statement lets a goroutine wait on multiple communication operations.

    A select blocks until one of its cases can run, then it executes that case. It chooses one at random if multiple are ready.

    package main import "fmt" func fibonacci(c, quit chan int) { x, y := 1, 1 for { select { case c <- x: x, y = y, x + y case <-quit: fmt.Println("quit") return } } } func main() { c := make(chan int) quit := make(chan int) go func() { for i := 0; i < 10; i++ { fmt.Println(<-c) } quit <- 0 }() fibonacci(c, quit) }

    Default Selection

    The default case in a select is run if no other case is ready.

    Use a default case to try a send or receive without blocking:

    select {
    case i := <-c:
    	// use i
    	// receiving from c would block

    Note: This example won't run through the web-based tour user interface because the sandbox environment has no concept of time. You may want to install Go to see this example in action.

    package main import ( "fmt" "time" ) func main() { tick := time.Tick(1e8) boom := time.After(5e8) for { select { case <-tick: fmt.Println("tick.") case <-boom: fmt.Println("BOOM!") return default: fmt.Println(" .") time.Sleep(5e7) } } }

    Exercise: Equivalent Binary Trees

    There can be many different binary trees with the same sequence of values stored at the leaves. For example, here are two binary trees storing the sequence 1, 1, 2, 3, 5, 8, 13.

    A function to check whether two binary trees store the same sequence is quite complex in most languages. We'll use Go's concurrency and channels to write a simple solution.

    This example uses the tree package, which defines the type:

    type Tree struct {
    	Left  *Tree
    	Value int
    	Right *Tree

    Exercise: Equivalent Binary Trees

    1. Implement the Walk function.

    2. Test the Walk function.

    The function tree.New(k) constructs a randomly-structured binary tree holding the values k, 2k, 3k, ..., 10k.

    Create a new channel ch and kick off the walker:

    go Walk(tree.New(1), ch)

    Then read and print 10 values from the channel. It should be the numbers 1, 2, 3, ..., 10.

    3. Implement the Same function using Walk to determine whether t1 and t2 store the same values.

    4. Test the Same function.

    Same(tree.New(1), tree.New(1)) should return true, and Same(tree.New(1), tree.New(2)) should return false.

    package main import "tourcode.google.com/p/learngo/tree" // Walk walks the tree t sending all values // from the tree to the channel ch. func Walk(t *tree.Tree, ch chan int) // Same determines whether the trees // t1 and t2 contain the same values. func Same(t1, t2 *tree.Tree) bool func main() { }

    Exercise: Web Crawler

    In this exercise you'll use Go's concurrency features to parallelize a web crawler.

    Modify the Crawl function to fetch URLs in parallel without fetching the same URL twice.

    package main import ( "fmt" ) type Fetcher interface { // Fetch returns the body of URL and // a slice of URLs found on that page. Fetch(url string) (body string, urls []string, err error) } // Crawl uses fetcher to recursively crawl // pages starting with url, to a maximum of depth. func Crawl(url string, depth int, fetcher Fetcher) { // TODO: Fetch URLs in parallel. // TODO: Don't fetch the same URL twice. // This implementation doesn't do either: if depth <= 0 { return } body, urls, err := fetcher.Fetch(url) if err != nil { fmt.Println(err) return } fmt.Printf("found: %s %q\n", url, body) for _, u := range urls { Crawl(u, depth-1, fetcher) } return } func main() { Crawl("http://golang.org/", 4, fetcher) } // fakeFetcher is Fetcher that returns canned results. type fakeFetcher map[string]*fakeResult type fakeResult struct { body string urls []string } func (f *fakeFetcher) Fetch(url string) (string, []string, error) { if res, ok := (*f)[url]; ok { return res.body, res.urls, nil } return "", nil, fmt.Errorf("not found: %s", url) } // fetcher is a populated fakeFetcher. var fetcher = &fakeFetcher{ "http://golang.org/": &fakeResult{ "The Go Programming Language", []string{ "http://golang.org/pkg/", "http://golang.org/cmd/", }, }, "http://golang.org/pkg/": &fakeResult{ "Packages", []string{ "http://golang.org/", "http://golang.org/cmd/", "http://golang.org/pkg/fmt/", "http://golang.org/pkg/os/", }, }, "http://golang.org/pkg/fmt/": &fakeResult{ "Package fmt", []string{ "http://golang.org/", "http://golang.org/pkg/", }, }, "http://golang.org/pkg/os/": &fakeResult{ "Package os", []string{ "http://golang.org/", "http://golang.org/pkg/", }, }, }

    Where to Go from here...

    You can get started by installing Go or downloading the Go App Engine SDK.

    Once you have Go on your machine, the The Go Documentation is a great place to continue start. It contains references, tutorials, videos, and more.

    If you need help with the standard library, see the package reference. For help with the language itself, you might be surprised to find the Language Spec is quite readable.

    To further explore Go's concurrency model, see the Share Memory by Communicating codewalk.

    The First Class Functions in Go codewalk gives an interesting perspective on Go's function types.

    The Go Blog has a large archive of informative Go articles.

    Visit golang.org for more.