Algorithms to Go

2 basic FIFO queue implementations

Mon, 01 Jan 0001 00:00:00 +0000

A simple way to implement a temporary queue data structure in Go is to use a slice:

to enqueue you use the built-in append function, and
to dequeue you slice off the first element.

var queue []string

queue = append(queue, "Hello ") // Enqueue
queue = append(queue, "world!")

for len(queue) > 0 {
	fmt.Print(queue[0]) // First element
	queue = queue[1:]   // Dequeue
}

Hello world!

Watch out for memory leaks

You may want to remove the first element before dequeuing.

2 basic set implementations

Mon, 01 Jan 0001 00:00:00 +0000

Map implementation

The idiomatic way to implement a set in Go is to use a map.

set := make(map[string]bool) // New empty set
set["Foo"] = true            // Add
for k := range set {         // Loop
	fmt.Println(k)
}
delete(set, "Foo")    // Delete
size := len(set)      // Size
exists := set["Foo"]  // Membership

Alternative

If the memory used by the booleans is an issue, which seems unlikely, you could replace them with empty structs. In Go, an empty struct typically doesn’t use any memory.

2 patterns for a do-while loop in Go

Mon, 01 Jan 0001 00:00:00 +0000

There is no do-while loop in Go. To emulate the C/Java code

do {
	work();
} while (condition);

you may use a for loop in one of these two ways:

for ok := true; ok; ok = condition {
	work()
}

for {
	work()
	if !condition {
		break
	}
}

Repeat-until loop

To write a repeat-until loop

repeat
	work();
until condition;

simply change the condition in the code above to its complement:

2 ways to delete an element from a slice

Mon, 01 Jan 0001 00:00:00 +0000

Fast version (changes order)

a := []string{"A", "B", "C", "D", "E"}
i := 2

// Remove the element at index i from a.
a[i] = a[len(a)-1] // Copy last element to index i.
a[len(a)-1] = ""   // Erase last element (write zero value).
a = a[:len(a)-1]   // Truncate slice.

fmt.Println(a) // [A B E D]

The code copies a single element and runs in constant time.

Slow version (maintains order)

a := []string{"A", "B", "C", "D", "E"}
i := 2

// Remove the element at index i from a.
copy(a[i:], a[i+1:]) // Shift a[i+1:] left one index.
a[len(a)-1] = ""     // Erase last element (write zero value).
a = a[:len(a)-1]     // Truncate slice.

fmt.Println(a) // [A B D E]

The code copies len(a) - i - 1 elements and runs in linear time.

3 dots in 4 places

Mon, 01 Jan 0001 00:00:00 +0000

Can you name four places where three dots (...) are used in Go?

Variadic function parameters

If the last parameter of a function has type ...T, it can be called with any number of trailing arguments of type T. The actual type of ...T inside the function is []T.

This example function can be called with, for instance, Sum(1, 2, 3) or Sum().

func Sum(nums ...int) int {
	res := 0
	for _, n := range nums {
		res += n
	}
	return res
}

Arguments to variadic functions

You can pass a slice s directly to a variadic function if you unpack it with the s... notation. In this case no new slice is created.

3 rules for efficient parallel computation

Mon, 01 Jan 0001 00:00:00 +0000

Dividing a large computation into work units for parallel processing is more of an art than a science.

Here are three rules of thumb.

Divide the work into units that take about 100μs to 1ms to compute.
- If the work units are too small, the administrative overhead of dividing the problem and scheduling sub-problems might be too large.
- If the units are too big, the whole computation may have to wait for a single slow work item to finish. This slowdown can happen for many reasons, such as scheduling, interrupts from other processes, and unfortunate memory layout.
Note that the number of work units is independent of the number of CPUs.
Try to minimize the amount of data sharing.
- Concurrent writes can be very costly, particularly so if goroutines execute on separate CPUs.
- Sharing data for reading is often much less of a problem.
Strive for good locality when accessing data.
- If data can be kept in cache memory, data loading and storing will be dramatically faster.
- Once again, this is particularly important for writing.

Whatever strategies you are using, don’t forget to benchmark and profile your code.

3 simple ways to create an error

Mon, 01 Jan 0001 00:00:00 +0000

String-based errors

The standard library offers two out-of-the-box options.

// simple string-based error
err1 := errors.New("math: square root of negative number")

// with formatting
err2 := fmt.Errorf("math: square root of negative number %g", x)

Custom errors with data

To define a custom error type, you must satisfy the predeclared error interface.

type error interface {
	Error() string
}

Here are two examples.

type SyntaxError struct {
	Line int
	Col  int
}

func (e *SyntaxError) Error() string {
	return fmt.Sprintf("%d:%d: syntax error", e.Line, e.Col)
}

type InternalError struct {
	Path string
}

func (e *InternalError) Error() string {
	return fmt.Sprintf("parse %v: internal error", e.Path)
}

If Foo is a function that can return a SyntaxError or an InternalError, you may handle the two cases like this.

3 ways to compare slices (arrays)

Mon, 01 Jan 0001 00:00:00 +0000

Basic case

In most cases, you will want to write your own code to compare the elements of two slices.

// Equal tells whether a and b contain the same elements.
// A nil argument is equivalent to an empty slice.
func Equal(a, b []int) bool {
	if len(a) != len(b) {
		return false
	}
	for i, v := range a {
		if v != b[i] {
			return false
		}
	}
	return true
}

For arrays, however, you can use the comparison operators == and !=.

3 ways to find a key in a map

Mon, 01 Jan 0001 00:00:00 +0000

Basics

When you index a map in Go you get two return values; the second one (which is optional) is a boolean that indicates if the key exists.

If the key doesn’t exist, the first value will be the default zero value.

Check second return value

m := map[string]float64{"pi": 3.14}
v, found := m["pi"] // v == 3.14  found == true
v, found = m["pie"] // v == 0.0   found == false
_, found = m["pi"]  // found == true

Use second return value directly in an if statement

m := map[string]float64{"pi": 3.14}
if v, found := m["pi"]; found {
	fmt.Println(v)
}
// Output: 3.14

Check for zero value

m := map[string]float64{"pi": 3.14}

v := m["pi"] // v == 3.14
v = m["pie"] // v == 0.0 (zero value)

Warning: This approach doesn't work if the zero value is a possible key.

3 ways to split a string into a slice

Mon, 01 Jan 0001 00:00:00 +0000

Split on comma or other substring

Use the strings.Split function to split a string into its comma separated values.

s := strings.Split("a,b,c", ",")
fmt.Println(s)
// Output: [a b c]

To include the separators, use strings.SplitAfter. To split only the first n values, use strings.SplitN and strings.SplitAfterN.

You can use strings.TrimSpace to strip leading and trailing whitespace from the resulting strings.

3 ways to trim whitespace (or other characters) from a string

Mon, 01 Jan 0001 00:00:00 +0000

Use the strings.TrimSpace function to remove leading and trailing whitespace as defined by Unicode.

s := strings.TrimSpace("\t Goodbye hair!\n ")
fmt.Printf("%q", s) // "Goodbye hair!"

To remove other leading and trailing characters, use strings.Trim.
To remove only the leading or the trailing characters, use strings.TrimLeft or strings.TrimRight.

4 basic if-else statement patterns

Mon, 01 Jan 0001 00:00:00 +0000

Basic syntax

if x > max {
	x = max
}

if x <= y {
	min = x
} else {
	min = y
}

An if statement executes one of two branches according to a boolean expression.

If the expression evaluates to true, the if branch is executed,
otherwise, if present, the else branch is executed.

With init statement

if x := f(); x <= y {
	return x
}

The expression may be preceded by a simple statement, which executes before the expression is evaluated. The scope of x is limited to the if statement.

4 basic range loop (for-each) patterns

Mon, 01 Jan 0001 00:00:00 +0000

Basic for-each loop (slice or array)

a := []string{"Foo", "Bar"}
for i, s := range a {
	fmt.Println(i, s)
}

0 Foo
1 Bar

The range expression, a, is evaluated once before beginning the loop.
The iteration values are assigned to the respective iteration variables, i and s, as in an assignment statement.
The second iteration variable is optional.
For a nil slice, the number of iterations is 0.

String iteration: runes or bytes

For strings, the range loop iterates over Unicode code points.

4 iota enum examples

Mon, 01 Jan 0001 00:00:00 +0000

Iota basic example

Complete enum type with strings

Naming convention

Iota basic example

The iota keyword represents successive integer constants 0, 1, 2,…
It resets to 0 whenever the word const appears in the source code,
and increments after each const specification.

const (
	C0 = iota
	C1 = iota
	C2 = iota
)
fmt.Println(C0, C1, C2) // "0 1 2"

This can be simplified to

5 basic for loop patterns

Mon, 01 Jan 0001 00:00:00 +0000

A for statement is used to execute a block of code repeatedly.

Three-component loop

This version of the Go for loop works just as in C or Java.

sum := 0
for i := 1; i < 5; i++ {
	sum += i
}
fmt.Println(sum) // 10 (1+2+3+4)

The init statement, i := 1, runs.
The condition, i < 5, is computed.

If true, the loop body runs,
otherwise the loop is done.

The post statement, i++, runs.
Back to step 2.

The scope of i is limited to the loop.

5 switch statement patterns

Mon, 01 Jan 0001 00:00:00 +0000

Basic switch with default

A switch statement runs the first case equal to the condition expression.
The cases are evaluated from top to bottom, stopping when a case succeeds.
If no case matches and there is a default case, its statements are executed.

switch time.Now().Weekday() {
case time.Saturday:
	fmt.Println("Today is Saturday.")
case time.Sunday:
	fmt.Println("Today is Sunday.")
default:
	fmt.Println("Today is a weekday.")
}

Unlike C and Java, the case expressions do not need to be constants.

A basic stack (LIFO) data structure

Mon, 01 Jan 0001 00:00:00 +0000

The idiomatic way to implement a stack data structure in Go is to use a slice:

to push you use the built-in append function, and
to pop you slice off the top element.

var stack []string

stack = append(stack, "world!") // Push
stack = append(stack, "Hello ")

for len(stack) > 0 {
	n := len(stack) - 1 // Top element
	fmt.Print(stack[n])

	stack = stack[:n] // Pop
}

Hello world!

Performance

Appending a single element to a slice takes constant amortized time. See Amortized time complexity for a detailed explanation.

A panic is an exception in Go

Mon, 01 Jan 0001 00:00:00 +0000

See Recover from a panic [best practices].

About

Mon, 01 Jan 0001 00:00:00 +0000

If some of these articles and code examples can help you become a better programmer, mission accomplished.

About me

My name is Stefan Nilsson.
I’m a former CS prof. at KTH.
Here I write about algorithms and Go.

My open-source software

About you

From the start in early 2018 to December 2019 this site has had over a million visits from all over the world.

Access environment variables

Mon, 01 Jan 0001 00:00:00 +0000

Use the os.Setenv, os.Getenv and os.Unsetenv functions to access environment variables.

fmt.Printf("%q\n", os.Getenv("SHELL")) // "/bin/bash"

os.Unsetenv("SHELL")
fmt.Printf("%q\n", os.Getenv("SHELL")) // ""

os.Setenv("SHELL", "/bin/dash")
fmt.Printf("%q\n", os.Getenv("SHELL")) // "/bin/dash"

The os.Environ function returns a slice of "key=value" strings listing all environment variables.

for _, s := range os.Environ() {
	kv := strings.SplitN(s, "=", 2) // unpacks "key=value"
	fmt.Printf("key:%q value:%q\n", kv[0], kv[1])
}

key:"SHELL" value:"/bin/bash"
key:"SESSION" value:"ubuntu"
key:"TERM" value:"xterm-256color"
key:"LANG" value:"en_US.UTF-8"
key:"XMODIFIERS" value:"@im=ibus"
…

Access private fields with reflection

Mon, 01 Jan 0001 00:00:00 +0000

With reflection it's possible to read, but not write, unexported fields of a struct defined in another package.

In this example, we access the unexported field len in the List struct in package container/list:

package list

type List struct {
	root Element
	len  int
}

This code reads the value of len with reflection.

package main

import (
	"container/list"
	"fmt"
	"reflect"
)

func main() {
	l := list.New()
	l.PushFront("foo")
	l.PushFront("bar")

	// Get a reflect.Value fv for the unexported field len.
	fv := reflect.ValueOf(l).Elem().FieldByName("len")
	fmt.Println(fv.Int()) // 2

	// Try to set the value of len.
	fv.Set(reflect.ValueOf(3)) // ILLEGAL
}

2
panic: reflect: reflect.Value.Set using value obtained using unexported field

goroutine 1 [running]:
reflect.flag.mustBeAssignable(0x1a2, 0x285a)
	/usr/local/go/src/reflect/value.go:225 +0x280
reflect.Value.Set(0xee2c0, 0x10444254, 0x1a2, 0xee2c0, 0x1280c0, 0x82)
	/usr/local/go/src/reflect/value.go:1345 +0x40
main.main()
	../main.go:18 +0x280

Algorithms: What’s the problem?

Mon, 01 Jan 0001 00:00:00 +0000

A good programmer describes algorithms in a form that can be efficiently executed by machines and easily understood by humans.

Algorithms and programs are pretty much the same thing – the main difference is that we can talk about algorithms without relying on a programming language. An algorithm invented today will be equally as useful when the last Java programmer has logged out. Here is an attempt at a formal definition.

Amortized time complexity

Mon, 01 Jan 0001 00:00:00 +0000

Amortized analysis is used for algorithms that have expensive operations that happen only rarely.

Amortized complexity analysis is most commonly used with data structures that have state that persists between operations. The basic idea is that an expensive operation can alter the state so that the worst case cannot occur again for a long time, thus amortizing its cost.

Let T₁, T₂, …, T_k be the complexities of a sequence of operations on a data structure. The amortized complexity of a single operation in this sequence is (T₁ + T₂ + …+ T_k) / k.

Example: a dynamic array

In a dynamic array, elements are stored at the start of an underlying fixed array, and the remaining positions are unused.

Anonymous functions and closures

Mon, 01 Jan 0001 00:00:00 +0000

A function literal (or lambda) is a function without a name.

In this example a function literal is passed as the less argument to the sort.Slice function.

func Slice(slice interface{}, less func(i, j int) bool)

people := []string{"Alice", "Bob", "Dave"}
sort.Slice(people, func(i, j int) bool {
	return len(people[i]) < len(people[j])
})
fmt.Println(people)
// Output: [Bob Dave Alice]

You can also use an intermediate variable.

people := []string{"Alice", "Bob", "Dave"}
less := func(i, j int) bool {
	return len(people[i]) < len(people[j])
}
sort.Slice(people, less)

Note that the less function is a closure: it references the people variable, which is declared outside the function.

API design: principles and best practices

Mon, 01 Jan 0001 00:00:00 +0000

Introduction

The aim of this text is to explore API design and try to find strategies and rules that can help us create code libraries that are safe, effective and easy to use.

Append text to a file

