Golang.

Go, also called Golang, is an open-source programming language developed by Google. It is statically typed, so the compiler checks types before the program runs. It compiles to native machine code instead of running on a virtual machine. A garbage collector manages memory automatically.

Concurrency is built in through goroutines, which are lightweight threads that the Go runtime schedules for you. The syntax is minimal, with few keywords, and builds are fast. The same program compiles for many operating systems and processor architectures.

Go has two ways to declare a variable: the var keyword and the short form :=. With var you can state the type, let the compiler infer it from the value, or leave the value out. A variable declared without a value starts at its type's zero value.

The short variable declaration name := "John" always needs a value, infers the type from it, and works only inside functions. Both forms can declare several variables on one line. The compiler rejects a local variable that is declared but never used.

// Explicit type declaration
var name string = "John"
var age int = 30

// Type inference
var user = "John"
var score = 30

// Short variable declaration (inside functions only)
nick := "John"
level := 30

// Multiple variable declaration
var a, b, c int = 1, 2, 3
x, y := 10, "hello"

var is the full declaration and works at package level and inside functions, while :=, the short variable declaration, works only inside functions. With var you can name the type and skip the value, and the variable then holds its zero value. := always needs a value and infers the type from it. At package level you must use var.

Inside a function, := can also redeclare a variable, as long as at least one name on its left is new. Redeclaring assigns to the existing variable. That is why val, err := f() can appear after err already exists.

One trap is := inside an inner block, which creates a new variable that shadows the outer one instead of assigning to it.

// Package level - must use var
var globalVar string

func main() {
    // Both are valid inside functions
    var localVar string    // Zero value: ""
    shortVar := "hello"    // Type inferred as string
    fmt.Println(globalVar, localVar, shortVar)
}

Go's basic types are booleans, numbers and strings. The numeric types come in several sizes:

• Signed integers: int, int8, int16, int32, int64
• Unsigned integers: uint, uint8, uint16, uint32, uint64
• Floating point: float32, float64
• Complex numbers: complex64, complex128

Most have a fixed size in their name, but int and uint are either 32 or 64 bits wide, depending on the platform.

A bool holds true or false. A string holds UTF-8 encoded text and cannot change once created. byte is an alias for uint8, used for raw data. rune is an alias for int32 and holds one Unicode code point.

Go never converts numeric types on its own, so mixing int and int64 needs an explicit conversion.

Declare a constant with the const keyword. Its value is fixed when the program compiles and can never change. You can group related constants in a const ( ... ) block. Inside a group, iota starts at 0 and goes up by one on each line, which makes it the usual way to build enum-like values.

A constant without a stated type is an untyped constant, so it takes the type the context needs. That is why Pi works with both float32 and float64 values. Only values the compiler can work out, such as numbers, strings and booleans, can be constants, so a slice cannot be one.

const Pi = 3.14159
const MaxUsers = 100

// Grouped constants
const (
    StatusOK     = 200
    StatusError  = 500
    StatusPending = 202
)

// iota for auto-incrementing constants
const (
    Sunday = iota  // 0
    Monday         // 1
    Tuesday        // 2
)

A slice is a growable view over an array, while an array has a fixed size. An array's size is part of its type, so [5]int and [6]int are different types. A slice is a small header of three fields: a pointer to the array, a length and a capacity.

Arrays are values, so assigning one copies every element. Assigning a slice copies only its header, so both slices share the same elements.

// Array - fixed size
var arr [5]int = [5]int{1, 2, 3, 4, 5}

// Slice - dynamic size
var slice []int = []int{1, 2, 3, 4, 5}
slice = append(slice, 6) // Can grow

// Creating slices
slice1 := make([]int, 5)      // length 5, capacity 5
slice2 := make([]int, 5, 10)  // length 5, capacity 10

Most Go code uses slices, because they grow with built-in functions like append() and pass cheaply to functions.

You create a map with make or a map literal, then read and write entries with m[key]. A map is Go's built-in hash table of key-value pairs. Reading a missing key returns the zero value. The comma-ok form v, ok := m[key] tells a missing key from a stored zero. delete removes a key, and len counts the entries.

• Keys must be comparable types, such as strings, numbers or structs of them.
• Iteration order is not specified, so never rely on it.
• A nil map can be read but panics on write, so always create the map first.
• Maps are not safe for concurrent writes, so guard a shared map with a sync.Mutex.

// Creating maps
ages := make(map[string]int)
ages["Alice"] = 30
ages["Bob"] = 25

// Map literal
ages = map[string]int{
    "Alice": 30,
    "Bob":   25,
}

// Checking if key exists
age, exists := ages["Alice"]
if exists {
    fmt.Println("Alice's age:", age)
}

// Deleting keys
delete(ages, "Bob")

A struct is a custom type that groups related data into named fields, with no inheritance. You create one with a composite literal, either by field name or by position in field order. Field names are safer, because adding a field later does not break the code.

Access fields with a dot. Go dereferences a struct pointer for you, so p3.Name works on &Person{...}. Fields you leave out get their zero values. Structs are values, so assigning one copies all of its fields.

type Person struct {
    Name string
    Age  int
    City string
}

// Creating struct instances
p1 := Person{Name: "Alice", Age: 30, City: "NYC"}
p2 := Person{"Bob", 25, "LA"} // positional
p3 := &Person{Name: "Charlie", Age: 35} // pointer to struct

// Accessing fields
fmt.Println(p1.Name)
p1.Age = 31

&x gives the address of x, and *p reads or writes the value at that address, so changing *p changes x. A pointer is a variable that stores such an address. The type *int means a pointer to an int, and its zero value is nil. Dereferencing a nil pointer panics at run time.

Go uses pass by value for every argument. Pass a pointer when a function must change the caller's variable, or when copying a large struct costs too much. Go has no pointer arithmetic. The garbage collector keeps a value alive while any pointer to it exists, so returning a pointer to a local variable is safe.

var x int = 42
var p *int = &x  // p points to x

fmt.Println(*p)  // Dereference: prints 42
*p = 21          // Change value through pointer
fmt.Println(x)   // prints 21

// Zero value of pointer is nil
var ptr *int
if ptr == nil {
    fmt.Println("Pointer is nil")
}

A function is defined with the func keyword, then its name, its parameters and its result types.

• Parameters that share a type can share one type name, as in a, b int.
• A Go function can return multiple values, and the usual pattern returns a result plus an error last.
• Named return values act as local variables, and a bare return sends back their current values.
• Functions are also values, so you can pass them as arguments, store them in variables and return them as closures.

func add(a, b int) int {
    return a + b
}

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}
func calculate(a, b int) (sum, product int) {
    sum = a + b
    product = a * b
    return // naked return
}