Ruby.CodeCompared.To/Go

Every Go source file begins with a package declaration. Executables must be in package main with a func main() entry point. The opening brace must be on the same line as the declaration — the compiler enforces this via automatic semicolon insertion. There is no script mode.

Go uses C-style comments. The // style is standard for all line comments; /* */ for block docs. The go doc tool reads // comments immediately preceding a declaration. The comment should begin with the name being documented: // Add returns… not // This adds…

Go mandates a tab character ( ) per indentation level — gofmt enforces this with no configuration. The tab width is a display setting: the Go spec assumes 8-character tab stops, but 4 is standard in most editors. Because every indent is always a single , the code is structurally identical at any display width. Within a line, spaces handle alignment (the struct field types are padded with spaces, not tabs), so column-aligned code stays stable at any tab width. gofmt applies the tabs-for-indentation, spaces-for-alignment rule automatically.

gofmt rewrites Go source to a single canonical style — specific spacing, aligned fields, standardized braces. The example on the left is valid but deliberately badly formatted. Click ▶ Run to see it reformatted instantly into canonical gofmt style. There are no style debates equivalent to RuboCop configurations; all Go code in the wild looks identical.

:= is the short variable declaration — it infers the type and is valid only inside function bodies. var works at both package and function scope. Every declared local variable that is never used is a compile error — not a warning. Constants are evaluated at compile time and cannot have their address taken.

Every type in Go has a zero value — what a variable holds when declared but not assigned. This eliminates uninitialized-memory bugs. Crucially, string's zero value is "", not nil — strings are value types. Only reference types (pointers, slices, maps, channels, functions, interfaces) have a zero value of nil.

iota resets to 0 at the start of each const block and increments by one per constant. It can appear in expressions — 1 << iota generates powers of two, the standard bitmask pattern. Use _ = iota to skip a value. There is no Ruby equivalent; the closest idiom is frozen symbol constants in a module.

Go has many distinct numeric types — you must choose explicitly. int and float64 are the right defaults. There is no implicit type coercion anywhere — adding an int and a float64 is a compile error. Every conversion must be explicit: float64(count). This eliminates a whole class of Ruby numeric surprises.

Unlike Ruby's method syntax, Go string operations are package-level functions from the strings package — the string type itself has no methods. len(string) returns bytes, not characters. A UTF-8 multi-byte character like é is 2 bytes; 🌍 is 4 bytes. Use []rune(str) for Unicode-correct character counting.

Go has no string interpolation — no backtick templates or #{}. The fmt package uses C-style format verbs. %v is the workhorse — it formats any value using its default representation. Use Sprintf to build strings; Printf to print; Fprintf to write to an io.Writer.

The range loop over a string iterates by rune (Unicode code point), not byte — each iteration gives the byte offset and the rune value. The byte offset may jump by more than 1 for multi-byte characters. Converting to []rune gives a slice indexed by character position, equivalent to Ruby's String#chars. The rune type is an alias for int32.

Go arrays have a fixed length that is part of the type — [3]int and [5]int are incompatible types. They are value types: assignment copies all elements. In practice, Go programmers almost always use slices instead. Arrays exist primarily as backing storage for slices. The [...]T syntax lets the compiler count elements.

Slices are the Go equivalent of Ruby arrays. A slice has three internal fields: a pointer to a backing array, a length, and a capacity. append returns a new slice header — you must assign the result back (numbers = append(numbers, 4)). Forgetting this is a common bug. Slicing a slice shares the backing array — see the Gotchas section.

The "comma-ok" pattern (value, ok := map[key]) is essential — a missing key returns the zero value of the value type (0 for int, "" for string), not nil. Without the ok check, a missing key and a stored 0 are indistinguishable. Maps are not safe for concurrent reads and writes — use sync.Map or a sync.RWMutex.

