introduction-to-go.slide

Introduction to Go
Internal SoftServe Golang Training
22 Dec 2016

Ivan Kutuzov
ikut@softserveinc.com
https://discuss.7insyde.com
https://golang.org.ua
@arbrix

* License and Materials

Dave Cheney is the original author of all this materials

This presentation is licensed under the [[https://creativecommons.org/licenses/by-sa/4.0/][Creative Commons Attribution-ShareAlike 4.0 International]] licence.

The materials for this presentation are available on GitHub:

.link https://github.com/davecheney/introduction-to-go

You are encouraged to remix, transform, or build upon the material, providing you give appropriate credit and distribute your contributions under the same license.

If you have suggestions or corrections to this presentation, please raise [[https://github.com/davecheney/introduction-to-go/isues][an issue on the GitHub project]].

* Agenda

This workshop is aimed at programmers with experience in another programming language and want to learn how to apply their skills to Go.

This workshop consists of five main sections:

- Basic Syntax
- Advanced Syntax
- Development environment and tooling
- The standard library
- Packages and applications

After each section we'll have time for questions.


* The Go programming language

- Modern
- Compact, concise, general-purpose
- Imperative, statically type-checked, dynamically type-safe
- Garbage-collected
- Compiles to native code, statically linked
- Fast compilation, efficient execution

Designed by programmers for programmers!

.link https://talks.golang.org/2014/taste.slide#2 Source: Robert Griesemer, A Taste of Go.

* Speed

Go is often noted for its fast compilation, but this is only one facet of the idea of Go being a _fast_ language to program in.

"False dichotomy of static languages being 'slow and painful' and dynamic languages being 'fast and fun'" -Rob Pike

"Clumsy type systems drive people to dynamically typed languages" -Robert Griesemer

Go is an attempt to demonstrate that a language can be both fast in terms of the programs it produces and fast (productive?) for the programmers.

* Safety

- Typed, and type safe

 var i int = -1
 var u uint = 200
 i = u   // nope, incompatible types

- Array accesses are bounds checked

 s := make([]string, 10)
 x := s[20] // will panic at runtime

- All memory is zeroed if not explicitly initialised

 var q int       // initialised to 0
 var f = 7       // initialised to 7, type defaults to int

- No implicit conversions; booleans and integers are not aliases

 i := 2
 if i { ... }    // nope, no coercion to bool

* Good support for concurrency and communication

- Multicore CPUs are a reality.
- Multiprocessing is not a solution.
- Networking support baked into the standard library, integrated into the runtime.

* Garbage collected

Go is a garbage collected language.

- Eliminates the bookkeeping errors related to ownership of shared values.
- Eliminates an entire class of use after free and memory leak bugs.
- Enables simpler, cleaner, APIs.

The garbage collector handles heaps into the 100's of GB range, and is designed for extremely low "stop the world" pauses.

In Go 1.7 these pauses are now less than 100 microseconds.

* Opinionated

Go is an opinionated language.

- Unused local variables are an error.
- Unused imports are also an error.
- The compiler does not issue warnings, only errors.
- A single way to format code as defined by `go`fmt`.

* Hello, http!

.code -edit src/hellohttp/hellohttp.go

* Basic Syntax

* Basic Syntax 

In this section we will walk through the basic syntax of a short Go program.

For this section all the code exercises will be inside this slide deck itself.

At the end of this section you'll know:

- How to declare constants and variables
- How to write `for` loops and use `if`.
- How types work.
- How to write your own functions.
- How packages and `import` statements work.

* Constants

A good place to start talking about Go are _Constants_.

Constants are values that do not change.

Here are some examples of constants:

 1
 "hello"
 false
 1.3

These are called _literal_constants_ because the value of evaluating each of these is the constant itself.

* Types of constants

There are six kinds of constants

- integer constants: `1`, `0`, `-6`, `9999999999999999999`, …
- floating point constants: `3.14`, `7.5e-2`, …
- complex number constants (rare): `1`-`0.707i`, …
- string constants: `"Hello,`東京"`, … 
- rune constants: `'a'`, `'す'`, `'シ'`, `'1'`, …
- boolean constants: `true`, `false`

* const

To make a constant, we declare one with the `const` keyword.

.code -edit src/const/const1/main.go /START OMIT/,/END OMIT/

* Identifiers

This is a good time to talk about _identifiers_.

An identifier is a name your give to something in your code.

In Go an identifier is any word that starts with a _letter_.

.code -edit src/identifier/identifier1/main.go /START OMIT/,/END OMIT/

A letter is anything that Unicode defines to be a letter, this includes Kanji, Cyrillic, Latin, etc.

* Identifiers (cont.)

An identifier must start with a Unicode letter, or the underscore character, `_`.

Numbers are not permitted at the start of an identifier, but can appear later in the identifier.

.code -edit src/identifier/identifier2/main.go /START OMIT/,/END OMIT/

Here are some examples of _invalid_ identifiers.

* Comments

Go supports two kinds of comments:

- Inline comments, which start with a double forward slash, `//`.
- Block comments, which start with a forward slash and a star, `/*`, and end with a star and forward slash, `*/`.

.code -edit src/comments/comments1/main.go /START OMIT/,/END OMIT/

Code that is commented out will not be compiled or run.

* Declarations

There are six kinds of _declarations_ in Go, we've seen one of them already.

They are:

- `const`: declares a new constant.
- `var`: declares a new variable.
- `type`: declares a new type.
- `func`: declares a new function, or method.
- `package`: declares the package this `.go` source file belongs to.
- `import`: declares that this package imports declarations from another. 

We'll cover each of the remaining five declarations in this section.

* Variables

A variable holds a value that can be changed over time.

You _declare_ a new variable with the `var` declaration.

.code -edit src/variable/variable1/main.go /START OMIT/,/END OMIT/

Just like constants, variable _identifiers_ can be any any valid Unicode word.

_note_: The circumference is printed in scientific notation 😕, that's ok, we'll talk about how to fix it later when we talk about the `fmt` package.

* Unused variable declarations

Unused variables are often the source of bugs. If you declare a variable in the scope of your function but do not use it, the Go compiler will complain.

If the variable is unused, you should delete it, or assign it temporarily to the magic variable called `_`.

.code -edit src/variable/variable2/main.go /START OMIT/,/END OMIT/

This program has four unused variables.

- Fix the program by removing the comment from the two lines at the bottom.
- Delete, or comment out, the declaration of `自転車` as it is unused.

* Statements

A _statement_ is a command to do something:

- _Declare_a_new_integer_variable_x_and_assign_it_the_value_10_.
- _Add_4_to_the_value_of_x_and_store_the_result_in_y_.
- _While_x_less_than_20_perform_these_statements_.

There are several kinds of statements in Go, we've seen a few already. The most common statements are:

- Declarations: `const`pi`=`3.14159265359`, `type`Counter`int32`, …
- Assignments: `count`=`count`+`1`, …
- Increment/Decrement: `x++`, `y--`
- Conditionals: `if`…`{`…`}`else`{`…`}`, `switch`{`…`}`
- Loops: `for`…`{`…`}`
- Control flow: `break`, `fallthrough`, `continue`, `goto`, `return`.

* Assignment

It is common that you need to change the value stored in a variable, this is called _Assignment_.

.code -edit src/assignment/assignment1/main.go /START OMIT/,/END OMIT/

In this example, we declare

- Check that program prints, `1`, `2`, `4`.
# - Update the program to declare a new variable, `z`, which has a value 2x larger than `y`.

* Assignment (cont.)

You can only assign a new value to _variables_.

.code -edit src/assignment/assignment2/main.go /START OMIT/,/END OMIT/

It is a syntax error to assign a new value to a constant.

- Edit the sample code to change the declaration of `x` from a constant (`const`) to a variable (`var`).

* Increment and decrement

Go supports a limited form of variable post-increment and post-decrement, ie. `x++`, `x--`.

.code -edit src/increment/increment1/main.go /START OMIT/,/END OMIT/

- Edit the sample code to subtract `1` from `i` using the decrement operator `i--`.

* Increment and decrement (cont.)

`i++` and `i--` are _statements_, not an _expressions_, they do not produce a value.

.code -edit src/increment/increment2/main.go /START OMIT/,/END OMIT/

This program has a syntax error. 

- Edit the sample code to correct the error by moving the `i++` statement above the declaration of `var`j`.

* Looping

Go has a single `for` loop construct that combines

- `while` _condition_ `{`…`}`
- `do`{`…`}`while` _condition_
- `do`{`…`}`until` _condition_

into one syntax.

- `for` _(init_statement)_; _condition_; _(post_statement)_ `{`…`}`

The parts of a `for` statement are:

- init statement: used to initalise the loop variable; `i`=`0`.
- condition: user to test if the loop is done; `i`<`10`, `true` means keep looping.
- post statement: user to increment the loop variable; `i++`, `i`=`i`-`1`.

* Looping (cont.) 

Let's practice using loops.

.code -edit src/loops/loops1/main.go /START OMIT/,/END OMIT/

This program counts from `1` to `10`, can you make it print only the _even_ numbers.

- Edit the program to make it print only the even numbers between `1` and `10`, inclusive.

_note_: you do not need to put `(` braces around the `for` condition `)`. In fact, if you do it's a syntax error. Try it.

* Looping (cont.) 

Let's practice counting down, this is where you would use a `while` loop in other languages.

.code -edit src/loops/loops2/main.go /START OMIT/,/END OMIT/

This program counts down from `10` to `1`, can you make it count from `7` to `3`.

- Edit the program to make it print only the numbers from `7` down to `3`.

_note_: this `for` loop only has a _condition_, there is no _init_statement_ or _post_statement_, so we can omit the semicolons, `;`.

* Conditional statements

Go has two conditional statements, `if` and `switch`.

`if` is used to choose between two choices based on a _condition_.

 if v > 0 {
         println("v is greater than zero")
 } else {
         println("v is less than or equal to zero")
 }

In some cases the body of the `else` block may be omitted. This is very common when checking preconditions in a method of a function.

 if v == 0 {
         // nothing to do
         return
 }
 // handle v

* if

Let's revisit our previous even numbers `for` loop example.

.code -edit src/conditionals/conditionals1/main.go /START OMIT/,/END OMIT/

This program counts from `1` to `10`, can you make it print only the _even_ numbers.

- Uncomment the `if`i%2`==`0`{` and `}` lines to make the program print only the even numbers between `1` and `10`.

_note_: `%` is the _modulo_ operator in Go. All even numbers divide wholly by `2`, leaving `0` as their _modulo_ (or remainder).

* continue

Unlike languages like Java, `if` statements in Go are often used as _guard_clauses_.

We say that when everything is true the code reads from the top to the bottom of the page.

We can rewrite the previous program using a new statement, `continue`, which _skips_ the body of the loop.

.code -edit src/conditionals/conditionals2/main.go /START OMIT/,/END OMIT/

- Uncomment the `if`i%1`==`1`{`, `continue`, and `}` lines.

* break

This program is an _infinite_loop_. There is no _condition_expression_ in the `for` loop.

We can use the `break` statement, which breaks out of the _current_ loop, to fix it.

.code -edit src/conditionals/conditionals3/main.go /START OMIT/,/END OMIT/

- Uncomment the `if`i`>`10`{`, `break`, and `}` lines.

* Type inference

In the examples so far we've avoided talking about types, this is because Go supports _type_inference_.

Type inference lets you omit the type of a variable during declaration.

For example:

 var i = 7

Go sees that `i` is being declared and initalised with the value `7`, so the compiler infers the type of `i` is an `int`.

However if we did

 var s = "seven"

Go sees that `s` is being initalised with the _string_ `"seven"`, so the compiler infers the type of `s` is a `string`.

* Explicit type declaration

Sometimes you will want to tell Go to use a specific type.

You do this when you declare a variable:

 var i int = 4
 var s string = "Слава Україні!"

Which tells the compiler that you are declaring `i` explicitly to be an `int` with the value `7`, and `s` to be a `string` with the value `"Слава Україні"`

We'll talk about the kinds of types that Go supports on the next slide.

* Types

Go is a strongly typed language, like Java, C, C++, and Python. Go has nine kinds of types, they are:

- strings: `string`.
- signed integers: `int8`, `int16`, `int32`, `int64`.
- unsigned integers: `uint8`, `uint6`, `uint32`, `uint64`.
- aliases: `byte`, `rune`, `int`, `uint`.
- booleans: `bool`.
- IEEE floating point: `float32`, `float64`.
- Complex types: `complex64`, `complex128`.
- Compound types: `array`, `slice`, `map`, `struct`.
- Pointer types: `*int`, `*bytes.Buffer`.

* String types

Strings are the most common data type in Go programs.

String types behave much as you would expect in other languages.

.code -edit src/strings/strings1/main.go /START OMIT/,/END OMIT/

Strings may be _concatenated_ with the `+` operator.

_note_: In Go an empty string is `""`, not `null` or `nil`.

* Integer types

Integer types are the second most common in Go.

Integer types come in two types; _signed_ and _unsigned_.

Integer types also come in several sizes, represented by the number of bits they represent;

- Signed integers: `int8`, `int16`, `int32`, `int64`.
- Unsigned integers: `uint8`, `uint16`, `uint32`, `uint64`.

Go has two integer types

- `int`, alias for `int32` or `int64` depending on platform.
- `uint`, alias for `uint32` or `uint64` depending on platform.

whose size depends on the platform you used to build your Go program.

* Integer types (cont.)

Why does Go support so many kinds of integer types?

Different _sized_ integer types can accommodate different ranges of numbers.

.code -edit src/types/types1/main.go /START OMIT/,/END OMIT/

This program contains two type errors.

- Fix the program by changing the declared types of `x` and `y`.

* Functions

Now it's time to talk about _functions_.

All Go you write is made up of functions, in fact, you've been writing functions all along.

.code -edit src/functions/functions1/main.go /START OMIT/,/END OMIT/

This is the same program as the previous example, showing the _function_declaration_, which was previously hidden.

- All Go programs start in a function called `main`, we call this the _main_function_.

* func

You can declare your own functions with the `func` declaration.
A function's name must be a valid identifier, just like `const` and `var`.

.code -edit src/functions/functions2/main.go /START OMIT/,/END OMIT/

This program declares two functions, `main` and `hello`.

- Uncomment the `println("Здоровеньки були")` statement in `func`hello`.

_note_: `println` is a _built_in_ function provided, you don't need to declare it.

* Function parameters

To make functions useful, you often need to pass _arguments_ to a function.

To pass an argument to a function, the type of the argument and the type of the function's _formal_parameter_ must be the same.

.code -edit src/functions/functions3/main.go /START OMIT/,/END OMIT/

In this program the type of the argument passed to `hello` does not match the type of the `name` parameter.

- Fix the declaration of `hello` so that the type of the parameter matches the type of the argument provided.

* Packages

A package is the unit in which software is shared and reused in Go. All Go code is arranged into packages.

Each source file in a package must begin with the same `package` declaration.

A package's name must be a valid identifier, just like `const`, `var`, and `func`.

.code -edit src/packages/packages1/main.go

This is the same example as the previous slide, revealing the `package` declaration.

`package`main` is the name of the package which contains the entry point to your program, `func`main`.

* main packages

This program has the wrong `package` declaration.

.code -edit src/packages/packages2/main.go

- Change the `package` declaration to make the program compile.

* Import

The final declaration we'll cover in this section is the _import_ declaration.

The `import` declaration allows you to use code from other _packages_ into your package.
When you `import` a package, the _public_ types, functions, variables, types, and constants, are available with a prefix of the package's name.

 time.Now	// denotes the Now function in package time

Note that

 import "fmt"
 import "time"

and

 import (
         "fmt"
         "time"
 )

both import the `fmt` and `time` packages. The syntax is different, but they are equivalent.

* Import (cont.)

The `import` declaration must appear _after_ the `package` declaration, but before any `type`, `const`, `var`, or `func` declarations.

.code -edit src/imports/imports1/main.go 

This program does not compile as the `import` declaration is in the wrong place.

- Move the `var`now`=`time.Now()` declaration _below_ the `import` declaration.

* Import (cont.)

Packages contain both _public_ and _private_ symbols. We also call these _exported_ and _not_exported_, respectively.

.code -edit src/imports/imports2/main.go 

This program does not compile as it refers to two _private_ symbols.

- Fix the program by using the correct case for `Println` and `Time`.

_note_: If you are running this slide from [[https://go-talks.golang.org/][gotalks.golang.org]], the time may be reported as `2009-11-10`23:00:00`+0000`UTC`. This is a technical limitation.

* fmt package

Do you remember this program?

.code -edit src/imports/imports3/main.go

Here it is again, showing the `func`, `package` and `import` declarations making it a complete Go program.

This program also uses the `Println` function from the `fmt` package, which is more capable than the built in `println` function.

* Recap

Now you know the basics of Go!

You've learnt:

- How to declare constants and variables
- How to write `for` loops and use `if`.
- How types work.
- How to write your own functions.
- How packages and `import` statements work.

Time for a quick break!

* Advanced Syntax

* Advanced Syntax

This section builds on the previous by exploring each of the things we learnt in a little more detail.

In this section we'll use the Go Playground, a simple online code editor to perform our exercises.

* Coding style

All Go code is formatted according to a single style guide which is enforced with a tool called `gofmt`

Having one single style that all Go code is formatted in improves readability and avoids the time wasted arguing about code formatting.

"Gofmt's style is no one's favorite, yet gofmt is everyone's favorite."
.caption [[https://go-proverbs.github.io/][Go Proverb]].

The Go playground can format your code according to the canonical Go style.

- Follow [[https://play.golang.org/p/0Hz57BQdTA][this link]] and press the *Format* button to see this in action.

* Zero value

In previous examples we've written code like this

 var name = "go"
 var counter = 1

Which both _declares_ and _initalises_ the variables `counter` and `name` respectively. What happens if we have code like this?

.code src/zerovalue/zerovalue1/main.go

What will this print?

- Follow [[https://play.golang.org/p/jioUB0t_LW][this link]] and press the *Run* button to see this in action.

* Zero value (cont.)

In Go, there is no unitialised memory. The Go runtime will always ensure that the memory allocated for each variable is initalised before use.

If we write something like 

 var name string
 var counter int

Then the memory assigned to the variables `name` and `counter` will be zeroed, as we have not provided an _initaliser_.

- The value of `name` will be `""` because that is the value of a string with zero length.
- The value of `counter` will be zero, because that is the value of an `int` if we wrote `0` to its memory location.

* Zero value (cont.)

Every type in Go has an associated _zero_value_. The value of that variable if we wrote zeros to its memory.

- The zero value for integer types: `int`, `int8`, `uint`, `uint64`, etc, is `0`.
- The zero value for floating point types: `float32`, `float64`, `complex128`, etc, is `0.0`.
- The zero value for arrays is the zero value for each element, ie. `[3]int` is `0`, `0`, `0`.
- The zero value for slices is `nil`.
- The zero value for structs is the zero value for each field.

* Equality

As Go is a strongly typed language, for two variables to be equal, both their _type_and_their_value_ must be equal.

Trying to compare two variables of _different_ types is detected at runtime.

.code src/equality/equality1/main.go

- Follow [[https://play.golang.org/p/LwiJm2xuXK][this link]] and press the *Run* button.
- Fix the program by declaring `x` and `y` to be the _same_ type.

* Type conversions

Sometimes you have variables of different integer types, you can _convert_ from one type to another using a conversion _expression_.

The expression `T(v)` converts the value `v` to the type `T`.

.code -edit src/types/types2/main.go

In this example the assignment of `y`=`x` fails because `x` and `y` are different integer types.

- Follow [[https://play.golang.org/p/wvG41C0lH4][this link]] and press the *Run* button.
- Fix the program by _converting_ `x` to an `int` with `int(x)`.

* Type conversions (cont.)

If you have variables of different _widths_, you can _convert_ from one type to another.

.code -edit src/types/types3/main.go

- Follow [[https://play.golang.org/p/l4Q48pWAla][this link]] and press the *Run* button.
- Fix the program by _converting_ `x` to an `int64` with `int64(x)`.

* Type conversions (cont.)

We can do the opposite and convert a wider type to a narrower type.

.code -edit src/types/types4/main.go

- Follow [[https://play.golang.org/p/NbNwRjbmRu][this link]] and press the *Run* button. Does it print the answer you expected?
- Fix the program by _declaring_ `y` as an `int32`.

* Integer overflow

Whenever you declare a variable in Go, you have to choose how many bits of memory it will consume.

When you convert a variable with a _smaller_ number of bits to a variable with a larger number of bits, this is fine, because they all fit.

When you convert a variable with a _larger_ number of bits to a variable with a smaller number of bits there is a risk of truncation, because there are less bits available to represent your number.

- Follow [[https://play.golang.org/p/NbNwRjbmRu][this link]] and press the *Run* button. Does it print the answer you expected?
- Fix the program by reducing the value of `x`. Hint: the value needs to be less than 33,000.

* Short declaration syntax

As you've probably noticed, Go has several ways to declare variables. All three of these are the same

 var x = 0
 var x int = 0
 var x int

If you've come from a language like Ruby or Python, you're probably wondering if this very common operation can be made more concise. Indeed it can.

 x := 0

This is what we call a _short_declaration_, which is the same as 
 
 var x int = 0

Short declaration is very common in Go programs, you'll see it everywhere, so let's do some exercises to familarise you with its use.

* Short declaration syntax (cont.)

A common use of the short declaration syntax is in `for` loops. Consider this program

 var i int
 for i = 1; i < 11; i++ {
         fmt.Println(i)
 }

This can be also written as

 for i := 1; i < 11; i++ {
         fmt.Println(i)
 }

[[https://play.golang.org/p/3Vl75w72JO][This program]] contains two `var` declarations and two `for` loops.

- Follow [[https://play.golang.org/p/3Vl75w72JO][this link]] and press the *Run* button.
- Rewrite the program using the short declaration syntax; there should be no `var` declarations, only `:=`.

* Slices

The next kind of type to discuss is the _Slice_. 

A slice is an ordered collection of values of a _single_ type.

The syntax for declaring a slice variable is very similar to declaring a _scalar_ variable.

 var i int      // an int called i
 var j []int    // a slice of ints called j

In this example, 

- `i` is a variable of type `int`. 
- `j` is a variable of type `[]int`, that is, a slice of `int`.

Slices are very important in Go programs, so we'll spend a bit of time discussing them.

_note_: A slice is _not_ an array. Go also supports arrays, but you'll see later than they aren't very common, or very easy to use, so we won't discuss them at the moment.

* How large is a slice?

If I declare a slice, `[]int`, how many items can it hold?

The _zero_value_ of a slice is empty, that is, it has a _length_ of zero; it can hold 0 items.

.code -edit src/slices/slices1/main.go

We can retrieve the length of a slice with the built-in `len` function.

- Follow [[https://play.golang.org/p/gZYvdE2zbT][this link]] and press the *Run* button.
- Did you guess the right answer?

* Making a slice

We can create a slice with space to hold items using the built-in `make` function.

.code -edit src/slices/slices2/main.go

In this example, on the first line `var i []int` declares `i` to be a slice of `int`.

On the second line, `i` is _assigned_ the result of `make([]int,`20)`.

- Follow [[https://play.golang.org/p/i_IWqjik6u][this link]] and press the *Run* button.
- Did `fmt.Println(len(i))` print the result you expected?

* Making a slice (cont.)

Because declaring a slice variable and initalising it with `make` is a common operation, it is common to see the _short_variable_declaration_ used to combine this operations.

.code -edit src/slices/slices3/main.go

This example declares `i` _and_ initalises it to be a slice of `int` with a length of 20.

- Follow [[https://play.golang.org/p/b92SJ0Gx9s][this link]] and press the *Run* button.
- Did `fmt.Println(len(i))` print the result you expected?

* Slice exercises

Let's do a quick exercise to familarise yourself with using slices.

.code -edit src/slices/slices4/main.go

- Follow [[https://play.golang.org/p/AJk1Jgp1iE][this link]] for instructions.
- Declare a variable called `i` which is a slice of 5 `int`.
- Declare a variable called `f` which is a slice of 9 `float64`.
- Declare a variable called `s` which is a slice of 4 `string`.
- Does your program print the expected result, `5`9`4`?

* Index expressions

To access, or assign, the contents of a slice element at index `i`, use the form `s[i]`.

Slices are zero indexed, so `s[0]` is the 1st element, `s[1]` is the second element, and so on.

When the _index_expression_ appears on the _left_hand_side_ of the equals operator, `=`

 s[7] = 20

We are assigning the number 20 to the 8'th element of the slice `s`.

When the _index_expression_ appears on the _right_hand_side_ of the equals operator, `=`

 x := s[7]

We are assigning the value at the 8th element of `s` to the variable `x`.

* Slice zero value

We saw earlier that the _zero_value_ of the slice

 var s []int

was and empty slice, a slice with length of zero.

What is the value of each of the elements of a newly created, with make, slice?

.code -edit src/slices/slices5/main.go

- Follow [[https://play.golang.org/p/kGh_C1l6KW][this link]] and press the *Run* button.
- Did the program print the result you expected?

* Slice initialisation

We want to create an `[]int` slice of the first 10 prime numbers, how could we do this?

One solution could be to create the slice and assign a value to each element in the slice.

.code -edit src/slices/slices6/main.go

* Slice initialisation (cont.)

Doing this manually is verbose and boring; how would you do this for the first 50 primes?

Go supports a method of assignment where we both _declare_ and _initalise_ the slice at once.

.code -edit src/slices/slices7/main.go

This is called the _composite_literal_ syntax.

- Follow [[https://play.golang.org/p/P-eBqzPCWh][this link]] and complete the exercise.

* append

So far we've been using slices with a known length. You can extend the contents of a slice with the built-in `append` function.

.code -edit src/slices/slices8/main.go

`append` increases the length of the slice to accommodate the new items, then returns a new slice value.

You can `append` multiple values in one statement, providing they are all the same type.

.link https://blog.golang.org/slices Further reading: Arrays, slices (and strings): The mechanics of 'append' (blog.golang.org)

* Subslices

What if we have a large slice, and want to refer to only a part of it. 

We call this slicing a slice, or _subslicing_.

Subslicing looks similar to the _indexing_ operation we saw a few slide ago, except it refers to a range of slice indexes.

.code -edit src/slices/slices12/main.go

The expression `brothers[0:3]` evaluates to a slice of the 1st to 3rd Marx brother.

- Follow [[https://play.golang.org/p/d1-jl42aTF][this link]] and complete the exercise.

* Subslices (cont.)

An important thing to remember when slicing a slice, is that both slices refer to the _same_ underying data.

.code -edit src/slices/slices10/main.go

To create two independent slice values, you would use the `copy` function, which we'll discuss later.

* Bounds checking

Each slice has a length which is decided when it is made.

You can increase the length of the slice with the `append` function, and create a smaller slice from a larger one using the slice operator.

What happens if you accidentally exceed the bounds of the slice?

.code -edit src/slices/slices11/main.go

- Follow [[https://play.golang.org/p/mIWm0a1amp][this link]] and press the *Run* button.
- Comment out `fmt.Println(primes[-1])` and see what happens.

* Multiple assignment

Go allows you to perform multiple assignments and declarations in one statement.

For example, if we wanted to declare, `x`, `y`, and `z`, with the values `1`, `2`, and `3` respectively. We could write

 var x = 1
 var y = 2
 var z = 3

We can write the same thing like this

 var x, y, z = 1, 2, 3

- Follow [[https://play.golang.org/p/d2hDJQAfkt][this link]] for some examples of multiple declaration.

* Multiple return values

Multiple assignment is important to understand because you can return multiple values from a function.

 func f(i int)

This is a function declaration for `f` which takes one argument, an `int`.

 func g(i int, j int, k string) int

This is a function declaration for `g`, which takes three arguments, two `int` s and a `string`, and returns an `int`.

 func h(i, j int) (int, int, string)

This is a function declaration for `h`, which takes two arguments, two `ints`, and returns three values, two `int` s and a `string`.

* Multiple return values (cont.)

Your program must return the number of values specified in the function signature.

.code -edit src/functions/functions4/main.go

* Assigning multiple return values

When you call a function that returns multiple values, you must assign _all_ of them or _none_ of them.

 func f() (int, bool, string)

 func main() {
         a, b, c := f()
         fmt.Println(a, b, c)
 }

`f` returns three values, so we assign them to `a`, `b`, and `c` using the short declaration syntax.

If we wanted to use only the first and third values we can ignore the second by assigning it to the underscore variable, `_`.

 func main() {
         a, _, c := f()
         fmt.Println(a, c)
 }

* Maps

Go has a built in Hash Map type, called a `map`.

Maps map values of key type K to values of type V

 var m map[string]int

Just like making a slice, making a map is accomplished with the `make` built-in.

.code -edit src/maps/maps1/main.go

* Inserting values into a map

Inserting a value into a map looks similar to assigning a value to a slice element.

.code -edit src/maps/maps2/main.go

If an entry already exits with that key, it will be overwritten.

- Follow [[https://play.golang.org/p/a-V5I0nZ5l][this link]] and complete the exercise.

_note_: maps are always _unordered_.

* Compact literal initalisation

Just like slices, maps support compact literal initalisation, which declares and initalises the map.

.code -edit src/maps/maps3/main.go

* Retrieving a values from a map

Just like a slice, you can retrieve the value stored in a map with the syntax `m[key]`.

If it is present the value will be returned, if not the _zero_value_ will be returned.

.code -edit src/maps/maps4/main.go

* Checking if a map value exists

In the previous slide we saw that `moons["Neptune"]` returned `0`.

How can we tell if Neptune actually has no moons, or if `0` was returned because there is no entry for Neptune?

Map look ups support a second syntax.

.code -edit src/maps/maps5/main.go

* Deleting a value from a map

To delete a value from a map, you use the built in `delete` function.

.code -edit src/maps/maps6/main.go

* Iterating over a map

If we wanted to print out all the values in a map we can use a form of the `for` syntax which is known as `range`.

.code -edit src/range/range1/main.go

`range` loops over each entry in the map, assigning the map key to `name`, and the map value to `pop`.

* Range over slices

We say previously that `for`range` works with maps, it also works with slices.

.code -edit src/range/range2/main.go

- Follow [[https://play.golang.org/p/AmQW-OrPC1][this link]] and complete the exercise.
- If you cannot figure it out, don't worry, there is an answer on the next slide.

* Switch

If you completed the previous exercise you may have written something like this

.code -edit src/range/range2a/main.go /START OMIT/,/END OMIT/

Heavily nested `if`else`if` blocks are discouraged in Go.

Instead we can use the other condition statement, `switch`.

* Switch (cont.)

`switch` can be used 

.code -edit src/switch/switch1/main.go /START OMIT/,/END OMIT/

* fmt

Let's conclude this section by talking about the fmt package.

`fmt` standard for formatted printing; the name is inherited from Go's Plan 9 legacy.

We've use `fmt.Println` a lot up to this point, but the `fmt` package has many other useful functions.

We'll focus on `fmt.Printf`, the `f` stands for _formatted_output_.

Here is an example.

.code -edit src/fmt/fmt1/main.go /START OMIT/,/END OMIT/

- Follow [[https://play.golang.org/p/UuzPWcwDrE][this link]] to experiment.

* Formatting verbs

If you're used to languages like Python or C, you're probably used to the idea of _formatting_verbs_.

The `fmt` package supports a large number of formatting verbs and modifiers. In the previous example you saw `%s` and `%d`, for `string` and `int` respectively.

The `fmt` package is smart enough to spot when you use the wrong formatting verb, or don't provide enough arguments to `fmt.Printf`.

.code -edit src/fmt/fmt2/main.go /START OMIT/,/END OMIT/

* Formatting verbs (cont.)

Having to choose the correct verb that matches the type of the value you want to print is boring.

To make it easier to use `fmt.Printf` in the simple case, you can use the `%v` verb, which know how to print _any_ value.

.code -edit src/fmt/fmt3/main.go /START OMIT/,/END OMIT/

- Follow [[https://play.golang.org/p/B-E7JOJ1Db][this link]] to experiment with a few more formatting verbs.

* Recap

Now you know most of Go!

You've learnt:

- How Go code is formatted.
- How what the zero value is and how it works.
- Equality and type conversions
- The short declaration syntax
- Multiple assignment.
- How slices work.
- How maps work.
- How the `fmt` package works.

Time for lunch!

* Development environment and tooling

* Development environment and tooling

This section focuses on the developer experience

- Installing Go.
- Setting up a `$GOPATH` workspace.
- Introduction to the `go` command.
- Writing unit tests with the go test command.

* Installing Go

The next few slides give examples of how to install Go on various systems.

The official installation documentation is here:

.link https://golang.org/doc/install

The current version of Go is 1.7.4.

- New minor releases, Go 1.8, Go 1.9, etc, ship twice a year. 
- Historically 2–4 bug fix or security releases occur during each six month period.

* Installing Go on OS X

Installing Go on OS X (also known as `darwin`) can be accomplished with

*Mac*OS*Installer*

The Go project provides an `.pkg` installer, use:

.link https://storage.googleapis.com/golang/go1.7.4.darwin-amd64.pkg

*Homebrew*

If you use Homebrew to manage third party software on your Mac, use:

 brew install golang

*MacPorts*

If you use MacPorts to manage third party software on your Mac, use:

 sudo port install go

* Installing Go on Windows

*MSI*Installer*

The Go project provides a `.msi` installer for 32bit and 64bit Windows, use:

.link https://storage.googleapis.com/golang/go1.7.4.windows-amd64.msi Windows 64bit MSI installer
.link https://storage.googleapis.com/golang/go1.7.4.windows-386.msi Windows 32bit MSI installer

*.zip*file*

The Go project provides a `.zip` file of the Go compiler and standard library, use:

.link https://storage.googleapis.com/golang/go1.7.4.windows-amd64.zip Windows 64bit zip file
.link https://storage.googleapis.com/golang/go1.7.4.windows-386.zip Windows 32bit zip file

Unzip the zip file and place it at `C:\Go`.

* Installing Go on Linux

Depending on your Linux distribution they may have an up to date version of Go, but this is rare.

The most reliable way to install the latest version of Go is to untar

.link https://storage.googleapis.com/golang/go1.7.4.linux-amd64.tar.gz

to the directory

 /usr/local

and add 
 
 /usr/local/go/bin

to your `$PATH`.

 echo "export PATH=$PATH:/usr/local/go/bin" >> ~/.bash_profile

* Go tool

Your Go installation comes with a tool we call the `go` tool, because that's its name.

The `go` tool can 

- compile your programs
- run your tests
- display documentation for a package
- fetch packages from the internet.

* $GOPATH

The `go` tool works inside a workspace where _all_ your Go source code is stored.

All the source code for this workshop is included with this repository.

You can set `$GOPATH` to be the base directory where you checked out this repository. eg.

 % export GOPATH=$HOME/introduction-to-go

Using a workspace allows you to import code from other packages with a fixed name. eg.

 import "github.com/pkg/profile"

Will import the code for the `profile` package stored in

 $GOPATH/src/github.com/pkg/profile

* go build

Go is a compiled language, so the usual work flow is 

- Edit code
- `go`build`
- Run program

Let's try building a Go program

- `cd`$GOPATH/src/helloworld`
- Read the source for `hello.go`
- Build the source with `go`build`
- Run the program `./helloworld`

* What time is it (exercise)

Let's write a clock, a program that prints out the current time

- `cd`$GOPATH/src/whattimeisit`
- edit `main.go` and finish the program (if you get stuck the answer is in `answer.go`)
- Build the program with, `go`build` (if you make an error, go back and edit `main.go`)
- Run your program `./whattimeisit`, it should print something like this

 The current time is 2016-12-05 12:33:18.222821474 +0900 JST

* Testing

I wanted to spend some time on testing because for the rest of the day we'll be using tests to complete code exercises.

The testing package can also contain benchmark functions and examples, which show up in godoc.

You should include tests for each package that you write.

The `testing` package is ideal for _unit_tests_. It's _ok_ for functional tests, but not really suitable for complex integration tests.

* go test

`go`test` is the unit testing framework built into the Go standard library. It lives in the `testing` package.

Tests live in `_test.go` files, eg. the `strings` package has these files:

- `strings.go` functions to manipulate UTF-8 encoded strings.
- `strings_test.go` tests for the `strings` package.

Each test is a function in the form

 func TestNameOfTest(t *testing.T) { ... }

- `NameOfTest` is the name of your test, it _must_ start with an upper case letter.
- Test functions take a `testing.T` value, which provides helpers like `t.Error` and `t.Fail`.

* Writing tests

Let's write some tests using our own version of the strings package, called `simplestrings`.

- The code for this exercise is in `$GOPATH/src/simplestrings/`
- Read the source code for `simplestrings.go`

Together we'll write some tests for the functions in our `simplestrings` package.

We'll use the test coverage (see next slide) tool to check our work.

* Test coverage

`go`test` can report coverage

 go test -coverprofile=cover.out

This produces a coverage file, `cover.out`

- `go`tool`cover`-func=cover.out` will print the coverage report
- `go`tool`cover`-html=cover.out` will open the report in a browser

_Protip_: I use these little shell functions to make this easier

 cover () {
   t=$(mktemp -t cover)
   go test $COVERFLAGS -coverprofile=$t $@ && go tool cover -func=$t && unlink $t
 }

 cover-web() {
   t=$(mktemp -t cover)
   go test $COVERFLAGS -coverprofile=$t $@ && go tool cover -html=$t && unlink $t
 }

* The standard library

Go ships with a rich standard library of packages. This includes

- file input / output
- string handling
- compression
- encoding and decoding of JSON and XML
- network handling
- HTTP client and server

* String formatting

As a warm up, let's do a small exercise together. 

The code for this exercise is in `$GOPATH/src/exercises/sprintf`

If you get stuck, the answers are in `$GOPATH/src/exercises/sprintf/answers_test.go`.

* Structs

So far we've discussed two kinds of types; _primitive_ types and _slice_ types.

Go supports what we call _compound_ types, that is, types that are _composed_ of other types. 

These are called _struct_ (for _structure_) types. We declare a struct like this:

 type Point struct {
          X int
          Y int
 }

`Point` is a position in two dimensional space, it has two fields, `X` and `Y`.

- Follow [[https://play.golang.org/p/fAnPV1MojK][this link]] to complete the example

* Methods

To this point we've talked about functions, which belong to a package

 // Max returns the larger of a or b.
 func Max(a, b int) int

In Go, you can attach a function to a type that you declare, this is called a _method_.

 type Point struct { X, Y int }

 func (p Point) String() string {
          return fmt.Sprintf("point: x=%d, y=%d", p.X, p.Y)
 }

Any type that implements a `String()`string` method will be used by the `fmt` package when it prints the value.

- Complete the exercise in `$GOPATH/src/exercises/methods` by making all the tests pass.

* Pointers

Whenever you pass a value to a function or method, the value is _copied_.

In Go, the method's receiver is also a value, so it's copied when you call a method.

.code -edit src/pointers/pointers1.go /START OMIT/,/END OMIT/

- Complete the exercise in `$GOPATH/src/exercises/pointers` by making the test pass.

* Interfaces

Go is an object oriented language; we have methods on types, but Go does not support inheritance or sub-classes.

Go supports polymorphism, _has_a_ (not _is_a_) with _interfaces_.

An interface declaration looks like this:

 type Reader interface { 
          Read(buf []byte) (int, error) 
 }

This is the [[https://golang.org/pkg/io/#Reader][`io.Reader`]] interface declaration from the [[https://golang.org/pkg/io/][`io`]] package.

Go does not have an _implements_ keyword, any type with the correct set of methods _is_ an implementation of the interface.

* Reading input

This exercise asks you to write a function that reads lines from an io.Reader and returns a string containing all the lines read.

The code for this exercise is in `$GOPATH/src/exercises/input`

* Readers

To familarise you with the `io.Reader` implementations available in the `io` package, this exercise is all about Readers.

- Complete the exercise in `$GOPATH/src/exercises/readers` by making the test pass.
- If you get stuck, consult the documentation in the [[https://golang.org/pkg/io/][`io`]] package.

* Error handling

You probably spotted that lots of methods and functions in the Go standard library return a value of type `error`. 

`error` is a _predeclared_type_, just like `int`, `string`, etc.

`error` is an interface, it's declaration is

 type error interface {
         Error() string
 }

Any type that has an `Error()`string` method, _implements_ the `error` interface.         

* Nil

`nil` is Go's version of `NULL`, `null`, `void`.

- The zero value of an interface type is `nil`.
- The zero value of a pointer type is `nil`.

Go uses the `error` interface and a simple convention to implement error handling.

- If no error occurs, the `err` value returned from a function or method will equal nil.
- If an error occurs, the `err` value returned from a function or method will not equal nil.

 if err != nil {
          // cleanup and handle error
 }

* Counting the number of lines in a file

Now we know about `io.Reader`'s, `error`'s, we can write some more useful programs.

The code for this exercise is in `$GOPATH/src/exercises/countlines`

_Note_:

- `go`test` always executes from the package's source directory, this makes it simple to include fixtures for your tests.
- The go tool ignores any directory called `testdata`, or starts with a `.` or `_`.

* defer

In `CountLines` from our previous example, if an error happened during reading lines, `f` may not be closed.

Go has a keyword `defer` to ensure operations _always_ happen.

.code -edit src/defer/defer1.go /START OMIT/,/END OMIT/

* Error handling (cont.)

In the previous counting example, if an error happened, the program would exit.

In this exercise, we'll handle errors by returning them to the caller.

The code for this exercise is in `$GOPATH/src/exercises/errorhandling`

* Passing in a reader

Let's turn out `Countlines` function into a program.

The code for this exercise is in `$GOPATH/src/exercises/linecount`

Complete the program so it reads the number of lines sent to it via stdin.

 % cat testdata/moby.txt | ./linecount 
 22659

* Handling multiple files

Let's extend our `linecount` program to handle files passed on the command line.

The code for this exercise is in `$GOPATH/src/exercises/countmanyfiles`

Complete the program so it counts the lines in files passed via the command line.

 % ./countmanyfiles testdata/*.txt
 testdata/dracula.txt    15973
 testdata/pride-and-prejudice.txt        13427
 testdata/sherlock.txt   13052

* Reading all the *.txt files in a directory

In the previous example we used the shell to list files to process.

In this exercise, let's extend our `countmanyfiles` program to walk the directory listing itself.

To do this we use the [[https://golang.org/pkg/os/#File.Readdir][`ReadDir`]] method on [[https://golang.org/pkg/os/#File][`os.File`]].

_Note_: Be careful to only read _files_, not directories, and do not read files that don't end in `.txt`

The code for this exercise is in `$GOPATH/src/exercises/countdir`

Complete the program so it counts the lines in files passed via the command line.

 % ./countdir testdata/
 testdata/christmas-carol.txt    4236
 testdata/tom-sawyer.txt 9209

* HTTP request

The Go standard library supports writing HTTP clients and servers with the [[https://golang.org/pkg/net/http/][`net/http`]] package.

Using the `net/http` package is very straight forward:

 resp, err := http.Get("http://example.com/")
 if err != nil {
         // handle error
 }
 
`resp` is a [[https://golang.org/pkg/net/http/#Response][`http.Response`]] structure, which has lots of interesting fields.

Let's write a simple HTTP client that can fetch HTTP URLs.

 % ./httpget http://httpbin.org/ip
 {
   "origin": "125.203.122.114"
 }

The code for this exercise is in `$GOPATH/src/exercises/httpget`

* JSON parsing

The service at `http://httpbin.org/` returns JSON bodies.

The [[https://golang.org/pkg/encoding/json/][`encoding/json`]] package can decode JSON data into a map.

 result := make(map[string]string)
 dec := json.NewDecoder(resp.Body)
 err := dec.Decode(&result)
 if err != nil {
         // handle error
 }

Let's use this to write a program that will tell us our public IP address.

 % ./whatismyip 
 My IP address is: 125.203.122.114

The code for this exercise is in `$GOPATH/src/exercises/whatismyip`

* JSON encoding

If you're writing a RESTful web service it's common to have to return JSON encoded data.

In Go the [[https://godoc.org/encoding/json][`encoding/json`]] package can turn Go maps and data structures into JSON.

.code -edit src/jsonenc/jsonenc1.go /START OMIT/,/END OMIT/

* Controlling JSON encoding

The `encoding/json` package requires the fields of a struct to be public (start with an upper case letter), this means the keys in your JSON document will be upper case.

We can fix this and control the output of the JSON with a _tag_.

The format of the JSON tag is documented on the [[https://golang.org/pkg/encoding/json/#Marshal][`json.Encode`]] method.

.code -edit src/jsonenc/jsonenc2.go /START OMIT/,/END OMIT/

* JSON encoding exercise

The code for this exercise is in `$GOPATH/src/exercises/jsonenc`

* Writing HTTP servers

Go's [[https://golang.org/pkg/net/http][`net/http`]] library can be used to write production web applications.

Writing web servers in Go can be as simple as a few lines. Here is an example:

.code -edit src/http/http1.go

* Writing http servers (cont.)

This is a simple HTTP handler

 func index(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "This is the index page")
 }

it takes two parameters

- `w`, a `http.ResponseWriter` which is used to send data to the client
- `r`, a `http.Request` which contains the uri, query parameters, and request body.

 mux := http.NewServeMux()

`http.NewServeMux` returns a `ServeMux`, what we usually call a HTTP router.
 
* Writing http servers (cont.)

 mux.HandleFunc("/", index)

Registers our `index` function, with the top level route, `"/"`.

 http.ListenAndServe(":8000", mux)

Opens a socket on port 8080 and sends and requests to our `mux` (our router).

`http.ListenAndServe` won't return unless something happens to that listening socket (wifi drops, cable unplugs)

* go get

`go`get` is a simple wrapper around `git` that knows how fetch packages from GitHub (and a few other places).

If a package's import path follows the `go`get` convention, `go`get` knows how to fetch the source code and download it to your `$GOPATH`.

`go`get` isn't a complete dependency manager like rubygems or npm, etc, but it good enough for writing many applications.

We'll use `go`get` to fetch the source for `gorilla/mux`, a more advanced HTTP router

 % go get github.com/gorilla/mux 
 % ls $GOPATH/src/github.com/gorilla/mux
 LICENSE                 context_gorilla.go      context_native_test.go  mux_test.go
 README.md               context_gorilla_test.go doc.go                  old_test.go
 bench_test.go           context_native.go       mux.go                  regexp.go
 route.go

* Using gorilla/mux

The standard HTTP router, `http.ServeMux` is quite basic, so we'll upgrade to the `gorilla/mux` http router.

.code -edit src/http/http2.go

* Line counting HTTP service

Let's write a HTTP service that counts the lines in a book via http.

Features:

- When the client requests `/books/{book}` we look up the book and return the number of lines counted.
- The response to the client should be in JSON format and include the number of lines and the title of the book.
- Book directory is configurable.

 % ./httplinecount ../../../books/ &
 [1] 17554
 % curl http://localhost:8080/books/moby.txt
 {"title":"moby.txt","lines":"22659"}

The code for this exercise is in `$GOPATH/src/exercises/httplinecount`

* Documenting packages with comments

Go code is traditionally documented with comments in the source code. This is similar to Python's heredoc convention.

Here are some examples

 // simplestrings provides simple helper functions to work with strings
 package simplestrings

 // APIVersion is the version of this package's API
 const APIVersion = 3

 // NextID returns the next ID in the sequence
 func NextID() uint64 { ... }

_Notes_

- Comments directly precede the thing they apply to, don't put an extra newline in between the comment and the symbol
- You should comment both Public and private symbols, but godoc will only show you the documents

* Scope

We've talked about all the ways to declare a variable in Go, now we need to discuss scope.

.code -edit src/scope/scope1/main.go

This program declares `x` four times. All four `x` 's are _different_ because they exist in different scopes.

- Follow [[https://play.golang.org/p/nIcOXVXgwl][this link]] and press the *Run* button.

* Scope (cont.)

The scope of a declaration is bound to the closest pair of curly braces, `{` and `}`.

.code -edit src/scope/scope2/main.go

In this example, we declare `x` to be 100 inside `main`, and 200 inside `f`.

- Follow [[https://play.golang.org/p/Xfi3GOhTiC][this link]] and press the *Run* button.
- Did the program print what you expected?

* Scope (cont.)

What do you expect this program will print?

.code -edit src/scope/scope3/main.go

- Follow [[https://play.golang.org/p/7uxrebFzmK][this link]] and press the *Run* button.
- Did you guess the right answer?

* Scope (cont.)

What do you expect this program will print?

.code -edit src/scope/scope4/main.go

- Follow [[https://play.golang.org/p/7hpZre9LhI][this link]] and press the *Run* button.
- Did you guess the right answer?

* Shadowing

What you are seeing is called _shadowing_.

.code -edit src/scope/scope5/main.go /START1 OMIT/,/END1 OMIT/

Most of you will be comfortable with a _function_scoped_ variable shadowing a _package_scoped_ variable.

.code -edit src/scope/scope5/main.go /START2 OMIT/,/END2 OMIT/

But a _block_scoped_ variable shadowing a _function_scoped_ variable may be surprising.

* Question time

* Conclusion

Thank you very much for participating today, I hope that you enjoyed yourself and are encouraged to learn more about Go.

I would like to recommend several online resources:

.link https://dave.cheney.net/resources-for-new-go-programmers Resources for new Go programmers
.link https://tour.golang.org/welcome/1 tour.golang.org
.link https://gobyexample.com/ Go by Example