How Go Interfaces Work Under the Hood

1. Introduction & The Implicit Interface Philosophy

• Implicit Satisfaction: Contrast Go's duck typing at compile-time with explicit implements interfaces in languages like Java or C#.
• The Core Thesis: While Go interfaces feel zero-cost and syntactic, they are concrete two-pointer structs managed dynamic-dispatch machinery at runtime.

2. Interface Internal Structures: eface vs. iface

• Explain how the Go runtime (src/runtime/runtime2.go) categorizes interfaces into two distinct internal layouts:
• Empty Interface (eface):
  • Used for interface{} / any.
  • Pointer to type metadata (_type) and pointer to underlying data (data).
• Non-Empty Interface (iface):
  • Used for interfaces with methods (e.g., io.Reader).
  • Consists of an itab pointer (tab) and data pointer (data).

3. The itab Deep Dive (Interface Table)

• What is an itab? Explain that itab holds type information as well as the virtual function table (vtable).
• Anatomy of itab:
  • inter: Pointer to the interface type metadata.
  • _type: Pointer to the concrete type metadata.
  • hash: Copy of concrete type's hash for fast type assertions.
  • fun: Function pointer array mapping interface methods to concrete implementations.
  • itab Caching: How the runtime uses a global hash table to cache itab lookups so type conversions only pay the construction cost once.

4. The "Interface Equals Nil" Pitfall

• Explain why an interface containing a nil pointer is not a nil interface.
• Show how iface.tab exists while iface.data is nil, leading to subtle bugs:

  var buf *bytes.Buffer // nil pointer var r io.Reader = buf // non-nil interface!
  (tab != nil, data == nil)
  
  fmt.Println(r == nil) // Evaluates to FALSE
  

5. Performance Costs & Escape Analysis

• Indirect Method Calls: Why dynamic dispatch via function pointers disables compiler inlining.
• Heap Allocations (Escape Analysis):
  • How converting values to interfaces often causes values to escape to the heap.
  • Pointer boxing: Primitive values or structs wrapped in unsafe.Pointer.
  • Benchmarks: Show a quick benchmark comparing direct method calls vs. interface dynamic calls.

6. Type Assertions & Type Switches Mechanics

• How val.(T) checks type matching using the hash field in itab or _type.
• The runtime function assertE2I / assertI2I mechanics.

7. Practical Engineering Takeaways

• Accept Interfaces, Return Structs: Why this idiom prevents unnecessary heap allocations and abstraction leaks.
• Keep Interfaces Small: Single-method interfaces (io.Reader, fmt.Stringer) maximize reuse and keep itab tables lean.
• Hot-Path Optimization: When to avoid interfaces in performance-critical inner loops to preserve inlining and zero-allocation guarantees.