Go Fundamentals: nil Slices, Interface Type Assertions, and Goroutine Scheduling

nil slice vs empty slice

A Go slice is a three-word struct: pointer to backing array, length, and capacity.

var nilSlice []int        // nilSlice = {ptr: nil, len: 0, cap: 0}
emptySlice := []int{}     // emptySlice = {ptr: 0x..., len: 0, cap: 0}

fmt.Println(nilSlice == nil)   // true
fmt.Println(emptySlice == nil) // false
fmt.Println(len(nilSlice))     // 0 — safe
fmt.Println(len(emptySlice))   // 0

// Both are safe to append to:
nilSlice = append(nilSlice, 1)     // works, allocates backing array
emptySlice = append(emptySlice, 1) // works

nil slice and empty slice behave identically for len, cap, range, and append. The only behavioral difference is nilSlice == nil returns true. The practical difference shows up in JSON serialization:

type Response struct {
    Items []string `json:"items"`
}

// nil slice → JSON: {"items": null}
// empty slice → JSON: {"items": []}

If API contracts require [] instead of null, initialize with []string{} or make([]string, 0).

Type assertion vs type conversion on interfaces

Type assertion (x.(T)) and type conversion (T(x)) look similar but have different semantics when interfaces are involved.

Type conversion — checked at compile time, requires structural compatibility:

type Stringer interface {
    String() string
    Print() string
}
type Printer interface {
    Print() string
}

var s Stringer = MyType{"hello"}
p := Printer(s)  // OK: Stringer includes all methods of Printer

This compiles because Stringer has a superset of Printer's methods. The assignment is a no-op on nil values — a nil Stringer converts to a nil Printer without panicking.

Type assertion — checked at runtime, asserts the concrete type:

var s Stringer = MyType{"hello"}
p := s.(Printer)  // OK: the concrete type MyType implements Printer

Type assertion panics if the concrete type doesn't implement the target interface, or if the interface value is nil:

var s Stringer       // nil interface
p := s.(Printer)     // PANIC: interface conversion: interface is nil, not main.Printer

Use the two-value form to avoid panics:

p, ok := s.(Printer)
if !ok {
    // s doesn't hold a value that implements Printer
}

// Classic bug: returning a typed nil
type MyError struct{ msg string }
func (e *MyError) Error() string { return e.msg }

func doWork() error {
    var err *MyError  // typed nil pointer
    return err        // returns non-nil interface!
}

func main() {
    err := doWork()
    if err != nil {
        fmt.Println("got error")  // prints "got error" even though *MyError is nil
    }
}

Fix: return nil (untyped nil), not a typed nil pointer.

Goroutines and the Go scheduler

Goroutines are not OS threads. The Go runtime multiplexes N goroutines onto M OS threads (the N:M scheduler):

// Starting a goroutine — cheap (~2KB stack, grows dynamically)
go func() {
    fmt.Println("running concurrently")
}()

// Starting an OS thread (via C FFI or cgo) — expensive (~1-8MB stack, fixed)

The Go scheduler (since Go 1.14) is preemptive — a goroutine running an infinite loop can be preempted. Before 1.14, it was cooperative: goroutines yielded only at function calls or blocking operations, meaning tight loops could starve other goroutines.

GOMAXPROCS controls the number of OS threads that can execute Go code simultaneously:

import "runtime"

runtime.GOMAXPROCS(4)  // use 4 OS threads
// Default: runtime.NumCPU()

var globalVar int  // OK: declaration with zero value

// ERROR: cannot assign to x outside a function
globalVar = 10

// OK: complex initialization goes in init()
func init() {
    globalVar = computeStartupValue()
}