Golang workshop

Golang Dominicana: Workshop

About meVíctor S. RecioCEO NerCore LLC,@vsrecio / [email protected]

Fundador y Organizador● Docker Santo Domingo● Linux Dominicana● Golang Dominicana● OpenSaturday.org

Software Developer Skills

Skills required for a software developer:

● Programming Language● Text Editor● Source Code Management● Operating System

Activity*: 5 minute group discussion (_Icebreaker_)

Ground Rules

- Workshops are hard, everyone works at a different pace- We will move on when about 50% are ready- Slides are online, feel free to work ahead or catch up

Requirements

- Not need experience in some other language (Python, Ruby, Java, etc.)- Know how to use Git version control system- Comfortable with one shell (Bash, Zsh)- Comfortable with one text editor (Vim, IntelliJ, Atom.)- Install Go plugin for your text editor/IDE: VIM, IntelliJ, Atom- Internet connectivity should be ensured- Operating system with Go support (Linux, Mac OS. FreeBSD)

Agenda

- Format: talk, exercise, talk, exercise ... (short Q&A in between)- General facts- Running a hello world- Reasons to use Go- Development environment setup- Types- Control structures- Data structures- Functions- Interfaces- Concurrency

Facts- General Purpose Programming Language- Free and Open Source (FOSS)- Created at Google by Robert Griesemer, Rob Pike and Ken Thompson- Development started in 2007 and publicly released in November 2009- C like syntax (no semicolons) (;)- Object Oriented (Composition over inheritance - no classes!)- Compiled (Statically linked)- Garbage collected- Statically typed- Strongly typed- built-in concurrency- Two major compilers: gc & gccgo- 25 keywords (less than C,C++,Python etc.)- Classification (Capitalized are exported - public)

Facts- Fast build (in seconds)- Unused imports and variables raise compile error- Operating Systems: Windows, GNU/Linux, Mac OS X, *BSD etc.- CPU Architectures: amd64, i386, arm etc.- Cross compilation- Standard library- No exceptions- Pointers (No pointer arithmetic!)

Hello World!

package main

import "fmt"

func main() {

fmt.Println("Hello, Comunidad de Golang Dominicana!")}

1

1

2

3

4

2

3

4

Este es conocido como declaracion de paquetes y es obligatorio.

Esta es la forma como incluimos código de otro paquete

Las funciones son los bloques de construcción de un programa en Go.

Las funciones poseen Input y Ouput y una serie de pasos llamados declaraciones o sentencias.

Why Golang?

● Go compiles very quickly.● Go supports concurrency at the language level.● Functions are first class objects in Go.● Go has garbage collection.● Strings and maps are built into the language.● Google is the owner

How are using Golang?

- Google- Docker Inc.- CoreOS- Open Stack- Digital Ocean- AWS- Twitter- iron.io

https://github.com/golang/go/wiki/GoUsers

Installing Go on Linux● Download Go compiler binary from https://golang.org/dl● Extract it into your home directory (`$HOME/go`)● Create directory named `mygo` in your home directory (`$HOME/mygo`)● Add the following lines to your `$HOME/.bashrc`

# Variables Golang export GOROOT=$HOME/go export PATH=$GOROOT/bin:$PATH

export GOPATH=$HOME/mygo export PATH=$GOPATH/bin:$PATH

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

Building and Running

- You can run the program using "go run" command: go run hello.go- You can also build (compile) and run the binary like this in GNU/Linux:

$ go build hello.go $ ./hello

(The first command produce a binary and second command executes the binary)

Formatting Code

● Use "go fmt <file.go>" to format Go source file● No more debate about formatting!● Can integrate with editors like Vim, Emacs etc.● *Proverb*: Gofmt's style is no one's favorite, yet gofmt is everyone's favorite.

(*Exercise*: 1)

Cross Compiling

● The "go build" command produce a binary file native to the operating system and the architecture of the CPU (i386, x86_64 etc.)

● Specify targeted platform using environment variables: GOOS & GOARCH● List of environment variables:

https://golang.org/doc/install/source#environment

GOOS=linuxGOARCH=x86-64

*Activity*: Produce binary for different operating systems and architectures

Formatting Code● *$GOPATH* directory is a workspace (sources, packages, and binaries)● Three sub-directories under $GOPATH: bin, pkg and src● *bin* directory contains executable binaries (add to $PATH)● The *src* directory contains the source files.● The *pkg* directory contains package objects used by go tool to create the final

executable● The Go tool understands the layout of a workspace

mygo |-- bin |-- pkg |-- src

If you are using GitHub for hosting code, you can create a directory structure under workspace like this:

src/github.com/<username>/<projectname>

Replace the <username> with your GitHub username or organization name and <projectname> with the name of the project. For example:

src/github.com/vsrecio/demo

(*Note*: When you fork a project in Github use "go get" with the upstream location)

Getting third party packages● The "go get" command download source repositories and places them in the

workspace

$ go get github.com/vsrecio/demo $ go get golang.org/x/tools/...

● Repo URL and package path will be same normally (This helps Go tool to fetch)● To update use "-u" flag

$ go get -u github.com/vsrecio/demo

- *Activity*: Run "go get" as given above

Exercise 1

Write a program to print ”Hello, World!” and save this in a file named helloworld.go. Compile the program and run it like this:

$ ./helloworld

Go Tools

● Run "go help" to see list of available commands● Use "go help [command]" for more information about a command

