SOLID Principles: The Foundation of Great Software Design

The Story of a Collapsing Codebase

What Does SOLID Stand For?

Design principles diagram 1

Single Responsibility Principle (SRP)

The Principle in Plain English

The Swiss Army Knife Problem

1. It's awkward to use - All those extra tools get in the way
2. It's harder to maintain - If the screwdriver breaks, you can't use any of it while it's being repaired
3. It's not the best at anything - A dedicated chef's knife will always outperform the Swiss Army blade

A Real World Disaster

go
// Filename: bad_user_service.go
// This is an example of TERRIBLE code - don't do this!

package main

import (
    "database/sql"
    "encoding/json"
    "fmt"
    "log"
    "net/smtp"
    "os"
    "time"
)

// User does EVERYTHING related to users
// Why this is bad: This struct has at least 5 different reasons to change
type User struct {
    ID        int
    Name      string
    Email     string
    Password  string
    CreatedAt time.Time

    // Database connection embedded in the model!
    db *sql.DB

    // Email configuration embedded too!
    smtpHost string
    smtpPort string
}

// Save handles database operations
// Why this is bad: If database schema changes, this changes
func (u *User) Save() error {
    query := "INSERT INTO users (name, email, password, created_at) VALUES (?, ?, ?, ?)"
    _, err := u.db.Exec(query, u.Name, u.Email, u.Password, u.CreatedAt)
    if err != nil {
        // Logging is also handled here!
        log.Printf("Failed to save user: %v", err)
        return err
    }

    // After saving, also send welcome email
    // Why this is bad: If email requirements change, this changes
    u.SendWelcomeEmail()

    return nil
}

// SendWelcomeEmail handles email sending
// Why this is bad: If email template changes, this changes
func (u *User) SendWelcomeEmail() error {
    auth := smtp.PlainAuth("", "noreply@company.com", "password", u.smtpHost)

    msg := fmt.Sprintf("Welcome %s! Thanks for joining.", u.Name)

    err := smtp.SendMail(
        u.smtpHost+":"+u.smtpPort,
        auth,
        "noreply@company.com",
        []string{u.Email},
        []byte(msg),
    )

    if err != nil {
        log.Printf("Failed to send email: %v", err)
    }

    return err
}

// ToJSON handles serialization
// Why this is bad: If API format changes, this changes
func (u *User) ToJSON() ([]byte, error) {
    return json.Marshal(map[string]interface{}{
        "id":    u.ID,
        "name":  u.Name,
        "email": u.Email,
        // Note: We're excluding password, but this logic lives in User
    })
}

// ValidatePassword handles security logic
// Why this is bad: If security requirements change, this changes
func (u *User) ValidatePassword() error {
    if len(u.Password) < 8 {
        return fmt.Errorf("password must be at least 8 characters")
    }
    // More validation logic...
    return nil
}

// GenerateReport handles reporting
// Why this is bad: If report format changes, this changes
func (u *User) GenerateReport() string {
    return fmt.Sprintf("User Report\n===========\nID: %d\nName: %s\nEmail: %s\nCreated: %s",
        u.ID, u.Name, u.Email, u.CreatedAt.Format("2006-01-02"))
}

// WriteToFile handles file operations
// Why this is bad: If file format requirements change, this changes
func (u *User) WriteToFile(filename string) error {
    data, _ := u.ToJSON()
    return os.WriteFile(filename, data, 0644)
}

1. Database schema changes - Save() needs updating
2. Email provider changes - SendWelcomeEmail() needs updating
3. API format changes - ToJSON() needs updating
4. Security policy changes - ValidatePassword() needs updating
5. Report format changes - GenerateReport() needs updating
6. File storage changes - WriteToFile() needs updating
7. Logging strategy changes - All methods with logging need updating

The Solution: Separation of Concerns

go
// Filename: srp_solution.go
package main

import (
    "database/sql"
    "encoding/json"
    "fmt"
    "net/smtp"
    "os"
    "time"
)

// =============================================================================
// DOMAIN LAYER: Pure data structures with no external dependencies
// =============================================================================

// User represents a user in our system
// Why: This struct has ONE job - represent user data
// It changes only when business definition of "user" changes
type User struct {
    ID        int
    Name      string
    Email     string
    Password  string
    CreatedAt time.Time
}

// =============================================================================
// PERSISTENCE LAYER: Handles all database operations
// =============================================================================

// UserRepository handles database operations for users
// Why: Single responsibility - data persistence
// Changes only when database/storage requirements change
type UserRepository struct {
    db *sql.DB
}

// NewUserRepository creates a repository with database connection
func NewUserRepository(db *sql.DB) *UserRepository {
    return &UserRepository{db: db}
}

// Save persists a user to the database
// Why: This method only cares about putting data in the database
func (r *UserRepository) Save(user *User) error {
    query := `INSERT INTO users (name, email, password, created_at)
              VALUES (?, ?, ?, ?)`

    result, err := r.db.Exec(query, user.Name, user.Email,
                              user.Password, user.CreatedAt)
    if err != nil {
        return fmt.Errorf("failed to save user: %w", err)
    }

    id, err := result.LastInsertId()
    if err != nil {
        return fmt.Errorf("failed to get user ID: %w", err)
    }

    user.ID = int(id)
    return nil
}

// FindByID retrieves a user by their ID
func (r *UserRepository) FindByID(id int) (*User, error) {
    query := "SELECT id, name, email, password, created_at FROM users WHERE id = ?"

    user := &User{}
    err := r.db.QueryRow(query, id).Scan(
        &user.ID, &user.Name, &user.Email,
        &user.Password, &user.CreatedAt,
    )

    if err != nil {
        return nil, fmt.Errorf("user not found: %w", err)
    }

    return user, nil
}