Mon, 01 Jan 0001 00:00:00 +0000

This code appends a line of text to the file text.log. It creates the file if it doesn’t already exist.

f, err := os.OpenFile("text.log",
	os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
	log.Println(err)
}
defer f.Close()
if _, err := f.WriteString("text to append\n"); err != nil {
	log.Println(err)
}

If you’re appending text to a file for logging purposes, see Write log to file.

Array won’t change

Mon, 01 Jan 0001 00:00:00 +0000

Why does the array value stick?

func Foo(a [2]int) {
	a[0] = 8
}

func main() {
	a := [2]int{1, 2}
	Foo(a)         // Try to change a[0].
	fmt.Println(a) // Output: [1 2]
}

Answer

Arrays in Go are values.
When you pass an array to a function, the array is copied.

If you want Foo to update the elements of a, use a slice instead.

func Foo(a []int) {
	if len(a) > 0 {
		a[0] = 8
	}
}

func main() {
	a := []int{1, 2}
	Foo(a)         // Change a[0].
	fmt.Println(a) // Output: [8 2]
}

A slice does not store any data, it just describes a section of an underlying array.

Assignment to entry in nil map

Mon, 01 Jan 0001 00:00:00 +0000

Why does this program panic?

var m map[string]float64
m["pi"] = 3.1416

panic: assignment to entry in nil map

Answer

You have to initialize the map using the make function (or a map literal) before you can add any elements:

m := make(map[string]float64)
m["pi"] = 3.1416

See Maps explained for more about maps.

Big O notation: definition and examples

Mon, 01 Jan 0001 00:00:00 +0000

Big O notation is a convenient way to describe how fast a function is growing.

Definition

When we compute the time complexity T(n) of an algorithm we rarely get an exact result, just an estimate. That’s fine, in computer science we are typically only interested in how fast T(n) is growing as a function of the input size n.

Binary search trees explained

Mon, 01 Jan 0001 00:00:00 +0000

Binary tree definitions

A binary tree is a data structure most easily described by recursion.

A binary tree

is either empty,

or consists of a node (also known as the root of the tree) and two subtrees, the left and right subtree, which are also binary trees.

A node with two empty subtrees is called a leaf.

Binary search: take a sortcut [sic]

Mon, 01 Jan 0001 00:00:00 +0000

See How to find an element in a slice/array.

Bitmasks, bitsets and flags

Mon, 01 Jan 0001 00:00:00 +0000

Bitmask

A bitmask is a small set of booleans, often called flags, represented by the bits in a single number.

type Bits uint8

const (
	F0 Bits = 1 << iota
	F1
	F2
)

func Set(b, flag Bits) Bits    { return b | flag }
func Clear(b, flag Bits) Bits  { return b &^ flag }
func Toggle(b, flag Bits) Bits { return b ^ flag }
func Has(b, flag Bits) bool    { return b&flag != 0 }

func main() {
	var b Bits
	b = Set(b, F0)
	b = Toggle(b, F2)
	for i, flag := range []Bits{F0, F1, F2} {
		fmt.Println(i, Has(b, flag))
	}
}

0 true
1 false
2 true

Larger bitsets

To represent larger sets of bits, you may want to use a custom data structure. The package github.com/yourbasic/bit provides a bit array implementation and some utility bit functions.

Bitwise operators [cheat sheet]

Mon, 01 Jan 0001 00:00:00 +0000

Gottfried Wilhelm Leibniz, 1697

Number literals

The binary number 10000₂ can be written as 020, 16 or 0x10 in Go.

Literal	Base	Note
`020`	8	Starts with `0`
`16`	10	Never starts with `0`
`0x10`	16	Starts with `0x`

Built-in operators

Operation	Result	Description
`0011 & 0101`	0001	Bitwise AND
`0011 \| 0101`	0111	Bitwise OR
`0011 ^ 0101`	0110	Bitwise XOR
`^0101`	1010	Bitwise NOT (same as `1111 ^ 0101`)
`0011 &^ 0101`	0010	Bitclear (AND NOT)
`00110101<<2`	11010100	Left shift
`00110101<<100`	00000000	No upper limit on shift count
`00110101>>2`	00001101	Right shift

The binary numbers in the examples are for explanation only. Integer literals in Go must be specified in octal, decimal or hexadecimal.
The bitwise operators take both signed and unsigned integers as input. The right-hand side of a shift operator, however, must be an unsigned integer.
Shift operators implement arithmetic shifts if the left operand is a signed integer and logical shifts if it is an unsigned integer.

Package `math/bits`

Operation	Result	Description
`bits.UintSize`	32 or 64	Size of a uint in bits
`bits.OnesCount8(00101110)`	4	Number of one bits (population count)
`bits.Len8(00101110)`	6	Bits required to represent number
`bits.Len8(00000000)`	0
`bits.LeadingZeros8(00101110)`	2	Number of leading zero bits
`bits.LeadingZeros8(00000000)`	8
`bits.TrailingZeros8(00101110)`	1	Number of trailing zero bits
`bits.TrailingZeros8(00000000)`	8
`bits.RotateLeft8(00101110, 3)`	01110001	The value rotated left by 3 bits
`bits.RotateLeft8(00101110, -3)`	11000101	The value rotated right by 3 bits
`bits.Reverse8(00101110)`	01110100	Bits in reversed order
`bits.ReverseBytes16(0x00ff)`	`0xff00`	Bytes in reversed order

The functions operate on unsigned integers.
They come in different forms that take arguments of different sizes. For example, Len, Len8, Len16, Len32, and Len64 apply to the types uint, uint8, uint16, uint32, and uint64, respectively.
The functions are recognized by the compiler and on most architectures they are treated as intrinsics for additional performance.

Bit manipulation code example

Bitmasks, bitsets and flags shows how to implement a bitmask, a small set of booleans, often called flags, represented by the bits in a single number.

Blackjack card counting risk analysis: poor gains at huge risk

Mon, 01 Jan 0001 00:00:00 +0000

It’s possible to win at blackjack by counting cards, but most fail. The mean is positive, but the variance is mean.

Always optimal strategy

Always use an optimal strategy adapted to the rules of your casino. Here is an example blackjack strategy. Every time you deviate from the optimal strategy – because of hunches or fear – it depletes your funds.

Count cards

If you find a casino with good rules, and if you play with an optimal strategy, the odds are still against you – but the house edge can sometimes be as low as 0.5%.

Blank identifier (underscore)

Mon, 01 Jan 0001 00:00:00 +0000

The blank identifier _ is an anonymous placeholder. It may be used like any other identifier in a declaration, but it does not introduce a binding.

Ignore values

The blank identifier provides a way to ignore left-hand side values in an assignment.

_, present := timeZone["CET"]

sum := 0
for _, n := range a {
	sum += n
}

Import for side effects

It can also be used to import a package solely for its side effects.

Bloom filters explained

Mon, 01 Jan 0001 00:00:00 +0000

A Bloom filter is a probabilistic data structure used to test set membership.

Bloom filter basics

The Bloom filter data structure tells whether an element may be in a set, or definitely isn’t. The only possible errors are false positives: a search for a nonexistent element can give an incorrect answer. With more elements in the filter, the error rate increases.

Broadcast a signal on a channel

Mon, 01 Jan 0001 00:00:00 +0000

All readers receive zero values on a closed channel.

In this example the Publish function returns a channel, which is used to broadcast a signal when a message has been published.

// Print text after the given time has expired.
// When done, the wait channel is closed.
func Publish(text string, delay time.Duration) (wait <-chan struct{}) {
	ch := make(chan struct{})
	go func() {
		time.Sleep(delay)
		fmt.Println("BREAKING NEWS:", text)
		close(ch) // Broadcast to all receivers.
	}()
	return ch
}

Notice that we use a channel of empty structs: struct{}. This clearly indicates that the channel will only be used for signalling, not for passing data.

Can’t change entries in range loop

Mon, 01 Jan 0001 00:00:00 +0000

Why isn’t the slice updated in this example?

s := []int{1, 1, 1}
for _, n := range s {
	n += 1
}
fmt.Println(s)
// Output: [1 1 1]

Answer

The range loop copies the values from the slice to a local variable n; updating n will not affect the slice.

Update the slice entries like this:

s := []int{1, 1, 1}
for i := range s {
	s[i] += 1
}
fmt.Println(s)
// Output: [2 2 2]

See 4 basic range loop (for-each) patterns for all about range loops in Go.

Channels offer synchronized communication

Mon, 01 Jan 0001 00:00:00 +0000

A channel is a mechanism for goroutines to synchronize execution and communicate by passing values.

A new channel value can be made using the built-in function make.

// unbuffered channel of ints
ic := make(chan int)

// buffered channel with room for 10 strings
sc := make(chan string, 10)

To send a value on a channel, use <- as a binary operator. To receive a value on a channel, use it as a unary operator.

Check if a number is prime

Mon, 01 Jan 0001 00:00:00 +0000

Sacks spiral of prime numbers

Ints

For integer types, use ProbablyPrime(0) from package math/big. This primality test is 100% accurate for inputs less than 2⁶⁴.

const n = 1212121
if big.NewInt(n).ProbablyPrime(0) {
	fmt.Println(n, "is prime")
} else {
	fmt.Println(n, "is not prime")
}

1212121 is prime

Larger numbers

For larger numbers, you need to provide the desired number of tests to ProbablyPrime(n). For n tests, the probability of returning true for a randomly chosen non-prime is at most (1/4)ⁿ. A common choice is to use n = 20; this gives a false positive rate 0.000,000,000,001.

Command-line arguments and flags

Mon, 01 Jan 0001 00:00:00 +0000

The os.Args variable holds the command-line arguments – starting with the program name – which are passed to a Go program.

func main() {
	if len(os.Args) != 3 {
		fmt.Println("Usage:", os.Args[0], "PATTERN", "FILE")
		return
	}
	pattern := os.Args[1]
	file := os.Args[2]
	// ...
}

$ go build grep.go
$ ./grep
Usage: ./grep PATTERN FILE

Flag parsing

The flag package implements basic command-line flag parsing.

Compute absolute value of an int/float

Mon, 01 Jan 0001 00:00:00 +0000

Integers

There is no built-in abs function for integers, but it’s simple to write your own.

// Abs returns the absolute value of x.
func Abs(x int64) int64 {
	if x < 0 {
		return -x
	}
	return x
}

Warning: The smallest value of a signed integer doesn’t have a matching positive value.

math.MinInt64 is -9223372036854775808, but

math.MaxInt64 is 9223372036854775807.

Unfortunately, our Abs function returns a negative value in this case.

Compute max of two ints/floats

Mon, 01 Jan 0001 00:00:00 +0000

Integers

There is no built-in max or min function for integers, but it’s simple to write your own.

// Max returns the larger of x or y.
func Max(x, y int64) int64 {
	if x < y {
		return y
	}
	return x
}

// Min returns the smaller of x or y.
func Min(x, y int64) int64 {
	if x > y {
		return y
	}
	return x
}

Floats

For floats, use math.Max and math.Min.

Concurrent programming

Mon, 01 Jan 0001 00:00:00 +0000

This tutorial covers the fundamentals of concurrent programming with examples in Go.

Before you start, you need to know how to write basic Go programs. If you need a refresher, the resources in this Go beginner’s guide will help you come up to speed quickly with Go.

Let’s start

Constant overflows int

Mon, 01 Jan 0001 00:00:00 +0000

Why doesn’t this code compile?

const n = 9876543210 * 9876543210
fmt.Println(n)

../main.go:2:13: constant 97546105778997104100 overflows int

Answer

The untyped constant n must be converted to a type before it can be assigned to the interface{} parameter in the call to fmt.Println.

fmt.Println(a ...interface{})

When the type can’t be inferred from the context, an untyped constant is converted to a bool, int, float64, complex128, string or rune depending of the format of the constant.

Constructors deconstructed [best practice]

Mon, 01 Jan 0001 00:00:00 +0000

Go doesn't have explicit constructors. The idiomatic way to set up new data structures is to use proper zero values coupled with factory functions.

Zero value

Try to make the default zero value useful and document its behavior. Sometimes this is all that’s needed.

// A StopWatch is a simple clock utility.
// Its zero value is an idle clock with 0 total time.
type StopWatch struct {
	start   time.Time
	total   time.Duration
	running bool
}

var clock StopWatch // Ready to use, no initialization needed.

StopWatch takes advantage of the useful zero values of time.Time, time.Duration and bool.
In turn, users of StopWatch can benefit from its useful zero value.

Factory

If the zero value doesn’t suffice, use factory functions named NewFoo or just New.

Conversions [complete list]

Mon, 01 Jan 0001 00:00:00 +0000

Basics

The expression T(x) converts the value x to the type T.

x := 5.1
n := int(x) // convert float to int

The conversion rules are extensive but predictable:

all conversions between typed expressions must be explicitly stated,
illegal conversions are caught by the compiler.

Conversions to and from numbers and strings may change the representation and have a run-time cost. All other conversions only change the type but not the representation of x.

Convert between byte array/slice and string

Mon, 01 Jan 0001 00:00:00 +0000

Basics

When you convert between a string and a byte slice (array), you get a brand new slice that contains the same bytes as the string, and vice versa.

The conversion doesn’t change the data;
the only difference is that strings are immutable, while byte slices can be modified.

If you need to manipulate the characters (runes) of a string, you may want to convert the string to a rune slice instead. See Convert between rune array/slice and string.

Convert between float and string

Mon, 01 Jan 0001 00:00:00 +0000

     3.141592653589793238462643383279
   5028841971693993751058209749445923
  07816406286208998628034825342117067
  9821    48086         5132
 823      06647        09384
46        09550        58223
17        25359        4081
          2848         1117
          4502         8410
          2701         9385
         21105        55964
         46229        48954
         9303         81964
         4288         10975
        66593         34461
       284756         48233
       78678          31652        71
      2019091         456485       66
     9234603           48610454326648
    2133936            0726024914127
    3724587             00660631558
    817488               152092096

String to float

Use the strconv.ParseFloat function to parse a string as a floating-point number with the precision specified by bitSize: 32 for float32, or 64 for float64.

Convert between int, int64 and string

Mon, 01 Jan 0001 00:00:00 +0000

int/int64 to string

Use strconv.Itoa to convert an int to a decimal string.

s := strconv.Itoa(97) // s == "97"

Warning: In a plain conversion the value is interpreted as a Unicode code point, and the resulting string will contain the character represented by that code point, encoded in UTF-8.
s := string(97) // s == "a"

Use strconv.FormatInt to format an int64 in a given base.

Convert between rune array/slice and string

Mon, 01 Jan 0001 00:00:00 +0000

Convert string to runes

When you convert a string to a rune slice, you get a new slice that contains the Unicode code points (runes) of the string.
For an invalid UTF-8 sequence, the rune value will be 0xFFFD for each invalid byte.

r := []rune("ABC€")
fmt.Println(r)        // [65 66 67 8364]
fmt.Printf("%U\n", r) // [U+0041 U+0042 U+0043 U+20AC]

