Go Programming

Gopher

• Go is syntactically similar to C, but with memory safety, garbage collection, structural typing, and CSP-style concurrency.
• There are two major implementations:
1. Google's self-hosting compiler toolchain targeting multiple operating systems, mobile devices, and WebAssembly.
2. gccgo, a GCC frontend.

memory safety

int a[10];
a[11] = 10;
    

garbage collection

void allocate_forever(void) {
  int *a = malloc(10 * sizeof(int));
  a[0] = 10;
}
    

structural typing

struct student {
  int  id;
  char surname[255];
  char forename[255];
};
    

• Go code is easy to read and easy to understand
• Go does not have a preprocessor
• Go uses static linking by default, which means that the binary files produced can be easily transferred to other machines with the same OS.

preprocessor

#define students_foreach_loop(stds, element) \
    struct students_el *element ## _el = stds->head; \
    const struct student *element = element ## _el->student; \
    for (; element ## _el != NULL; element ## _el = element ## _el->next, element = element ## _el ? element ## _el->student : NULL)

  students_foreach_loop(stds, el) {
    fprintf(fp, "Name: %s\n", el->name);
    fprintf(fp, "ID: %s\n", el->id);
    fprintf(fp, "\n");
  }
    

• A syntax and environment adopting patterns more common in dynamic languages:
• Optional concise variable declaration and initialization through type inference (x := 0 instead of int x = 0;).
• Fast compilation.
• Remote package management (go get) and online package documentation.

• Distinctive approaches to particular problems:
• Built-in concurrency primitives: light-weight processes (goroutines), channels, and the select statement.
• An interface system in place of virtual inheritance, and type embedding instead of non-virtual inheritance.
• A toolchain that, by default, produces statically linked native binaries without external dependencies.
• A desire to keep the language specification simple enough to hold in a programmer's head, in part by omitting features that are common in similar languages.

Variables

var name type = expression

name := expression // inside functions only

Statically typed:

var x int
var s, t string
    

Implicitly or explicitly initialized:

var x int                       // x = 0
var s, t string = "foo", "bar"  // multiple assignment

var x = 42                      // int
var s, b = "foo", true          // string, bool
    

Short variable declaration:

x := 42
s, b := "foo", true
    

Pointers ⚰️

• A pointer value is the address of a variable.
• Not every value has an address, but every variable does.
• With a pointer, we can read or update the value of a variable indirectly

x := 1
p := &x     // p, of type *int, points to x
fmt.Println(*p) // 1
*p = 2          // equivalent to x = 2
fmt.Println(x)  // 2
    

Predeclared Name

which can be reused

true false iota nil
    

int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
float32 float64 complex128 complex64
bool byte rune string error
    

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

which can't be reused

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
    

The new Function

• Another way to create a variable is to use the built-in function new
• The expression new(T) create an unnamed variable of type T, initializes it to the zero value of T, and return its address, which is a value of type *T
• The new function is relatively rarely used.

func newInt() *int {
  return new(int)
}

// the same thing, written out
func newIntLongWay() *int {
  var dummy int
  return &dummy
}
    

Statements

• Unified for syntax

// a traditional infinite loop
for {
  // ...
}
    

for initialization; condition; post {
  // zero or more statements
}
    

// a traditional "while" loop
for condition {
  // ...
}
    

• range over arrays, slices, and maps
• In each iteration of the loop, range produces a pair of values: the index and the value of the element at that index.
• If you don't want the index variable you can use the blank identifier, whose name is _ (that is, an underscore).

for i, num := range numbers { ... }
for city, pop := range population { ... }
    

Result

please enter n: 10
is 10 prime? false
10th prime is 29
gcd 10 20 is 10
gcd 13 15 is 1
    

• Go has one loop keyword. for covers the counter, the while, and the infinite loop

Interaction

package main

import "fmt"

func main() {
  var n int
  fmt.Scanf("%d", &n)
  fmt.Printf("%d\n", n)
}
    

Strings

• A string is an immutable sequence of bytes
• Text strings are conventionally interpreted as UTF-8 encoded sequence of Unicode code points (runes)
• The built-in len function returns the number of bytes (not runes) in a string, and the index operation s[i] retrieves the i-th byte of string s, where 0 <= i < len(s)

s := "hello, world"
fmt.Println(len(s)) // 12
fmt.Println(s[0], s[7]) // 'h' and 'w'
    

• Constructions that try to modify a string's data in place are not allowed:

s[0] = 'L' // compile error: cannot assign to s[0]
      

• Four standard packages are particularly important for manipulating strings:
• bytes
• strings
• strconv
• unicode

go doc bytes
    

Unicode

• unicode.org
• Which collects all of the characters in all of the world's writing systems, plus accents and other diacritical marks, control codes like tab and carriage return, etc.

Conversions between Strings and Numbers

• To convert an integer to a string, one option is to use fmt.Sprintf; another is to use the function strconv.Itoa.
• strconv.FormatInt() and strconv.FormatUint can be used to format numbers in a different base
• The fmt.Printf verbs %b, %d, %o, and %x are often more convenient than Format functions

x := 123
y := fmt.Sprintf("%d", x)
fmt.Println(y, strconv.Itoa(x)) // "123 123"
    

• To parse a string representing an integer, use the strconv.Atoi or strconv.ParseInt, or strconv.ParseUint for unsigned integers
• The third argument of ParseInt gives the size of the integer type that the result must fit into
• In any case, the type of the result is always int64, which you can then convert to a smaller type
• fmt.Sscanf is useful for parsing input that consists of orderly mixtures of strings and number all on a single line

x, err := strconv.Atoi("123")              // x is an int
y, err := strconv.ParseInt("123", 10, 64)  // base 10, up to 64 bits
    

Result

17 (len(s3)) != 9
[216 179 217 132 216 167 217 133 32 216 175 217 134 219 140 216 167]
72
Parham Alvani
216
179
³
[0]: س [2]: ل [4]: ا [6]: م [8]:   [9]: د [11]: ن [13]: ی [15]: ا
Global string is which defined
    

What Happened?

• len(s3) is 17, not 9: those letters need two bytes each in UTF-8
• s3[0] is 216, half of a character, and printing it as %c gives nonsense
• range decodes runes, so the index jumps 0, 2, 4, … and each character arrives whole

Arrays

• An array is a fixed-length sequence of zero or more elements of a particular type.
• Because of their fixed length, arrays are rarely used directly in Go.
• By default the elements of a new array variable are initially set to the zero value for the element type, which is 0 for numbers.

var a [3]int                // array of 3 integers
fmt.Println(a[0])           // print the first element
fmt.Println(a[len(a) - 1])  // print the last element, a[2]
    

a := [2]int{1, 2}
b := [...]int{1, 2}
c := [2]int{1, 3}

fmt.Println(a == b, a == c, b == c) // "true false false"

d := [3]int{1, 2}
fmt.Println(a == d) // compile error: cannot compare [2]int == [3]int
    

// Print the indices and elements.
for i, v := range a {
  fmt.Printf("%d %d\n", i, v)
}

// Print the elements only.
for _, v := range a {
  fmt.Printf("%d\n", v)
}
    

Slices

[]T  // slice of T
      

• Descriptor for an underlying array segment
• May grow and shrink
• Has length and capacity
• Assigning a slice copies the descriptor, not the underlying array

• Common slice operations:
• The slice operators[i:j], where 0 <= i <= j <= cap(s), creates a new slice that refers to elements i through j - 1 of the sequence s.

len(s)
s[i]
s[i:j]
append(s, x)  // append element x to slice s and return new slice
      

• Slices play the role of dynamically sized arrays
• Widely used in Go code

Result

s1: [10 20 30 0 0 0 0 0 0 0], len(s1): 10, cap(s1): 10
s1: [10 20 30 0 0 0 0 0 0 0 10], len(s1): 11, cap(s1): 20
s2: [10], len(s2): 1, cap(s2): 10

before appending a new variable into s
address of s is 0x76fb35a2a048
address of s[0] is 0x76fb35a280a0
after appending a new variable into s
address of s is 0x76fb35a2a048
address of s[0] is 0x76fb35a24140
    

• The append passed the capacity, so Go allocated a new array and copied: capacity went 10 → 20
• The slice header did not move, but &s[0] changed: anything still pointing at the old array no longer sees the updates

Structures

package main

type Sample struct {
  S1      int
  S2      int
  S3      string
  private float64
}

func main() {
  var smp Sample
  smp.S1 = 10
  smp.S2 = 20
  smp.S3 = "Hello World"
}
  

• A struct is an aggregate data type that groups together zero or more named values of arbitrary types as a single entity
• Each value is called a field
• C Structures 🕺
• Data hiding:
• The name of a struct field is exported if it begins with a capital letter; this is Go's main access control mechanism.
• S1, S2, S3 are public and can be accessed from anywhere.
• private is private and is only visible to code in the same package.

Result

we can compare student structs
Name: Parham, Family: Alvani, age: 27
student, Parham Alvani
Hello Torvalds, I am Parham Alvani (27)
    

• Println found String() and used it, instead of printing the fields
• Uncomment the slice field and the comparison stops compiling: a struct is comparable only when all of its fields are

Result

Linus Torvalds
p is not a person
Hello
    

• Student satisfies Printer just by having the method: interfaces are satisfied implicitly
• p.(Person) without , ok would panic; with it you get false instead

Module Path

• A module path should describe both what the module does and where to find it.

• The repository root path is the portion of the module path that corresponds to the root directory of the version control repository where the module is developed.
• Most modules are defined in their repository's root directory, so this is usually the entire path.
• For example, golang.org/x/net is the repository root path for the module of the same name.
• If the module is not defined in the repository's root directory, the module subdirectory is the part of the module path that names the directory, not including the major version suffix.
• If the module is released at major version 2 or higher, the module path must end with a major version suffix like /v2.
• This may or may not be part of the subdirectory name. For example, the module with path golang.org/x/repo/sub/v2 could be in the /sub or /sub/v2 subdirectory of the repository golang.org/x/repo.

The Whole Server

package main

import (
  "fmt"
  "log"
  "net/http"
)

func main() {
  mux := http.NewServeMux()

  mux.HandleFunc("GET /hello", func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Hello World")
  })

  log.Fatal(http.ListenAndServe(":1373", mux))
}
    