// FindByEmail retrieves a user by email
func (r *UserRepository) FindByEmail(email string) (*User, error) {
    query := "SELECT id, name, email, password, created_at FROM users WHERE email = ?"

    user := &User{}
    err := r.db.QueryRow(query, email).Scan(
        &user.ID, &user.Name, &user.Email,
        &user.Password, &user.CreatedAt,
    )

    if err != nil {
        return nil, fmt.Errorf("user not found: %w", err)
    }

    return user, nil
}

// =============================================================================
// EMAIL LAYER: Handles all email operations
// =============================================================================

// EmailConfig holds SMTP configuration
type EmailConfig struct {
    Host     string
    Port     string
    Username string
    Password string
    From     string
}

// EmailService handles sending emails
// Why: Single responsibility - email communication
// Changes only when email requirements change
type EmailService struct {
    config EmailConfig
}

// NewEmailService creates an email service with configuration
func NewEmailService(config EmailConfig) *EmailService {
    return &EmailService{config: config}
}

// SendWelcome sends a welcome email to a new user
func (e *EmailService) SendWelcome(user *User) error {
    subject := "Welcome to Our Platform!"
    body := fmt.Sprintf(`
Dear %s,

Welcome to our platform! We're excited to have you on board.

Your account has been created successfully. You can now log in
using your email: %s

If you have any questions, feel free to reach out to our support team.

Best regards,
The Team
`, user.Name, user.Email)

    return e.send(user.Email, subject, body)
}

// SendPasswordReset sends a password reset email
func (e *EmailService) SendPasswordReset(user *User, resetToken string) error {
    subject := "Password Reset Request"
    body := fmt.Sprintf(`
Dear %s,

We received a request to reset your password.

Click the link below to reset your password:
https://ourplatform.com/reset?token=%s

If you didn't request this, please ignore this email.

Best regards,
The Team
`, user.Name, resetToken)

    return e.send(user.Email, subject, body)
}

// send is a private helper that actually sends the email
func (e *EmailService) send(to, subject, body string) error {
    auth := smtp.PlainAuth("", e.config.Username, e.config.Password, e.config.Host)

    msg := []byte(fmt.Sprintf(
        "To: %s\r\nSubject: %s\r\n\r\n%s",
        to, subject, body,
    ))

    addr := fmt.Sprintf("%s:%s", e.config.Host, e.config.Port)
    return smtp.SendMail(addr, auth, e.config.From, []string{to}, msg)
}

// =============================================================================
// VALIDATION LAYER: Handles all validation logic
// =============================================================================

// PasswordPolicy defines rules for valid passwords
type PasswordPolicy struct {
    MinLength        int
    RequireUppercase bool
    RequireNumbers   bool
    RequireSpecial   bool
}

// DefaultPasswordPolicy returns standard password requirements
func DefaultPasswordPolicy() PasswordPolicy {
    return PasswordPolicy{
        MinLength:        8,
        RequireUppercase: true,
        RequireNumbers:   true,
        RequireSpecial:   false,
    }
}

// UserValidator handles validation of user data
// Why: Single responsibility - data validation
// Changes only when validation rules change
type UserValidator struct {
    passwordPolicy PasswordPolicy
}

// NewUserValidator creates a validator with given policy
func NewUserValidator(policy PasswordPolicy) *UserValidator {
    return &UserValidator{passwordPolicy: policy}
}

// ValidateForRegistration checks if user data is valid for new registration
func (v *UserValidator) ValidateForRegistration(user *User) []string {
    var errors []string

    // Validate name
    if len(user.Name) < 2 {
        errors = append(errors, "name must be at least 2 characters")
    }
    if len(user.Name) > 100 {
        errors = append(errors, "name cannot exceed 100 characters")
    }

    // Validate email
    if !v.isValidEmail(user.Email) {
        errors = append(errors, "invalid email format")
    }

    // Validate password
    passwordErrors := v.validatePassword(user.Password)
    errors = append(errors, passwordErrors...)

    return errors
}

// validatePassword checks password against policy
func (v *UserValidator) validatePassword(password string) []string {
    var errors []string

    if len(password) < v.passwordPolicy.MinLength {
        errors = append(errors,
            fmt.Sprintf("password must be at least %d characters",
                v.passwordPolicy.MinLength))
    }

    if v.passwordPolicy.RequireUppercase && !v.hasUppercase(password) {
        errors = append(errors, "password must contain at least one uppercase letter")
    }

    if v.passwordPolicy.RequireNumbers && !v.hasNumber(password) {
        errors = append(errors, "password must contain at least one number")
    }

    return errors
}

func (v *UserValidator) isValidEmail(email string) bool {
    // Simple validation - in production, use a proper library
    return len(email) > 5 &&
           containsString(email, "@") &&
           containsString(email, ".")
}

func (v *UserValidator) hasUppercase(s string) bool {
    for _, r := range s {
        if r >= 'A' && r <= 'Z' {
            return true
        }
    }
    return false
}

func (v *UserValidator) hasNumber(s string) bool {
    for _, r := range s {
        if r >= '0' && r <= '9' {
            return true
        }
    }
    return false
}

func containsString(s, substr string) bool {
    return len(s) >= len(substr) &&
           (s == substr || len(s) > 0 && containsString(s[1:], substr) ||
            len(s) >= len(substr) && s[:len(substr)] == substr)
}

// =============================================================================
// SERIALIZATION LAYER: Handles data format conversions
// =============================================================================

// UserSerializer handles converting users to different formats
// Why: Single responsibility - data serialization
// Changes only when output format requirements change
type UserSerializer struct{}

// UserDTO is the Data Transfer Object for API responses
// Why: Separates internal User model from external API contract
type UserDTO struct {
    ID        int    `json:"id"`
    Name      string `json:"name"`
    Email     string `json:"email"`
    CreatedAt string `json:"created_at"`
    // Note: Password is intentionally excluded
}

