Taller de trabajo con Golang para miembros de la comunidad de Rep. Dominicana.

1. Golang Dominicana:
Workshop

2. About me
Víctor S. Recio
CEO NerCore LLC,
@vsrecio / vrecio@nercore.com
Fundador y Organizador
● Docker Santo Domingo
● Linux Dominicana
● Golang Dominicana
● OpenSaturday.org

3. Software Developer Skills
Skills required for a software developer:
● Programming Language
● Text Editor
● Source Code Management
● Operating System
Activity*: 5 minute group discussion (_Icebreaker_)

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

5. 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)

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

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

8. 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!)

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

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

11. How are using Golang?
- Google
- Docker Inc.
- CoreOS
- Open Stack
- Digital Ocean
- AWS
- Twitter
- iron.io
https://github.com/golang/go/wiki/GoUsers

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

13. 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)

14. 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)

15. 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=linux
GOARCH=x86-64
*Activity*: Produce binary for different operating systems and architectures

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

17. 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)

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

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

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

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

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

23. Primitive types
int, uint, int8, uint8, ...
bool, string
float32, float64
complex64, complex128
package main
import "fmt"
func main() {
fmt.Printf("Value: %v, Type: %Tn", "Baiju", "Baiju")
fmt.Printf("Value: %v, Type: %Tn", 7, 7)
fmt.Printf("Value: %v, Type: %Tn" uint(7), uint(7))
fmt.Printf("Value: %v, Type: %Tn", int8(7), int8(7))
fmt.Printf("Value: %v, Type: %Tn" true, true)
fmt.Printf("Value: %v, Type: %Tn" 7.0, 7.0)
fmt.Printf("Value: %v, Type: %Tn" (1 + 6i), (1 + 6i))
}

24. 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 int
var tall bool
var name, place string
fmt.Printf("%#v, %#v, %#v, %#vn", age, tall, name, place)
}

25. ● Type is explicitly specified and initialized with given values
package main
import "fmt"
func main() {
var age int = 10
var tall bool = true
var name, place string = "Baiju", "Bangalore"
fmt.Printf("%#v, %#v, %#v, %#vn", age, tall, name, place)
}

26. ● Type is inferred from the values that is given for initialization
package main
import "fmt"
func main() {
var i = 10 // int
var s, b = "Baiju", true //string, bool
fmt.Printf("%#v, %#v, %#v, %#vn", i, s, b)
}

27. ● 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 // int
s, b := "Baiju", true //string, bool
fmt.Printf("%#v, %#v, %#v, %#vn", i, s, b)
}

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

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

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

31. ● 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
}

32. 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 main
import ("fmt", "strconv")
func main() {
i, err := strconv.Atoi("42")
if err != nil {
fmt.Printf("couldn't convert number: %vn", err)
return
}
fmt.Println("Converted integer:", i)
}

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

34. ● 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"
)

35. 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()

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

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

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

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

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

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