
Go is statically typed - every value has a type known at compile time. The built-in scalar types cover booleans, integers of specific widths, floating-point numbers, and text.

<ExamplePair>
<ExampleProse>

Boolean values are `true` or `false`. Go has no truthiness - non-zero integers and non-nil pointers are not implicitly boolean.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    fmt.Println(true && false) // false
    fmt.Println(true || false) // true
    fmt.Println(!true)         // false
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Go has signed integers (`int8`, `int16`, `int32`, `int64`, and `int`), unsigned variants (`uint8`/`byte`, `uint16`, `uint32`, `uint64`, `uint`), and two floating-point types. `int` and `uint` are platform-width - 64 bits on modern systems.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    fmt.Println(1 + 2)           // 3       (int)
    fmt.Println(7.0 / 3.0)       // 2.3333… (float64)
    fmt.Println(7 / 3)           // 2       (integer division)
    fmt.Println(7 % 3)           // 1

    var b byte = 255             // alias for uint8
    fmt.Println(b)               // 255
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Strings in Go are immutable sequences of bytes (UTF-8 encoded). `rune` is an alias for `int32` and represents a Unicode code point. `byte` is an alias for `uint8` and represents a raw byte.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    s := "Hello, 世界"

    fmt.Println(len(s))           // 13 - byte count, not character count
    fmt.Println([]rune(s))        // slice of Unicode code points

    for i, r := range s {
        fmt.Printf("%d: %c\n", i, r)
    }
    // i is the byte offset; r is the rune at that offset
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
`range` over a string yields runes (Unicode code points); `len()` returns bytes. Mixing them causes silent truncation on emoji and CJK input - `s[3]` gives the fourth byte, not the fourth character. In international products, always iterate with `range` when you care about user-visible characters, and use `utf8.RuneCountInString` instead of `len` when you need a character count for display or truncation.
</InProduction>


Go's built-in scalar types - bool, integer variants, float32/float64, byte, rune, and string.

Values


Go has two ways to declare variables: the `var` keyword (explicit type, works anywhere) and the short variable declaration `:=` (inferred type, inside functions only). Both are valid - use `var` at package scope or when you want to name the type explicitly; use `:=` inside functions for brevity.

<ExamplePair>
<ExampleProse>

`var` declares a variable with an explicit or inferred type. When no initial value is given, the variable is set to its zero value - `0` for numbers, `false` for booleans, `""` for strings, and `nil` for pointers, slices, maps, channels, and functions.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

var globalCount int // zero value: 0

func main() {
    var x int         // 0
    var s string      // ""
    var b bool        // false

    fmt.Println(x, s, b)  // 0  false
    fmt.Println(globalCount) // 0
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Inside a function, `:=` declares and initialises in one step. The compiler infers the type from the right-hand side.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    name := "Alice"   // string
    age := 30         // int
    active := true    // bool

    fmt.Println(name, age, active)

    // Multiple assignment in one line
    x, y := 1, 2
    fmt.Println(x + y) // 3

    // Swap without a temp variable
    x, y = y, x
    fmt.Println(x, y)  // 2 1
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

When declaring several related variables together, the `var` block form is readable and avoids repetition.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

func main() {
    var (
        host = "localhost"
        port = 5432
        ssl  = false
    )
    fmt.Println(host, port, ssl)
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Zero values are a deliberate design feature, not an oversight. A struct field you forget to initialise is not a nil panic - it's a predictable zero. This makes Go programs more robust by default, but it also means that "is this value set?" requires a sentinel or a separate boolean flag, not a nil check. Know your types' zero values before adding defensive nil checks that paper over bad initialisation. The pattern `if cfg.Timeout == 0 { cfg.Timeout = defaultTimeout }` is idiomatic Go.
</InProduction>


var declarations, short variable declaration :=, zero values, and multiple assignment.

Variables


The smallest complete Go program proves the toolchain is wired up and your code runs. Go requires exactly one `main` package and one `main` function as the entry point - no global scripts, no implicit execution.

<ExamplePair>
<ExampleProse>

Every Go program lives in a package. The `main` package is special: the compiler turns it into an executable binary. `fmt.Println` writes its arguments to stdout followed by a newline.

</ExampleProse>
<ExampleCode>

```go
package main

import "fmt"

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

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Run it directly with `go run`:

</ExampleProse>
<ExampleCode>

```shell
$ go run hello.go
Hello, World!
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Or compile it into a binary first:

</ExampleProse>
<ExampleCode>

```shell
$ go build -o hello hello.go
$ ./hello
Hello, World!
```

</ExampleCode>
</ExamplePair>

Go was designed for the cloud era - `go build` produces a single statically linked binary with no runtime dependency, which is why Go services fit naturally into scratch or distroless container images.

<InProduction>
`fmt.Println` writes plain text to stdout. In containerised services, replace it with a structured logger - [zerolog](https://github.com/rs/zerolog) or [zap](https://github.com/uber-go/zap) - that writes JSON. Plain text logs are unqueryable in Datadog or Grafana Loki, bypass log levels, and make request-ID serialisation impossible. In containers, write to stderr (not stdout) unless your orchestrator explicitly reads stdout; mixing application logs with stdout output from sub-processes is a common source of log corruption in production.
</InProduction>


The smallest runnable Go program - package main, the main function, and fmt.Println.