Go Programming

Internet Engineering

Go is

• Modern
• Generic Purpose
• Open Source

Programming Language

• Officially announced at November 10, 2009
• It began as an internal Google project
• The designers were primarily motivated by their shared dislike of C++
• Its spiritual fathers are
  • Robert Griesemer
  • Ken Thomson
  • Rob Pike

• version 1.0 was released in March 2012.
• Go is widely used in production at Google and in many other organizations and open-source projects.
• Lack of support for generic programming and the verbosity of error handling in Go 1.x had drawn considerable criticism.

package main

import "fmt"

func main() {
  fmt.Printf("Hello, دنیا\n")
}
  

• Go code is organized into packages, which are similar to libraries or modules in other languages.
• The import declaration must follow the package declaration.
• You must import exactly the packages you need.
• A function declaration consists of the keyword func, the name of the function, a parameter list (empty for main), a result list (also empty here), and the body of the function - the statements that define what it does - enclosed in braces.

Constants

Maintained precisely:

const e = 2.71828182845904523536028747135266249775724709369995957496696763
const third = 1/3
  

Typed or without type:

const M64 int64 = 1<<20
const M = 1<<20
  

Evaluated at compile-time:

const big = 1<<100 / 1e30  // valid constant expression
  

Calculation

x := 42
y := x + 10
var c = (f - 32) * 5 / 9

var x uint8 = 1 << 1 | 1 << 5
var y uint8 = 1 << 1 | 1 << 2

fmt.Printf("%08b\n", x) // "00100010"
fmt.Printf("%08b\n", y) // "00000110"

fmt.Printf("%08b\n", x&y) // "00000010"
fmt.Printf("%08b\n", x|y)     // "00100110"
fmt.Printf("%08b\n", x^y)     // "00100100"
  

Assignment

• Tuple Assignment
• Allows several variables to be assigned at once.
• All of the right-hand side expressions are evaluated before any of the variable are updated.

// tuple assignment

a, b = b, a // swap

f, err = os.Open(filename) // multiple assignment

func gcd(x, y int) int {
  for y != 0 {
    x, y = y, x % y
  }

  return x
}
  

Statements

• Curly braces (C style)
• Multiple assignments and some other new constructs
• Statements are not Expressions.
• Many cleanups 🧹:
  • mandatory braces
  • no parentheses for conditionals
  • implicit break in switches
  • no semicolons
  • ...

Statements

if x < y {
  return x
} else {
  return y
}

switch day {
case Mon:
  ...
  // break is implicit
case Tue, Wed:
  ...
}
  

• Not shown: break, goto, continue, fallthrough

Functions

package main

import "fmt"

func Fibonacci(n int) int {
  if n == 0 || n == 1 {
    return 1
  } else {
    return Fibonacci(n-1) + Fibonacci(n-2)
  }
}

func main() {
  fmt.Printf("%d\n", Fibonacci(10))
}
  

Methods

package main

import "fmt"

type Example struct {
  Val   string
  count int
}

// define a custom type based on go standard types
type integer int

func (i integer) log() {
  fmt.Printf("%d\n", i)
}

// pointer reciever which can change 'example' fields
func (e *Example) Log() {
  e.count++
  fmt.Printf("%d %s\n", e.count, e.Val)
}

func main() {
  var i integer
  exm := Example{
    Val:   "Example",
    count: 10}
  i.log()
  exm.Log()
}
    

Interfaces

package main

import "fmt"

type Printer interface {
  Print()
}

type Foo struct {
  X, Y int
}

type Bar struct {
  X, Y float64
}

func (f Foo) Print() {
  fmt.Printf("%d %d\n", f.X, f.Y)
}

func (b Bar) Print() {
  fmt.Printf("%g %g\n", b.X, b.Y)
}
  

Casting Types

• type conversion: A type conversion is similar to a cast in C. It reinterprets the value as a new type

package main

func main() {
  one := 1
  var float float32
  float = float32(one)
}
  

Type Assertion

• type assertion: They do not convert between types; they simply state to the compiler that the underlying value has the specific type.

package main

import "fmt"

type empty interface{}

type example struct {
  A int
}

func main() {
  one := 1
  var i empty = one
  j := example{A: 10}
  var k empty = j
  fmt.Println(k.(example).A)
}
  

Create Point Interface

type Point interface {
  Distance() float64
  ImageOnX() float64
  ImageOnY() float64
}
    

Create Cartesian Point Structure

type Cartesian struct {
  X float64
  Y float64
}

func (c *Cartesian) Distance() float64 {
  return math.Sqrt(c.X*c.X + c.Y*c.Y)
}

func (c *Cartesian) ImageOnX() float64 {
  return c.X
}

func (c *Cartesian) ImageOnY() float64 {
  return c.Y
}
    

Create Polar Point Structure

type Polar struct {
  R    float64
  Teta float64
}

func (p *Polar) Distance() float64 {
  return p.R
}

func (p *Polar) ImageOnX() float64 {
  return p.R * math.Cos(p.Teta)
}

func (p *Polar) ImageOnY() float64 {
  return p.R * math.Sin(p.Teta)
}
    

