Go
Last updated
Last updated
Always remove previous versions before installing newer ones.
Officially, Go docs tells to manually download the latest version and install it.
Add this env to .bashrc.
There is a kind of like python pyenv.
It automatically adds the Path variables to .bashrc and installs the latest Go version.
Other commands:
Run an uncompiled file.go file with:
In Windows the compiled will be a .exe file, whether in Linux or Mac it will be a executable file.
Go automatically manages memory with its Garbage Collector.
Most of variables allocation definition is done at compile time. But they can be moved in certain circunstances at runtime.
Check escape analysis and heap allocation by running go build -gcflags '-m'.
Don't always use pointers in parameters to pass values like structs, to avoid memory duplication. (Target pointers to > 64 bytes structs, or if used in multiple functions)
Prefer Stack allocation when possible.
Used for small, local, short-lived, and that do not escape the function variables.
Automatically cleaned up when function exits. (That's why short-lived)
Variables allocated in the Stack, can be moved at runtime to the heap if they escape their initial scope.
They will be in the Stack or stay there if no conditions to go to the Heap are met.
Used for large or long-lived variables (slower, garbage-collected)
They live until garbage collected. (That's why long-lived)
A closure captures a variable
func() { x++ }
The variable outlives the function
Returning a pointer to a local variable
return &x
The local variable must persist
Structs stored in an interface
var i interface{} = MyStruct{}
Interfaces store references
Large arrays/slices (Maps always)
make([]int, 100000)
Avoids stack overflow
Structs passed by reference
func test(p *Person){}
Explicit heap allocation
But its underlying Array is in the Heap IF they are large.
Monitor memory leaks using pprof (Go's profiling tool)
Usually happen when Heap memory isn't freed properly.
Global variables holding large data
Avoid unnecessary global variables
Unclosed Goroutines
Use sync.WaitGroup or context.Context to stop them
Slices growing without limit
Use make() with a sensible capacity
Forgotten closures holding memory
Set function references to nil when no longer needed
To build and generate an executable the project needs a .
themselves (the slice header: pointer, length, capacity) is allocated in the Stack.
are always allocated in the Heap, because internally, it contains a pointer to a hash table, which lives in the heap.