In an anonymous function if a parameter is not used within the function the parameter name can be omitted

During compilation you can set the GOAMD64 and GOARM64 environment variables to specify the minimum architecture requirements to your machines. The compiler will then generate instructions that are only executable on defined architectures or newer ones.

In a hanging go program, you can get a stack dump of all your goroutines by using SIGABRT or SIGQUIT.

SIGQUIT can be invoked via CTRL + \.

If this doesn't work (because of other keyboard settings) you can also do killall -QUIT <processname> or killall -ABRT <processname>.

Goroutines have a stack which can grow. This differs from other programming languages (like C f.e.) where the stack size is fixed. The stack memory of a goroutine comes from the process heap. The stack memory allocation happens in the userspace, managed by the go runtime.

In Go, the TZ environment variable is used to set the local timezone. If the variable is set, go attempts to load the respective timezone data.

This can be provided via a path in ZONEINFO environment variable, some standard OS locations (f.e. /usr/share/zoneinfo on UNIX).

Go maps do not shrink in size in terms of allocated memory, even if you delete the elements from the map.

If you use pointers as map values and then delete the elements, the memory for the values will be freed, but the memory for the map itself will still be allocated.

It is possible to use index expressions on array pointers without dereferencing them:

a := &[3]string{"a", "b", "c"}
fmt.Println(a[1])

It is not possible to do the same thing with slices.

In Go, it is possible to create a nil slice using type conversion. It works like this:
g := []string(nil)

In this example nil is converted to the type []string, e.g. a slice of strings

In go when we call the defer statement, a _defer object is created. It can be allocated on the heap, stack or be a so-called open coded defer.

Pointers can point to other pointers in Golang. The following code will print 5:

var number = 5
var pointer *int = &number
var pointerToPointer **int = &pointer

fmt.Println(**pointerToPointer)

Note the **int type of the pointerToPointer variable.

A nil pointer in Go does not point to any memory address.

It is possible to provide a capacity while initializing a map by providing a second argument to the make function in Go. It is however not possible to retrieve the capacity of a map using the cap function.

The %q formatting directive, which is usually used to enquote a string, can be used to identify unprintable byte sequences.

For example:

test := "\xdc"
fmt.Printf("%q", test)

will print the value of test in quotes.

If we change the value of test to "\x64", "d" will be printed.

Since a string in Go is just a slice of bytes, indexing a string in go returns a byte.

A for key, value := range loop, however, retrieves runes as values and byte starting positions as keys.

Further read: go.dev/blog/strings

In Go you can declare typed and untyped constants.

const untyped = "abc"
const typed string = "def"

Untyped constants can be not only assigned to string variables, but also to variables of a type which is a string alias.

More on this in the golang blog: go.dev/blog/constants

A nil channel is never ready for communication. This means that receiving from and sending to a nil channel blocks forever.

Executing a code which sends to or receives from a nil channel results in a deadlock error.

In Go, if you use a pointer receiver, only pointer types implement the interface. On the other hand, if you use a value receiver, both pointer and non-pointer types implement the interface.

Appending to a slice in golang does not create a new slice, even when we thereby create a new variable. This can lead to unwanted side effects.