Welcome to ByteWise
ByteWise is a comprehensive computer science education book written for engineers who want to understand programming concepts deeply — not just pass interviews, but build real intuition for how systems work.
Every chapter starts from first principles, explains the why before the how, and connects theory to the real systems you interact with every day: Google Search, Netflix streaming, Slack messages, Docker containers.
What You Will Learn
| Part | Topics | Focus |
|---|---|---|
| Part 0 — How Computers Work | Low-Level vs High-Level Programming, Networking (Top-Down) | The foundation beneath all code |
| Part 1 — Foundations | Big O, Data Structures, Hash Tables, Recursion | The vocabulary of CS |
| Part 2 — Design Patterns (LLD) | SOLID, Creational, Structural, Behavioral | How to structure code |
| Part 3 — Algorithms | Binary Search, Sorting, Graphs, Dynamic Programming | Problem-solving techniques |
| Part 3 — System Design | APIs, Databases, Caching, Load Balancing | Building scalable backends |
| Part 4 — Advanced | CAP Theorem, Message Queues, Microservices, Rate Limiting | Distributed systems |
| Part 5 — Modern Engineering | CI/CD, Docker, OAuth, WebSockets | Professional toolchain |
| Part 7 — AI & LLMs | Agentic AI, Retail Case Study | Large language models in production |
Part 0 — How Computers Work
Before algorithms, before data structures — before any of it — there is the question of what a computer actually is, how code turns into machine instructions, and how computers talk to each other.
- Low-Level vs High-Level Programming — The abstraction ladder from transistors to Python
Networking (Computer Networking: Top-Down Approach)
- The Internet & Computer Networks — Packet switching, ISPs, protocol layers, and how the internet is structured
- Application Layer — HTTP, DNS, SMTP, cookies, web caching, and socket programming
- Transport Layer — TCP vs UDP, reliable delivery, flow control, and congestion control
- Network Layer — IP addressing, CIDR, NAT, DHCP, routing algorithms (OSPF, BGP)
- Link Layer & LANs — Ethernet, MAC addresses, ARP, switches, and VLANs
- Wireless & Mobile Networks — Wi-Fi (802.11), 4G/5G cellular, mobile IP, and handoff
- Multimedia Networking — Video streaming, DASH, CDNs, VoIP, RTP, and QoS
- Network Security — Cryptography, TLS, firewalls, VPNs, and common network attacks
Part 1 — Foundations
The bedrock of computer science. These concepts appear in every technical interview, every code review, and every system you'll ever build.
Part 2 — Design Patterns (LLD)
Low-Level Design — how to structure code so it stays maintainable as requirements change.
-
SOLID Principles — The five rules of object-oriented design
-
OOP Fundamentals — Encapsulation, Abstraction, Inheritance, Polymorphism, Composition
-
Creational Patterns — Singleton, Factory, Builder, Prototype
-
Structural Patterns — Adapter, Decorator, Proxy, Facade, Composite
-
Behavioral Patterns — Observer, Strategy, Command, Iterator, State
-
Big O Notation & Time Complexity — The language of algorithmic efficiency
-
Data Structures — Arrays, linked lists, stacks, and queues
-
Hash Tables & Hashing — O(1) lookup and how it works
-
Recursion & the Call Stack — Solving problems by solving smaller versions
Part 2 — Algorithms
Classic algorithms that power everything from database indexes to navigation apps.
- Binary Search — search in sorted data
- Sorting Algorithms — Merge sort, quicksort, and when to use each
- Graph Traversal (BFS & DFS) — Navigating networks and relationships
- Dynamic Programming — Optimal substructure and memoization
Part 3 — System Design
How to design the backend systems that serve millions of users.
- APIs & REST — HTTP, REST design, and API contracts
- Databases — SQL vs NoSQL — When to use each and why
- Caching (Redis, CDNs) — Speeding up reads at scale
- Load Balancing & Horizontal Scaling — Distributing traffic across servers
Part 4 — Advanced Concepts
The concepts that distinguish senior engineers from juniors.
- CAP Theorem — The fundamental trade-off in distributed systems
- Message Queues & Event-Driven Architecture — Decoupling services with async messaging
- Microservices vs Monolith — Architecture trade-offs and when to split
- Rate Limiting & Throttling — Protecting APIs under load
Part 5 — Modern Engineering
The professional toolchain every engineer uses in production.
- CI/CD Pipelines — Shipping code safely with automation
- Docker & Containers — The packaging revolution
- OAuth & Authentication Flows — Identity and authorization in the modern web
- WebSockets & Real-Time Systems — Building always-on connections
Part 7 — AI & LLMs
How large language models work and how to build systems with them.
- Agentic AI — How LLMs move beyond single responses to plan, use tools, and complete multi-step tasks autonomously
- Case Study: Agentic AI in Retail Merchandising — How agentic AI transforms retail from dashboard overload to proactive decisions
- Case Study: Bloomberg-Style Fintech Platform — Engineering a scalable financial intelligence platform with Next.js ISR, Supabase, and Cloudflare R2
How to Read ByteWise
Sequential: Start with Part 1 and work through in order. Each part builds on the previous. Recommended for CS students and career changers building from scratch.
Topic-first: Jump directly to the topic you need. Each chapter is self-contained with its own explanations and references. Recommended for working engineers filling in gaps.
Interview prep: Focus on Parts 1–3 for coding interviews, Parts 3–4 for system design interviews.
Ready? Start with Low-Level vs High-Level Programming →