Lectures

We break down interfaces in Go as a set of methods (method set): why an interface describes only behavior, why you can’t require fields, and how implicit implementation works without the implements keyword. In practice, we build an extension point using TaskFormatter and the PrintTasks function, look at standard library interfaces ( error, fmt.Stringer), reinforce the idea with a mermaid diagram, and analyze typical mistakes (fields through an interface, “almost matching signature”, interfaces that are too large).

We break down why an interface in Go is not a “box,” but a pair (dynamic type, dynamic value), and where the typed nil trap comes from: when err prints like nil, but the comparison err != nil is unexpectedly true. Using practical examples with error, fmt.Stringer, and diagnostics via fmt.Printf( "%T"), we reinforce the rule: on the success path, return exactly nil, not (*T)(nil) packaged into an interface.

We break down a practical Go principle: an interface is the price of a contract. We learn to design dependencies around minimal behavior (for example, TaskLister with the List() method), separate reads and writes ( TaskAdder, TaskCompleter), compose contracts via embedding ( TaskStore), spot “combine harvesters” like MegaTaskService, and refactor them into small interfaces without unnecessary dependencies and stubs.

Let’s break down a practical Go rule: interfaces are most often declared on the consumer side—where the code depends on the abstraction and wants to call methods without knowing the implementation. Using a mini example Tasker, we’ll see why a type interface like TaskStore makes more sense to keep in the tasker package rather than in memstore, how this affects dependencies, the public API, and swapping implementations ( EmptyStore, different stores), and what mistakes are made most often when choosing where an interface should live.

We break down how a method set ( method set) in Go depends on the receiver and why an interface can accept * T but not T. Using the TaskStore interface and the MemStore implementation, we will see the classic “ Add has pointer receiver” mistake, understand the difference between a convenient method call and verifying an interface implementation, learn to diagnose a dynamic type via fmt.Printf( "%T", x), and avoid the typed nil trap in interfaces like error.