
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.

Hello, World


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.