introduction-to-go-v2.slide

Introduction to Go (Part 1) v2
SoftServe Golang Training
09 Jul 2018

Ivan Kutuzov
ikut@softserveinc.com
https://golang.org.ua
https://golang-ua.slack.com
@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

- Golang
- Basic Syntax
- Language details

* 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.8 usually under 100 microseconds and often as low as 10 microseconds.

.link https://golang.org/doc/go1.8#gc Source: Go 1.8 Release Notes

* 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`.

* Go has lots of Rules/Guidelines

.image ./img/golang-rules-and-limitations.png _ 800

.link https://slides.com/junedev/node-and-go-2#/24 Source: Node.js | Go. A Tale of Two Worlds


* Why you should learn Go?

- ... the concrete and immediate expression of some piece of program logic might serve better than trying to pull out a more generic version of the same logic that might never be re-used in practice.

- ...  a little less patient with the amount of behind-the-scenes magic that the Spring Boot framework puts into play, and wishing for something a little more lightweight and transparent.

- Learning Go won’t teach you any exciting new computer science concepts, or introduce you to a whole new paradigm of software development. But it will give you a better understanding of the breadth and variety of the design space for programming languages.

.link https://opencredo.com/java-go-back/ Source: Dominic Fox. From Java to Go, and Back Again

* Who and why use Go

- [[https://github.com/golang/go/wiki/whygo][github wiki: Why Go]]
- [[https://github.com/golang/go/wiki/GoUsers][github wiki: Go Users]]
- [[https://github.com/golang/go/wiki/FromXToGo][github wiki: From X To Go]]
- [[https://github.com/golang/go/wiki/SuccessStories][github wiki: Success Stories]]

* 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.


* 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`.

* Go Operators

- Arithmetic Operators: `-` `+` `*` `/` `%` `++` `--`
- Relational Operators: `==` `!=` `>` `<` `>=` `<=`
- Logical Operators: `&&` `||` `!`
- Bitwise Operators: `&` `|` `^` `<<` `>>`
- Assignment Operators: `=` `+=` `-=` `*=` `/=` `%=` `&=` `|=` `^=` `<<=` `>>=`
- Misc Operators: `&` `*`