• No dependencies, no go get, one file

Handlers

• A handler is anything with this method:

type Handler interface {
  ServeHTTP(w http.ResponseWriter, r *http.Request)
}
      

• w is where you write the response, r is the request you read
• http.HandlerFunc adapts a plain function to that interface, which is why HandleFunc accepts a function

Routing Patterns

mux.HandleFunc("GET /hello", h.Get)
mux.HandleFunc("POST /hello", h.Post)
mux.HandleFunc("GET /hello/{username}", h.User)
    

• A leading method restricts the route; a request with the wrong method gets 405 Method Not Allowed without you writing anything
• {username} is a wildcard, read back with r.PathValue("username")
• {path...} matches the rest of the path, and a trailing / matches a subtree
• When two patterns match, the more specific one wins

Reading the Request

// path:  GET /hello/{username}
name := r.PathValue("username")

// query: GET /hello?hello=IE
value := r.FormValue("hello")

// body:  POST /hello  with application/json
var req request.Name
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
  http.Error(w, err.Error(), http.StatusBadRequest)
  return
}
    

• Check the Content-Type before decoding, with mime.ParseMediaType, so application/json; charset=utf-8 is still accepted

Writing the Response

enc, err := json.Marshal(fmt.Sprintf("Hello World from %s", h.From))
if err != nil {
  w.WriteHeader(http.StatusInternalServerError)
  return
}