You can also use a range loop to access the code points of a string.

Convert interface to string

Mon, 01 Jan 0001 00:00:00 +0000

Use fmt.Sprintf to convert an interface value to a string.

var x interface{} = "abc"
str := fmt.Sprintf("%v", x)

In fact, the same technique can be used to get a string representation of any data structure.

var x interface{} = []int{1, 2, 3}
str := fmt.Sprintf("%v", x)
fmt.Println(str) // "[1 2 3]"

Fmt cheat sheet

Top fmt formatting tips

Convert string to int/int64

Mon, 01 Jan 0001 00:00:00 +0000

See Convert between int/int64 and string.

Create a new image

Mon, 01 Jan 0001 00:00:00 +0000

Use the image, image/color, and image/png packages to create a PNG image.

width := 200
height := 100

upLeft := image.Point{0, 0}
lowRight := image.Point{width, height}

img := image.NewRGBA(image.Rectangle{upLeft, lowRight})

// Colors are defined by Red, Green, Blue, Alpha uint8 values.
cyan := color.RGBA{100, 200, 200, 0xff}

// Set color for each pixel.
for x := 0; x < width; x++ {
	for y := 0; y < height; y++ {
		switch {
		case x < width/2 && y < height/2: // upper left quadrant
			img.Set(x, y, cyan)
		case x >= width/2 && y >= height/2: // lower right quadrant
			img.Set(x, y, color.White)
		default:
			// Use zero value.
		}
	}
}

// Encode as PNG.
f, _ := os.Create("image.png")
png.Encode(f, img)

Output (image.png):

Create a temporary file or directory

Mon, 01 Jan 0001 00:00:00 +0000

File

Use ioutil.TempFile in package io/ioutil to create a globally unique temporary file. It’s your own job to remove the file when it’s no longer needed.

file, err := ioutil.TempFile("dir", "prefix")
if err != nil {
	log.Fatal(err)
}
defer os.Remove(file.Name())

fmt.Println(file.Name()) // For example "dir/prefix054003078"

The call to ioutil.TempFile

creates a new file with a name starting with "prefix" in the directory "dir",
opens the file for reading and writing,
and returns the new *os.File.

To put the new file in os.TempDir(), the default directory for temporary files, call ioutil.TempFile with an empty directory string.

Create, initialize and compare structs

Mon, 01 Jan 0001 00:00:00 +0000

Struct types

A struct is a typed collection of fields, useful for grouping data into records.

type Student struct {
	Name string
	Age  int
}

var a Student    // a == Student{"", 0}
a.Name = "Alice" // a == Student{"Alice", 0}

To define a new struct type, you list the names and types of each field.
The default zero value of a struct has all its fields zeroed.
You can access individual fields with dot notation.

2 ways to create and initialize a new struct

The new keyword can be used to create a new struct. It returns a pointer to the newly created struct.

Data races explained

Mon, 01 Jan 0001 00:00:00 +0000

A data race happens when two goroutines access the same variable concurrently, and at least one of the accesses is a write.

Data races are quite common and can be very hard to debug.

This function has a data race and it’s behavior is undefined. It may, for example, print the number 1. Try to figure out how that can happen – one possible explanation comes after the code.

func race() {
	wait := make(chan struct{})
	n := 0
	go func() {
		n++ // read, increment, write
		close(wait)
	}()
	n++ // conflicting access
	<-wait
	fmt.Println(n) // Output: <unspecified>
}

The two goroutines, g1 and g2, participate in a race and there is no way to know in which order the operations will take place. The following is one out of many possible outcomes.

Days between two dates

Mon, 01 Jan 0001 00:00:00 +0000

func main() {
	// The leap year 2016 had 366 days.
	t1 := Date(2016, 1, 1)
	t2 := Date(2017, 1, 1)
	days := t2.Sub(t1).Hours() / 24
	fmt.Println(days) // 366
}

func Date(year, month, day int) time.Time {
	return time.Date(year, time.Month(month), day, 0, 0, 0, 0, time.UTC)
}

Days in a month

Mon, 01 Jan 0001 00:00:00 +0000

To compute the last day of a month, you can use the fact that time.Date accepts values outside their usual ranges – the values are normalized during the conversion.

To compute the number of days in February, look at the day before March 1.

func main() {
	t := Date(2000, 3, 0) // the day before 2000-03-01
	fmt.Println(t)        // 2000-02-29 00:00:00 +0000 UTC
	fmt.Println(t.Day())  // 29
}

func Date(year, month, day int) time.Time {
	return time.Date(year, time.Month(month), day, 0, 0, 0, 0, time.UTC)
}

AddDate normalizes its result in the same way. For example, adding one month to October 31 yields December 1, the normalized form of November 31.

Default zero values for all Go types

Mon, 01 Jan 0001 00:00:00 +0000

Variables declared without an initial value are set to their zero values:

0 for all integer types,
0.0 for floating point numbers,
false for booleans,
"" for strings,
nil for interfaces, slices, channels, maps, pointers and functions.

The elements of an array or struct will have its fields zeroed if no value is specified. This initialization is done recursively:

type T struct {
	n int
	f float64
	next *T
}
fmt.Println([2]T{}) // [{0 0 <nil>} {0 0 <nil>}]

Defer a function call (with return value)

Mon, 01 Jan 0001 00:00:00 +0000

Defer statement basics

A defer statement postpones the execution of a function until the surrounding function returns, either normally or through a panic.

func main() {
	defer fmt.Println("World")
	fmt.Println("Hello")
}

Hello
World

Deferred calls are executed even when the function panics:

Do you make these Go coding mistakes?

Mon, 01 Jan 0001 00:00:00 +0000

This collection of Go gotchas and pitfalls will help you find and fix similar problems in your own code.

Some of the puzzles are pretty easy. To solve all 27, you have to be a ninja.

Let’s start

Go Gotchas

Dynamic programming [step-by-step example]

Mon, 01 Jan 0001 00:00:00 +0000

This text contains a detailed example showing how to solve a tricky problem efficiently with recursion and dynamic programming – either with memoization or tabulation.

A dynamic programming algorithm solves a complex problem by dividing it into simpler subproblems, solving each of those just once, and storing their solutions.
Memoization is an optimization technique used to speed up programs by storing the results of expensive function calls and returning the cached result when the same inputs occur again.
Tabulation is an approach where you solve a dynamic programming problem by first filling up a table, and then compute the solution to the original problem based on the results in this table.

Problem

You’ve just got a tube of delicious chocolates and plan to eat one piece a day – either by picking the one on the left or the right.

Efficient string concatenation [full guide]

Mon, 01 Jan 0001 00:00:00 +0000

Clean and simple string building

For simple cases where performance is a non-issue, fmt.Sprintf is your friend. It’s clean, simple and fairly efficient.

s := fmt.Sprintf("Size: %d MB.", 85) // s == "Size: 85 MB."

The fmt cheat sheet lists the most common formatting verbs and flags.

High-performance string concatenationGo 1.10

A strings.Builder is used to efficiently append strings using write methods.

Enum with String function

Mon, 01 Jan 0001 00:00:00 +0000

See iota enum examples.

Error handling best practice

Mon, 01 Jan 0001 00:00:00 +0000

Go has two different error-handling mechanisms:

most functions return errors;
only a truly unrecoverable condition, such as an out-of-range index, produces a run-time exception, known as a panic.

Go’s multivalued return makes it easy to return a detailed error message alongside the normal return value. By convention, such messages have type error, a simple built-in interface:

type error interface {
    Error() string
}

Error handling example

The os.Open function returns a non-nil error value when it fails to open a file.

Escapes and multiline strings

Mon, 01 Jan 0001 00:00:00 +0000

Raw string literals

Raw string literals, delimited by backticks (back quotes), are interpreted literally. They can contain line breaks, and backslashes have no special meaning.

const s = `First line
Second line`
fmt.Println(s)

First line
Second line

Backtick escape

It’s not possible to include a backtick in a raw string literal, but you can do

Find current working directory

Mon, 01 Jan 0001 00:00:00 +0000

Current directory

Use os.Getwd to find the path name for the current directory.

path, err := os.Getwd()
if err != nil {
	log.Println(err)
}
fmt.Println(path)  // for example /home/user

Warning: If the current directory can be reached via multiple paths (due to symbolic links), Getwd may return any one of them.

Current executable

Use os.Executable to find the path name for the executable that started the current process.

Find element in slice/array with linear or binary search

Mon, 01 Jan 0001 00:00:00 +0000

Linear search

Go doesn’t have an out-of-the-box linear search function for slices and arrays. Here are two example linear search implementations, which you can use as templates.

// Find returns the smallest index i at which x == a[i],
// or len(a) if there is no such index.
func Find(a []string, x string) int {
	for i, n := range a {
		if x == n {
			return i
		}
	}
	return len(a)
}

// Contains tells whether a contains x.
func Contains(a []string, x string) bool {
	for _, n := range a {
		if x == n {
			return true
		}
	}
	return false
}

Binary search

Binary search is faster than linear search, but only works if your data is in order. It's a sortcut. – Dan Bentley

If the array is sorted, you can use a binary search instead. This will be much more efficient, since binary search runs in worst-case logarithmic time, making O(log n) comparisons, where n is the size of the slice.

Find the type of an object

Mon, 01 Jan 0001 00:00:00 +0000

Use fmt for a string type description

You can use the %T flag in the fmt package to get a Go-syntax representation of the type.

var x interface{} = []int{1, 2, 3}
xType := fmt.Sprintf("%T", x)
fmt.Println(xType) // "[]int"

(The empty interface denoted by interface{} can hold values of any type.)

A type switch lets you choose between types

Use a type switch to do several type assertions in series.

var x interface{} = 2.3
switch v := x.(type) {
case int:
	fmt.Println("int:", v)
case float64:
	fmt.Println("float64:", v)
default:
	fmt.Println("unknown")
}
// Output: float64: 2.3

Reflection gives full type information

Use the reflect package if the options above don’t suffice.

fmt.Printf formatting tutorial and cheat sheet

Mon, 01 Jan 0001 00:00:00 +0000

Basics

With the Go fmt package you can format numbers and strings padded with spaces or zeroes, in different bases, and with optional quotes.

Format a time or date [complete guide]

Mon, 01 Jan 0001 00:00:00 +0000

Basic example

Go doesn’t use yyyy-mm-dd layout to format a time. Instead, you format a special layout parameter

Mon Jan 2 15:04:05 MST 2006

the same way as the time or date should be formatted. (This date is easier to remember when written as 01/02 03:04:05PM ‘06 -0700.)

const (
	layoutISO = "2006-01-02"
	layoutUS  = "January 2, 2006"
)
date := "1999-12-31"
t, _ := time.Parse(layoutISO, date)
fmt.Println(t)                  // 1999-12-31 00:00:00 +0000 UTC
fmt.Println(t.Format(layoutUS)) // December 31, 1999

The function

Format byte size as kilobytes, megabytes, gigabytes, ...

Mon, 01 Jan 0001 00:00:00 +0000

These utility functions convert a size in bytes to a human-readable string in either SI (decimal) or IEC (binary) format.

Input	ByteCountSI	ByteCountIEC
999	`"999 B"`	`"999 B"`
1000	`"1.0 kB"`	`"1000 B"`
1023	`"1.0 kB"`	`"1023 B"`
1024	`"1.0 kB"`	`"1.0 KiB"`
987,654,321	`"987.7 MB"`	`"941.9 MiB"`
`math.MaxInt64`	`"9.2 EB"`	`"8.0 EiB"`

func ByteCountSI(b int64) string {
	const unit = 1000
	if b < unit {
		return fmt.Sprintf("%d B", b)
	}
	div, exp := int64(unit), 0
	for n := b / unit; n >= unit; n /= unit {
		div *= unit
		exp++
	}
	return fmt.Sprintf("%.1f %cB",
		float64(b)/float64(div), "kMGTPE"[exp])
}

func ByteCountIEC(b int64) string {
	const unit = 1024
	if b < unit {
		return fmt.Sprintf("%d B", b)
	}
	div, exp := int64(unit), 0
	for n := b / unit; n >= unit; n /= unit {
		div *= unit
		exp++
	}
	return fmt.Sprintf("%.1f %ciB",
		float64(b)/float64(div), "KMGTPE"[exp])
}

byte-count.go

Function types and values

Mon, 01 Jan 0001 00:00:00 +0000

Function types and function values can be used and passed around just like other values:

type Operator func(x float64) float64

// Map applies op to each element of a.
func Map(op Operator, a []float64) []float64 {
	res := make([]float64, len(a))
	for i, x := range a {
		res[i] = op(x)
	}
	return res
}

func main() {
	op := math.Abs
	a := []float64{1, -2}
	b := Map(op, a)
	fmt.Println(b) // [1 2]

	c := Map(func(x float64) float64 { return 10 * x }, b)
	fmt.Println(c) // [10, 20]
}

The second call to Map uses a function literal (or lambda). See Anonymous functions and closures for more about lambdas in Go.

Functional programming in Go [case study]

Mon, 01 Jan 0001 00:00:00 +0000

A graph implementation based entirely on functions

The Petersen graph and its complement

Introduction

This text is about the implementation of a Go tool based entirely on functions – the API contains only immutable data types, and the code is built on top of a struct with five func fields.

It’s a tool for building virtual graphs. In a virtual graph no vertices or edges are stored in memory, they are instead computed as needed. The tool is part of a larger library of generic graph algorithms:

Generate a random string (password)

Mon, 01 Jan 0001 00:00:00 +0000

Random string

This code generates a random string of numbers and characters from the Swedish alphabet (which includes the non-ASCII characters å, ä and ö).

rand.Seed(time.Now().UnixNano())
chars := []rune("ABCDEFGHIJKLMNOPQRSTUVWXYZÅÄÖ" +
	"abcdefghijklmnopqrstuvwxyzåäö" +
	"0123456789")
length := 8
var b strings.Builder
for i := 0; i < length; i++ {
	b.WriteRune(chars[rand.Intn(len(chars))])
}
str := b.String() // E.g. "ExcbsVQs"

Warning: To generate a password, you should use cryptographically secure pseudorandom numbers. See User-friendly access to crypto/rand.

Random string with restrictions

This code generates a random ASCII string with at least one digit and one special character.

Generate a unique string (UUID, GUID)

Mon, 01 Jan 0001 00:00:00 +0000

A universally unique identifier (UUID), or globally unique identifier (GUID), is a 128-bit number used to identify information.

A UUID is for practical purposes unique: the probability that it will be duplicated is very close to zero.
UUIDs don’t depend on a central authority or on coordination between those generating them.

The string representation of a UUID consists of 32 hexadecimal digits displayed in 5 groups separated by hyphens. For example:

Generate all permutations

Mon, 01 Jan 0001 00:00:00 +0000

// Perm calls f with each permutation of a.
func Perm(a []rune, f func([]rune)) {
	perm(a, f, 0)
}

