code-quality

Code Quality Best Practices

This skill provides code quality principles, design patterns, and practices for writing maintainable, clean code across multiple programming languages.

SOLID Principles

S - Single Responsibility Principle

A class/function should have only one reason to change.

// ❌ Bad: Multiple responsibilities
class User {
  save() { /* database logic */ }
  sendEmail() { /* email logic */ }
  validate() { /* validation logic */ }
}

// ✅ Good: Single responsibility
class User {
  validate() { /* validation only */ }
}

class UserRepository {
  save(user: User) { /* database logic */ }
}

class EmailService {
  sendEmail(user: User) { /* email logic */ }
}

O - Open/Closed Principle

Open for extension, closed for modification.

// ✅ Good: Extensible without modification
interface PaymentProcessor {
  process(amount: number): Promise<PaymentResult>;
}

class CreditCardProcessor implements PaymentProcessor {
  async process(amount: number) { /* credit card logic */ }
}

class PayPalProcessor implements PaymentProcessor {
  async process(amount: number) { /* PayPal logic */ }
}

L - Liskov Substitution Principle

Subtypes must be substitutable for their base types.

// ✅ Good: Subtypes can replace base types
class Bird {
  move() { /* generic movement */ }
}

class Sparrow extends Bird {
  move() { this.fly(); }
}

class Penguin extends Bird {
  move() { this.walk(); }
}

I - Interface Segregation Principle

Clients shouldn't depend on interfaces they don't use.

// ❌ Bad: Fat interface
interface Worker {
  work(): void;
  eat(): void;
  sleep(): void;
}

// ✅ Good: Segregated interfaces
interface Workable {
  work(): void;
}

interface Eatable {
  eat(): void;
}

interface Sleepable {
  sleep(): void;
}

D - Dependency Inversion Principle

Depend on abstractions, not concretions.

// ❌ Bad: Depends on concrete class
class OrderService {
  private emailService = new EmailService();
}

// ✅ Good: Depends on abstraction
class OrderService {
  constructor(private emailService: IEmailService) {}
}