Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.

Golang workshop

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

  • Login to see the comments

Golang workshop

  1. 1. Golang Dominicana: Workshop
  2. 2. About me Víctor S. Recio CEO NerCore LLC, @vsrecio / Fundador y Organizador ● Docker Santo Domingo ● Linux Dominicana ● Golang Dominicana ●
  3. 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. 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. 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. 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. 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. 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. 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. 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. 11. How are using Golang? - Google - Docker Inc. - CoreOS - Open Stack - Digital Ocean - AWS - Twitter -
  12. 12. Installing Go on Linux ● Download Go compiler binary from ● 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 ●
  13. 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. 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. 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: GOOS=linux GOARCH=x86-64 *Activity*: Produce binary for different operating systems and architectures
  16. 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. 17. If you are using GitHub for hosting code, you can create a directory structure under workspace like this: src/<username>/<projectname> Replace the <username> with your GitHub username or organization name and <projectname> with the name of the project. For example: src/ (*Note*: When you fork a project in Github use "go get" with the upstream location)
  18. 18. Getting third party packages ● The "go get" command download source repositories and places them in the workspace $ go get $ go get ● Repo URL and package path will be same normally (This helps Go tool to fetch) ● To update use "-u" flag $ go get -u - *Activity*: Run "go get" as given above
  19. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 29. Exercise 2 Write a program that converts from Fahrenheit into Celsius (C = (F - 32) * 5/9)
  30. 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. 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. 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. 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. 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" "" )
  35. 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" _ "" ) ● Blank identifier can be used to ignore return values from function x, _ := someFunc()
  36. 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. 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. 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. 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. 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. 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