Go

How Go automatically initializes variables without explicit assignment.

The difference between fixed-size arrays and dynamic slices.

Key-value hash tables in Go.

Creating custom data types and simulating object-oriented behavior.

Organizing and managing dependencies in Go.

How to share and mutate data without making expensive copies.

Implicitly fulfilled contracts for polymorphism.

Extracting the concrete underlying value from an interface.

Routing logic based on the underlying type of an interface.

Writing reusable functions and data structures without losing type safety.

Lightweight, user-space threads managed by the Go runtime.

The primary mechanism for communicating safely between Goroutines.

Waiting on multiple channel operations simultaneously.

Waiting for a collection of Goroutines to finish executing.

Preventing race conditions by locking shared memory.

Lock-free synchronization for simple counters and flags.

Controlling concurrency limits to prevent out-of-memory crashes.

Multiplexing and demultiplexing data streams across channels.

Streaming data through a series of concurrent processing stages.

When concurrent operations ruin data integrity, and how to find them.

When goroutines wait on each other forever.

Propagating request-scoped data, cancellations, and timeouts.

Manually aborting goroutines using WithCancel.

Setting an absolute timestamp for a context to expire.

Setting relative time limits on operations.

Errors are just values in Go.

Adding context to errors while preserving the original cause.

Inspecting the root cause of wrapped errors.

Handling catastrophic failures and preventing server crashes.

How pointers interact with the Stack and the Heap.

How the compiler decides between Stack and Heap allocation.

How Go automatically frees unused memory.

How Go manages internal memory via Arenas and Spans.

The invisible engine embedded in every Go application.

How Go multiplexes thousands of Goroutines onto a few OS threads.

The internal architecture of the Go Scheduler.

The states of a Goroutine from creation to death.

The gold standard for web servers and clients.

Why you shouldn't use http.ListenAndServe in production.

Making external API calls correctly.

Tuning the http.Transport for high-throughput.

Stopping the server without dropping active user requests.

The standard abstraction layer for SQL databases in Go.

Tuning *sql.DB for production loads.

Executing multiple queries reliably.

Identifying bottlenecks in your Go applications.

Live profiling for running web servers.

Measuring the exact speed and memory allocations of your code.

Why heap allocations kill your server's throughput.

Visualizing the Go Scheduler and Goroutine blocks.

The built-in testing framework in Go.

The definitive Go pattern for writing clean, repetitive tests.

Isolating code by simulating dependencies.

Implementing performance tests in the testing framework.

Finding edge-case bugs by throwing random garbage at your code.

How your Go app interacts with Kubernetes Pod Lifecycle events.

Why you shouldn't use log.Println in production.

Monitoring the health of your Go application.

Following a request across multiple microservices.

Managing dependencies, versions, and the vendor directory.

The end of formatting arguments.

Catching bugs before they compile.

Enforcing quality standards across large teams.

Inspecting and modifying types at runtime.

Bypassing Go's type safety and memory protections.

Recycling objects to save the Garbage Collector.

Lock-free synchronization at the hardware level.

What interviewers look for in a Senior Go Engineer.

Common algorithmic and concurrency tasks asked in Go interviews.

Tricky Go snippets designed to test your knowledge of mechanics.