// ToJSON converts a user to JSON format
func (s *UserSerializer) ToJSON(user *User) ([]byte, error) {
    dto := UserDTO{
        ID:        user.ID,
        Name:      user.Name,
        Email:     user.Email,
        CreatedAt: user.CreatedAt.Format(time.RFC3339),
    }
    return json.Marshal(dto)
}

// ToJSONList converts multiple users to JSON array
func (s *UserSerializer) ToJSONList(users []*User) ([]byte, error) {
    dtos := make([]UserDTO, len(users))
    for i, user := range users {
        dtos[i] = UserDTO{
            ID:        user.ID,
            Name:      user.Name,
            Email:     user.Email,
            CreatedAt: user.CreatedAt.Format(time.RFC3339),
        }
    }
    return json.Marshal(dtos)
}

// =============================================================================
// REPORTING LAYER: Handles report generation
// =============================================================================

// UserReportGenerator creates reports about users
// Why: Single responsibility - report generation
// Changes only when report format requirements change
type UserReportGenerator struct{}

// GenerateSummary creates a text summary for a user
func (r *UserReportGenerator) GenerateSummary(user *User) string {
    return fmt.Sprintf(`
╔══════════════════════════════════════╗
║          USER SUMMARY REPORT          ║
╠══════════════════════════════════════╣
║ ID:       %-28d ║
║ Name:     %-28s ║
║ Email:    %-28s ║
║ Created:  %-28s ║
╚══════════════════════════════════════╝
`, user.ID, user.Name, user.Email, user.CreatedAt.Format("2006-01-02 15:04:05"))
}

// GenerateCSVRow creates a CSV row for a user
func (r *UserReportGenerator) GenerateCSVRow(user *User) string {
    return fmt.Sprintf("%d,%s,%s,%s",
        user.ID,
        user.Name,
        user.Email,
        user.CreatedAt.Format("2006-01-02"),
    )
}

// =============================================================================
// FILE STORAGE LAYER: Handles file operations
// =============================================================================

// FileStorage handles writing data to files
// Why: Single responsibility - file system operations
// Changes only when file storage requirements change
type FileStorage struct {
    basePath string
}

// NewFileStorage creates a file storage with base path
func NewFileStorage(basePath string) *FileStorage {
    return &FileStorage{basePath: basePath}
}

// SaveJSON writes JSON data to a file
func (f *FileStorage) SaveJSON(filename string, data []byte) error {
    path := fmt.Sprintf("%s/%s", f.basePath, filename)
    return os.WriteFile(path, data, 0644)
}

// =============================================================================
// ORCHESTRATION LAYER: Coordinates the pieces
// =============================================================================

// UserService orchestrates user-related operations
// Why: This is a thin coordination layer that delegates to specialists
// It changes when the workflow changes, not when implementation details change
type UserService struct {
    repository *UserRepository
    validator  *UserValidator
    email      *EmailService
    serializer *UserSerializer
}

// NewUserService creates a user service with all dependencies
func NewUserService(
    repo *UserRepository,
    validator *UserValidator,
    email *EmailService,
    serializer *UserSerializer,
) *UserService {
    return &UserService{
        repository: repo,
        validator:  validator,
        email:      email,
        serializer: serializer,
    }
}

// RegisterUser handles the complete user registration workflow
func (s *UserService) RegisterUser(name, email, password string) (*User, error) {
    // Create user object
    user := &User{
        Name:      name,
        Email:     email,
        Password:  password, // In production, hash this!
        CreatedAt: time.Now(),
    }

    // Step 1: Validate
    if errors := s.validator.ValidateForRegistration(user); len(errors) > 0 {
        return nil, fmt.Errorf("validation failed: %v", errors)
    }

    // Step 2: Save to database
    if err := s.repository.Save(user); err != nil {
        return nil, fmt.Errorf("failed to save user: %w", err)
    }

    // Step 3: Send welcome email (don't fail registration if email fails)
    go func() {
        if err := s.email.SendWelcome(user); err != nil {
            // Log error but don't fail the registration
            fmt.Printf("Warning: failed to send welcome email: %v\n", err)
        }
    }()

    return user, nil
}

// GetUserJSON retrieves a user and returns as JSON
func (s *UserService) GetUserJSON(id int) ([]byte, error) {
    user, err := s.repository.FindByID(id)
    if err != nil {
        return nil, err
    }
    return s.serializer.ToJSON(user)
}

// =============================================================================
// DEMONSTRATION
// =============================================================================

func main() {
    fmt.Println("SRP Example - Each component has a single responsibility")
    fmt.Println("=========================================================")

    // In a real app, these would be injected via dependency injection
    // Here we demonstrate the structure

    // Create a user for demonstration
    user := &User{
        ID:        1,
        Name:      "Alice Johnson",
        Email:     "alice@example.com",
        Password:  "SecurePass123",
        CreatedAt: time.Now(),
    }

    // Demonstrate serialization (single responsibility)
    serializer := &UserSerializer{}
    jsonData, _ := serializer.ToJSON(user)
    fmt.Println("\nSerialized User (UserSerializer responsibility):")
    fmt.Println(string(jsonData))

    // Demonstrate reporting (single responsibility)
    reporter := &UserReportGenerator{}
    report := reporter.GenerateSummary(user)
    fmt.Println("\nUser Report (UserReportGenerator responsibility):")
    fmt.Println(report)

    // Demonstrate validation (single responsibility)
    validator := NewUserValidator(DefaultPasswordPolicy())
    errors := validator.ValidateForRegistration(user)
    fmt.Println("Validation Result (UserValidator responsibility):")
    if len(errors) == 0 {
        fmt.Println("✓ User data is valid")
    } else {
        fmt.Printf("✗ Validation errors: %v\n", errors)
    }
}

