Skip to content
What's new

What's new

Every release of the library, newest first. Works offline.

  1. v2.5.1

    Latest

    SRP vs encapsulation clarification

    • Expanded 20-programming-principles.md — added a dedicated SRP vs encapsulation contrast (they act on different axes: SRP = decomposition by reason-to-change/cohesion; encapsulation = information-hiding + invariant-protection at the boundary/coupling; orthogonal, every combination possible). "SRP decides where the wall goes; encapsulation decides what the wall lets through."

  2. v2.5.0

    Authentication & Authorization

    • Added 26-authentication-and-authorization.md — a from-zero treatment of authentication vs authorization, sessions vs tokens, OAuth 2.0 & OIDC (the four roles, the Authorization Code + PKCE flow step-by-step, grant types, access/ID/refresh tokens, JWT vs opaque), where authz is enforced (incl. the Next.js middleware CVE-2025-29927), RBAC/ABAC/ReBAC, the BFF/token-handler pattern, passkeys/WebAuthn, SSO/SAML, and the 2026 library landscape (Better Auth, Auth.js v5, Clerk, WorkOS, Supabase Auth, Auth0). File 17 keeps the token-storage/threat angle and now cross-links to 26.

  3. v2.4.0

    Additional principles

    • Added to 20-programming-principles.md: Command–Query Separation (CQS) (with example, cross-linked to CQRS in 13); a GRASP subsection (Information Expert, Creator, Controller, Pure Fabrication, Indirection, Protected Variations, etc.) framed as the "where does a responsibility go?" complement to SRP; and the coupling/cohesion taxonomy (the worst→best spectrums) folded into Foundations.
    • Added named entries to "Other durable heuristics": Tell-Don't-Ask, Single Level of Abstraction (SLAP), Design by Contract, Orthogonality, Hyrum's Law, Gall's Law, Postel's Law (with the modern caveat), Unix philosophy, and Rule-of-Three/AHA; plus a note on CUPID as a modern counter-lens to SOLID.
    • Updated books (Larman/GRASP, Meyer/CQS+DbC, North/CUPID) and interview questions. *(Deliberately kept these curated — more principles isn't automatically better; the genuinely additive ones got full entries, the rest a line each.)*

  4. v2.3.0

    "Unit" clarification & Conway's Law

    • Clarified the SRP "pocket test" in 20-programming-principles.md — defined what a *"piece of code" / "unit"* actually means (a candidate for extraction at any zoom level — "anything you'd give its own name"), with a three-zoom illustration (lines-in-a-function → file/module → service).
    • Added a Conway's Law subsection (Conway 1967 + the Inverse Conway Maneuver) explaining why responsibilities end up matching teams — the bridge from SRP ("one unit per actor") to org design ("at scale, an actor is a team"). Cross-linked to the decision-making application in 25. (Conway's Law was previously only referenced in passing in 20; it's now defined there, and remains applied in 09/13/24/25.)
    • Updated interview questions (Conway's Law; "what is a piece of code") and connections.

  5. v2.2.0

    SRP-in-practice & encapsulation

    • Reframed the responsibility/concern explanation in 20-programming-principles.md with the more concrete "who walks up to your desk" model (concern = property of the *code*; responsibility = property of the *people the code serves*), plus the two mismatch cases that prove they're distinct.
    • Added an "SRP in depth" subsection answering how it applies in practice: that SRP is recursive (function → class/module → service, with the grain chosen by how change arrives), and how it differs in FP vs OOP (responsibility attaches to a function/module and is preserved by composition, vs attaching to a class and wired by injection).
    • Added a new core principle, Encapsulation & information hiding (with ❌/✅ example and the FP equivalents — module boundaries, closures, immutable smart constructors) and an explicit SoC vs SRP vs encapsulation comparison ("SoC/SRP draw the boundaries; encapsulation builds the wall and locks the door"; encapsulation is what turns a *separation* into a *decoupling* and protects invariants).
    • Updated interview questions (added responsibility-vs-concern, FP-vs-OOP SRP, and encapsulation) and pitfalls (leaky encapsulation; separating by concern but never by actor). *(Bumped minor, not patch, because it adds a new principle and substantial new material rather than only swapping the framing.)*

  6. v2.1.1

    SRP clarification

    • Expanded 20-programming-principles.md — added a "what is a *responsibility*, exactly?" note under SRP (reason-to-change / actor framing) and a precise responsibility vs concern distinction (different axes: who/why vs what-kind; SRP as module-level SoC with "actor" as the cut line), plus a cross-pointer from the Separation of Concerns section.

  7. v2.1.0

    Principles expansion (pattern vs anti-pattern)

    • Expanded 20-programming-principles.md — added paired ❌ anti-pattern / ✅ pattern code examples (with explicit "why it's WET / why it's DRY"-style reasoning on *both* sides) to the principles that were prose-only: a concrete coupling/cohesion contrast in Foundations, SSOT, Fail Fast / illegal-states-unrepresentable, and a full before/after for each of the five SOLID principles (S, O, L, I, D). File grew from ~175 to ~470 lines.

  8. v2.0.0

    Foundations & architecture expansion

    • Major scope expansion: re-aimed from a senior-only reference to a complete zero-to-senior guide, adding the programming-foundations pillars and broader architecture/system/infra coverage. Backward-compatible (no existing file removed or renumbered), but a large enough mission change to warrant a major bump.
    • Added 20-programming-principles.md — DRY, KISS, YAGNI, SOLID, SoC, coupling/cohesion, composition over inheritance, Law of Demeter, POLA, SSOT, and more.
    • Added 21-oop-foundations.md — objects/classes, the four pillars, JS prototypes vs class, composition over inheritance, GoF design patterns (incl. Observer/Strategy/Adapter/Decorator/Facade).
    • Added 22-functional-programming.md — pure functions, immutability, HOFs, composition, currying/partial application, recursion, and functors, applicatives, monads (Maybe/Either/IO), plus FP-in-React.
    • Added 23-data-structures-and-algorithms.md — Big-O, arrays/maps/sets/stacks/queues/trees/heaps/graphs/tries, and the interview/real-world algorithmic patterns.
    • Added 24-system-and-infrastructure-architecture.md — scaling, load balancing, caching tiers, databases, queues, CDN/edge, containers/K8s, CI/CD, IaC, observability, deployment strategies.
    • Added 25-architecture-decisions-and-tradeoffs.md — monolith vs microservices (with an e-commerce case), SPA vs MPA vs micro-frontends use cases, modular monolith, Conway's Law, ADRs.
    • Expanded 10-frontend-architecture.md — added a head-to-head hexagonal vs onion vs clean comparison (table + how-to-choose).
    • Expanded 08-nextjs-and-meta-frameworks.md — added a dedicated Multi-Zones deep dive (routing, assetPrefix, when to use vs Module Federation).
    • Updated this README — version/changelog, broadened scope statement, from-zero learning path, file index (20–25), and master book list (foundations, OOP, FP, DSA, system design).

  9. v1.0.0

    Initial library

    • Files 00–19: browser/JS/TS/web-platform foundations, React internals, state, rendering, Next/meta-frameworks, micro-frontends, frontend architecture, design systems, BFF, microservices, build tools, performance, testing, security, networking, accessibility.