// Permute the values at index i to len(a)-1.
func perm(a []rune, f func([]rune), i int) {
	if i > len(a) {
		f(a)
		return
	}
	perm(a, f, i+1)
	for j := i + 1; j < len(a); j++ {
		a[i], a[j] = a[j], a[i]
		perm(a, f, i+1)
		a[i], a[j] = a[j], a[i]
	}
}

Example usage:

Generate random numbers, characters and slice elements

Mon, 01 Jan 0001 00:00:00 +0000

Go pseudo-random number basics

Use the rand.Seed and rand.Int63 functions in package math/rand to generate a non-negative pseudo-random number of type int64:

rand.Seed(time.Now().UnixNano())
n := rand.Int63() // for example 4601851300195147788

Similarly, rand.Float64 generates a pseudo-random float x, where 0 ≤ x < 1:

Generics (alternatives and workarounds)

Mon, 01 Jan 0001 00:00:00 +0000

Go has some built-in generic data types, such as slices and maps, and some generic functions, such as append and copy. However, there is no mechanism for writing your own.

Here are some techniques that can be used in place of parametric polymorphism in Go.

Find a well-fitting interface

Describe the generic behaviour of your data with an interface.

The io.Reader interface, which represents the read end of a stream of data, is a good example:

Get slices of keys and values from a map

Mon, 01 Jan 0001 00:00:00 +0000

You can use a range statement to extract slices of keys and values from a map.

keys := make([]keyType, 0, len(myMap))
values := make([]valueType, 0, len(myMap))

for k, v := range myMap {
	keys = append(keys, k)
	values = append(values, v)
}

Get year, month, day from time

Mon, 01 Jan 0001 00:00:00 +0000

The Date function returns the year, month and day of a time.Time.

func (t Time) Date() (year int, month Month, day int)

In use:

year, month, day := time.Now().Date()
fmt.Println(year, month, day)      // For example 2009 November 10
fmt.Println(year, int(month), day) // For example 2009 11 10

You can also extract the information with seperate calls:

t := time.Now()
year := t.Year()   // type int
month := t.Month() // type time.Month
day := t.Day()     // type int

The time.Month type specifies a month of the year (January = 1, …).

Get your priorities right

Mon, 01 Jan 0001 00:00:00 +0000

Why doesn’t this code compute the number of hours and seconds?

n := 43210 // time in seconds
fmt.Println(n/60*60, "hours and", n%60*60, "seconds")

43200 hours and 600 seconds

Answer

The *, /, and % operators have the same precedence and are evaluated left to right: n/60*60 is the same as (n/60)*60.

Insert a pair of parantheses to force the correct evaluation order.

fmt.Println(n/(60*60), "hours and", n%(60*60), "seconds")

12 hours and 10 seconds

Or better yet, use a constant.

Go and Pythagoras

Mon, 01 Jan 0001 00:00:00 +0000

Pythagorean triples are integer solutions to the Pythagorean Theorem, a² + b² = c².

A well-known example is (3, 4, 5):

fmt.Println(3^2+4^2 == 5^2) // true

The triple (6, 8, 10) is another example, but Go doesn't seem to agree.

fmt.Println(6^2+8^2 == 10^2) // false

Answer

The circumflex ^ denotes bitwise XOR in Go. The computation written in base 2 looks like this:

0011 ^ 0010 == 0001   (3^2 == 1)
0100 ^ 0010 == 0110   (4^2 == 6)
0101 ^ 0010 == 0111   (5^2 == 7)

Of course, 1 + 6 == 7; Go and Pythagoras agree on that. See Bitwise operators cheat sheet for more about bitwise calculations in Go.

Go as a scripting language: lightweight, safe and fast

Mon, 01 Jan 0001 00:00:00 +0000

This example is a simplified version of the Unix grep command. The program searches the input file for lines containing the given pattern and prints these lines.

func main() {
	log.SetPrefix("grep: ")
	log.SetFlags(0) // no extra info in log messages

	if len(os.Args) != 3 {
		fmt.Printf("Usage: %v PATTERN FILE\n", os.Args[0])
		return
	}

	pattern, err := regexp.Compile(os.Args[1])
	if err != nil {
		log.Fatalln(err)
	}

	file, err := os.Open(os.Args[2])
	if err != nil {
		log.Fatalln(err)
	}
	defer file.Close()

	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		line := scanner.Text()
		if pattern.MatchString(line) {
			fmt.Println(line)
		}
	}
	if err := scanner.Err(); err != nil {
		log.Println(err)
	}
}

Go beginner’s guide: top 4 resources to get you started

Mon, 01 Jan 0001 00:00:00 +0000

Code in Go (try it out)

The Go Playground is an interactive web service that lets you run small Go programs, such as this “Hello, world!” program, inside a sandbox. Try it out!

package main

import "fmt"

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

Learn Go basics

A Tour of Go is an interactive tutorial with many example programs. It comes from the official golang site and teaches you the basics of Go programming directly in your browser. Try it out, it’s fun!

Go blueprints: code for common tasks

Mon, 01 Jan 0001 00:00:00 +0000

These code examples are intended to help you quickly solve some common everyday tasks in Go. There are also a few oddities that may be nice to have when writing more exotic code.

Go operator precedence spells MACAO

Mon, 01 Jan 0001 00:00:00 +0000

See Operators: complete list.

Go step by step

Mon, 01 Jan 0001 00:00:00 +0000

Detailed descriptions of core Go concepts

Go string handling overview [cheat sheet]

Mon, 01 Jan 0001 00:00:00 +0000

String literals (escape characters)

Expression	Result	Note
`""`		Default zero value for type `string`
`"Japan 日本"`	Japan 日本	Go code is Unicode text encoded in UTF‑8
`"\xe6\x97\xa5"`	日	`\xNN` specifies a byte
`"\u65E5"`	日	`\uNNNN` specifies a Unicode value
`"\\"`	\	Backslash
`"\""`	"	Double quote
`"\n"`		Newline
`"\t"`		Tab
`\xe6`	\xe6	Raw string literal*
`html.EscapeString("<>")`	<>	HTML escape for <, >, &, ' and "
`url.PathEscape("A B")`	A%20B	URL percent-encoding net/url

* In `` string literals, text is interpreted literally and backslashes have no special meaning. See Escapes and multiline strings for more on raw strings, escape characters and string encodings.

Go tutorials

Mon, 01 Jan 0001 00:00:00 +0000

Go vs. Java: 15 main differences

Mon, 01 Jan 0001 00:00:00 +0000

The following Java code, adapted from Effective Java, implements an immutable class representing a complex number.

public final class Complex {
    private final double re;
    private final double im;

    public Complex(double re, double im) {
        if (Double.isNaN(re) || Double.isNaN(im)) {
            throw new ArithmeticException();
        }
        this.re = re;
        this.im = im;
    }

    public double realPart()      { return re; }
    public double imaginaryPart() { return im; }

    public Complex add(Complex c) {
        return new Complex(re + c.re, im + c.im);
    }

    @Override public boolean equals(Object o) {
        if (o == this)
            return true;
        if (!(o instanceof Complex))
            return false;
        Complex c = (Complex) o;
        return Double.compare(re, c.re) == 0 &&
               Double.compare(im, c.im) == 0;
    }

    @Override public int hashCode() {
        int result = 17 + Double.hashCode(re);
        result = 31 * result + Double.hashCode(im);
        return result;
    }

    @Override public String toString() {
        return "(" + re + (im < 0 ? "" : "+") + im + "i)";
    }

    public static void main(String[] args) {
        Complex z = new Complex(1, 2);
        System.out.println(z.add(z));
    }
}

The same program written in idiomatic Go would consist of two separate packages.

Goroutines are lightweight threads

Mon, 01 Jan 0001 00:00:00 +0000

The go statement runs a function in a separate thread of execution.

You can start a new thread of execution, a goroutine, with the go statement. It runs a function in a different, newly created, goroutine. All goroutines in a single program share the same address space.

go list.Sort() // Run list.Sort in parallel; don’t wait for it.

The following program will print “Hello from main goroutine”. It might also print “Hello from another goroutine”, depending on which of the two goroutines finish first.

Hash checksums: MD5, SHA-1, SHA-256

Mon, 01 Jan 0001 00:00:00 +0000

String checksum

To compute the hash value of a string or byte slice, use the Sum function from a crypto package such as crypto/md5, crypto/sha1, or crypto/sha256.

s := "Foo"

md5 := md5.Sum([]byte(s))
sha1 := sha1.Sum([]byte(s))
sha256 := sha256.Sum256([]byte(s))

fmt.Printf("%x\n", md5)
fmt.Printf("%x\n", sha1)
fmt.Printf("%x\n", sha256)

1356c67d7ad1638d816bfb822dd2c25d
201a6b3053cc1422d2c3670b62616221d2290929
1cbec737f863e4922cee63cc2ebbfaafcd1cff8b790d8cfd2e6a5d550b648afa

File checksum

To compute the hash value of a file or other input stream:

create a new hash.Hash from a crypto package such as crypto/md5, crypto/sha1, or crypto/sha256,
add data by writing to its io.Writer function,
extract the checksum by calling its Sum function.

input := strings.NewReader("Foo")

hash := sha256.New()
if _, err := io.Copy(hash, input); err != nil {
	log.Fatal(err)
}
sum := hash.Sum(nil)

fmt.Printf("%x\n", sum)

1cbec737f863e4922cee63cc2ebbfaafcd1cff8b790d8cfd2e6a5d550b648afa

Hash tables explained [step-by-step example]

Mon, 01 Jan 0001 00:00:00 +0000

Basics

Hash tables are used to implement map and set data structures in most common programming languages. In C++ and Java they are part of the standard libraries, while Python and Go have builtin dictionaries and maps.

A hash table is an unordered collection of key-value pairs, where each key is unique.

Hello world HTTP server example

Mon, 01 Jan 0001 00:00:00 +0000

A basic web server

If you access the URL http://localhost:8080/world on a machine where the program below is running, you will be greeted by this page.

package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", HelloServer)
    http.ListenAndServe(":8080", nil)
}

func HelloServer(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, %s!", r.URL.Path[1:])
}

The call to http.HandleFunc tells the net.http package to handle all requests to the web root with the HelloServer function.
The call to http.ListenAndServe tells the server to listen on the TCP network address :8080. This function blocks until the program is terminated.
Writing to an http.ResponseWriter sends data to the HTTP client.
An http.Request is a data structure that represents a client HTTP request.
r.URL.Path is the path component of the requested URL. In this case, "/world" is the path component of "http://localhost:8080/world".

How does characters add up?

Mon, 01 Jan 0001 00:00:00 +0000

Why doesn’t these print statements give the same result?

fmt.Println("H" + "i")
fmt.Println('H' + 'i')

Hi
177

Answer

The rune literals 'H' and 'i' are integer values identifying Unicode code points: 'H' is 72 and 'i' is 105.

You can turn a code point into a string with a conversion.

fmt.Println(string(72) + string('i')) // "Hi"

You can also use the fmt.Sprintf function.

s := fmt.Sprintf("%c%c, world!", 72, 'i')
fmt.Println(s)// "Hi, world!"

This fmt cheat sheet lists the most common formatting verbs and flags.

How to analyze time complexity: Count your steps

Mon, 01 Jan 0001 00:00:00 +0000

Time complexity estimates the time to run an algorithm. It's calculated by counting elementary operations.

Example (iterative algorithm)

What’s the running time of the following algorithm?

// Compute the maximum element in the array a.
Algorithm max(a):
	max ← a[0]
	for i = 1 to len(a)-1
		if a[i] > max
			max ← a[i]
	return max

The answer depends on factors such as input, programming language and runtime, coding skill, compiler, operating system, and hardware.

How to append anything (element, slice or string) to a slice

Mon, 01 Jan 0001 00:00:00 +0000

Append function basics

With the built-in append function you can use a slice as a dynamic array. The function appends any number of elements to the end of a slice:

if there is enough capacity, the underlying array is reused;
if not, a new underlying array is allocated and the data is copied over.

Append returns the updated slice. Therefore you need to store the result of an append, often in the variable holding the slice itself:

How to avoid initializing memory [in theory]

Mon, 01 Jan 0001 00:00:00 +0000

Consider an algorithm that uses a large memory area. If the running time of the algorithm is smaller than the size of the memory, initializing the memory will take longer than running the algorithm. However, using a shrewd trick, it’s possible to refrain from initializing the memory.

This mysterious trick is used quite frequently in research articles, often without explanation and a reference to Exercise 2.12 in The Design and Analysis of Computer Algorithms by Aho, Hopcroft, and Ullman, 1974.

How to best clear a slice: empty vs. nil

Mon, 01 Jan 0001 00:00:00 +0000

Remove all elements

To remove all elements, simply set the slice to nil.

a := []string{"A", "B", "C", "D", "E"}
a = nil
fmt.Println(a, len(a), cap(a)) // [] 0 0

This will release the underlying array to the garbage collector (assuming there are no other references).

Keep allocated memory

To keep the underlying array, slice the slice to zero length.

How to best implement an iterator

Mon, 01 Jan 0001 00:00:00 +0000

Go has a built-in range loop for iterating over slices, arrays, strings, maps and channels. See 4 basic range loop (for-each) patterns.

To iterate over other types of data, an iterator function with callbacks is a clean and fairly efficient abstraction.

Basic iterator pattern

// Iterate calls the f function with n = 1, 2, and 3.
func Iterate(f func(n int)) {
	for i := 1; i <= 3; i++ {
		f(i)
	}
}

In use:

How to debug deadlocks

Mon, 01 Jan 0001 00:00:00 +0000

A deadlock happens when a group of goroutines are waiting for each other and none of them is able to proceed.

Take a look at this simple example.

func main() {
	ch := make(chan int)
	ch <- 1
	fmt.Println(<-ch)
}

The program will get stuck on the channel send operation waiting forever for someone to read the value. Go is able to detect situations like this at runtime. Here is the output from our program:

How to detect data races

Mon, 01 Jan 0001 00:00:00 +0000

Data races can happen easily and are hard to debug. Luckily, the Go runtime is often able to help.

Use -race to enable the built-in data race detector.

$ go test -race [packages]
$ go run -race [packages]

Example

Here’s a program with a data race:

package main
import "fmt"

func main() {
	i := 0
	go func() {
		i++ // write
	}()
	fmt.Println(i) // concurrent read
}

Running this program with the -race options tells us that there’s a race between the write at line 7 and the read at line 9:

How to disable logging

Mon, 01 Jan 0001 00:00:00 +0000

See Write log to file (or /dev/null).

How to find the day of week

Mon, 01 Jan 0001 00:00:00 +0000

The Weekday function returns returns the day of the week of a time.Time.

func (t Time) Weekday() Weekday

In use:

weekday := time.Now().Weekday()
fmt.Println(weekday)      // "Tuesday"
fmt.Println(int(weekday)) // "2"

Type Weekday

