code-quality

Files (35)

• SKILL.md
• SKILL.md · abstract-factory/
• SKILL.md · adapter/
• SKILL.md · bridge/
• SKILL.md · builder/
• SKILL.md · chain-of-responsibility/
• SKILL.md · command/
• SKILL.md · composite/
• SKILL.md · decompose-conditional/
• SKILL.md · decorator/
• SKILL.md · extract-class/
• SKILL.md · extract-method/
• SKILL.md · extract-variable/
• SKILL.md · facade/
• SKILL.md · factory-method/
• SKILL.md · flyweight/
• SKILL.md · guard-clauses/
• SKILL.md · inline-method/
• SKILL.md · introduce-parameter-object/
• SKILL.md · iterator/
• SKILL.md · mediator/
• SKILL.md · memento/
• SKILL.md · move-method/
• SKILL.md · observer/
• SKILL.md · prototype/
• SKILL.md · proxy/
• SKILL.md · replace-conditional-polymorphism/
• SKILL.md · replace-magic-number/
• SKILL.md · replace-temp-with-query/
• SKILL.md · separate-query-from-modifier/
• SKILL.md · singleton/
• SKILL.md · state/
• SKILL.md · strategy/
• SKILL.md · template-method/
• SKILL.md · visitor/

SKILL.md (first lines)

# code-quality

Code quality mastery — programming principles (SOLID, DRY, KISS, YAGNI…), refactoring techniques, and design patterns to write clean, maintainable, extensible software.

## Instructions

Apply code quality practices to continuously improve codebases:

### Programming Principles

Core principles every codebase should follow regardless of language or paradigm.

#### SOLID

Five OOP principles that make systems easy to extend and maintain:

| Principle | Full name | Rule |
|-----------|-----------|------|
| **S** | Single Responsibility | A class/module has one reason to change |
| **O** | Open/Closed | Open for extension, closed for modification |
| **L** | Liskov Substitution | Subtypes must be substitutable for their base type |
| **I** | Interface Segregation | Prefer many small interfaces over one fat interface |
| **D** | Dependency Inversion | Depend on abstractions, not concretions |

**S — Single Responsibility**
```ts
// ❌ one class handles both data and formatting
class Report { generate() {} formatAsPdf() {} sendByEmail() {} }

// ✅ each class has one job
class Report      { generate(): ReportData {} }
class PdfRenderer { render(data: ReportData): Buffer {} }
class Mailer      { send(to: string, body: Buffer) {} }
```

**O — Open/Closed**
```ts
// ❌ must edit existing class to add discount type
class Discount { calc(type: string, price: number) {
  if (type === 'vip') return price * 0.8;
  if (type === 'seasonal') return price * 0.9;
}}

// ✅ add new behaviour by adding a new class
interface Discount { apply(price: number): number; }
class VipDiscount      implements Discount { apply(p) { return p * 0.8; } }
class SeasonalDiscount implements Discount { apply(p) { return p * 0.9; } }
```

**L — Liskov Substitution**
```ts
// ❌ Square overrides setWidth in a way that violates Rectangle's contract
class Rectangle { setWidth(w: number) {} setHeight(h: number) {} area() {} }
class Square extends Rectangle { setWidth(w: number) { super.setWidth(w); super.setHeight(w); } }

// ✅ use a shared Shape interface instead of inheritance
interface Shape { area(): number; }
class Rectangle implements Shape { area() { return this.w * this.h; } }
class Square    implements Shape { area() { return this.side ** 2; } }
```

**I — Interface Segregation**
```ts
// ❌ Printer forced to implement fax it doesn't support
interface Machine { print(): void; scan(): void; fax(): void; }

// ✅ split into focused interfaces
interface Printer { print(): void; }
interface Scanner { scan(): void; }
interface Fax     { fax(): void; }
class SimplePrinter implements Printer { print() {} }
```

**D — Dependency Inversion**
```ts
// ❌ high-level module depends on low-level concrete class
class OrderService { private db = new MySqlDatabase(); }

// ✅ depend on an abstraction; inject the implementation
interface Database { save(data: object): void; }
class OrderService { constructor(private db: Database) {} }
```

---

#### DRY — Don't Repeat Yourself

> "Every piece of knowledge must have a single, unambiguous, authoritative representation within a system." — The Pragmatic Programmer

- **Duplication of logic** → extract into a shared function, class, or module
- **Duplication of data** → derive it from a single source of truth; don't copy-paste constants
- **Duplication of structure** → use generics, templates, or higher-order functions
- **What DRY is NOT**: don't blindly deduplicate code that looks the same but represents different concepts — premature abstraction is worse than duplication

```ts
// ❌ same validation logic copy-pasted in three places
function createUser(email: string) { if (!email.includes('@')) throw new Error('Invalid'); }
function updateUser(email: string) { if (!email.includes('@')) throw new Error('Invalid'); }

// ✅ single source of truth
function assertValidEmail(email: string) { if (!email.includes('@')) throw new Error('Invalid email'); }
function createUser(email: string) { assertValidEmail(email); }
function updateUser(email: string) { assertValidEmail(email); }
```

---

#### KISS — Keep It Simple, Stupid

> "Simplicity is the ultimate sophistication." — Leonardo da Vinci

- Write the simplest solution that solves the problem
- Avoid clever tricks, unnecessary abstractions, and premature generalisation
- Code is read far more often than it is written — optimise for the reader
- If you need a comment to explain *what* code does, the code is probably too complex

```ts
// ❌ over-engineered
const isAdult = (age: number) => !!(age >= 18 ? true : false) === true;

From Satcomx00-x00/skills-db, MIT.

More from Satcomx00-x00/skills-db