Interface Practice

Build a logger and storage abstraction that demonstrates real-world interface design, mock implementations, and testable code.

8 min readProgramming Foundations (Go)Code

Design the Interfaces

Good interfaces are discovered from usage, not designed upfront. Start with the concrete type, extract the interface when you need a second implementation or a test double.

Gologger-and-store-interfaces.go

31 linesLn 1, Col 1Go

Each interface is small and focused: `Logger` does one thing, `Store` does three related things. Keeping them separate lets you mix and match implementations — a file-backed store with a JSON logger, or a memory store with a no-op logger in tests.

Concrete Implementations

Concrete implementations are the real production types. They satisfy the interface implicitly by having the right methods.

Goconsole-logger-and-in-memory-store.go

73 linesLn 1, Col 1Go

`ConsoleLogger` and `MemoryStore` satisfy `Logger` and `Store` respectively without any explicit declaration. The compiler verifies this whenever they are used in a context that expects the interface.

Mock Implementations

A mock replaces a real implementation for testing. Because our code depends on interfaces, not concrete types, we can inject a mock without changing any production code.

Gomock-store-and-logger-for-testing.go

69 linesLn 1, Col 1Go

`TaskService` depends only on the `Store` and `Logger` interfaces — it never imports a specific database driver or logger. Injecting `FailingStore` and `RecordingLogger` lets tests verify error handling without writing to disk or stdout.

Composing with Interfaces

Small interfaces compose naturally. A ReadWriter interface embeds Reader and Writer. A logging wrapper can implement Store by forwarding to another Store. These patterns appear throughout the standard library.

Gologging-store-wrapper.go

72 linesLn 1, Col 1Go

`LoggingStore` satisfies `Store` and wraps any other `Store`. You can wrap the same `MemStore` with a `CachingStore`, a `LoggingStore`, and a `MetricsStore` — stacking behaviour without modifying the original type. This is the **decorator pattern** in Go.

Mark this lesson complete to store local progress and unlock a cleaner resume path the next time you visit.

Stage 1 · Code

Methods, Interfaces & Errors