The time.Weekday type specifies a day of the week (Sunday = 0, …).

type Weekday int

const (
	Sunday Weekday = iota
	Monday
	Tuesday
	Wednesday
	Thursday
	Friday
	Saturday
)

How to get current timestamp

Mon, 01 Jan 0001 00:00:00 +0000

Use time.Now and one of time.Unix or time.UnixNano to get a timestamp.

now := time.Now()      // current local time
sec := now.Unix()      // number of seconds since January 1, 1970 UTC
nsec := now.UnixNano() // number of nanoseconds since January 1, 1970 UTC

fmt.Println(now)  // time.Time
fmt.Println(sec)  // int64
fmt.Println(nsec) // int64

2009-11-10 23:00:00 +0000 UTC m=+0.000000000
1257894000
1257894000000000000

How to kill a goroutine

Mon, 01 Jan 0001 00:00:00 +0000

One goroutine can't forcibly stop another.

To make a goroutine stoppable, let it listen for a stop signal on a dedicated quit channel, and check this channel at suitable points in your goroutine.

quit := make(chan bool)
go func() {
	for {
		select {
		case <-quit:
			return
		default:
			// …
		}
	}
}()
// …
quit <- true

Here is a more complete example, where we use a single channel for both data and signalling.

How to reverse a string by byte or rune

Mon, 01 Jan 0001 00:00:00 +0000

Byte by byte

It’s pretty straightforward to reverse a string one byte at a time.

// Reverse returns a string with the bytes of s in reverse order.
func Reverse(s string) string {
	var b strings.Builder
	b.Grow(len(s))
	for i := len(s) - 1; i >= 0; i-- {
		b.WriteByte(s[i])
	}
	return b.String()
}

Rune by rune

To reverse a string by UTF-8 encoded characters is a bit trickier.

How to use JSON with Go [best practices]

Mon, 01 Jan 0001 00:00:00 +0000

The JSON data-interchange format is easy for humans to read and write, and efficient for machines to parse and generate.

Default types

The default Go types for decoding and encoding JSON are

bool for JSON booleans,
float64 for JSON numbers,
string for JSON strings, and
nil for JSON null.

Additionally, time.Time and the numeric types in the math/big package can be automatically encoded as JSON strings.

How to use the copy function

Mon, 01 Jan 0001 00:00:00 +0000

The built-in copy function copies elements into a destination slice dst from a source slice src.

func copy(dst, src []Type) int

It returns the number of elements copied, which will be the minimum of len(dst) and len(src). The result does not depend on whether the arguments overlap.

As a special case, it’s legal to copy bytes from a string to a slice of bytes.

copy(dst []byte, src string) int

Examples

Copy from one slice to another

var s = make([]int, 3)
n := copy(s, []int{0, 1, 2, 3}) // n == 3, s == []int{0, 1, 2}

Copy from a slice to itself

s := []int{0, 1, 2}
n := copy(s, s[1:]) // n == 2, s == []int{1, 2, 2}

Copy from a string to a byte slice (special case)

var b = make([]byte, 5)
copy(b, "Hello, world!") // b == []byte("Hello")

How to use the io.Reader interface

Mon, 01 Jan 0001 00:00:00 +0000

Basics

The io.Reader interface represents an entity from which you can read a stream of bytes.

type Reader interface {
        Read(buf []byte) (n int, err error)
}

Read reads up to len(buf) bytes into buf and returns the number of bytes read – it returns an io.EOF error when the stream ends.

The standard library provides numerous Reader implementations (including in-memory byte buffers, files and network connections), and Readers are accepted as input by many utilities (including the HTTP client and server implementations).

How to use the io.Writer interface

Mon, 01 Jan 0001 00:00:00 +0000

Basics

The io.Writer interface represents an entity to which you can write a stream of bytes.

type Writer interface {
        Write(p []byte) (n int, err error)
}

Write writes up to len(p) bytes from p to the underlying data stream – it returns the number of bytes written and any error encountered that caused the write to stop early.

Immutable strings

Mon, 01 Jan 0001 00:00:00 +0000

Why doesn’t this code compile?

s := "hello"
s[0] = 'H'
fmt.Println(s)

../main.go:3:7: cannot assign to s[0]

Answer

Go strings are immutable and behave like read-only byte slices (with a few extra properties).

To update the data, use a rune slice instead.

buf := []rune("hello")
buf[0] = 'H'
s := string(buf)
fmt.Println(s)  // "Hello"

If the string only contains ASCII characters, you could also use a byte slice.

Index out of range

Mon, 01 Jan 0001 00:00:00 +0000

Why does this program crash?

a := []int{1, 2, 3}
for i := 1; i <= len(a); i++ {
	fmt.Println(a[i])
}

panic: runtime error: index out of range

goroutine 1 [running]:
main.main()
	../main.go:3 +0xe0

Answer

In the last iteration, i equals len(a) which is outside the bounds of a.

Arrays, slices and strings are indexed starting from zero so the values of a are found at a[0], a[1], a[2], …, a[len(a)-1].

Insertion sort vs. selection sort (time complexity and performance)

Mon, 01 Jan 0001 00:00:00 +0000

Insertion sort

Insertion sort is a simple sorting algorithm with quadratic worst-case time complexity, but in some cases it’s still the algorithm of choice.

It’s efficient for small data sets. It typically outperforms other simple quadratic algorithms, such as selection sort or bubble sort.
It’s adaptive: it sorts data sets that are already substantially sorted efficiently. The time complexity is O(nk) when each element is at most k places away from its sorted position.
It’s stable: it doesn’t change the order of elements with equal keys.
It’s in-place: it only requires a constant amount of additional memory.
It has good branch prediction characteristics, typically limited to a single misprediction per key.

// InsertionSort sorts the elements of a in ascending order.
func InsertionSort(a []int) {
	for j := 1; j < len(a); j++ {
		// Invariant: a[:j] contains the same elements as
		// the original slice a[:j], but in sorted order.
		key := a[j]
		i := j - 1
		for i >= 0 && a[i] > key {
			a[i+1] = a[i]
			i--
		}
		a[i+1] = key
	}
}

Selection sort

In practice, selection sort generally performs worse than insertion sort.

Introduction to graph algorithms: definitions and examples

Mon, 01 Jan 0001 00:00:00 +0000

Search algorithms

This text introduces basic graph terminology, standard graph data structures, and three fundamental algorithms for traversing a graph in a systematic way.

Invalid memory address or nil pointer dereference

Mon, 01 Jan 0001 00:00:00 +0000

Why does this program panic?

type Point struct {
	X, Y float64
}

func (p *Point) Abs() float64 {
	return math.Sqrt(p.X*p.X + p.Y*p.Y)
}

func main() {
	var p *Point
	fmt.Println(p.Abs())
}

panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0xffffffff addr=0x0 pc=0xd2c5a]

goroutine 1 [running]:
main.(*Point).Abs(...)
	../main.go:6
main.main()
	../main.go:11 +0x1a

Answer

The uninitialized pointer p in the main function is nil, and you can’t follow the nil pointer.

Is "three" a digit?

Mon, 01 Jan 0001 00:00:00 +0000

Why does the regular expression [0-9]*, which is supposed to match a string with zero or more digits, match a string with characters in it?

matched, err := regexp.MatchString(`[0-9]*`, "12three45")
fmt.Println(matched) // true
fmt.Println(err)     // nil (regexp is valid)

Answer

The function regexp.MatchString (as well as most functions in the regexp package) does substring matching.

To check if a full string matches [0-9]*, anchor the start and the end of the regular expression:

Iteration variable doesn’t see change in range loop

Mon, 01 Jan 0001 00:00:00 +0000

Why doesn’t the iteration variable x notice that a[1] has been updated?

var a [2]int
for _, x := range a {
	fmt.Println("x =", x)
	a[1] = 8
}
fmt.Println("a =", a)

x = 0
x = 0        <- Why isn't this 8?
a = [0 8]

Answer

The range expression a is evaluated once before beginning the loop and a copy of the array is used to generate the iteration values.

Iteration variables and closures

Mon, 01 Jan 0001 00:00:00 +0000

Why does this program

func main() {
	var wg sync.WaitGroup
	wg.Add(5)
	for i := 0; i < 5; i++ {
		go func() {
			fmt.Print(i)
			wg.Done()
		}()
	}
	wg.Wait()
	fmt.Println()
}

(A WaitGroup waits for a collection of goroutines to finish.)

Answer

There is a data race: the variable i is shared by six (6) goroutines.

A data race occurs when two goroutines access the same variable concurrently and at least one of the accesses is a write.

Java to Go in-depth tutorial

Mon, 01 Jan 0001 00:00:00 +0000

This tutorial is intended to help Java developers come up to speed quickly with Go.

Hello stack (example)

Let’s start with a small but complete example. It shows how to implement and use a simple abstract data type in Go.

Las Vegas vs. Monte Carlo algorithms

Mon, 01 Jan 0001 00:00:00 +0000

Zener cards

A Las Vegas algorithm is a randomized algorithm that always gives the correct result but gambles with resources.

Monte Carlo simulations are a broad class of algorithms that use repeated random sampling to obtain numerical results.

Monte Carlo simulations are typically used to simulate the behaviour of other systems.
Monte Carlo algorithms, on the other hand, are randomized algorithms whose output may be incorrect with a certain, typically small, probability.

Random point in circle (Las Vegas)

It’s easy and convenient to compute a random point in a circle with a Las Vegas algorithm.

Last item in a slice/array

Mon, 01 Jan 0001 00:00:00 +0000

Read last element

Use the index len(a)-1 to access the last element of a slice or array a.

a := []string{"A", "B", "C"}
s := a[len(a)-1] // C

Go doesn't have negative indexing like Python does. This is a deliberate design decision — keeping the language simple can help save you from subtle bugs.

Remove last element

a = a[:len(a)-1] // [A B]

Watch out for memory leaks

Warning: If the slice is permanent and the element temporary, you may want to remove the reference to the element before slicing it off.
a[len(a)-1] = "" // Erase element (write zero value)
a = a[:len(a)-1] // [A B]

Learn to love your compiler

Mon, 01 Jan 0001 00:00:00 +0000

The Go compiler sometimes confuses and annoys developers who are new to the language.

This is a list of short articles with strategies and workarounds for common compiler error messages that tend to confuse fresh Go programmers.

imported and not used
Programs with unused imports won't compile.
declared and not used
You must use all local variables.
multiple-value in single-value context
When a function returns multiple values, you must use all of them.
syntax error: unexpected newline, expecting comma or }
In a multi-line slice, array or map literal, every line must end with a comma.
cannot assign to …
Go strings are immutable and behave like read-only byte slices.
constant overflows int
An untyped constant is converted before it is assigned to a variable.
syntax error: unexpected ++, expecting expression comma or )
Increment and decrement operations can’t be used as expressions, only as statements.
syntax error: non-declaration statement outside function body
Short variable declarations can only be used inside functions.
missing function body for …
An opening brace cannot appear on a line by itself.

List all files (recursively) in a directory

Mon, 01 Jan 0001 00:00:00 +0000

Directory listing

Use the ioutil.ReadDir function in package io/ioutil. It returns a sorted slice containing elements of type os.FileInfo.

The code in this example prints a sorted list of all file names in the current directory.

files, err := ioutil.ReadDir(".")
if err != nil {
	log.Fatal(err)
}
for _, f := range files {
	fmt.Println(f.Name())
}

Example output:

dev
etc
tmp
usr

Visit all files and folders in a directory tree

Use the filepath.Walk function in package path/filepath.

Loop invariants can give you coding superpowers

Mon, 01 Jan 0001 00:00:00 +0000

An invariant is a statement about program variables that is true every time the execution of the program reaches the invariant.

When struggling with a tricky 3-way partition algorithm as a student, a friend suggested a well-fitting invariant. It was like getting a secret superpower: suddenly I could write code that used to be impossible.

Make slices, maps and channels

Mon, 01 Jan 0001 00:00:00 +0000

Slices, maps and channels can be created with the built-in make function. The memory is initialized with zero values.

Call	Type	Description
`make(T, n)`	slice	slice of type T with length n
`make(T, n, c)`		capacity c
`make(T)`	map	map of type T
`make(T, n)`		initial room for approximately n elements
`make(T)`	channel	unbuffered channel of type T
`make(T, n)`		buffered channel with buffer size n

s := make([]int, 10, 100)      // slice with len(s) == 10, cap(s) == 100
m := make(map[string]int, 100) // map with initial room for ~100 elements
c := make(chan int, 10)        // channel with a buffer size of 10

Slices, arrays and maps can also be created with composite literals.

Maps explained: create, add, get, delete

Mon, 01 Jan 0001 00:00:00 +0000

Go maps are implemented by hash tables and have efficient add, get and delete operations.

Create a new map

var m map[string]int                // nil map of string-int pairs

m1 := make(map[string]float64)      // Empty map of string-float64 pairs
m2 := make(map[string]float64, 100) // Preallocate room for 100 entries

m3 := map[string]float64{           // Map literal
    "e":  2.71828,
    "pi": 3.1416,
}
fmt.Println(len(m3))                // Size of map: 2

A map (or dictionary) is an unordered collection of key-value pairs, where each key is unique.
You create a new map with a make statement or a map literal.
The default zero value of a map is nil. A nil map is equivalent to an empty map except that elements can’t be added.
The len function returns the size of a map, which is the number of key-value pairs.

Warning: If you try to add an element to an uninitialized map you get the mysterious run-time error Assignment to entry in nil map.

Add, update, get and delete keys/values

m := make(map[string]float64)

m["pi"] = 3.14             // Add a new key-value pair
m["pi"] = 3.1416           // Update value
fmt.Println(m)             // Print map: "map[pi:3.1416]"

v := m["pi"]               // Get value: v == 3.1416
v = m["pie"]               // Not found: v == 0 (zero value)

_, found := m["pi"]        // found == true
_, found = m["pie"]        // found == false

if x, found := m["pi"]; found {
	fmt.Println(x)
}                           // Prints "3.1416"

delete(m, "pi")             // Delete a key-value pair
fmt.Println(m)              // Print map: "map[]"

When you index a map you get two return values; the second one (which is optional) is a boolean that indicates if the key exists.
If the key doesn’t exist, the first value will be the default zero value.

For-each range loop

m := map[string]float64{
	"pi": 3.1416,
	"e":  2.71828,
}
fmt.Println(m) // "map[e:2.71828 pi:3.1416]"

for key, value := range m { // Order not specified 
	fmt.Println(key, value)
}

Iteration order is not specified and may vary from iteration to iteration.
If an entry that has not yet been reached is removed during iteration, the corresponding iteration value will not be produced.
If an entry is created during iteration, that entry may or may not be produced during the iteration.

Starting with Go 1.12, the fmt package prints maps in key-sorted order to ease testing.

Maximum value of an int

Mon, 01 Jan 0001 00:00:00 +0000

Go has two predeclared integer types with implementation-specific sizes:

