Go · Beginner interview

Go is a statically typed, compiled language built for simplicity, fast compilation, and concurrency. It deliberately omits features like inheritance, generics-everywhere, and exceptions in favour of a small spec, composition, explicit error handling, and built-in goroutines/channels. The result is code that's easy to read and maintain across large teams, with a fast toolchain and good performance.

Every type has a zero value used when you declare a variable without initializing it — 0 for numbers, "" for strings, false for bool, nil for pointers/slices/maps. var declares a variable (optionally with a type and value); := is short declaration that infers the type from the value and only works inside functions. Zero values mean you rarely have 'uninitialized' bugs.

var count int      // 0
name := "Ada"      // inferred string

Go has no exceptions for ordinary errors; functions return an error value as their last result, and you check it explicitly with if err != nil. This makes error paths visible and forces you to handle them where they happen. panic/recover exists for truly exceptional, unrecoverable situations, not normal control flow.

f, err := os.Open(path)
if err != nil { return err }

An array has a fixed size that's part of its type ([3]int), so it's rarely used directly. A slice is a flexible, dynamically-sized view over an underlying array, with a length and capacity, and is what you use in practice. You create slices with literals or make, and grow them with append.

A map is Go's hash table, mapping keys to values, created with make or a literal. Accessing a missing key returns the value type's zero value, and the two-return form (v, ok := m[k]) tells you whether the key existed. Maps aren't safe for concurrent writes, and iteration order is randomized intentionally.

m := map[string]int{"a": 1}
v, ok := m["b"] // 0, false

A slice has a length (elements in use) and capacity (room in the underlying array). append adds elements; if capacity is exceeded it allocates a new, larger array and copies, so the returned slice may point to different memory — which is why you always reassign s = append(s, x). Slices also share backing arrays, so a sub-slice can alias and mutate the original.

A struct is a composite type grouping named fields, Go's main way to model data (there are no classes). You attach behaviour by defining methods on the struct type, and you compose structs by embedding rather than inheriting. Structs are value types, so assigning or passing one copies it unless you use a pointer.

type User struct { ID string; Age int }

A value receiver gets a copy, so it can't modify the original and is fine for small, immutable data. A pointer receiver operates on the original, so it can mutate it and avoids copying large structs. The convention is to be consistent per type and use pointer receivers when you mutate state or the struct is large.

func (u *User) Birthday() { u.Age++ } // mutates

An interface defines a set of method signatures, and any type that implements those methods satisfies it automatically — there's no 'implements' keyword (structural/implicit satisfaction). This decouples code: functions accept interfaces and work with any concrete type providing the behaviour. Small interfaces (often one method, like io.Reader) are idiomatic.

A goroutine is a lightweight thread managed by the Go runtime — you start one by prefixing a call with the go keyword. They're cheap (a few KB of stack, growing as needed), so you can run thousands. The runtime multiplexes them onto OS threads, making concurrent I/O easy without manual thread management.

go process(item) // runs concurrently

Channels are typed conduits for sending and receiving values between goroutines, providing safe communication and synchronization without shared-memory locks — Go's motto is 'share memory by communicating'. Sending and receiving block until the other side is ready (for unbuffered channels), which coordinates goroutines naturally. You close a channel to signal no more values.

ch := make(chan int)
go func() { ch <- 42 }()
v := <-ch

defer schedules a function call to run when the surrounding function returns, commonly for cleanup like closing files — it runs even if the function panics. panic stops normal flow and unwinds the stack; recover, called in a deferred function, stops a panic and lets you handle it. You use panic/recover sparingly, for unrecoverable errors, not normal error handling.