Go if always requires braces — no one-liners, no unless. Parentheses around the condition are not required and gofmt removes them. The init statement (if value := expr; condition) is idiomatic for error checks and scopes the variable to the if/else block. There is no ternary operator.

Go functions always require explicit return — there is no implicit last-expression return. Parameter types follow the parameter name (name type, not type name). When consecutive parameters share a type, write a, b int. Functions are first-class values. The return type comes after the parameter list.

Multiple return values are Go's idiomatic replacement for Ruby's array returns, exceptions, and rescue. The (result, error) pattern is universal — callers are forced to acknowledge failures. Use _ to discard a return value you don't need. Named return values (e.g., (result float64, err error)) document intent but naked return hurts readability in longer functions.

Variadic parameters (...T) collect extra arguments into a slice — equivalent to Ruby's splat (*args). A variadic parameter must be the last parameter. To pass a slice to a variadic function, spread it with ...: sum(values...). Unlike Ruby, Go allows only one variadic parameter per function, and it must collect values of the same type.

Go closures capture variables by reference — the closure sees the variable itself, not a snapshot of its value at creation time. This matches Ruby's block/lambda behaviour. A common goroutine gotcha: capturing a loop variable captures the variable (which keeps changing), not its current value. Fix: assign to a local variable inside the loop before spawning the goroutine.

Go has no classes — structs with methods are the equivalent. Exported identifiers (fields, methods, types, functions) begin with an uppercase letter; unexported (private to the package) begin with lowercase. Methods are defined outside the struct body, linked by a receiver. The receiver is named by convention with a 1–2 letter abbreviation of the type. There is no self keyword.

Use pointer receivers (*T) when a method needs to modify the struct, or when the struct is large enough that copying is expensive. Use value receivers when the method only reads and the struct is small. Consistency matters: if any method uses a pointer receiver, all methods should. Go automatically takes the address when you call a pointer-receiver method on an addressable value.

The fmt.Stringer interface (String() string) is Go's equivalent of Ruby's to_s. Any type implementing it controls how fmt.Println and %v/%s display it. The %+v verb bypasses Stringer and prints raw struct fields — useful for debugging. fmt.GoStringer (GoString() string) maps to Ruby's inspect.

Embedding is Go's composition mechanism — the embedded type's fields and methods are promoted to the outer struct. This is not inheritance: no polymorphism, no super, no "is-a" relationship. It is purely a syntactic convenience. The outer type can shadow a promoted method by defining its own method with the same name. This is the Go equivalent of Ruby's include.

Go interfaces are satisfied implicitly — a type implements an interface if it has all the required methods, with no implements declaration. This is structurally equivalent to Ruby's duck typing but verified at compile time. The io.Reader, io.Writer, and error interfaces are the cornerstone of Go's standard library. any (alias for interface{}) is satisfied by all types.

The error interface has one method: Error() string. Functions that can fail return (value, error). %w in fmt.Errorf wraps an error, preserving the chain for errors.Is (identity check) and errors.As (type check). There are no exceptions. Returning errors as values forces acknowledgment at every call site — this is intentional, not a deficiency.

Type switches are the idiomatic pattern for branching on the underlying type of an interface value — the direct Go equivalent of Ruby's case/when with class checks. The comma-ok form of a type assertion (value, ok := x.(Type)) is safe; the single-return form (value := x.(Type)) panics if the type does not match.

Go error handling is explicit and intentionally repetitive. The if err != nil { return nil, err } pattern appears constantly. Wrap errors with %w to preserve the chain for callers using errors.Is or errors.As. There are no silent exceptions, no unexpected control-flow jumps, and no hidden rescue clauses. This verbosity is the design.

defer is Go's ensure — deferred calls run when the function exits (normally or via panic) in LIFO order. Use it for cleanup: closing files, releasing locks, closing connections. panic is reserved for programming errors that should never occur — not for expected failures. recover can catch a panic inside a deferred function; this pattern is rare in application code.