a uint (unsigned integer) has either 32 or 64 bits,
an int (signed integer) has the same size as a uint.

This code computes the limit values as untyped constants.

const UintSize = 32 << (^uint(0) >> 32 & 1) // 32 or 64

const (
	MaxInt  = 1<<(UintSize-1) - 1 // 1<<31 - 1 or 1<<63 - 1
	MinInt  = -MaxInt - 1         // -1 << 31 or -1 << 63
	MaxUint = 1<<UintSize - 1     // 1<<32 - 1 or 1<<64 - 1
)

The UintSize constant is also available in package math/bits.

Measure execution time

Mon, 01 Jan 0001 00:00:00 +0000

Measure a piece of code

start := time.Now()
// Code to measure
duration := time.Since(start)

// Formatted string, such as "2h3m0.5s" or "4.503μs"
fmt.Println(duration)

// Nanoseconds as int64
fmt.Println(duration.Nanoseconds())

Measure a function call

You can track the execution time of a complete function call with this one-liner, which logs the result to the standard error stream.

func foo() {
	defer duration(track("foo"))
	// Code to measure
}

func track(msg string) (string, time.Time) {
	return msg, time.Now()
}

func duration(msg string, start time.Time) {
	log.Printf("%v: %v\n", msg, time.Since(start))
}

Benchmarks

The testing package has support for benchmarking that can be used to examine the performance of your code.

Methods explained

Mon, 01 Jan 0001 00:00:00 +0000

Go doesn't have classes, but you can define methods on types.

You can define methods on any type declared in a type definition.

A method is a function with an extra receiver argument.
The receiver sits between the func keyword and the method name.

In this example, the HasGarage method is associated with the House type. The method receiver is called p.

type House struct {
	garage bool
}

func (p *House) HasGarage() bool { return p.garage }

func main() {
	house := new(House)
	fmt.Println(house.HasGarage()) // Prints "false" (zero value)
}

Conversions and methods

If you convert a value to a different type, the new value will have the methods of the new type, but not the old.

Missing function body

Mon, 01 Jan 0001 00:00:00 +0000

As you may have noticed, programs with an opening brace on separate line do not compile.

func main()
{
	fmt.Println("Hello")
}

