shahroz's notes

How I Read Technical Books

  • Published
  • Last Updated
  • 5 min read

Reading a technical book is not the same as reading a normal book. You don’t “finish” a technical book. You build through it.

Here’s why:

  • Technical material is dense. You often need multiple passes to truly understand it.
  • Some pages are extremely heavy (new abstractions, mental models, syntax), while others are light and quick. The difficulty is not evenly distributed.
  • You cannot just read; you often need to:
    • Code along
    • Debug
    • Research unfamiliar keywords
    • Revisit fundamentals before moving forward

If the basics aren’t clear, the advanced parts will collapse later. So instead of reading once, I use round-based learning.

The Multi-Round Approach

Round 1 → Exposure (High-Level Read)

First pass is not about mastery.

It’s about:

  • Getting a feel for the chapter
  • Understanding the direction
  • Highlighting key ideas
  • Writing down questions for later

This is momentum-driven reading. No deep dives. No perfectionism.

Round 2 → Digestion (Rewrite & Clarify)

Now the real learning begins.

  • Rewrite highlights in my own words.
  • Answer the questions I wrote earlier.
  • Use docs, Google, ChatGPT if needed.
  • No copy-paste allowed.

If I cannot explain something clearly in my own words, I don’t understand it yet. Rewriting removes what I call cognitive debt—the illusion that I understood something just because I read it.

Round 3 → Implementation (Hands-On)

If the chapter includes code, I don’t skip this.

I:

  • Write the code myself
  • Debug it
  • Break it
  • Experiment with variations

Reading without implementation gives fake confidence. Implementation forces clarity.

Further Rounds?

Depends on:

  • The depth of the book
  • My goals
  • Whether I’m preparing for interviews, production work, or research

But the first three rounds are non-negotiable.

All book PDFs live inside:RESOURCES > PDFs > Books

Reading Time Rules

I don’t optimize for page count. I optimize for retention and depth.

Default Structure

  • Work in chunks of ~5 pages.
  • Especially when concepts are new or complex.
  • Technical books are meant to be read slowly.

But:

  • 5 pages is a guideline.
  • Time blocking is the real constraint.

I block ~1 hour (depending on availability).

Within that time:

  • I read as much as I reasonably can.
  • I do not rush to hit page targets.
  • I do not skip rounds to “move faster.”

The real goal is:

  • Knowledge retention
  • Hands-on ability
  • Long-term mastery

Not speed.

Round 1—High-Level Reading

This is familiarity, not mastery.

Goals

  • Read without getting stuck.
  • Maintain flow.
  • Highlight key lines, diagrams, explanations (PDF++).
  • Write questions for later.

Mindset

  • No deep dives.
  • No overanalyzing.
  • This is input collection.

Understanding comes later.

Workflow

  • Create a book folder inside PROJECTS.

  • Create a chapter note: Chapter 3 - Reference

  • Apply Book Chapter Template.

  • Split screen: note on one side, PDF on the other.

  • Highlight directly in PDF (PDF++).

  • Add quick notes and questions in the chapter note.

  • Work in fixed chunks (5 pages per session).

Chunk-Based Rule

If a chapter has 40 pages:

Day 1:

## Pages 1–5
- Highlight A
- Question B

Day 2 (append only):

## Pages 6–10
- Highlight C

Rules:

  • Never edit previous chunks.
  • The note grows downward only.
  • If Round 2 is pending → no new reading.

Round 2—Rewrite & Clarify

This is digestion. Not rereading.

Goals

  • Rewrite concepts in my own words.
  • Answer earlier questions.
  • Expand unclear ideas.
  • Avoid copy-paste at all costs.

If I cannot teach it simply, I don’t understand it. Rewriting removes passive understanding and replaces it with active clarity.

Workflow

  • Duplicate the reference note.

  • Rename to: Chapter X - Rewrite

  • Set type → chapter-rewrite

  • Update created.

  • Process one chunk at a time.

  • Rewrite, expand, clarify.

  • Mark chunk as processed.

Example:

## Pages 1–5 (Processed)

Ownership works by...
The borrow checker ensures...

Rules:

  • Only append downward.
  • Never modify completed chunks.

Time Constraint Rule

If I only have ~1 hour:

  • Finish pending Rewrite first.
  • No new reading if Rewrite is incomplete.
  • New chunk only starts after full completion.

Forward-only system.

Round 3—Hands-on Coding

This is where theory becomes real. Start only after Round 2 is complete for the same chunk.

Goals

  • Write and run the code.
  • Validate conceptual understanding.
  • Build execution confidence.

Workflow

  • Create a project folder inside PROJECTS. (Same name as book notes folder.)

  • Initialize a Git repo.

  • Create chapter-number subfolders.

  • Each chapter folder contains only that chapter’s code.

  • Build incrementally.

  • Use one development environment for the entire book (single venv, single setup).

Chunk Rule

If you processed:

## Pages 1–5 (Processed)

Then:

  • Code only for Pages 1–5.
  • No jumping ahead.
  • No mixing chunks.

If time runs out:

  • Stop immediately.
  • Resume the same round next day.
  • Do not advance prematurely.

Core Principle

Each page chunk must go through:

  1. Reference
  2. Rewrite
  3. Code

Only then move forward.

No skipping.

No rushing.

No illusion of progress.

Three-Round Chunk Learning Flow

flowchart TD

A[Select Chapter] --> B[Select Page Chunk<br/>Pages 1–5]

B --> C[Round 1<br/>Read]
C --> D{Finished Round 1?}

D -- No --> W1[⚠ Daily Time Limit Reached<br/>Stop Now<br/>Resume Round 1 Tomorrow]
W1 --> C

D -- Yes --> E[Round 2<br/>Rewrite]

E --> F{Finished Round 2?}
F -- No --> W2[⚠ Daily Time Limit Reached<br/>Stop Now<br/>Resume Round 2 Tomorrow]
W2 --> E

F -- Yes --> G[Round 3<br/>Code]

G --> H{Finished Round 3?}
H -- No --> W3[⚠ Daily Time Limit Reached<br/>Stop Now<br/>Resume Round 3 Tomorrow]
W3 --> G

H -- Yes --> I[Chunk Complete<br/>All 3 Rounds Done]

I --> J[Move to Next Page Chunk]
J --> B

Graph View