[[https://www.tutorialspoint.com/go/go_operators.htm][Go Operators]]

* 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`).

* 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 = "Go BootCamp"

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 `Go` `BootCamp`

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`.

* 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`.

* 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.

  var x int64 = 64000
  var y int16 = int16(x)
  println(y)

* 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)
 }

* 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)
 }

* Control Structures

* 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

.link https://medium.com/@matryer/line-of-sight-in-code-186dd7cdea88 Mat Ryer: Line of sight in code
* Switch

  // Convert hexadecimal character to an int value
  switch {
  case '0' <= c && c <= '9':
      return c - '0'
  case 'a' <= c && c <= 'f':
      return c - 'a' + 10
  case 'A' <= c && c <= 'F':
      return c - 'A' + 10
  }
  return 0

* 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, `;`.

* 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.

* Range

  list := []string{"a", "b", "c", "d", "e", "f"}
  for k, v := range list {
      // do something with k and v
  }

* Built-in Functions

`close`new`panic`complex`
`delete`make`recover`real`
`len`append`print`imag`
`cap`copy`println`

* Let's make a break

* 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`.
.code -edit src/range/range1/main.go

* Array

An array is defined by: [n]<type>, where _n_ is the length of the array and _<type>_ is the stuff you want to store.

  var arr [10]int
  arr[0] = 42
  arr[1] = 13
  fmt.Printf("The first element is %d\n", arr[0])


* Pointers

  var p *int
  fmt.Printf("%v", p)
  
  var i int
  p = &i
  
  fmt.Printf("%v", p)

* Allocation


- new(T) returns *T pointing to a zeroed T
- make(T) returns an initialized T

  var p *[]int = new([]int)
  var v  []int = make([]int, 100)
  
  var p *[]int = new([]int)
  *p = make([]int, 100, 100)
  
  v := make([]int, 100)

* Slices

The next kind of type to discuss is the _Slice_. 

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

First we create an _array_ of _m_ elements of the type `int:`var`array[m]int`.

`slice`:=`array[:n]`//`n`<`m`


- len(slice) == n
- cap(slice) == m
- len(array) == cap(array) == m

* Make & slice

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

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 initialisation

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

* 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?

* 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.

  a := [...]int{1, 2, 3, 4, 5}
  s1 := a[2:4]
  s2 := a[1:5]
  s3 := a[:]
  s4 := a[:4]
  s5 := s2[:]
  s6 := a[2:4:5]

* 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

* 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.

  s0 := []int{0, 0}
  s1 := append(s0, 2)
  s2 := append(s1, 3, 5, 7)
  s3 := append(s2, s0...)


`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)

* Copy

  var a = [...]int{0, 1, 2, 3, 4, 5, 6, 7}
  var s = make([]int, 6)
  n1 := copy(s, a[0:])
  n2 := copy(s, s[2:]) 

To create two independent slice values, you would use the `copy` function. 
.link https://divan.github.io/posts/avoid_gotchas Ivan Danyluk: Blog Post about Golang gotchas

* 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.

* 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

* 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`.

  monthdays := map[string]int{
      "Jan": 31, "Feb": 28, "Mar": 31,
      "Apr": 30, "May": 31, "Jun": 30,
      "Jul": 31, "Aug": 31, "Sep": 30,
      "Oct": 31, "Nov": 30, "Dec": 31,
  }
  year := 0
  for _, days := range monthdays
      year += days
  }
  fmt.Printf("Numbers of days in a year: %d\n", year)

* 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_.

* Function declaration

  type mytype int
  func (p mytype) funcname(q int) (r,s int) { return 0,0 }
   1        2        3      4        5         6

1. To declare a function, you use the func keyword.
2. You can optionally bind to a specific type called receiver.
3. You write the name of your function.
4. Define that the variable q of type int is the input parameter. Parameters are passed pass-by-value.
5. The variables r and s are the named return parameters for this function.
6. The body of the function.

* Scope

  package main
  
  var a int
  
  func main() {
      a = 5
      print(a)
      f()
  }
  
  func f() {
      a := 6
      print(a)
      g()
  }
  
  func g() {
      print(a)
  }

* Functions as values

  import "fmt"
  
  func main() {
  	a := func() {
  		fmt.Println("Hello")
  	}
  	a()
  }

* Deferred Code

  func ReadWrite() bool {
      file.Open("filename")
      defer file.Close()
      // Do your thing
      if failureX {
          return false
      }
      if failureY {
          return false
      }
      return true
  }

* Variadic Parameter

  func myfunc(arg ...int) {
  
    for _, n := range arg {
        fmt.Printf("And the number is: %d\n", n)
    }
  }

* Panic and recovering

  func Panic(f func()) (b bool) {
      defer func() {
          if x := recover(); x != nil {
              b = true
          }
      }()
      f()
      return
  }


* 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

* More on structure fields

  struct {
      x, y int
      A *[]int
      F func()
  }
  
  struct {
      T1        // Field name is T1.
      *T2       // Field name is T2.
      P.T3      // Field name is T3.
      x, y int  // Field names are x and y.
  }


* 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.

* Pointer receivers

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.

* Interface example

  type S struct { i int }
  func (p *S) Get() int  { return p.i }
  func (p *S) Put(v int) { p.i = v }
  
  type I interface {
      Get() int
      Put(int)
  }
  
  func f(p I) {
      fmt.Println(p.Get())
      p.Put(1)
  }

* Which is what?

  type R struct { i int }
  func (p *R) Get() int  { return p.i }
  func (p *R) Put(v int) { p.i = v }
  
  func f(p I) {
      switch p.(type) {
          case *S:
          case *R:
          default:
      }
  }

* Empty interface

  func g(something interface{}) int {
      return something.(I).Get()
  }


* Other Go BootCamps

- [[http://www.golangbootcamp.com/book][Matt Aimonetti: Go Bootcamp]]
- [[https://miek.nl/go/][Miek Gieben: Learning Go]]
- [[https://github.com/ZacharyJacobCollins/Golang-Bootcamp][ZacharyJacobCollins/Golang-Bootcamp]]

* Question time

* Resources

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://golang.org/doc/code.html How to Write Go Code
.link https://tour.golang.org/welcome/1 tour.golang.org
.link https://golang.org/doc/effective_go.html Effective Go
.link https://gobyexample.com/ Go by Example
.link http://www.goin5minutes.com/ Go in 5 minutes
.link https://miek.nl/go/ LEARNING GO online book
.link https://habrahabr.ru/hub/go/ Habrahabr