../main.go:1:6: missing function body for "main"
../main.go:2:1: syntax error: unexpected semicolon or newline before {

You must write:

func main() {
	fmt.Println("Hello")
}

This is a trade-off in the design of the Go language.

Some have argued that the lexer should do lookahead to permit the brace to live on the next line. We disagree. Since Go code is meant to be formatted automatically by gofmt, some style must be chosen. […] The advantages of a single, programmatically mandated format for all Go programs greatly outweigh any perceived disadvantages of the particular style. Go FAQ: Why are there braces but no semicolons? And why can’t I put the opening brace on the next line?

Multiple-value in single-value context

Mon, 01 Jan 0001 00:00:00 +0000

Why does this code give a compile error?

t := time.Parse(time.RFC3339, "2018-04-06T10:49:05Z")
fmt.Println(t)

../main.go:9:17: multiple-value time.Parse() in single-value context

Answer

The time.Parse function returns two values, a time.Time and an error, and you must use both.

t, err := time.Parse(time.RFC3339, "2018-04-06T10:49:05Z")
if err != nil {
	// TODO: Handle error.
}
fmt.Println(t)

2018-04-06 10:49:05 +0000 UTC

Blank identifier (underscore)

You can use the blank identifier to ignore unwanted return values.

m := map[string]float64{"pi": 3.1416}
_, exists := m["pi"] // exists == true

Mutual exclusion lock (mutex)

Mon, 01 Jan 0001 00:00:00 +0000

Mutexes let you synchronize data access by explicit locking, without channels.

Sometimes it’s more convenient to synchronize data access by explicit locking instead of using channels. The Go standard library offers a mutual exclusion lock, sync.Mutex, for this purpose.

Use with caution

For this type of locking to be safe, it’s crucial that all accesses to the shared data, both reads and writes, are performed only when a goroutine holds the lock. One mistake by a single goroutine is enough to introduce a data race and break the program.

Named return values [best practice]

Mon, 01 Jan 0001 00:00:00 +0000

In Go return parameters may be named and used as regular variables. When the function returns, they are used as return values.

func f() (i int, s string) {
	i = 17
	s = "abc"
	return // same as return i, s
}

Named return parameters are initialized to their zero values.

The names are not mandatory but can make for good documentation. Correctly used, named return parameters can also help clarify and clean up the code.

Nil is not nil

Mon, 01 Jan 0001 00:00:00 +0000

Why is nil not equal to nil in this example?

func Foo() error {
	var err *os.PathError = nil
	// …
	return err
}

func main() {
	err := Foo()
	fmt.Println(err)        // <nil>
	fmt.Println(err == nil) // false
}

Answer

An interface value is equal to nil only if both its value and dynamic type are nil. In the example above, Foo() returns [nil, *os.PathError] and we compare it with [nil, nil].

No end in sight

Mon, 01 Jan 0001 00:00:00 +0000

Why does this loop run forever?

var b byte
for b = 250; b <= 255; b++ {
	fmt.Printf("%d %c\n", b, b)
}

Answer

After the b == 255 iteration, b++ is executed. This overflows (since the maximum value for a byte is 255) and results in b == 0. Therefore b <= 255 still holds and the loop restarts from 0.

For unsigned integer values, the operations +, -, *, and << are computed modulo 2ⁿ, where n is the bit width of the unsigned integer type.

No JSON in sight

Mon, 01 Jan 0001 00:00:00 +0000

Why does json.Marshal produce empty structs in the JSON text output?

type Person struct {
	name string
	age  int
}

p := Person{"Alice", 22}
jsonData, _ := json.Marshal(p)
fmt.Println(string(jsonData))

{}

Answer

Only exported fields of a Go struct will be present in the JSON output.

type Person struct {
	Name string // Changed to capital N
	Age  int    // Changed to capital A
}

p := Person{"Alice", 22}

jsonData, _ := json.Marshal(p)
fmt.Println(string(jsonData))

{"Name":"Alice","Age":22}

You can specify the JSON field name explicitly with a json: tag.

Non-declaration statement outside function body

Mon, 01 Jan 0001 00:00:00 +0000

As you may have noticed, a program with short variable declarations outside a function doesn’t compile.

package main

n := 1 // illegal

func main() {}

../main.go:3:1: syntax error: non-declaration statement outside function body

Short variable declarations can only be used inside functions. You have to write

package main

var n = 1

func main() {}

This is a trade-off in the design of the Go language.

Numbers that start with zero

Mon, 01 Jan 0001 00:00:00 +0000

What’s up with the counting in this example?

const (
	Century = 100
	Decade  = 010
	Year    = 001
)
// The world's oldest person, Emma Morano, lived for a century,
// two decades and two years.
fmt.Println("She was", Century+2*Decade+2*Year, "years old.")

She was 118 years old.

Answer

010 is a number in base 8, therefore it means 8, not 10.

Integer literals in Go are specified in octal, decimal or hexadecimal. The number 16 can be written as 020, 16 or 0x10.

O(n log log n) time integer sorting

Mon, 01 Jan 0001 00:00:00 +0000

The fastest sorting algorithm?

Which sorting algorithm is the fastest? Ask this question to any group of programmers and you’ll get an animated discussion. Of course, there is no one answer. It depends not only on the algorithm, but also on the computer, data, and implementation. However, if you count the number of operations needed to sort integer numbers on a standard von Neumann computer, there is a clear winner – the algorithm presented in the paper “Sorting In Linear Time?” by A. Andersson, T. Hagerup, S. Nilsson, and R. Raman (Proceedings of the 27th Annual ACM Symposium on the Theory of Computing, 1995). It sorts n integers in time proportional to n log log n. In this article, I’ll give you a complete description of this algorithm.

Object-oriented programming without inheritance

Mon, 01 Jan 0001 00:00:00 +0000

Go doesn’t have inheritance – instead composition, embedding and interfaces support code reuse and polymorphism.

Object-oriented programming with inheritance

Inheritance in traditional object-oriented languages offers three features in one. When a Dog inherits from an Animal

the Dog class reuses code from the Animal class,
a variable x of type Animal can refer to either a Dog or an Animal,
x.Eat() will choose an Eat method based on what type of object x refers to.

In object-oriented lingo, these features are known as code reuse, polymorphism and dynamic dispatch.

On induction and recursive functions, with an application to binary search

Mon, 01 Jan 0001 00:00:00 +0000

To make sense of recursive functions, you can use a way of thinking closely related to mathematical induction.

Mathematical induction

Mathematical induction is a proof method often used to prove statements about integers.

We’ll use the notation P(n), where n ≥ 0, to denote such a statement. To prove P(n) with induction is a two-step procedure.

Operators: complete list

Mon, 01 Jan 0001 00:00:00 +0000

Arithmetic

Operator	Name	Types
`+`	sum	integers, floats, complex values, strings
`-`	difference	integers, floats, complex values
`*`	product
`/`	quotient
`%`	remainder	integers
`&`	bitwise AND
`\|`	bitwise OR
`^`	bitwise XOR
`&^`	bit clear (AND NOT)
`<<`	left shift	integer << unsigned integer
`>>`	right shift	integer >> unsigned integer

See Arithmetic operators in the Go language specification for complete definitions of the shift, quotient and remainder operators, integer overflow, and floating point behavior.

Optional parameters, default parameter values and method overloading

Mon, 01 Jan 0001 00:00:00 +0000

By design, Go does not support

optional parameters,
default parameter values,
or method overloading.

Method dispatch is simplified if it doesn’t need to do type matching as well. Experience with other languages told us that having a variety of methods with the same name but different signatures was occasionally useful but that it could also be confusing and fragile in practice. Matching only by name and requiring consistency in the types was a major simplifying decision in Go’s type system. Go FAQ: Why does Go not support overloading of methods and operators?

Package documentation

Mon, 01 Jan 0001 00:00:00 +0000

godoc.org website

The GoDoc website hosts documentation for all public Go packages on Bitbucket, GitHub, Google Project Hosting and Launchpad.

Local godoc server

The godoc command extracts and generates documentation for all locally installed Go programs, both your own code and the standard libraries.

The following command starts a web server that presents the documentation at http://localhost:6060/.

Package initialization and program execution order

Mon, 01 Jan 0001 00:00:00 +0000

Basics

First the main package is initialized.
- Imported packages are initialized before the package itself.
- Packages are initialized one at a time:
  - first package-level variables are initialized in declaration order,
  - then the init functions are run.
Finally the main function is called.

Program execution

Program execution begins by initializing the main package and then calling the function main. When main returns, the program exits. It does not wait for other goroutines to complete.

Packages explained: declare, import, download, document

Mon, 01 Jan 0001 00:00:00 +0000

Basics

Every Go program is made up of packages and each package has an import path:

"fmt"
"math/rand"
"github.com/yourbasic/graph"

Packages in the standard library have short import paths, such as "fmt" and "math/rand". Third-party packages, such as "github.com/yourbasic/graph", typically have an import path that includes a hosting service (github.com) and an organization name (yourbasic).

Panics, stack traces and how to recover [best practice]

Mon, 01 Jan 0001 00:00:00 +0000

A panic is an exception in Go

Panics are similar to C++ and Java exceptions, but are only intended for run-time errors, such as following a nil pointer or attempting to index an array out of bounds. To signify events such as end-of-file, Go programs use the built-in error type. See Error handling best practice and 3 simple ways to create an error for more on errors.

Pass a slice to a variadic function

Mon, 01 Jan 0001 00:00:00 +0000

See Variadic functions (…T).

Pick the right one: int vs. int64

Mon, 01 Jan 0001 00:00:00 +0000

Use int for indexing

An index, length or capacity should normally be an int. The int type is either 32 or 64 bits, and always big enough to hold the maximum possible length of an array.

See Maximum value of an int for code to compute the maximum value of an int.

Use int64 and friends for data

The types int8, int16, int32, and int64 (and their unsigned counterparts) are best suited for data. An int64 is the typical choice when memory isn’t an issue.

Pointer vs. value receiver

Mon, 01 Jan 0001 00:00:00 +0000

Basic guidelines

For a given type, don’t mix value and pointer receivers.
If in doubt, use pointer receivers (they are safe and extendable).

Pointer receivers

You must use pointer receivers

if any method needs to mutate the receiver,
for structs that contain a sync.Mutex or similar synchronizing field (they musn’t be copied).

You probably want to use pointer receivers

for large structs or arrays (it can be more efficient),
in all other cases.

Value receivers

You probably want to use value receivers

Pointers explained

Mon, 01 Jan 0001 00:00:00 +0000

A pointer is a variable that contains the address of an object.

Basics

Structs and arrays are copied when used in assignments and passed as arguments to functions. With pointers this can be avoided.

Pointers store addresses of objects. The addresses can be passed around more efficiently than the actual objects.

A pointer has type *T. The keyword new allocates a new object and returns its address.

Print null in Java

Mon, 01 Jan 0001 00:00:00 +0000

What happens if you try to print null in Java? It depends.

What the compiler said

The following line will not compile.

System.out.println(null);

This is the message from my compiler.

reference to println is ambiguous, both
method println(char[]) in java.io.PrintStream and
method println(java.lang.String) in java.io.PrintStream match

In fact, println(java.lang.Object) in java.io.PrintStream is yet another match, but Java has a way of choosing between that one and each of the two methods above. It’s just the string and the character array parameters that cause ambiguity; character arrays and objects can happily coexist.

Professor Nilssons fuskföreläsning

Mon, 01 Jan 0001 00:00:00 +0000

Den går man på.
– Okänd student på KTH

Dafaq did I just see?
– Anton Lövmar 3 Sep 2012

Otroligt rolig och underhållande förställning. Fattar ingenting.
– Mattias Folke 17 Okt 2013

Om föreställningen

Professor Nilsson lär dig fuska i en föreställning med många överraskningar och goda skratt.

Till skillnad från andra korthajar så hjälper professorn sina medspelare att vinna. Alla som varit modiga nog att spela kort med Professor Nilsson har slutat som segrare och fått utmärkta betyg.

Public vs. private

Mon, 01 Jan 0001 00:00:00 +0000

A package is the smallest unit of private encapsulation in Go.

All identifiers defined within a package are visible throughout that package.
When importing a package you can access only its exported identifiers.
An identifier is exported if it begins with a capital letter.

Exported and unexported identifiers are used to describe the public interface of a package and to guard against certain programming errors.

Quicksort optimizations explained [complete code]

Mon, 01 Jan 0001 00:00:00 +0000

Most Quicksort optimizations give only small improvements. Here are three that can make a real difference.

Algorithm overview

Pick an element p, called a pivot, from the list.
Partition the list so that
- all elements less than p come first,
- all elements greater than p come last,
- elements equal to p go into the middle.
Recursively apply the above steps to the sublists of small and large elements.
For short sublists, use a simpler sorting algorithm.

//  Quicksort sorts the elements of v in ascending order.
func Quicksort(v []int) {
	if len(v) < 20 {
		InsertionSort(v)
		return
	}
	p := Pivot(v)
	low, high := Partition(v, p)
	Quicksort(v[:low])
	Quicksort(v[high:])
}

With some ingenuity this algorithm can be implemented to run very fast.

Radix sorting basics

Mon, 01 Jan 0001 00:00:00 +0000

Radix sorting is a simple and efficient sorting method that sometimes outperforms comparison-based algorithms.

Radix sort is a non-comparative sorting algorithm for sorting numbers or strings. It distributes elements into buckets according to the digits of the numbers or the characters of the strings.

Bucket sort

Bucket sort is the basic building block of most radix sorting schemes. It solves the special case of sorting n integers drawn from a small set {0, 1, …, m-1}.

Read a file (stdin) line by line

Mon, 01 Jan 0001 00:00:00 +0000

Read from file

Use a bufio.Scanner to read a file line by line.

file, err := os.Open("file.txt")
if err != nil {
	log.Fatal(err)
}
defer file.Close()

scanner := bufio.NewScanner(file)
for scanner.Scan() {
	fmt.Println(scanner.Text())
}

if err := scanner.Err(); err != nil {
	log.Fatal(err)
}

Read from stdin

Use os.Stdin to read from the standard input stream.

scanner := bufio.NewScanner(os.Stdin)
for scanner.Scan() {
	fmt.Println(scanner.Text())
}

if err := scanner.Err(); err != nil {
	log.Println(err)
}

Read from any stream

A bufio.Scanner can read from any stream of bytes, as long as it implements the io.Reader interface. See How to use the io.Reader interface.

Redeclaring variables

Mon, 01 Jan 0001 00:00:00 +0000

You can’t redeclare a variable which has already been declared in the same block.

func main() {
	m := 0
	m := 1
	fmt.Println(m)
}

../main.go:3:4: no new variables on left side of :=

However, variables can be redeclared in short multi-variable declarations where at least one new variable is introduced.

func main() {
	m := 0
	m, n := 1, 2
	fmt.Println(m, n)
}

Unlike regular variable declarations, a short variable declaration may redeclare variables provided they were originally declared earlier in the same block (or the parameter lists if the block is the function body) with the same type, and at least one of the non-blank variables is new. […] Redeclaration does not introduce a new variable; it just assigns a new value to the original.

Regexp tutorial and cheat sheet

Mon, 01 Jan 0001 00:00:00 +0000

A regular expression is a sequence of characters that define a search pattern.

Basics

The regular expression a.b matches any string that starts with an a, ends with a b, and has a single character in between (the period matches any character).

Remove all duplicate whitespace

Mon, 01 Jan 0001 00:00:00 +0000

space := regexp.MustCompile(`\s+`)
s := space.ReplaceAllString("Hello  \t \n world!", " ")
fmt.Printf("%q", s) // "Hello world!"

\s+ is a regular expression:

the character class \s matches a space, tab, new line, carriage return or form feed,
and + says “one or more of those”.

In other words, the code will replace each whitespace substring with a single space character.

Trim leading and trailing space

To trim leading and trailing whitespace, use the strings.TrimSpace function.

Round float to 2 decimal places

Mon, 01 Jan 0001 00:00:00 +0000

Float to string

To display the value as a string, use the fmt.Sprintf method.

s := fmt.Sprintf("%.2f", 12.3456) // s == "12.35"

The fmt cheat sheet lists the most common formatting verbs and flags.

Float to float

To round to a floating-point value, use one of these techniques.

x := 12.3456
fmt.Println(math.Floor(x*100)/100) // 12.34 (round down)
fmt.Println(math.Round(x*100)/100) // 12.35 (round to nearest)
fmt.Println(math.Ceil(x*100)/100)  // 12.35 (round up)

Due to the quirks of floating point representation, these rounded values may be slightly off.

Round float to integer value

Mon, 01 Jan 0001 00:00:00 +0000

Round away from zeroGo 1.10

Use math.Round to return the nearest integer, as a float64, rounding ties away from zero.

fmt.Println(math.Round(-0.6)) // -1
fmt.Println(math.Round(-0.4)) // -0
fmt.Println(math.Round(0.4))  // 0
fmt.Println(math.Round(0.6))  // 1

Note the special cases.

Round(±0) = ±0
Round(±Inf) = ±Inf
Round(NaN) = NaN

Round to even numberGo 1.10

Use math.RoundToEven to return the nearest integer, as a float64, rounding ties to an even number.

Runes and character encoding

Mon, 01 Jan 0001 00:00:00 +0000

Runic letters encoded in stone, Ballstorp 1900

Characters, ASCII and Unicode

The rune type is an alias for int32, and is used to emphasize than an integer represents a code point.

ASCII defines 128 characters, identified by the code points 0–127. It covers English letters, Latin numbers, and a few other characters.

Unicode, which is a superset of ASCII, defines a codespace of 1,114,112 code points. Unicode version 10.0 covers 139 modern and historic scripts (including the runic alphabet, but not Klingon) as well as multiple symbol sets.

Select waits on a group of channels

Mon, 01 Jan 0001 00:00:00 +0000

The select statement waits for multiple send or receive operations simultaneously.

The statement blocks as a whole until one of the operations becomes unblocked.
If several cases can proceed, a single one of them will be chosen at random.

// blocks until there's data available on ch1 or ch2
select {
case <-ch1:
	fmt.Println("Received from ch1")
case <-ch2:
	fmt.Println("Received from ch2")
}

Send and receive operations on a nil channel block forever. This can be used to disable a channel in a select statement:

Shadowed variables

Mon, 01 Jan 0001 00:00:00 +0000

Why doesn’t n change?

func main() {
	n := 0
	if true {
		n := 1
		n++
	}
	fmt.Println(n) // 0
}

Answer

The statement n := 1 declares a new variable which shadows the original n throughout the scope of the if statement.

To reuse n from the outer block, write n = 1 instead.

func main() {
	n := 0
	if true {
		n = 1
		n++
	}
	fmt.Println(n) // 2
}

Detecting shadowed variables

To help detect shadowed variables, you may use the experimental -shadow feature provided by the vet tool. It flags variables that may have been unintentionally shadowed. Passing the original version of the code to vet gives a warning message.

Shuffle a slice or array

Mon, 01 Jan 0001 00:00:00 +0000

The rand.Shuffle function in package math/rand shuffles an input sequence using a given swap function.

a := []int{1, 2, 3, 4, 5, 6, 7, 8}
rand.Seed(time.Now().UnixNano())
rand.Shuffle(len(a), func(i, j int) { a[i], a[j] = a[j], a[i] })

[5 8 6 4 3 7 2 1]

Warning: Without the call to rand.Seed you will get the same sequence of pseudorandom numbers each time you run the program.

Slices/arrays explained: create, index, slice, iterate

Mon, 01 Jan 0001 00:00:00 +0000

Basics

A slice doesn’t store any data, it just describes a section of an underlying array.

When you change an element of a slice, you modify the corresponding element of its underlying array, and other slices that share the same underlying array will see the change.
A slice can grow and shrink within the bounds of the underlying array.
Slices are indexed in the usual way: s[i] accesses the ith element, starting from zero.

Construction

var s []int                   // a nil slice
s1 := []string{"foo", "bar"}
s2 := make([]int, 2)          // same as []int{0, 0}
s3 := make([]int, 2, 4)       // same as new([4]int)[:2]
fmt.Println(len(s3), cap(s3)) // 2 4

The default zero value of a slice is nil. The functions len, cap and append all regard nil as an empty slice with 0 capacity.
You create a slice either by a slice literal or a call to the make function, which takes the length and an optional capacity as arguments.
The built-in len and cap functions retrieve the length and capacity.

Slicing

a := [...]int{0, 1, 2, 3} // an array
s := a[1:3]               // s == []int{1, 2}        cap(s) == 3
s = a[:2]                 // s == []int{0, 1}        cap(s) == 4
s = a[2:]                 // s == []int{2, 3}        cap(s) == 2
s = a[:]                  // s == []int{0, 1, 2, 3}  cap(s) == 4

You can also create a slice by slicing an existing array or slice.

Sort a map by key or value

Mon, 01 Jan 0001 00:00:00 +0000

A map is an unordered collection of key-value pairs.
If you need a stable iteration order, you must maintain a separate data structure.

This example uses a sorted slice of keys to print a map[string]int in key order.

m := map[string]int{"Alice": 23, "Eve": 2, "Bob": 25}

keys := make([]string, 0, len(m))
for k := range m {
	keys = append(keys, k)
}
sort.Strings(keys)

for _, k := range keys {
	fmt.Println(k, m[k])
}

Output:

Stack traces in detail

Mon, 01 Jan 0001 00:00:00 +0000

See Recover from a panic [best practices].

Start a new Go project [standard layout]

Mon, 01 Jan 0001 00:00:00 +0000

The repository at github.com/yourbasic/fenwick is a small but complete Go library package. It shows the structure of a basic project and can be used as a template.

In addition to source code and resources, it includes

a README file with sections on
- installation,
- documentation and
- compatibility policy,
unit tests,
benchmarks,
godoc links,
a testable doc example and
a licence.

Table-driven unit tests

Mon, 01 Jan 0001 00:00:00 +0000

Here is the code we want to test.

package search

// Find returns the smallest index i at which x <= a[i].
// If there is no such index, it returns len(a).
// The slice must be sorted in ascending order.
func Find(a []int, x int) int {
	switch len(a) {
	case 0:
		return 0
	case 1:
		if x <= a[0] {
			return 0
		}
		return 1
	}
	mid := len(a) / 2
	if x <= a[mid-1] {
		return Find(a[:mid], x)
	}
	return mid + Find(a[mid:], x)
}

Put the test code in a file whose name ends with _test.go.
Write a function TestXXX with a single argument of type *testing.T. The test framework runs each such function.
To indicate a failed test, call a failure function such as t.Errorf.

package search

import "testing"

var tests = []struct {
	a   []int
	x   int
	exp int
}{
	{[]int{}, 1, 0},
	{[]int{1, 2, 3, 3}, 0, 0},
	{[]int{1, 2, 3, 3}, 1, 0},
	{[]int{1, 2, 3, 3}, 2, 1},
	{[]int{1, 2, 3, 3}, 3, 3}, // incorrect test case
	{[]int{1, 2, 3, 3}, 4, 4},
}

func TestFind(t *testing.T) {
	for _, e := range tests {
		res := Find(e.a, e.x)
		if res != e.exp {
			t.Errorf("Find(%v, %d) = %d, expected %d",
				e.a, e.x, res, e.exp)
		}
	}
}

Run the tests with go test.

The 3 ways to sort in Go

Mon, 01 Jan 0001 00:00:00 +0000

Sort a slice of ints, float64s or strings

Use one of the functions

s := []int{4, 2, 3, 1}
sort.Ints(s)
fmt.Println(s) // [1 2 3 4]

Package radix contains a drop-in replacement for sort.Strings, which can be more than twice as fast in some settings.

The empty interface

Mon, 01 Jan 0001 00:00:00 +0000

See Interfaces in a nutshell.

Time complexity of array/list operations [Java, Python]

Mon, 01 Jan 0001 00:00:00 +0000

To write fast code, you must know the difference between constant and linear time array operations.

Alternatives

Accidentally inefficient list code with quadratic time complexity is very common and can be hard to spot, but when the list grows your code grinds to a halt.

Time complexity of recursive functions [Master theorem]

Mon, 01 Jan 0001 00:00:00 +0000

It's often possible to compute the time complexity of a recursive function by formulating and solving a recurrence relation.

This text contains a few examples and a formula, the “master theorem”, which gives the solution to a class of recurrence relations that often show up when analyzing recursive functions.

We also show how to analyze recursive algorithms that depend on the size and shape of a data structure.

Time is not a number

Mon, 01 Jan 0001 00:00:00 +0000

Why doesn’t this compile?

n := 100
time.Sleep(n * time.Millisecond)

invalid operation: n * time.Millisecond (mismatched types int and time.Duration)

Answer

There is no mixing of numeric types in Go. You can only multiply a time.Duration with

another time.Duration, or
an untyped integer constant.

Here are three correct examples.

var n time.Duration = 100
time.Sleep(n * time.Millisecond)

const n = 100
time.Sleep(n * time.Millisecond)

time.Sleep(100 * time.Millisecond)

See Untyped numeric constants with no limits for details about typed and untyped integer and floating point constants and their limits.

Time zones

Mon, 01 Jan 0001 00:00:00 +0000

Each Time has an associated Location, which is used for display purposes.

The method In returns a time with a specific location. Changing the location in this way changes only the presentation; it does not change the instant in time.

Here is a convenience function that changes the location associated with a time.

// TimeIn returns the time in UTC if the name is "" or "UTC".
// It returns the local time if the name is "Local".
// Otherwise, the name is taken to be a location name in
// the IANA Time Zone database, such as "Africa/Lagos".
func TimeIn(t time.Time, name string) (time.Time, error) {
	loc, err := time.LoadLocation(name)
	if err == nil {
		t = t.In(loc)
	}
	return t, err
}

In use:

Timer and Ticker: events in the future

Mon, 01 Jan 0001 00:00:00 +0000

Timers and Tickers let you execute code in the future, once or repeatedly.

Timeout (Timer)

time.After waits for a specified duration and then sends the current time on the returned channel:

select {
case news := <-AFP:
	fmt.Println(news)
case <-time.After(time.Hour):
	fmt.Println("No news in an hour.")
}

The underlying time.Timer will not be recovered by the garbage collector until the timer fires. If this is a concern, use time.NewTimer instead and call its Stop method when the timer is no longer needed:

Top programming languages in use 2000-2020 [informal study]

Mon, 01 Jan 0001 00:00:00 +0000

Summary

This informal long-time study gives a broad estimate of what programming languages are used commercially in the US. For the last 20 years, I’ve done a job search at www.dice.com for some of the most popular languages.

Main takeaways:

Some much-talked-about languages find only little use in industry.
Java, JavaScript, and Python have taken a large and stable market share during the last 20 years.
C/C++ has slipped to fourth position.
A huge number of programming jobs disappeared from the US job market after the dot-com crash in 2000.

Language trends 2000–2020

Number of hits (x1,000) on Dice, tech jobs search engine, March 2020.

Treaps: Randomized search trees

Mon, 01 Jan 0001 00:00:00 +0000

A treap stores items in sorted order and offers efficient lookup, addition and removal of items.

If you could use only one data structure, which one would you choose? A hash table? While it supports the basic lookup, addition and removal operations, it doesn’t keep the elements sorted. Therefore it can’t efficiently perform some common tasks, such as finding the minimum element or producing an ordered list of all elements.

Type alias explained

Mon, 01 Jan 0001 00:00:00 +0000

An alias declaration has the form

type T1 = T2

as opposed to a standard type definition

type T1 T2

An alias declaration doesn’t create a new distinct type different from the type it’s created from. It just introduces an alias name T1, an alternate spelling, for the type denoted by T2.

Type aliases are not meant for everyday use. They were introduced to support gradual code repair while moving a type between packages during large-scale refactoring. Codebase Refactoring (with help from Go) covers this in detail.

Type assertions and type switches

Mon, 01 Jan 0001 00:00:00 +0000

A type assertion provides access to an interface’s concrete value.

Type assertions

A type assertion doesn’t really convert an interface to another data type, but it provides access to an interface’s concrete value, which is typically what you want.

The type assertion x.(T) asserts that the concrete value stored in x is of type T, and that x is not nil.

If T is not an interface, it asserts that the dynamic type of x is identical to T.
If T is an interface, it asserts that the dynamic type of x implements T.

var x interface{} = "foo"

var s string = x.(string)
fmt.Println(s)     // "foo"

s, ok := x.(string)
fmt.Println(s, ok) // "foo true"

n, ok := x.(int)
fmt.Println(n, ok) // "0 false"

n = x.(int)        // ILLEGAL

panic: interface conversion: interface {} is string, not int

Type switches

A type switch performs several type assertions in series and runs the first case with a matching type.

Type, value and equality of interfaces

Mon, 01 Jan 0001 00:00:00 +0000

Interface type

An interface type consists of a set of method signatures. A variable of interface type can hold any value that implements these methods.

In this example both Temp and *Point implement the MyStringer interface.

type MyStringer interface {
	String() string
}

type Temp int

func (t Temp) String() string {
	return strconv.Itoa(int(t)) + " °C"
}

type Point struct {
	x, y int
}

func (p *Point) String() string {
	return fmt.Sprintf("(%d,%d)", p.x, p.y)
}

Actually, *Temp also implements MyStringer, since the method set of a pointer type *T is the set of all methods with receiver *T or T.

Unexpected ++, expecting expression

Mon, 01 Jan 0001 00:00:00 +0000

Why doesn’t these lines compile?

i := 0
fmt.Println(++i)
fmt.Println(i++)

main.go:9:14: syntax error: unexpected ++, expecting expression
main.go:10:15: syntax error: unexpected ++, expecting comma or )

