Programming tricks that make OOP click

OOP AEIP (A=Abstraction, E=Encapsulation, I=Inheritance, P=Polymorphism — the four pillars of Object-Oriented Programming): Abstraction, Encapsulation, Inheritance, Polymorphism

AAbstraction — hide implementation

EEncapsulation — bundle data and behavior

IInheritance — child extends parent

PPolymorphism — same interface, different behavior

Recursion: base case stops it, recursive case reduces toward base case

Recursion — Every recursive function needs: (1) base case that stops recursion, (2) recursive case moving toward base case. Factorial: n! = n × (n-1)!, base case: 0! = 1. Without base case → stack overflow.

DRY (Do Not Repeat Yourself): Don't Repeat Yourself — extract repeated logic into functions

DRY Principle — If you write the same logic twice, extract it. Changes only need to be made once. Related: SOLID principles. Opposite of WET (Write Everything Twice) code.

Time vs Space complexity: often trade one for the other

Complexity Trade-offs — Caching (memoization): use more memory to save computation time. Streaming: process in chunks, save memory at cost of speed. Profile before optimizing — premature optimization wastes time.

SOLID (S=Single Responsibility, O=Open/Closed, L=Liskov Substitution, I=Interface Segregation, D=Dependency Inversion): Single responsibility, Open/closed, Liskov, Interface Segregation, Dependency inversion

SOLID Principles — S: one class, one job. O: open for extension, closed for modification. L: subclasses should be substitutable for parent classes. I: don't force classes to implement interfaces they don't use. D: depend on abstractions, not concretions.

Functional programming: pure functions (no side effects) + immutable data. Map, filter, reduce.

Functional Programming — Pure functions: same input always produces same output, no side effects. Immutable data: never modify, create new. First-class functions: functions as values — pass them, return them. Map: transform each element. Filter: keep elements matching condition. Reduce: combine elements into single value. Haskell, Clojure, Scala.

Design patterns: Singleton (one instance), Factory (create objects), Observer (notify subscribers), Strategy (swap algorithms)

SingletonOne instance — database connections

FactoryCreate objects without specifying class

ObserverPublish-subscribe — event listeners

StrategySwap algorithms at runtime

Version control: Git. Commit = snapshot. Branch = parallel development. Merge = combine branches.

Version Control with Git — Commit: snapshot of all tracked files at a point in time. Branch: independent line of development (feature/main). Merge: combine changes from two branches. Pull request: request to merge branch, enables code review. Common workflow: create branch → make changes → commit → push → pull request → merge.

Testing types: unit (single function), integration (modules together), end-to-end (full system), regression (old bugs)

UnitSingle function, fast, isolated

IntegrationMultiple modules working together

E2EFull user workflow

RegressionPrevent old bugs from returning

Big O space complexity: track memory used. Recursive algorithms use O(n) stack space for n calls.

Space Complexity — Algorithms have both time AND space complexity. Iterative O(n) sum: O(1) space. Recursive O(n) sum: O(n) space (n stack frames). Merge sort: O(n) extra space for merging. In-place algorithms: O(1) extra space (bubble sort, selection sort). Space-time tradeoff: often use more memory to go faster.

API (Application Programming Interface). REST (Representational State Transfer): stateless, HTTP verbs, JSON. Endpoint = specific URL.

APIs and REST — API: defined interface for software interaction. REST (Representational State Transfer): architectural style for web APIs. Stateless: each request contains all info needed. Resources identified by URLs. HTTP verbs: GET/POST/PUT/DELETE. Response typically JSON. Status codes: 200 OK, 404 Not Found, 500 Server Error.

Concurrency vs parallelism: concurrency = dealing with multiple things. Parallelism = doing multiple things simultaneously.

Concurrency and Parallelism — Concurrency: structuring program to handle multiple tasks — can be done on a single core by interleaving. Parallelism: actually executing multiple tasks simultaneously — requires multiple cores. Race condition: two threads access shared data simultaneously → unpredictable results. Mutex/lock: ensures only one thread accesses resource at a time.