Few commonly used commands:

- build - compile packages and dependencies- fmt - run gofmt on package sources- get - download and install packages and dependencies- install - compile and install packages and dependencies- run - compile and run Go program- test - test packages- version - print Go version

Keywords● Keywords are reserved words● Cannot be used as identifiers● Provide structure and meaning to the language

break default func interface select case defer go map struct chan else goto package switch const fallthrough if range type continue for import return var

Comments● Two kinds of comments● C Style

/* This is a multi-line comment ... and this is a the second line */

● C++ style

// Single line number // Starts with two slashes

*Activity*: Update the `hello.go` with few comments and run

Primitive typesint, uint, int8, uint8, ...bool, stringfloat32, float64complex64, complex128

package main

import "fmt"

func main() {fmt.Printf("Value: %v, Type: %T\n", "Baiju", "Baiju")fmt.Printf("Value: %v, Type: %T\n", 7, 7)fmt.Printf("Value: %v, Type: %T\n" uint(7), uint(7))fmt.Printf("Value: %v, Type: %T\n", int8(7), int8(7))fmt.Printf("Value: %v, Type: %T\n" true, true)fmt.Printf("Value: %v, Type: %T\n" 7.0, 7.0)fmt.Printf("Value: %v, Type: %T\n" (1 + 6i), (1 + 6i))

}

Variables● Type is explicitly specified but initialized with default zero values● The zero value is 0 for numeric types, false for Boolean type and empty

string for strings.

package main

import "fmt"

func main() {var age intvar tall boolvar name, place stringfmt.Printf("%#v, %#v, %#v, %#v\n", age, tall, name, place)

}

● Type is explicitly specified and initialized with given values

package main

import "fmt"

func main() {var age int = 10var tall bool = truevar name, place string = "Baiju", "Bangalore"fmt.Printf("%#v, %#v, %#v, %#v\n", age, tall, name, place)

}

● Type is inferred from the values that is given for initialization

package main

import "fmt"

func main() {var i = 10 // intvar s, b = "Baiju", true //string, boolfmt.Printf("%#v, %#v, %#v, %#v\n", i, s, b)

}

● Short variable declaration inside functions (Similar to above - type is inferred from the values that is given for initialization)

package main

import "fmt"

func main() {i := 10 // ints, b := "Baiju", true //string, boolfmt.Printf("%#v, %#v, %#v, %#v\n", i, s, b)

}

Constants● Constants are declared like variables, but with the const keyword.● Constants can be character, string, Boolean, or numeric values.● Constants cannot be declared using the := syntax.

const Male = true const Pi = 3.14 const Name = "Baiju"

- *Activity*: Write a program to define the above constants and print it

Exercise 2

Write a program that converts from Fahrenheit into Celsius (C = (F - 32) * 5/9)

If Conditions● Syntax inspired by C● Curly brace is mandatory

package main

import "fmt"

func main() {if 1 < 2 {

fmt.Printf("1 is less than 2")}

}

● 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● Variables declared inside an if short statement are also available inside any of

the else block

package main

import "fmt"

func main() {if money := 20000; money > 15000 {

fmt.Println("I am going to buy a car.")} else {

fmt.Println("I am going to buy a bike.")}// can't use the variable `money` here

}

Errors● Go programs express error state with *error* values● The error type is a built-in interface● -Functions often return an error value, and calling code should handle

errors by testing whether the error equals *nil*.

package mainimport ("fmt", "strconv")func main() {

i, err := strconv.Atoi("42")if err != nil {

fmt.Printf("couldn't convert number: %v\n", err)return

}fmt.Println("Converted integer:", i)

}

Packages● Every Go program is made up of packages● Package name must be declared in source files● To create executable use name of package as *main*● Programs start running in package main● All the package files resides in a directory

package main

● Import give access to exported stuff from other packages● Any "unexported" names are not accessible from outside the package● Foo is an exported name, as is FOO. The name foo is not exported● By convention, package name is the same as the last element of the import

path● Initialization logic for package goes into a function named *init*● Use alias to avoid package name ambiguity with package imports

import ( "fmt""github.com/baijum/fmt"

)

Blank identifier

● Underscore (*_*) is the blank identifier● Blank identifier can be used as import alias to invoke *init* function without

using the package

import ( "database/sql" _ "github.com/lib/pq" )

● Blank identifier can be used to ignore return values from function

x, _ := someFunc()

For Loop● The only looping construct (no while loop)● Syntax inspired by C● No parenthesis (not even optional)● Curly brace is mandatory

package main

import "fmt"

func main() {for i := 0; i < 5; i++ {

fmt.Println("Baiju")}

}

Exercise 3

Write a program that prints all the numbers between 1 and 100, that are evently divisible by 3 (3, 6,9).

Switch statement● The cases are evaluated top to bottom until a match is found● There is no automatic fall through● Cases can be presented in comma-separated lists● break statements can be used to terminate a switch early

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.")}

}

Defer statement● Ensure a cleanup function is called later● To recover from runtime panic● Executed in LIFO order

package main

import "fmt"

func main() {defer fmt.Println("world")fmt.Println("hello")

}

Write a program that prints all the numbers between 1 to 100, for multiples of three, print “Fizz” instead of the number, and for the multiples of five, print “Buzz”. For numbers that are multiples of both three and five, print “FizzBuzz”.

Exercise 4