Answer

In Go increment and decrement operations can’t be used as expressions, only as statements. Also, only the postfix notation is allowed.

The above snippet needs to be written as:

i := 0
i++
fmt.Println(i)
fmt.Println(i)
i++

Without pointer arithmetic, the convenience value of pre- and postfix increment operators drops. By removing them from the expression hierarchy altogether, expression syntax is simplified and the messy issues around order of evaluation of ++ and -- (consider f(i++) and p[i] = q[++i]) are eliminated as well. The simplification is significant. Go FAQ: Why are ++ and – statements and not expressions?

Unexpected newline

Mon, 01 Jan 0001 00:00:00 +0000

Why doesn’t this program compile?

func main() {
	fruit := []string{
		"apple",
		"banana",
		"cherry"
	}
	fmt.Println(fruit)
}

../main.go:5:11: syntax error: unexpected newline, expecting comma or }

Answer

In a multi-line slice, array or map literal, every line must end with a comma.

func main() {
	fruit := []string{
		"apple",
		"banana",
		"cherry", // comma added
	}
	fmt.Println(fruit) // "[apple banana cherry]"
}

This behavior is a consequence of the Go semicolon insertion rules.

Unexpected values in range loop

Mon, 01 Jan 0001 00:00:00 +0000

Why does this code

primes := []int{2, 3, 5, 7}
for p := range primes {
	fmt.Println(p)
}

Answer

For arrays and slices, the range loop generates two values:

first the index,
then the data at this position.

If you omit the second value, you get only the indices.

To print the data, use the second value instead:

primes := []int{2, 3, 5, 7}
for _, p := range primes {
	fmt.Println(p)
}

In this case, the blank identifier (underscore) is used for the return value you're not interested in.

Unit cost vs. bit cost in time complexity

Mon, 01 Jan 0001 00:00:00 +0000

Unit-cost multiplication

Unit cost and bit cost are two different cost functions used to compute space and time complexity.

Unit cost is used in a simplified model where a number, of any size, fits within a memory cell, and where standard arithmetic operations take constant time.
With bit cost we take into account that computations with bigger numbers can be more expensive.

Unit cost often works well in practice as modern processors can perform arithmetics on 64-bit integer and floating point numbers in constant time.

Untyped numeric constants with no limits

Mon, 01 Jan 0001 00:00:00 +0000

Constants may be typed or untyped.

const a uint = 17
const b = 55

An untyped constant has no limits. When it’s used in a context that requires a type, a type will be inferred and a limit applied.

const big = 10000000000  // Ok, even though it's too big for an int.
const bigger = big * 100 // Still ok.
var i int = big / 100    // No problem: the new result fits in an int.

// Compile time error: "constant 10000000000 overflows int"
var j int = big

The inferred type is determined by the syntax of the value:

Unused local variables

Mon, 01 Jan 0001 00:00:00 +0000

As you may have noticed, programs with unused local variables do not compile.

func main() {
	var n int // "n declared and not used"
	n = 5     // this doesn't help
}

../main.go:2:6: n declared and not used

This is a deliberate feature of the Go language.

The presence of an unused variable may indicate a bug […] Go refuses to compile programs with unused variables or imports, trading short-term convenience for long-term build speed and program clarity. Go FAQ: Can I stop these complaints about my unused variable/import?

Unused package imports

Mon, 01 Jan 0001 00:00:00 +0000

As you may have noticed, programs with unused package imports do not compile.

package main

import (
	"fmt"
	"log" // "imported and not used: log"
)

func main() {
	fmt.Println("Hello")
}

../main.go:5:2: imported and not used: "log"

This is a deliberate feature of the Go language.

The presence of an unused variable may indicate a bug […] Go refuses to compile programs with unused variables or imports, trading short-term convenience for long-term build speed and program clarity. Go FAQ: Can I stop these complaints about my unused variable/import?

User-friendly access to crypto/rand

Mon, 01 Jan 0001 00:00:00 +0000

Go has two packages for random numbers:

math/rand implements a large selection of pseudo-random number generators.
crypto/rand implements a cryptographically secure pseudo-random number generator with a limited interface.

The two packages can be combined by calling rand.New in package math/rand with a source that gets its data from crypto/rand.

import (
	crand "crypto/rand"
	rand "math/rand"

	"encoding/binary"
	"fmt"
	"log"
)

func main() {
	var src cryptoSource
	rnd := rand.New(src)
	fmt.Println(rnd.Intn(1000)) // a truly random number 0 to 999
}

type cryptoSource struct{}

func (s cryptoSource) Seed(seed int64) {}

func (s cryptoSource) Int63() int64 {
	return int64(s.Uint64() & ^uint64(1<<63))
}

func (s cryptoSource) Uint64() (v uint64) {
	err := binary.Read(crand.Reader, binary.BigEndian, &v)
	if err != nil {
		log.Fatal(err)
	}
	return v
}

Warning: The crand.Reader returns an error if the underlying system call fails. For instance if it can't read /dev/urandom on a Unix system, or if CryptAcquireContext fails on a Windows system.

Variadic functions (...T)

Mon, 01 Jan 0001 00:00:00 +0000

Basics

If the last parameter of a function has type ...T it can be called with any number of trailing arguments of type T.

func Sum(nums ...int) int {
	res := 0
	for _, n := range nums {
		res += n
	}
	return res
}

func main()
	fmt.Println(Sum())        // 0
	fmt.Println(Sum(1, 2, 3)) // 6
}

The actual type of ...T inside the function is []T.

Waiting for goroutines

Mon, 01 Jan 0001 00:00:00 +0000

A sync.WaitGroup waits for a group of goroutines to finish.

var wg sync.WaitGroup
wg.Add(2)
go func() {
	// Do work.
	wg.Done()
}()
go func() {
	// Do work.
	wg.Done()
}()
wg.Wait()

First the main goroutine calls Add to set the number of goroutines to wait for.
Then two new goroutines run and call Done when finished.

At the same time, Wait is used to block until these two goroutines have finished.

What happened to ABBA?

Mon, 01 Jan 0001 00:00:00 +0000

What’s up with strings.TrimRight?

fmt.Println(strings.TrimRight("ABBA", "BA")) // Output: ""

Answer

The Trim, TrimLeft and TrimRight functions strip all Unicode code points contained in a cutset. In this case, all trailing A:s and B:s are stripped from the string, leaving the empty string.

To strip a trailing string, use strings.TrimSuffix.

fmt.Println(strings.TrimSuffix("ABBA", "BA")) // Output: "AB"

See String functions cheat sheet for more about strings in Go.

What’s a seed in a random number generator?

Mon, 01 Jan 0001 00:00:00 +0000

In reality pseudorandom numbers aren't random at all. They are computed using a fixed deterministic algorithm.

The seed is a starting point for a sequence of pseudorandom numbers. If you start from the same seed, you get the very same sequence. This can be quite useful for debugging.

If you want a different sequence of numbers each time, you can use the current time as a seed.

Whatever remains

Mon, 01 Jan 0001 00:00:00 +0000

Why isn’t -1 odd?

func Odd(n int) bool {
	return n%2 == 1
}

func main() {
	fmt.Println(Odd(-1)) // false
}

Answer

The remainder operator can give negative answers if the dividend is negative: if n is an odd negative number, n % 2 equals -1.

The quotient q = x / y and remainder r = x % y satisfy the relationships

x = q*y + r  and  |r| < |y|

where x / y is truncated towards zero.

Where is my copy?

Mon, 01 Jan 0001 00:00:00 +0000

Why does the copy disappear?

var src, dst []int
src = []int{1, 2, 3}
copy(dst, src) // Copy elements to dst from src.
fmt.Println("dst:", dst)

dst: []

Answer

The number of elements copied by the copy function is the minimum of len(dst) and len(src). To make a full copy, you must allocate a big enough destination slice.

var src, dst []int
src = []int{1, 2, 3}
dst = make([]int, len(src))
n := copy(dst, src)
fmt.Println("dst:", dst, "(copied", n, "numbers)")

dst: [1 2 3] (copied 3 numbers)

The return value of the copy function is the number of elements copied. See Copy function for more about the built-in copy function in Go.

Where is the ternary conditional operator?

Mon, 01 Jan 0001 00:00:00 +0000

See 4 basic if-else statement patterns.

Why doesn’t append work every time? [scary bug]

Mon, 01 Jan 0001 00:00:00 +0000

What’s up with the append function?

a := []byte("ba")

a1 := append(a, 'd')
a2 := append(a, 'g')

fmt.Println(string(a1)) // bag
fmt.Println(string(a2)) // bag

Answer

If there is room for more elements, append reuses the underlying array. Let's take a look:

a := []byte("ba")
fmt.Println(len(a), cap(a)) // 2 32

This means that the slices a, a1 and a2 will refer to the same underlying array in our example.

To avoid this, we need to use two separate byte arrays.

Why Go? – Key advantages you may have overlooked

Mon, 01 Jan 0001 00:00:00 +0000

Go makes it easier (than Java or Python) to write correct, clear and efficient code.

Choosing a programming language isn’t easy. The separate features of a language may look great at first, but it takes time and experience to spot the drawbacks.

As a CS professor and longtime Go and Java developer, I’d like to share some of my thoughts and explain why I prefer Go to Java or Python – Go makes it much easier for me to write good code.

Write log to file (or /dev/null)

Mon, 01 Jan 0001 00:00:00 +0000

This code appends a log message to the file text.log. It creates the file if it doesn’t already exist.

f, err := os.OpenFile("text.log",
	os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
	log.Println(err)
}
defer f.Close()

logger := log.New(f, "prefix", log.LstdFlags)
logger.Println("text to append")
logger.Println("more text to append")

Contents of text.log:

prefix: 2017/10/20 07:52:58 text to append
prefix: 2017/10/20 07:52:58 more text to append

log.New creates a new log.Logger that writes to f.
The prefix appears at the beginning of each generated log line.
The flag argument defines which text to prefix to each log entry.

Disable logging

To turn off all output from a log.Logger, set the output destination to ioutil.Discard, a writer on which all calls succeed without doing anything.

Your basic int: a most powerful data type

Mon, 01 Jan 0001 00:00:00 +0000

The int data type is generic, effective, simple and efficient.

Introduction

Every kid can spot an integer number, and every programmer is familiar with the int data type. Still we frequently forget how powerful an integer can be.

Generic
An int or []int is a bit pattern that can represent any digital data. Furthermore, an int can point into any type of array. That’s as generic as it gets.
Effective
With an int you have all of basic mathematics at your fingertips, and boolean algebra, implemented with bit-level parallelism, to boot.
Simple
Not really, but we’ve used arithmetic since childhood so it feels that way. Familiarity breeds both simplicity and contempt.
Efficient
An int fits inside a register sitting on the main datapath of the CPU, and an []int is the main focus of hardware memory optimization. It doesn’t get much faster or more efficient than that.

Resources

This text comes with four Go example libraries:

Zero knowledge (besserwisser alert)

Mon, 01 Jan 0001 00:00:00 +0000

See Numbers that start with zero.

Algorithms to Go

2 basic FIFO queue implementations

Watch out for memory leaks

2 basic set implementations

Map implementation

Alternative

2 patterns for a do-while loop in Go

Repeat-until loop

2 ways to delete an element from a slice

Fast version (changes order)

Slow version (maintains order)

3 dots in 4 places

Variadic function parameters

Arguments to variadic functions

3 rules for efficient parallel computation

3 simple ways to create an error

String-based errors

Custom errors with data

3 ways to compare slices (arrays)

Basic case

3 ways to find a key in a map

Basics

Check second return value

Use second return value directly in an if statement

Check for zero value

Further reading

3 ways to split a string into a slice

Split on comma or other substring

3 ways to trim whitespace (or other characters) from a string

Further reading

4 basic if-else statement patterns

Basic syntax

With init statement

4 basic range loop (for-each) patterns

Basic for-each loop (slice or array)

String iteration: runes or bytes

4 iota enum examples

Iota basic example

5 basic for loop patterns

Three-component loop

5 switch statement patterns

Basic switch with default

A basic stack (LIFO) data structure

Performance

A panic is an exception in Go

About

About me

About you

Access environment variables

Access private fields with reflection

Algorithms: What’s the problem?

Amortized time complexity

Example: a dynamic array

Anonymous functions and closures

API design: principles and best practices

Introduction

Append text to a file

Array won’t change

Answer

Assignment to entry in nil map

Answer

Big O notation: definition and examples

Definition

Binary search trees explained

Binary tree definitions

Binary search: take a sortcut [sic]

Bitmasks, bitsets and flags

Bitmask

Larger bitsets

Bitwise operators [cheat sheet]

Number literals

Built-in operators

Package math/bits

Bit manipulation code example

Blackjack card counting risk analysis: poor gains at huge risk

Always optimal strategy

Count cards

Blank identifier (underscore)

Ignore values

Import for side effects

Package `math/bits`