SRP Example - Each component has a single responsibility
=========================================================

Serialized User (UserSerializer responsibility):
{"id":1,"name":"Alice Johnson","email":"alice@example.com","created_at":"2024-02-13T10:30:00Z"}

User Report (UserReportGenerator responsibility):

╔══════════════════════════════════════╗
║          USER SUMMARY REPORT          ║
╠══════════════════════════════════════╣
║ ID:       1                            ║
║ Name:     Alice Johnson                ║
║ Email:    alice@example.com            ║
║ Created:  2024-02-13 10:30:00          ║
╚══════════════════════════════════════╝

Validation Result (UserValidator responsibility):
✓ User data is valid

Why SRP Matters in Real Life

Design principles diagram 2

Open/Closed Principle (OCP)

The Principle in Plain English

• Open for extension: You can add new behavior
• Closed for modification: You don't change existing code to add that behavior

The Power Outlet Analogy

A Real World Violation

go
// Filename: bad_payment_processor.go
// This violates OCP - we modify this function for every new payment method

package main

import "fmt"

// ProcessPayment handles all payment types
// Why this is bad: Adding a new payment method means modifying this function
func ProcessPayment(paymentType string, amount float64, details map[string]string) error {
    switch paymentType {
    case "credit_card":
        // Credit card processing logic
        cardNumber := details["card_number"]
        expiry := details["expiry"]
        cvv := details["cvv"]
        fmt.Printf("Processing credit card payment: %s, Amount: $%.2f\n",
            cardNumber[:4]+"****", amount)
        // Connect to Stripe, Authorize.net, etc.
        return nil

    case "paypal":
        // PayPal processing logic
        email := details["email"]
        fmt.Printf("Processing PayPal payment for: %s, Amount: $%.2f\n",
            email, amount)
        // Connect to PayPal API
        return nil

    case "bank_transfer":
        // Bank transfer logic
        accountNumber := details["account_number"]
        routingNumber := details["routing_number"]
        fmt.Printf("Processing bank transfer: %s, Amount: $%.2f\n",
            accountNumber, amount)
        // Connect to bank API
        return nil

    case "crypto":
        // ADDED LATER: Cryptocurrency payment
        // Every time we add a payment method, we modify this function!
        walletAddress := details["wallet"]
        fmt.Printf("Processing crypto payment to: %s, Amount: $%.2f\n",
            walletAddress, amount)
        return nil

    case "apple_pay":
        // ADDED EVEN LATER: Apple Pay
        // This function keeps growing and becoming more complex!
        token := details["token"]
        fmt.Printf("Processing Apple Pay with token: %s, Amount: $%.2f\n",
            token[:8]+"...", amount)
        return nil

    default:
        return fmt.Errorf("unsupported payment type: %s", paymentType)
    }
}

func main() {
    // Usage
    ProcessPayment("credit_card", 99.99, map[string]string{
        "card_number": "4111111111111111",
        "expiry":      "12/25",
        "cvv":         "123",
    })
}

1. Risk: Every new payment method requires modifying tested, working code
2. Testing: You need to retest all payment methods when adding a new one
3. Complexity: The function grows linearly with each new payment type
4. Merge Conflicts: Multiple developers adding payment methods will conflict
5. Violation of SRP: This function knows too much about too many payment systems

The Solution: Extension Through Abstraction

go
// Filename: ocp_payment_processor.go
package main

import (
    "fmt"
    "time"
)

// =============================================================================
// THE ABSTRACTION: Define what a payment processor must do
// =============================================================================

// PaymentResult contains the outcome of a payment attempt
type PaymentResult struct {
    Success       bool
    TransactionID string
    Message       string
    ProcessedAt   time.Time
}

// PaymentProcessor defines the contract for all payment methods
// Why: This interface is CLOSED - we won't change it
// But the system is OPEN - anyone can add new implementations
type PaymentProcessor interface {
    // ProcessPayment handles the payment
    ProcessPayment(amount float64) (*PaymentResult, error)

    // Validate checks if the payment details are valid before processing
    Validate() error

    // Name returns a human-readable name for logging/display
    Name() string
}

// =============================================================================
// IMPLEMENTATION 1: Credit Card Processor
// =============================================================================

// CreditCardProcessor handles credit card payments
type CreditCardProcessor struct {
    CardNumber string
    Expiry     string
    CVV        string
    CardHolder string
}

// NewCreditCardProcessor creates a credit card processor
func NewCreditCardProcessor(cardNumber, expiry, cvv, holder string) *CreditCardProcessor {
    return &CreditCardProcessor{
        CardNumber: cardNumber,
        Expiry:     expiry,
        CVV:        cvv,
        CardHolder: holder,
    }
}

func (c *CreditCardProcessor) Name() string {
    return "Credit Card"
}

func (c *CreditCardProcessor) Validate() error {
    if len(c.CardNumber) != 16 {
        return fmt.Errorf("invalid card number length")
    }
    if len(c.CVV) != 3 {
        return fmt.Errorf("invalid CVV")
    }
    // More validation...
    return nil
}

func (c *CreditCardProcessor) ProcessPayment(amount float64) (*PaymentResult, error) {
    // In real implementation: Connect to payment gateway (Stripe, etc.)
    fmt.Printf("💳 Connecting to credit card network...\n")
    fmt.Printf("💳 Authorizing card ending in %s\n", c.CardNumber[12:])
    fmt.Printf("💳 Charging $%.2f to %s\n", amount, c.CardHolder)

    return &PaymentResult{
        Success:       true,
        TransactionID: fmt.Sprintf("CC-%d", time.Now().UnixNano()),
        Message:       "Payment approved",
        ProcessedAt:   time.Now(),
    }, nil
}