func main() {
  p := Polar{
    R:    1,
    Teta: math.Pi / 2,
  }

  c := Cartesian{
    X: 3,
    Y: 4,
  }

  fmt.Printf("%g %g\n", p.Distance(), c.Distance())
  fmt.Printf("%g %g\n", c.ImageOnX(), c.ImageOnY())
  fmt.Printf("%g %g\n", p.ImageOnX(), p.ImageOnY())
}

package main

import (
  "fmt"
  "math"
)

type Point interface {
  Distance() float64
  ImageOnX() float64
  ImageOnY() float64
}

type Cartesian struct {
  X float64
  Y float64
}

func (c *Cartesian) Distance() float64 {
  return math.Sqrt(c.X*c.X + c.Y*c.Y)
}

func (c *Cartesian) ImageOnX() float64 {
  return c.X
}

func (c *Cartesian) ImageOnY() float64 {
  return c.Y
}

type Polar struct {
  R    float64
  Teta float64
}

func (p *Polar) Distance() float64 {
  return p.R
}

func (p *Polar) ImageOnX() float64 {
  return p.R * math.Cos(p.Teta)
}

func (p *Polar) ImageOnY() float64 {
  return p.R * math.Sin(p.Teta)
}

func main() {
  p := Polar{
    R:    1,
    Teta: math.Pi / 2,
  }

  c := Cartesian{
    X: 3,
    Y: 4,
  }

  fmt.Printf("%g %g\n", p.Distance(), c.Distance())
  fmt.Printf("%g %g\n", c.ImageOnX(), c.ImageOnY())
  fmt.Printf("%g %g\n", p.ImageOnX(), p.ImageOnY())
}
    

Go Packages

• A package is made up of Go files that live in the same directory and have the same package statement at the beginning.

greet Package

└── gopherguides
    └── greet
        └── greet.go
  

package greet

import "fmt"

func Hello() {
    fmt.Println("Hello, World!")
}
  

main Package

└── gopherguides
    └── example
        └── main.go
  

package main

import "github.com/gopherguides/greet"

func main() {
    greet.Hello()
}
  

• Go does not have the concept of public, private, or protected modifiers like other languages do.
• External visibility is controlled by capitalization.
• Types, variables, functions, and so on, that start with a capital letter are available, publicly, outside the current package.
• A symbol that is visible outside its package is considered to be exported.

Go Modules

• A module is a collection of packages that are released, versioned, and distributed together. Modules may be downloaded directly from version control repositories or from module proxy servers.
• A module is identified by a module path, which is declared in a go.mod file, together with information about the module's dependencies.
• the module golang.org/x/net contains a package in the directory html. That package's path is golang.org/x/net/html.

HTTP Server

• We want to write our http server to handle request in our way
• Golang has core and third party libraries for implementing the http server
• We are going to use echo

Install Echo

> go mod init github.com/1995parham-teaching/go-lecture/echo
> go get github.com/labstack/echo/v4
  

Routes

• Build an instance of echo

e := echo.New()
    

• Specify which function shold be called for each route

e.POST("/hello", func (c echo.Context) error {
  c.JSON(http.StatusOK, "Hello World")
})
    

Goroutines

• The go statement launches a function call as a goroutine

go f()
go f(x, y, ...)
    

• A goroutine runs concurrently (but not necessarily in parallel)
• A goroutine is a thread of control within the program, with its own local variables and stack. Much cheaper to create and schedule than operating system threads.

A Simple Example

Function f is launched as 3 different goroutines, all running concurrently:

package main

import (
  "fmt"
  "time"
)

func f(msg string, delay time.Duration) {
  for {
    fmt.Println(msg)
    time.Sleep(delay)
  }
}

func main() {
  go f("A--", 300*time.Millisecond)
  go f("-B-", 500*time.Millisecond)
  go f("--C", 1100*time.Millisecond)
  time.Sleep(20 * time.Second)
}
  

Communication via channels

• A channel type specifies a channel value type (and possibly a communication direction):

chan int
chan<- string  // send-only channel
<-chan T       // receive-only channel
    

• A channel is a variable of channel type:

var ch chan int
ch := make(chan int)  // declare and initialize with newly made channel
    

• A channel permits _sending_ and _receiving_ values:

ch <- 1   // send value 1 on channel ch
x = <-ch  // receive a value from channel ch (and assign to x)
  

• Channel operations synchronize the communicating goroutines.

Communicating goroutines

Each goroutine sends its results via channel ch:

func f(msg string, delay time.Duration, ch chan string) {
  for {
    ch <- msg
    time.Sleep(delay)
  }
}
  

The main goroutine receives (and prints) all results from the same channel:

func main() {
  ch := make(chan string)
  go f("A--", 300*time.Millisecond, ch)
  go f("-B-", 500*time.Millisecond, ch)
  go f("--C", 1100*time.Millisecond, ch)

  for i := 0; i < 100; i++ {
    fmt.Println(i, <-ch)
  }
}
  

References 📚

• https://www.digitalocean.com/community/tutorials/how-to-write-packages-in-go
• https://golang.org/ref/mod