Separation of Concerns: A Comprehensive Guide

# PRESENTATION LAYER
class UserController:
    def __init__(self, user_service: UserService):
        self.user_service = user_service
    
    def handle_register(self, request):
        try:
            user = self.user_service.register(
                email=request['email'],
                password=request['password']
            )
            return {"status": 201, "user": user.to_dict()}
        except ValidationError as e:
            return {"status": 400, "error": str(e)}

# BUSINESS LOGIC LAYER
class UserService:
    def __init__(self, user_repo: UserRepository, email_service: EmailService):
        self.user_repo = user_repo
        self.email_service = email_service
    
    def register(self, email: str, password: str) -> User:
        if self.user_repo.find_by_email(email):
            raise ValidationError("Email already exists")
        user = User.create(email, password)
        self.user_repo.save(user)
        self.email_service.send_welcome(user)
        return user

# DATA ACCESS LAYER
class UserRepository:
    def save(self, user: User):
        db.session.add(user)
        db.session.commit()
    
    def find_by_email(self, email: str) -> User | None:
        return db.session.query(User).filter_by(email=email).first()

// MODEL — data and business rules
class TodoModel {
  constructor() {
    this.todos = [];
  }
  
  add(text) {
    this.todos.push({ id: Date.now(), text, done: false });
  }
  
  toggle(id) {
    const todo = this.todos.find(t => t.id === id);
    if (todo) todo.done = !todo.done;
  }
}

// VIEW — rendering (no logic)
class TodoView {
  render(todos) {
    const list = document.getElementById('todo-list');
    list.innerHTML = todos.map(t => 
      `<li class="${t.done ? 'done' : ''}" data-id="${t.id}">
        ${t.text} <button class="toggle">✓</button>
      </li>`
    ).join('');
  }
}

// CONTROLLER — user input handling
class TodoController {
  constructor(model, view) {
    this.model = model;
    this.view = view;
  }
  
  addTodo(text) {
    this.model.add(text);
    this.view.render(this.model.todos);
  }
  
  toggleTodo(id) {
    this.model.toggle(id);
    this.view.render(this.model.todos);
  }
}

# BAD: Cross-cutting concern injected into business logic
class UserService:
    def register(self, email, password):
        logger.info(f"Registering user: {email}")  # Logging in business logic
        start = time.time()  # Timing in business logic
        # ... actual logic
        logger.info(f"Registration took: {time.time() - start}s")

# GOOD: Using decorators/AOP
import functools
import time
import logging

logger = logging.getLogger(__name__)

def log_execution(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        logger.info(f"Calling: {func.__name__}")
        start = time.time()
        result = func(*args, **kwargs)
        duration = time.time() - start
        logger.info(f"{func.__name__} took {duration:.3f}s")
        return result
    return wrapper

class UserService:
    @log_execution
    def register(self, email, password):
        # Pure business logic — no cross-cutting concerns
        user = User(email, password)
        self.repo.save(user)
        return user

// BAD: Everything mixed together
app.get('/api/users/:id', async (req, res) => {
  const db = await pool.connect();
  try {
    const result = await db.query(
      'SELECT * FROM users WHERE id = $1', [req.params.id]
    );
    if (!result.rows[0]) {
      return res.status(404).send('Not found');
    }
    res.json({
      id: result.rows[0].id,
      name: result.rows[0].name,
      email: result.rows[0].email
    });
  } finally {
    db.release();
  }
});

// GOOD: Separated into route, service, and repository
// userRouter.js
router.get('/:id', async (req, res) => {
  try {
    const user = await userService.getUser(req.params.id);
    res.json(user);
  } catch (err) {
    res.status(err.status || 500).json({ error: err.message });
  }
});

// userService.js
async function getUser(id) {
  const user = await userRepo.findById(id);
  if (!user) throw new NotFoundError('User not found');
  return user;
}

// userRepo.js
async function findById(id) {
  const result = await db.query(
    'SELECT * FROM users WHERE id = $1', [id]
  );
  return result.rows[0] || null;
}