// =============================================================================
// IMPLEMENTATION 2: PayPal Processor
// =============================================================================

// PayPalProcessor handles PayPal payments
type PayPalProcessor struct {
    Email    string
    Password string // In reality, use OAuth tokens
}

func NewPayPalProcessor(email, password string) *PayPalProcessor {
    return &PayPalProcessor{
        Email:    email,
        Password: password,
    }
}

func (p *PayPalProcessor) Name() string {
    return "PayPal"
}

func (p *PayPalProcessor) Validate() error {
    if p.Email == "" {
        return fmt.Errorf("PayPal email is required")
    }
    return nil
}

func (p *PayPalProcessor) ProcessPayment(amount float64) (*PaymentResult, error) {
    fmt.Printf("🅿️ Connecting to PayPal...\n")
    fmt.Printf("🅿️ Authenticating %s\n", p.Email)
    fmt.Printf("🅿️ Processing $%.2f\n", amount)

    return &PaymentResult{
        Success:       true,
        TransactionID: fmt.Sprintf("PP-%d", time.Now().UnixNano()),
        Message:       "PayPal payment complete",
        ProcessedAt:   time.Now(),
    }, nil
}

// =============================================================================
// IMPLEMENTATION 3: Cryptocurrency Processor (ADDED WITHOUT MODIFYING ABOVE!)
// =============================================================================

// CryptoProcessor handles cryptocurrency payments
// Why: We added this entire payment method WITHOUT changing any existing code!
type CryptoProcessor struct {
    WalletAddress string
    Currency      string // BTC, ETH, etc.
}

func NewCryptoProcessor(wallet, currency string) *CryptoProcessor {
    return &CryptoProcessor{
        WalletAddress: wallet,
        Currency:      currency,
    }
}

func (c *CryptoProcessor) Name() string {
    return fmt.Sprintf("Cryptocurrency (%s)", c.Currency)
}

func (c *CryptoProcessor) Validate() error {
    if len(c.WalletAddress) < 20 {
        return fmt.Errorf("invalid wallet address")
    }
    return nil
}

func (c *CryptoProcessor) ProcessPayment(amount float64) (*PaymentResult, error) {
    fmt.Printf("₿ Connecting to %s network...\n", c.Currency)
    fmt.Printf("₿ Sending to wallet: %s...%s\n",
        c.WalletAddress[:6], c.WalletAddress[len(c.WalletAddress)-4:])
    fmt.Printf("₿ Amount: $%.2f equivalent\n", amount)

    return &PaymentResult{
        Success:       true,
        TransactionID: fmt.Sprintf("CRYPTO-%d", time.Now().UnixNano()),
        Message:       fmt.Sprintf("%s payment broadcast to network", c.Currency),
        ProcessedAt:   time.Now(),
    }, nil
}

// =============================================================================
// IMPLEMENTATION 4: Apple Pay (ADDED EVEN LATER - STILL NO MODIFICATIONS!)
// =============================================================================

// ApplePayProcessor handles Apple Pay payments
type ApplePayProcessor struct {
    PaymentToken string
    DeviceID     string
}

func NewApplePayProcessor(token, deviceID string) *ApplePayProcessor {
    return &ApplePayProcessor{
        PaymentToken: token,
        DeviceID:     deviceID,
    }
}

func (a *ApplePayProcessor) Name() string {
    return "Apple Pay"
}

func (a *ApplePayProcessor) Validate() error {
    if a.PaymentToken == "" {
        return fmt.Errorf("Apple Pay token is required")
    }
    return nil
}

func (a *ApplePayProcessor) ProcessPayment(amount float64) (*PaymentResult, error) {
    fmt.Printf("🍎 Verifying Apple Pay token...\n")
    fmt.Printf("🍎 Device verified: %s\n", a.DeviceID[:8])
    fmt.Printf("🍎 Processing $%.2f\n", amount)

    return &PaymentResult{
        Success:       true,
        TransactionID: fmt.Sprintf("APPLE-%d", time.Now().UnixNano()),
        Message:       "Apple Pay authorized",
        ProcessedAt:   time.Now(),
    }, nil
}

// =============================================================================
// THE PAYMENT SERVICE: Works with ANY processor without modification
// =============================================================================

// PaymentService processes payments using any PaymentProcessor
// Why: This service is CLOSED for modification
// It works with any processor that implements the interface
type PaymentService struct {
    // We could add logging, metrics, retry logic here
    // And none of the processors need to know about it
}

// Process handles a payment using the given processor
// Why: This method never needs to change when we add new payment methods
func (s *PaymentService) Process(processor PaymentProcessor, amount float64) (*PaymentResult, error) {
    fmt.Printf("\n{'='*50}\n")
    fmt.Printf("Processing %s payment for $%.2f\n", processor.Name(), amount)
    fmt.Printf("{'='*50}\n\n")

    // Step 1: Validate
    if err := processor.Validate(); err != nil {
        return &PaymentResult{
            Success:     false,
            Message:     fmt.Sprintf("Validation failed: %v", err),
            ProcessedAt: time.Now(),
        }, err
    }
    fmt.Println("✓ Validation passed")

    // Step 2: Process
    result, err := processor.ProcessPayment(amount)
    if err != nil {
        return result, err
    }

    // Step 3: Log success
    fmt.Printf("\n✓ Payment successful!\n")
    fmt.Printf("  Transaction ID: %s\n", result.TransactionID)
    fmt.Printf("  Processed at: %s\n", result.ProcessedAt.Format(time.RFC3339))

    return result, nil
}