w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
_, _ = w.Write(enc)
    

• Order matters: headers, then status, then body
• Writing the body first sends an implicit 200, and your WriteHeader afterwards is ignored

Handlers That Need Something

• A handler usually needs a logger, a database, a config. Make it a method on a struct instead of reaching for a global

type Hello struct {
  From   string
  Logger *slog.Logger
}

func (h Hello) User(w http.ResponseWriter, r *http.Request) {
  h.Logger.Info("path parameter", "username", r.PathValue("username"))
  w.WriteHeader(http.StatusNoContent)
}

// wiring it up
h := handler.Hello{From: "Golang", Logger: logger}
mux.HandleFunc("GET /hello/{username}", h.User)
    

Middleware Is Just a Function

func logging(logger *slog.Logger, next http.Handler) http.Handler {
  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    start := time.Now()

    next.ServeHTTP(w, r)

    logger.Info("request",
      "method", r.Method,
      "path", r.URL.Path,
      "took", time.Since(start),
    )
  })
}

srv.Handler = logging(logger, mux)
    

• Takes a handler, returns a handler. Auth, CORS, and recovery are all this same shape, and they compose by nesting

Do Not Use ListenAndServe in Production

• The package-level helper has no timeouts, so one slow client can hold a connection open forever

srv := &http.Server{
  Addr:              "0.0.0.0:1373",
  Handler:           mux,
  ReadHeaderTimeout: 5 * time.Second,
  ReadTimeout:       15 * time.Second,
  WriteTimeout:      15 * time.Second,
  IdleTimeout:       60 * time.Second,
}
    

Graceful Shutdown

ctx, stop := signal.NotifyContext(context.Background(),
  os.Interrupt, syscall.SIGTERM)
defer stop()

go func() {
  if err := srv.ListenAndServe(); err != nil &&
    !errors.Is(err, http.ErrServerClosed) {
    logger.Error("http server failed", "error", err.Error())
  }
}()

<-ctx.Done()

shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()

_ = srv.Shutdown(shutdownCtx)
    

• Shutdown stops accepting new connections and lets in-flight requests finish
• A clean stop returns http.ErrServerClosed, so that one is not an error

Result

$ curl -i localhost:1373/hello
HTTP/1.1 200 OK
Content-Type: text/plain; charset=utf-8
Content-Length: 25

"Hello World from Golang"

$ curl -i -X POST -H 'Content-Type: application/json' \
    -d '{"name":"Parham","count":3}' localhost:1373/hello
HTTP/1.1 200 OK
Content-Type: application/json

"Hello to Parham from Golang"

$ curl -o /dev/null -w '%{http_code}\n' -X DELETE localhost:1373/hello
405
    

• Nobody wrote that 405. There is a GET /hello pattern and no DELETE one, so the ServeMux answered for us

Server Side

level=INFO msg="http server listening" addr=0.0.0.0:1373
level=INFO msg="read hello from query parameter" handler=hello hello=IE
level=INFO msg="read username from path parameter" handler=hello username=parham
level=INFO msg="There is a count" handler=hello count=3
    

• log/slog writes key-value pairs, so the logs are greppable and machine readable without a library
• handler=hello comes from logger.With("handler", "hello") — set once at wiring time, attached to every line