Myth of the Side Hustle

Every complex system is built upon simpler foundations. In this chapter, we examine those building blocks.

Abstraction

Abstraction is the art of hiding complexity behind simple interfaces. It’s one of the most powerful tools in our arsenal.noteThe concept of abstraction in computing dates back to the 1950s when programmers began creating subroutines to hide implementation details. Today, it remains the primary mechanism for managing complexity in software systems.

When you use a smartphone, you don’t think about the millions of transistors switching on and off. You tap an icon and an app opens. That’s abstraction at work.

Layers of Abstraction

Modern systems are built in layers, each one hiding the complexity of the layer below:

• User Interface — What you see and interact with
• Application Logic — The rules and processes
• Data Layer — Where information is stored
• Infrastructure — The machines that run everything

Modularity

Breaking systems into independent components makes them easier to understand, build, and maintain.

A well-designed module has:

1. Clear boundaries — You know where it starts and ends
2. Defined interfaces — You know how to interact with it
3. Single responsibility — It does one thing well

// A modular approach to user management
type UserService struct {
    repo UserRepository
    auth AuthService
    log  Logger
}

func (s *UserService) CreateUser(email string) (*User, error) {
    // Each dependency handles its own concern
    if err := s.auth.ValidateEmail(email); err != nil {
        return nil, err
    }
    
    user := &User{Email: email}
    if err := s.repo.Save(user); err != nil {
        s.log.Error("failed to save user", err)
        return nil, err
    }
    
    return user, nil
}

Iteration

Progress rarely happens in a single leap. Instead, we improve through repeated cycles of building, testing, and refining.

The key principles of iteration:

• Start small — Begin with the simplest version that could work
• Get feedback — Learn from real-world usage
• Improve incrementally — Make small, focused changes
• Repeat — Continue the cycle indefinitely

Summary

These three principles—abstraction, modularity, and iteration—form the foundation for everything else we’ll explore in this book.