Effective Kotlin Best practices, 2nd Edition (Marcin Moskala) (z-library.sk, 1lib.sk, z-lib.sk)

【One-Line Pitch】 A rule-by-rule field guide for developers who already know Kotlin syntax but want to write code that is safer, clearer, and easier to maintain. Read it if you want judgment about *when* to use a feature, not another tour of the language. 【Book Arc】 - **Opening (~0%–10%)**: Frames the book's pragmatic philosophy and opens the Safety chapter by arguing that mutability is the root of many bugs, then shows how Kotlin's `val`, read-only collections, and related features help you limit it. - **Early (~10%–35%)**: Continues the safety toolkit — synchronization and concurrent collections for shared state, tightening variable scope, declaring expectations with `require`/`check`/`error`, handling nullability and `lateinit`, choosing between `null`, `Result`, and exceptions, and writing unit tests. - **Middle (~35%–50%)**: Shifts to Readability and Reusability: reducing cognitive load, avoiding clever-but-obscure constructs like misused `let`, operator overloading discipline, receiver/DSL design, and when code repetition is actually the right call versus when to extract abstractions. - **Late (~50%–85%)**: Moves into code design and efficiency — the excerpts do not cover these chapters in detail, but the blurb and introduction promise advanced material on inline functions and classes, DSLs, and platform types. - **Ending (~85%–100%)**: The excerpts do not cover the closing chapters; expect the book to consolidate its practices rather than introduce new themes. 【Book Arc note】 The excerpt sample is front-loaded: roughly the first half of the book (Safety, Readability, early Reusability) is well represented, while design, efficiency, and advanced topics are only signaled by the blurb and introduction. 【Key Takeaways】 - **Mutability is a cost, not a default** (Opening): The book opens by enumerating why mutable state is hard to reason about, test, and parallelize, then recommends mutability only where it earns its keep — Kotlin's `val` and read-only types make limiting it cheap. - **Protect shared state deliberately** (Early): Synchronized blocks with a lock, atomic values, and concurrent collections are presented as tools with trade-offs; the `UserRepository` example shows synchronizing only writes when reads dominate. - **Declare expectations as early as possible** (Early): `require` for arguments, `check` for state, `error` for impossible states, and the Elvis operator with `return`/`throw` turn implicit assumptions into explicit, fail-fast code. - **Match error style to expectation** (Early): Return `null` or `Result.failure` for *expected* errors; throw exceptions for *unexpected* ones. `Result` wins over nullable when you need to carry error details like codes or messages. - **Tighten scope to shrink state** (Early): Prefer local variables over properties and declare variables in the narrowest block that uses them — fewer visible mutation points means fewer states to reason about and test. - **Optimize for cognitive load, not cleverness** (Middle): Familiar structures beat short ones; the misused-`let` example shows how a popular idiom can silently change behavior. The book explicitly warns against over-correcting into banning idioms outright. - **Repetition is not always duplication** (Middle): Extract only when two pieces of code represent the *same knowledge* — ask whether they are more likely to change together. Independent build configs that merely look alike should stay separate. - **Type inference can leak into APIs** (Middle): The `DEFAULT_CAR` example shows how inferring a public value's type can silently narrow an interface's contract; specify types at API boundaries. 【Reading Tips】 - **Read Safety and Readability closely; skim what you already practice.** These chapters are dense with concrete before/after snippets and are the book's strongest material per the excerpts. - **Treat each item as a checklist, not a lecture.** The rule-of-thumb format rewards jumping to items relevant to code you're writing now; the summaries at chapter ends are good refreshers. - **Pause on the counterexamples.** The `let` misuse, `DEFAULT_CAR` inference, and premature-extraction cases teach judgment better than the positive rules do — note *why* the "bad" version fails. - **Expect the advanced chapters (inline, DSL, platform types) to be harder.** The excerpts don't cover them, so budget extra time and have the companion source repository open. - **Take away one habit per chapter.** E.g., from Safety: default to `val` and narrow scope; from Readability: prefer explicit receivers in DSLs. 【Coverage Limits】 This guide is based on stratified excerpts concentrated in the book's first half (Safety, Readability, early Reusability); the design, efficiency, and advanced-topic chapters are described only via the blurb and introduction, so their specific items are not summarized here.