Go is pass-by-value — every function argument is a copy. Use pointers (*T) to share a value and allow mutation, or to avoid copying large structs. & takes the address of a variable; * dereferences a pointer to get or set its value. There is no pointer arithmetic. Ruby hides all of this — all objects are implicitly references. Go surfaces memory ownership explicitly.

Goroutines are Go's lightweight concurrency primitive — far cheaper than OS threads (starting at ~2KB stack). The go keyword starts a function call in a new goroutine and returns immediately. sync.WaitGroup is the equivalent of Thread#join: Add registers goroutines, Done signals completion (via defer), and Wait blocks until all complete.

Channels are typed, goroutine-safe queues. <- sends to a channel; value := <-channel receives. An unbuffered channel synchronises sender and receiver — both block until the other is ready. A buffered channel blocks the sender only when full. Always close from the sender, never the receiver. range over a channel reads until it is closed.

select waits on multiple channel operations simultaneously — whichever is ready first executes. If multiple are ready, one is chosen at random. A default case makes the select non-blocking. time.After returns a channel that receives once after the duration — the standard timeout pattern. select is to channels what switch is to values.

sync.Mutex is Go's equivalent of Ruby's Mutex#synchronize. Use defer mu.Unlock() immediately after mu.Lock() — it is idiomatic and ensures the lock is released even on panic. context.Context propagates cancellation, deadlines, and request-scoped values across goroutines. Pass it as the first parameter to any function that does I/O. Always defer cancel().

Go modules (go.mod) replaced GOPATH in Go 1.11. The module path is typically a URL (github.com/user/repo) — the globally unique namespace. go.sum records cryptographic hashes of downloaded modules; always commit it. go mod tidy is idempotent — run it before every commit. There is no bundle exec equivalent; go run and go build always use the module's dependencies.

The capitalisation rule applies to everything at package scope: types, functions, methods, fields, variables, and constants. Uppercase = exported (public); lowercase = unexported (package-private). There are exactly two access levels — no protected. Unexported identifiers are accessible to all code in the same package, including _test.go files that declare the same package name.

Tests live in *_test.go files alongside the code they test. Test functions must begin with Test and accept *testing.T. Table-driven tests (a slice of struct test cases) are the standard Go idiom — equivalent to RSpec's parameterised examples. Use t.Errorf for non-fatal failures and t.Fatalf to stop immediately. There is no built-in assertion library.

The Go compiler refuses to compile code with unused local variables or unused imports. This catches typos and dead code at compile time. The blank identifier _ explicitly discards a value and tells the compiler "I know I'm not using this". Blank imports (import _ "pkg") run the package's init() for side effects (e.g., registering a database driver).

The nil interface subtlety is a classic Go bug: an interface value is nil only if both its type and value fields are nil. Assigning a typed nil pointer to an interface sets the type field, making the interface non-nil even though the underlying pointer is nil.

Use copy() or append([]int{}, original[1:4]...) to get a truly independent copy. This sharing is intentional for performance but is a common source of subtle bugs when slices are passed to goroutines.

Goroutines are not garbage-collected while running or blocked. A goroutine blocked on a channel receive with no sender is a goroutine leak — it holds memory until the process exits. Always give long-running goroutines a way to stop: pass a context.Context and check ctx.Done(), or signal via a dedicated done channel. The goleak package detects leaks in tests.

Go map iteration order is intentionally randomised on each run — the runtime shuffles it to prevent programs from accidentally depending on insertion order. Unlike Ruby's Hash (which has preserved insertion order since Ruby 1.9), Go maps make no ordering guarantee. To iterate in consistent order, collect the keys into a slice, sort it, then iterate.

Rubyists expect ensure-like per-iteration cleanup, but defer inside a loop queues all cleanup until the entire function exits, potentially exhausting file descriptors. Fix: wrap the loop body in a helper function so each call gets its own defer scope.