this is a-z Programming. everything I need to know.
- Binary, Hex, ASCII/Unicode — know how data sits in memory.
- Big-O notation & basic complexity classes (
O(1), O(log n), O(n log n), O(n²)).
- Data structures — array, linked list, stack, queue, hash map, tree, graph.
- Algorithms — sorting (quick, merge, heap), searching (binary, BFS/DFS), recursion vs iteration.
- Number bases & bitwise ops (
<<, >>, &, |, ^).
Practice
- Implement each data structure from scratch.
- Write and benchmark the three classic sorts; print timing results.
Pick a main stack (e.g. TypeScript + Node, Python 3.12, or Rust 1.80). Commit.
Core Topics
- Lexical scope, closures, first-class functions
- Type system (static vs dynamic, generics, type inference)
- Memory model (stack vs heap, ownership/lifetimes if Rust)
- Concurrency primitives (threads, async/await, event loop)
- Module packaging and dependency management
Practice
- Build a CLI todo app → refactor into REST API → add WebSocket streaming.
- Instrument with unit tests (coverage ≥ 90 %).
- Git internals (objects, refs, reflog)
- Branching strategies (trunk-based vs GitFlow)
- Rebasing vs merging, interactive rebase
- Conventional commits & semantic versioning
Practice
- Reconstruct a corrupted repository using
git fsck.
- Perform a clean rebase of a 5-commit feature branch onto main without conflicts.
- TDD / red-green-refactor loop
- Unit, integration, e2e layers
- Mocks, stubs, test doubles
- Property-based testing
- Mutation testing
Practice
- Write failing tests first for every new module this month.
- Introduce mutation testing and drive the surviving mutants to zero.
- SOLID principles
- Design patterns (factory, strategy, observer, decorator, command)
- Refactoring techniques (extract method, parameter object, composition over inheritance)
- Domain-Driven Design (entities, value objects, aggregates, bounded contexts)
Practice
- Take a 300-line god-class, apply extract-class and strategy; ensure tests stay green.
- REST vs gRPC, GraphQL basics
- Message queues (RabbitMQ, Kafka basics: partitions, offsets, consumer groups)
- CAP theorem, consistency models
- Caching strategies (LRU, write-through, write-behind)
- Twelve-Factor App standards
Practice
- Design a URL-shortener system: produce data-flow diagram + API spec + scaling plan.
- CI/CD pipelines (GitHub Actions, GitLab CI)
- Containerization (Dockerfile layers, multi-stage builds)
- Orchestration (Kubernetes objects: Pod, Deployment, Service, Ingress)
- Infrastructure as Code (Terraform HCL basics)
- Metrics, logs, traces; alert thresholds & SLOs
Practice
- Ship the REST API from §2 via Docker to a staging cluster; set up Prometheus + Grafana dashboard.
- OWASP Top 10 (injection, XSS, CSRF, auth flaws)
- HTTPS/TLS handshake basics
- JWT vs opaque tokens, OAuth 2.1 flows
- Static analysis, dependency scanning (Snyk, Trivy)
Practice
- Perform threat-modeling on the URL-shortener; patch every OWASP category.
- CPU vs I/O bound, event loops, epoll/kqueue basics
- Profilers (
perf, py-spy, Chrome DevTools)
- Memory leaks, GC tuning
- Caching layers, CDNs
Practice
- Profile the REST API under 1 000 RPS; hit 50 ms p95 latency.
- Code-review etiquette & checklist
- Estimation (story points vs timeboxing)
- Incident response & post-mortems
- Documentation stack (README, ADRs, diagrams-as-code with Mermaid)
Practice
- Lead a simulated sev-1 incident; write the post-mortem within 30 minutes.
| Term |
Definition |
| Idempotent |
Same input ⇒ same outcome, no side-effects after first call |
| Race condition |
Two+ threads/events access shared state, order matters |
| Atomicity |
Operation completes entirely or not at all |
| Backpressure |
Mechanism to slow producers when consumers lag |
| Circuit breaker |
Fail-fast pattern, stops hitting unstable dependency |
| Immutable |
Data that never changes after creation |
| CSR/SSR/SSG |
Client-/Server-side rendering, Static site generation |
| Blue-Green deploy |
Two environments, swap traffic for zero-downtime |
| Sharding |
Horizontal data partitioning |
| Dead letter queue |
Storage for messages that can’t be processed |
Phase 1 (Weeks 1-4) — Fundamentals + primary language syntax & tests
Phase 2 (Weeks 5-8) — Git mastery, TDD, clean code refactors
Phase 3 (Weeks 9-12) — REST API → containerized → CI pipeline live
Phase 4 (Weeks 13-16) — Distributed systems design, performance profiling
Phase 5 (Weeks 17-20) — Security hardening, full system demo, incident drill
You’ll code, test, deploy, and defend every layer. Stay locked—next step: Phase 1, Day 1: implement a dynamic array and benchmark push/insert/delete. Start now.