// ProcessMultiple handles multiple payment processors (split payment)
func (s *PaymentService) ProcessMultiple(processors []PaymentProcessor, amounts []float64) ([]*PaymentResult, error) {
    if len(processors) != len(amounts) {
        return nil, fmt.Errorf("processors and amounts must match")
    }

    var results []*PaymentResult
    for i, processor := range processors {
        result, err := s.Process(processor, amounts[i])
        if err != nil {
            return results, fmt.Errorf("payment %d failed: %w", i+1, err)
        }
        results = append(results, result)
    }

    return results, nil
}

// =============================================================================
// DEMONSTRATION
// =============================================================================

func main() {
    service := &PaymentService{}

    // Process credit card payment
    creditCard := NewCreditCardProcessor(
        "4111111111111111",
        "12/25",
        "123",
        "John Doe",
    )
    service.Process(creditCard, 99.99)

    // Process PayPal payment
    paypal := NewPayPalProcessor("john@example.com", "secret")
    service.Process(paypal, 49.99)

    // Process crypto payment - NO CHANGES TO PaymentService!
    crypto := NewCryptoProcessor(
        "0x742d35Cc6634C0532925a3b844Bc9e7595f",
        "ETH",
    )
    service.Process(crypto, 150.00)

    // Process Apple Pay - STILL NO CHANGES TO PaymentService!
    applePay := NewApplePayProcessor(
        "apple_pay_token_abc123xyz",
        "DEVICE-12345",
    )
    service.Process(applePay, 29.99)

    fmt.Println("\n" + "="*50)
    fmt.Println("KEY INSIGHT: We added 4 different payment methods")
    fmt.Println("without ever modifying PaymentService!")
    fmt.Println("="*50)
}

==================================================
Processing Credit Card payment for $99.99
==================================================

✓ Validation passed
💳 Connecting to credit card network...
💳 Authorizing card ending in 1111
💳 Charging $99.99 to John Doe

✓ Payment successful!
  Transaction ID: CC-1707820800123456789
  Processed at: 2024-02-13T10:00:00Z

==================================================
Processing PayPal payment for $49.99
==================================================

✓ Validation passed
🅿️ Connecting to PayPal...
🅿️ Authenticating john@example.com
🅿️ Processing $49.99

✓ Payment successful!
  Transaction ID: PP-1707820800123456790
  Processed at: 2024-02-13T10:00:01Z

==================================================
Processing Cryptocurrency (ETH) payment for $150.00
==================================================

✓ Validation passed
₿ Connecting to ETH network...
₿ Sending to wallet: 0x742d...95f
₿ Amount: $150.00 equivalent

✓ Payment successful!
  Transaction ID: CRYPTO-1707820800123456791
  Processed at: 2024-02-13T10:00:02Z

==================================================
Processing Apple Pay payment for $29.99
==================================================

✓ Validation passed
🍎 Verifying Apple Pay token...
🍎 Device verified: DEVICE-1
🍎 Processing $29.99

✓ Payment successful!
  Transaction ID: APPLE-1707820800123456792
  Processed at: 2024-02-13T10:00:03Z

==================================================
KEY INSIGHT: We added 4 different payment methods
without ever modifying PaymentService!
==================================================

The Power of OCP Visualized

Design principles diagram 3

Liskov Substitution Principle (LSP)

The Principle in Plain English

The Rectangle-Square Paradox

go
// This seems logical but is WRONG!

type Rectangle interface {
    SetWidth(w int)
    SetHeight(h int)
    Area() int
}

type Square struct {
    side int
}

// When you set width on a square, you MUST also change height
// Otherwise it's not a square anymore!
func (s *Square) SetWidth(w int) {
    s.side = w  // This also implicitly sets height
}

func (s *Square) SetHeight(h int) {
    s.side = h  // This also implicitly sets width
}

func (s *Square) Area() int {
    return s.side * s.side
}

go
func DoubleWidth(r Rectangle) {
    w := r.Width()
    r.SetWidth(w * 2)
    // After doubling width, area should be width * 2 * height
    // For a 3x4 rectangle: new area should be 6 * 4 = 24
}

• Before: Area = 9
• Set width to 6 (doubles)
• Expected area: 6 * 3 = 18 (if it were a rectangle)
• Actual area: 6 * 6 = 36 (because Square changed height too!)

A Better Design

go
// Filename: lsp_shapes.go
package main

import (
    "fmt"
    "math"
)

// =============================================================================
// CORRECT DESIGN: Focus on what shapes CAN DO, not what they ARE
// =============================================================================

// Shape represents any geometric shape
// Why: We define behavior that ALL shapes must support
// Any shape can be substituted for any other in calculations
type Shape interface {
    Area() float64
    Perimeter() float64
    Name() string
}

// Drawable represents shapes that can be drawn
type Drawable interface {
    Draw() string
}

