General Programming

DRY (Don't Repeat Yourself) Every piece of knowledge should have a single, authoritative representation. Duplication creates maintenance burden and consistency risks.

KISS (Keep It Simple, Stupid) Prefer the simplest solution. Complexity is the primary enemy of reliability and long-term maintainability.

YAGNI (You Aren't Gonna Need It) Don't build features speculatively. Unused abstractions are technical debt with zero payoff.

SOLID Principles
• Single Responsibility: one reason to change
• Open/Closed: extend without modifying
• Liskov Substitution: subtypes are substitutable
• Interface Segregation: small, focused interfaces
• Dependency Inversion: depend on abstractions

Separation of Concerns Distinct features/responsibilities belong in distinct modules. Business logic, data access, and presentation layers should be independently changeable.

Creational Patterns
• Singleton: exactly one instance globally
• Factory Method: subclass decides which object to create
• Builder: fluent construction of complex objects
• Prototype: clone existing objects

Structural Patterns
• Adapter: convert one interface to another
• Decorator: wrap objects to add behavior
• Facade: simplified interface to a subsystem
• Composite: treat individual and composite objects uniformly

Behavioral Patterns
• Observer: event-based publish/subscribe
• Strategy: swap algorithms at runtime
• Command: encapsulate requests as objects (undo/redo)
• Chain of Responsibility: pass requests along a handler chain
• Template Method: define algorithm skeleton, let subclasses fill in steps

Naming Use intention-revealing names. calculateMonthlyRevenue() beats calc(). Avoid mental mapping i is fine in a loop; i as a user id is not.

Functions Do one thing. If you need a comment to describe what a function does, split it. Aim for ≤20 lines.

Comments Explain WHY, not WHAT. The code shows what happens; comments explain context, trade-offs, and constraints.

Error Handling Errors are not exceptional anticipate them. Prefer exceptions over error codes. Never swallow errors silently.

Code Formatting Consistent style removes cognitive friction. Use automated formatters (Prettier, Black, gofmt). Style debates waste engineering time.

Refactoring Continuously improve structure without changing behavior. Apply Boy Scout Rule: leave code cleaner than you found it.

Test Pyramid
• Unit tests (many): single function/class in isolation, milliseconds to run
• Integration tests (some): interaction between real components
• End-to-end tests (few): full user flows, slow but high-confidence

FIRST Properties
• Fast: feedback in milliseconds
• Isolated: no inter-test dependencies
• Repeatable: deterministic results every run
• Self-validating: pass/fail without human inspection
• Timely: written alongside production code

TDD (Test-Driven Development) Red → Green → Refactor. Write a failing test first, then implement the minimum to pass, then clean up.

Test Doubles Mock, Stub, Fake, Spy. Replace real dependencies (DB, APIs) with controlled test versions to isolate the unit under test.

Layered Architecture Presentation → Business Logic → Data Access → Database. Each layer only calls the layer below it.

Hexagonal Architecture (Ports & Adapters) Business logic at the center, external systems (DB, APIs, UI) as plug-in adapters. Makes the core independently testable.

Event-Driven Architecture Components communicate via events. Loose coupling, high scalability. Requires careful handling of eventual consistency.

Microservices vs Monolith Monolith first simple to build, deploy, debug. Extract services when clear team/scaling boundaries emerge. Don't prematurely distribute.

Conway's Law System architecture mirrors the communication structure of the organization. Design teams before designing systems.

Premature Optimization "The root of all evil" (Knuth). Profile first find the actual bottleneck. Most code paths are not performance-critical.

Profiling Tools Python cProfile, Node.js --prof, Java Flight Recorder, Chrome DevTools Performance tab. Data beats intuition.

Algorithmic Optimization Changing O(n²) to O(n log n) beats any micro-optimization. Understand your data structures and their cost profile.

Caching Store computed results to avoid redundant work. Trade memory for speed. Cache invalidation is notoriously hard prefer simple TTL-based strategies.

Concurrency Async/await and event loops for I/O-bound work. Thread pools for CPU-bound work. Avoid shared mutable state use message passing or immutable data.

Memory Management Understand GC (Java, Python, Go), reference counting (Swift, Rust RC), and manual (C/C++). GC pressure and memory leaks are common production issues.