Kotlin Notes for Professionals (Mike Stebbins)（Z-Library）

# Kotlin Notes for Professionals — Reading Guide ## 【One-Line Pitch】 A practical, example-driven reference for Kotlin developers who want to move beyond tutorials and get straight to idiomatic patterns, from basic syntax to advanced features like DSLs and variance. Ideal for Java developers transitioning to Kotlin or intermediate programmers seeking a consolidated handbook. ## 【Book Arc】 - **Opening (~0%–11%)**: Table of contents and early chapters establish the book's structure as a "notes" style reference—each section is a self-contained recipe with code examples. Topics begin with fundamentals: Hello World, JVM compilation details, string indexing, and primitive arrays. - **Early (~11%–26%)**: Core language mechanics take center stage—functions (basic, inline, lambda, operator, shorthand), vararg parameters with the spread operator, conditional statements (when-expressions), and enum classes with members. The emphasis is on Kotlin's expressive syntax over Java's verbosity. - **Early–Middle (~26%–42%)**: Collection operations and functional iteration patterns dominate. The book demonstrates how map, filter, and chaining replace traditional loops, alongside control flow (break/continue with labels) and range iteration with step functions. - **Middle (~42%–58%)**: Advanced idioms emerge—regex matching in when-expressions, null-safety patterns (safe calls, apply, let), inheritance with the open keyword, visibility modifiers, and generics variance (declaration-site vs. use-site, star projections). - **Middle–Late (~58%–end)**: The book culminates in practical application: building DSLs through infix functions and operator overloading, idiomatic patterns (DTOs, filtering, delegation), Android-specific topics like RecyclerView, stream operations, Kotlin caveats, and build configuration with Gradle. ## 【Key Takeaways】 - **Functions are first-class citizens** (Early): Kotlin's function types like `() -> Any?` allow passing lambdas as parameters, enabling higher-order functions such as `twice { println("Foo") }`—a pattern that underpins much of Kotlin's standard library design. - **The spread operator (`*`) simplifies vararg calls** (Early): Passing arrays into vararg functions becomes trivial—`printNumbers(*numbers)`—and works even mid-argument-list, making interop between arrays and varargs seamless. - **Primitive arrays avoid boxing overhead** (Early): Types like `IntArray` and `BooleanArray` map directly to JVM primitives (`int[]`, `boolean[]`), with factory functions (`intArrayOf()`) and rich extension methods (`average()`, `sortedArray()`, `component1()`) that return `Double` or handle edge cases gracefully. - **When-expressions replace verbose if-else chains** (Early): Kotlin's `when` handles enum exhaustiveness naturally and works as an expression, making conditional logic more readable and safer than traditional switch statements. - **Functional iteration transforms collection processing** (Middle): Chaining `filter { it % 2 == 0 }.map { "Number $it" }` demonstrates how Kotlin's standard library encourages declarative, composable data transformations over imperative loops. - **Null-safety is enforced at compile time** (Middle): Safe calls (`string?.length`) prevent NPEs, while `apply` and `let` provide elegant ways to operate on null-checked objects—`obj?.apply { foo(); bar() }` runs the block only when non-null. - **Classes are final by default** (Middle): The `open` keyword explicitly opts into inheritance, a deliberate design choice that encourages composition over inheritance and prevents accidental API extension. - **Variance annotations map to Java wildcards** (Middle): `MutableList<out SomeType>` corresponds to `List<? extends SomeType>`, with clear rules about what operations are allowed—reading from out-projections, writing to in-projections, and the limitations of star-projections. ## 【Reading Tips】 - **Skim the table of contents first** (~0%–11%): This book is organized as discrete recipes, not a narrative. Identify which sections match your current needs—whether it's basic syntax, generics, or Android-specific topics—and jump directly. - **Deep-read Chapters 7–9** (~16%–32%): Functions, varargs, and conditionals form the backbone of idiomatic Kotlin. Master these early; they appear throughout the rest of the book and in real-world code. - **Pay special attention to null-safety idioms** (~53%): The `apply`/`let` patterns and safe-call operator are among Kotlin's most distinctive features. Practice these until they feel natural—they'll save you countless null checks. - **Use the generics section as a reference** (~53%–58%): Variance is conceptually dense. Don't try to memorize everything; instead, return to this section when you encounter compilation errors about type projections in your own code. - **Skip the Android-specific chapters if you're not doing mobile development** (~63%+): Sections like RecyclerView are useful only for Android developers. The DSL and idioms chapters, however, are valuable for all Kotlin programmers. ## 【Coverage Limits】 This guide synthesizes the first ~58% of the book in detail. Later sections on RecyclerView, streams, Kotlin caveats, and Gradle configuration are mentioned but not deeply analyzed; excerpts do not cover the full content of these chapters. ##