Computer Science From Scratch (David Kopec)（Z-Library）

【One-Line Pitch】 A hands-on tour of computer science fundamentals for experienced Python programmers, taught through seven build-it-yourself projects spanning interpreters, retro graphics, emulators, and machine learning. Read this if you can already write Python but want to understand the machinery underneath the syntax. 【Book Arc】 - **Opening (~0%–10%)**: Frames the book's premise and audience—intermediate/advanced Python programmers who lack formal CS training—and previews the four project parts plus an appendix on bitwise operations. - **Early (~10%–30%)**: Part I on interpreters. Builds a Brainfuck interpreter to expose the tokenizer/parser/runtime structure, then a NanoBASIC interpreter, establishing the core interpreter pipeline before moving on. - **Middle (~30%–55%)**: Part II on computational art. Covers dithering and the MacPaint file format with run-length encoding, then a stochastic painting algorithm using hill-climbing to generate abstract impressions of images. - **Late (~55%–80%)**: Part III on emulators. Starts with a CHIP-8 virtual machine as a gentle entry point, then escalates to a partial NES emulator covering CPU and PPU emulation. - **Ending (~80%–100%)**: Part IV on machine learning. Implements KNN for classification (fish, handwritten digits) and regression (predicting fish weights, filling in missing digit pixels), closing with an afterword on further learning. 【Key Takeaways】 - **Interpreters decompose into tokenizer, parser, and runtime** (Early): Brainfuck and NanoBASIC show how even a Turing-complete language reduces to a small set of mechanisms—cells, jumps, and branching. - **Turing-completeness needs surprisingly little** (Middle): Integer variables, mutation, conditionals, and a goto suffice; this reframes "real" vs. "toy" languages as a matter of degree, not kind. - **Emulation teaches computer architecture from the inside** (Late): Building a CHIP-8 VM and then an NES emulator forces engagement with registers, memory, instruction execution, and graphics hardware. - **Dithering and run-length encoding connect algorithms to real hardware constraints** (Middle): Adapting color images to a 1-bit Macintosh display shows how historical limitations drive algorithmic design. - **Stochastic search can produce sophisticated art** (Middle): Matching random shapes to an underlying image, optimized by hill-climbing, demonstrates algorithmic creativity beyond deterministic pipelines. - **KNN is a readable gateway to machine learning** (Ending): Classification and regression with k-nearest neighbors demystify ML without heavy math, reaching ~98% accuracy on handwritten digits. - **Bitwise operations underpin several projects** (Early): The appendix on binary, shifts, AND/OR/XOR, and complement is essential groundwork for the emulator and graphics work. - **Each chapter closes with real-world context and exercises** (throughout): Extensions and notes point readers toward deeper study rather than leaving projects as isolated toys. 【Reading Tips】 - Skim the acknowledgments and front matter; start real reading at the Introduction to calibrate whether the book's level matches yours. - Deep-read Part I (interpreters) even if you only care about emulators or ML—the tokenizer/parser/runtime model recurs throughout. - Treat the appendix on bitwise operations as required reading before Part III; the emulator chapters assume fluency with binary manipulation. - Type out and run the code rather than reading passively; the book's value is in the build, and the GitHub repo provides source and a requirements file. - Use the end-of-chapter exercises and "real-world applications" sections as a menu for what to explore next, not as obligations. 【Coverage Limits】 The excerpts cover the book's structure, audience, and project descriptions but do not include detailed chapter content, so this guide cannot summarize specific implementation techniques beyond what the table of contents and introduction reveal.