Protocol-Driven Development: Rethinking Software Architecture

Rediscover the essence of message-passing systems, inspired by Smalltalk and designed to tackle real-world application challenges.

In traditional software systems, architectures resemble rigid vehicles, limiting adaptability and making changes cumbersome. Protocol-Driven Development (PDD) offers a fresh perspective, presenting the idea of building software like hydraulic machinery with flexible connections and interchangeable components.

The Problem with Conventional Architectures

Most modern codebases are entity-centric, with closely tied components leading to challenging bug tracing and maintenance tasks. Services often resemble bloated function bags, with interfaces primarily used for mocking or REST APIs, creating brittle connections that complicate modifications.

Comparing Vehicles to Hydraulics

• Vehicles: Conventional systems are tightly-coupled, where altering one component requires exact replacements. Bugs can be entwined in interdependencies, leading to complex debugging.
• Hydraulics: In contrast, hydraulic systems function with standardized parts, connected through simple adapters. Components interact via well-defined messages, achieving compatibility through protocol matching, not rigid dependencies.

Understanding Protocol-Driven Development (PDD)

PDD emphasizes:

• Explicit message contracts to model behavior
• Separation of concerns: Logic is distinct from storage, UI, and timing
• Late binding and runtime substitutions
• Minimal and focused protocols that serve as foundational elements in system design

PDD is not merely about utilizing interfaces; it is about architecting systems around them for enhanced flexibility and composability.

Key Quotes on PDD

• "The key in making great and growable systems is much more to design how its modules communicate rather than what their internal properties and behaviors should be." — Alan Kay
• "OOP to me means only messaging, local retention and protection and hiding of state-process, and extreme late-binding of all things." — Alan Kay
• "Complexity is anything related to the structure of a system that makes it hard to understand or change." — Rich Hickey

A Transformative Insight

Historically, many programming paradigms have explored similar concepts, but real breakthroughs often come from rethinking how components interact. PDD offers an innovative approach inspired by foundational programming ideals, connecting behaviors and data through well-defined messaging.

Example: Implementing Protocols in Go

type Repository[T any] interface {
    Save(t *T) (int64, error)
    Get(id int64) (*T, error)
    Delete(id int64) error
    List() ([]*T, error)
}

type Entity struct {
    ID   int64
    Name string
}

type EntityRepository interface {
    Repository[Entity]
}

type EntityManager struct {
    Repo EntityRepository
}
}

func (m *EntityManager) Rename(id int64, newName string) error {
    entity, err := m.Repo.Get(id)
    if err != nil {
        return err
    }
    entity.Name = newName
    _, err = m.Repo.Save(entity)
    return err
}

This design ensures that the system remains flexible and easily testable, allowing for the seamless incorporation of new functionalities without hindering existing components.

Final Thoughts

With PDD, software systems can evolve more naturally through composable design. By defining primary components and their interactions, developers can construct robust architectures, emphasizing protocols that guide behavior while maintaining a fluid system structure.

Embrace Protocol-Driven Development to unlock a new dimension in software design, focusing on clear communication through protocols and ensuring a resilient codebase.