// Rectangle is a shape with width and height
type Rectangle struct {
    Width  float64
    Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

func (r Rectangle) Name() string {
    return "Rectangle"
}

func (r Rectangle) Draw() string {
    return fmt.Sprintf(`
┌%s┐
│%s│
│%s│
└%s┘`,
        repeatChar("─", int(r.Width)),
        repeatChar(" ", int(r.Width)),
        repeatChar(" ", int(r.Width)),
        repeatChar("─", int(r.Width)),
    )
}

// Square is ALSO a shape, but NOT a subtype of Rectangle
// Why: Square has different construction (one dimension, not two)
// but it fulfills the Shape contract perfectly
type Square struct {
    Side float64
}

func (s Square) Area() float64 {
    return s.Side * s.Side
}

func (s Square) Perimeter() float64 {
    return 4 * s.Side
}

func (s Square) Name() string {
    return "Square"
}

func (s Square) Draw() string {
    size := int(s.Side)
    return fmt.Sprintf(`
┌%s┐
%s
└%s┘`,
        repeatChar("─", size),
        repeatLines("│"+repeatChar(" ", size)+"│\n", size-2),
        repeatChar("─", size),
    )
}

// Circle is another shape
type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

func (c Circle) Perimeter() float64 {
    return 2 * math.Pi * c.Radius
}

func (c Circle) Name() string {
    return "Circle"
}

// Triangle completes our shape collection
type Triangle struct {
    Base   float64
    Height float64
    Side1  float64
    Side2  float64
    Side3  float64
}

func NewEquilateralTriangle(side float64) Triangle {
    height := side * math.Sqrt(3) / 2
    return Triangle{
        Base:   side,
        Height: height,
        Side1:  side,
        Side2:  side,
        Side3:  side,
    }
}

func (t Triangle) Area() float64 {
    return 0.5 * t.Base * t.Height
}

func (t Triangle) Perimeter() float64 {
    return t.Side1 + t.Side2 + t.Side3
}

func (t Triangle) Name() string {
    return "Triangle"
}

// =============================================================================
// FUNCTIONS THAT WORK WITH ANY SHAPE (LSP in action!)
// =============================================================================

// TotalArea calculates the total area of multiple shapes
// Why: This function doesn't care about the specific shape type
// Any Shape can be passed in, and it will work correctly
func TotalArea(shapes []Shape) float64 {
    var total float64
    for _, shape := range shapes {
        total += shape.Area()
    }
    return total
}

// TotalPerimeter calculates the total perimeter of multiple shapes
func TotalPerimeter(shapes []Shape) float64 {
    var total float64
    for _, shape := range shapes {
        total += shape.Perimeter()
    }
    return total
}

// PrintShapeInfo prints information about any shape
// Why: LSP guarantees this works for ALL shapes, present and future
func PrintShapeInfo(shape Shape) {
    fmt.Printf("┌─────────────────────────────┐\n")
    fmt.Printf("│ Shape: %-20s │\n", shape.Name())
    fmt.Printf("├─────────────────────────────┤\n")
    fmt.Printf("│ Area:      %14.2f   │\n", shape.Area())
    fmt.Printf("│ Perimeter: %14.2f   │\n", shape.Perimeter())
    fmt.Printf("└─────────────────────────────┘\n")
}

// FindLargest finds the shape with the largest area
// Why: Works with ANY shape - Square, Rectangle, Circle, or any future shape
func FindLargest(shapes []Shape) Shape {
    if len(shapes) == 0 {
        return nil
    }

    largest := shapes[0]
    for _, shape := range shapes[1:] {
        if shape.Area() > largest.Area() {
            largest = shape
        }
    }
    return largest
}

// ScalableShape extends Shape with scaling capability
type ScalableShape interface {
    Shape
    Scale(factor float64) ScalableShape
}

// ScalableRectangle can be scaled
type ScalableRectangle struct {
    Rectangle
}

func (r ScalableRectangle) Scale(factor float64) ScalableShape {
    return ScalableRectangle{
        Rectangle: Rectangle{
            Width:  r.Width * factor,
            Height: r.Height * factor,
        },
    }
}

// ScalableCircle can be scaled
type ScalableCircle struct {
    Circle
}

func (c ScalableCircle) Scale(factor float64) ScalableShape {
    return ScalableCircle{
        Circle: Circle{
            Radius: c.Radius * factor,
        },
    }
}

// DoubleSize doubles any scalable shape
// Why: LSP - any ScalableShape works here
func DoubleSize(shape ScalableShape) ScalableShape {
    return shape.Scale(2.0)
}

// Helper functions
func repeatChar(char string, times int) string {
    result := ""
    for i := 0; i < times; i++ {
        result += char
    }
    return result
}

func repeatLines(line string, times int) string {
    result := ""
    for i := 0; i < times; i++ {
        result += line
    }
    return result
}

// =============================================================================
// DEMONSTRATION
// =============================================================================

func main() {
    fmt.Println("╔══════════════════════════════════════════════════════════╗")
    fmt.Println("║     LISKOV SUBSTITUTION PRINCIPLE DEMONSTRATION          ║")
    fmt.Println("╚══════════════════════════════════════════════════════════╝")

    // Create various shapes
    shapes := []Shape{
        Rectangle{Width: 10, Height: 5},
        Square{Side: 4},
        Circle{Radius: 3},
        NewEquilateralTriangle(6),
    }

    // Print info for each shape
    // LSP: PrintShapeInfo works identically for ALL shapes
    fmt.Println("\n📐 Individual Shape Information:")
    fmt.Println("================================")
    for _, shape := range shapes {
        PrintShapeInfo(shape)
        fmt.Println()
    }

    // Calculate totals
    // LSP: TotalArea works with any combination of shapes
    fmt.Println("📊 Aggregate Calculations:")
    fmt.Println("==========================")
    fmt.Printf("Total Area of all shapes: %.2f\n", TotalArea(shapes))
    fmt.Printf("Total Perimeter of all shapes: %.2f\n", TotalPerimeter(shapes))

    // Find largest
    // LSP: FindLargest correctly compares any shapes
    largest := FindLargest(shapes)
    fmt.Printf("\nLargest shape: %s (Area: %.2f)\n", largest.Name(), largest.Area())

    // Demonstrate scaling
    fmt.Println("\n🔄 Scaling Demonstration:")
    fmt.Println("=========================")

    scalableRect := ScalableRectangle{Rectangle{Width: 5, Height: 3}}
    scalableCircle := ScalableCircle{Circle{Radius: 2}}

    fmt.Printf("Original rectangle area: %.2f\n", scalableRect.Area())
    doubled := DoubleSize(scalableRect)
    fmt.Printf("Doubled rectangle area: %.2f\n", doubled.Area())

    fmt.Printf("\nOriginal circle area: %.2f\n", scalableCircle.Area())
    doubledCircle := DoubleSize(scalableCircle)
    fmt.Printf("Doubled circle area: %.2f\n", doubledCircle.Area())

    fmt.Println("\n" + repeatChar("═", 60))
    fmt.Println("KEY INSIGHT: Every shape is substitutable for any other")
    fmt.Println("in functions that accept the Shape interface!")
    fmt.Println(repeatChar("═", 60))
}

╔══════════════════════════════════════════════════════════╗
║     LISKOV SUBSTITUTION PRINCIPLE DEMONSTRATION          ║
╚══════════════════════════════════════════════════════════╝

📐 Individual Shape Information:
================================
┌─────────────────────────────┐
│ Shape: Rectangle            │
├─────────────────────────────┤
│ Area:              50.00   │
│ Perimeter:         30.00   │
└─────────────────────────────┘

┌─────────────────────────────┐
│ Shape: Square               │
├─────────────────────────────┤
│ Area:              16.00   │
│ Perimeter:         16.00   │
└─────────────────────────────┘

┌─────────────────────────────┐
│ Shape: Circle               │
├─────────────────────────────┤
│ Area:              28.27   │
│ Perimeter:         18.85   │
└─────────────────────────────┘

┌─────────────────────────────┐
│ Shape: Triangle             │
├─────────────────────────────┤
│ Area:              15.59   │
│ Perimeter:         18.00   │
└─────────────────────────────┘

📊 Aggregate Calculations:
==========================
Total Area of all shapes: 109.86
Total Perimeter of all shapes: 82.85

Largest shape: Rectangle (Area: 50.00)

🔄 Scaling Demonstration:
=========================
Original rectangle area: 15.00
Doubled rectangle area: 60.00

Original circle area: 12.57
Doubled circle area: 50.27

════════════════════════════════════════════════════════════
KEY INSIGHT: Every shape is substitutable for any other
in functions that accept the Shape interface!
════════════════════════════════════════════════════════════

LSP Violations in the Wild

Design principles diagram 4

Interface Segregation Principle (ISP)

The Principle in Plain English

The TV Remote Analogy

• You have to navigate around buttons you don't need
• You might accidentally press the wrong button
• The remote is bigger and more complex than necessary
• If the remote breaks, you lose control of everything

A Real Problem: The God Interface

go
// Filename: bad_worker_interface.go
// This is a BAD example - Don't do this!

package main

// Worker is a "God Interface" - it tries to do everything
// Why this is bad: Not all workers can do all things!
type Worker interface {
    Work()
    Eat()
    Sleep()
    TakeBreak()
    AttendMeeting()
    WriteReport()
    ManageTeam()
    ReviewCode()
    DeployApplication()
    HandleSupport()
    TrainNewHires()
}

// HumanDeveloper can do most things
type HumanDeveloper struct {
    Name string
}

func (h *HumanDeveloper) Work()              { /* writes code */ }
func (h *HumanDeveloper) Eat()               { /* eats lunch */ }
func (h *HumanDeveloper) Sleep()             { /* goes home and sleeps */ }
func (h *HumanDeveloper) TakeBreak()         { /* coffee break */ }
func (h *HumanDeveloper) AttendMeeting()     { /* joins standup */ }
func (h *HumanDeveloper) WriteReport()       { /* weekly report */ }
func (h *HumanDeveloper) ManageTeam()        { /* if senior */ }
func (h *HumanDeveloper) ReviewCode()        { /* pull requests */ }
func (h *HumanDeveloper) DeployApplication() { /* CI/CD */ }
func (h *HumanDeveloper) HandleSupport()     { /* on-call */ }
func (h *HumanDeveloper) TrainNewHires()     { /* mentoring */ }

// Robot worker - doesn't eat, sleep, or take breaks
// But MUST implement all methods to satisfy Worker interface!
type RobotWorker struct {
    ID string
}

func (r *RobotWorker) Work()          { /* processes tasks */ }
func (r *RobotWorker) Eat()           { panic("Robots don't eat!") }           // FORCED!
func (r *RobotWorker) Sleep()         { panic("Robots don't sleep!") }         // FORCED!
func (r *RobotWorker) TakeBreak()     { panic("Robots don't take breaks!") }   // FORCED!
func (r *RobotWorker) AttendMeeting() { /* can join video calls */ }
func (r *RobotWorker) WriteReport()   { /* generates reports */ }
func (r *RobotWorker) ManageTeam()    { panic("Robots don't manage!") }        // FORCED!
func (r *RobotWorker) ReviewCode()    { /* automated code review */ }
func (r *RobotWorker) DeployApplication() { /* automated deployment */ }
func (r *RobotWorker) HandleSupport()     { /* chatbot support */ }
func (r *RobotWorker) TrainNewHires()     { panic("Robots don't train!") }     // FORCED!

// Contractor - only works, doesn't do internal activities
type Contractor struct {
    Name string
}

func (c *Contractor) Work()              { /* specific task */ }
func (c *Contractor) Eat()               { /* maybe, on own time */ }
func (c *Contractor) Sleep()             { /* not company's business */ }
func (c *Contractor) TakeBreak()         { /* own schedule */ }
func (c *Contractor) AttendMeeting()     { panic("Not in scope!") }     // FORCED!
func (c *Contractor) WriteReport()       { panic("Not in scope!") }     // FORCED!
func (c *Contractor) ManageTeam()        { panic("Not in scope!") }     // FORCED!
func (c *Contractor) ReviewCode()        { panic("Not in scope!") }     // FORCED!
func (c *Contractor) DeployApplication() { panic("Not in scope!") }     // FORCED!
func (c *Contractor) HandleSupport()     { panic("Not in scope!") }     // FORCED!
func (c *Contractor) TrainNewHires()     { panic("Not in scope!") }     // FORCED!