Atomic Kotlin (Bruce Eckel and Svetlana Isakova)（Z-Library）

【One-Line Pitch】 A deliberately small-step Kotlin course that turns "one concept per chapter" into a complete path from first program to advanced language features, written for dedicated beginners and for experienced programmers who want Kotlin's idioms rather than a Java translation. Best for self-learners who will actually type the exercises, not for readers hunting a quick syntax reference. 【Book Arc】 - **Opening (~0%–10%)**: Front matter, licensing, and the book's teaching philosophy — "atoms" as indivisible single-concept units, baby steps and small wins, plus how the free sample, exercises, and IntelliJ EduTools course fit together. - **Early (~10%–30%)**: Programming basics — `main()`, `println()`, comments, `var` vs `val`, data types, functions and signatures, `if` expressions, string templates, number types, Booleans, `while`, ranges, and the `in` keyword. This stage builds the vocabulary every later atom assumes. - **Middle (~30%–55%)**: Introduction to objects and usability — classes, properties, constructors, visibility, packages, testing, exceptions, collections (lists, sets, maps), then extension functions, named/default arguments, overloading, `when`, enums, data classes, destructuring, nullable types, safe calls, Elvis, and an introduction to generics. - **Late (~55%–80%)**: Functional and object-oriented programming — lambdas and their importance, collection operations, member references, higher-order functions, sequences, folding, recursion; then interfaces, inheritance, abstract classes, upcasting, polymorphism, composition, delegation, downcasting, sealed classes, type checking, nested/inner/companion objects. - **Ending (~80%–100%)**: Preventing failure and power tools — exception handling, check instructions, the `Nothing` type, resource cleanup, logging, unit testing; then extension lambdas, scope functions, creating generics, operator overloading, property delegation, lazy and late initialization, closing with appendices on AtomicTest and Java interoperability. 【Key Takeaways】 - **The "atom" structure is the book's real method, not a gimmick** (Early): each chapter introduces one concept so it cannot be subdivided, which keeps Kotlin's many-ways-to-express-one-feature richness from becoming overwhelming. - **`val` over `var` is a design stance, not just syntax** (Middle): the authors argue that programs are safer and easier to maintain when reassignment is avoided, and that `var` is a rare escape hatch rather than a default. - **Functions are the primary unit of organization and reuse** (Middle): signature, parameters vs arguments, return types, and library functions are established early because everything later — lambdas, higher-order functions, extensions — builds on that model. - **String templates replace concatenation as the idiomatic way to build text** (Middle): `$identifier` and `${expression}` interpolation, escaping, and triple-quoted literals are treated as core fluency, not trivia. - **Nullability is handled through the type system** (Middle): nullable types, safe calls, the Elvis operator, non-null assertions, and extensions for nullable types form a coherent toolkit rather than scattered tricks. - **Functional programming is taught as collection manipulation** (Late): lambdas, member references, higher-order functions, sequences, and folding are framed around practical list and map work. - **Object-oriented design gets a full progression, not a summary** (Late): interfaces through sealed classes, delegation, and companion objects are sequenced so each builds on the previous. - **Failure prevention and "power tools" are first-class topics** (Ending): exceptions, check instructions, `Nothing`, resource cleanup, logging, and unit testing sit alongside operator overloading, property delegation, and lazy/late initialization. 【Reading Tips】 - Experienced programmers should follow the authors' own advice: skim Summary 1 and Summary 2, then start where the material becomes unfamiliar rather than reading linearly. - Solve each atom's exercises immediately after reading it; the IntelliJ EduTools integration gives automatic checking and hints, which is where most of the learning happens. - Deep-read the nullability, generics, and delegation atoms — these are the spots where Kotlin diverges most from Java habits and where skimming costs the most later. - Treat the appendices (AtomicTest, Java Interoperability) as reference material to consult when writing tests or mixing Kotlin with Java, not as required linear reading. - The excerpts do not cover the actual body text of most later atoms, so use the table of contents as the map and the book itself for the detail. 【Coverage Limits】 The excerpts are dominated by front matter, licensing, and the opening basics; the middle and later sections are represented mainly by the table of contents and a few early atoms, so this guide describes the book's structure and stated approach more than the specific content of advanced chapters.