Prices shown are a USD base. Your local-market price is calculated at checkout in your own currency, plus any local sales tax.
What is inside
20 chapters, in the order the interviews tend to ask them:
Null safety, nullable types and platform types
Data classes, sealed hierarchies and exhaustive when
Extension functions and the rules that resolve them
Scope functions and the implicit receiver
The collections API, sequences and lazy evaluation
Coroutines and structured concurrency
Flow, streams and cold versus hot
Channels, actors and pipeline concurrency
Inline functions, reified generics and the cost model
Type inference and the places it stops
DSL construction and builder patterns
Destructuring declarations and component functions
Function types, references and higher order design
Java interoperability and the nullability boundary
Testing coroutines and Flow
Android architecture with the Jetpack libraries
Kotlin on the JVM, the compiler and its runtime cost
Multiplatform, expect and actual declarations
Performance, boxing and allocation on Android
Code style, linting and static analysis
How the answers are built
Each chapter opens with the checklist the question is really testing. A few from this pack:
A question mark in a type declaration makes null a legal value, and every member access on that value becomes a compile error until something narrows it.
A data class generates equals, hashCode and toString from the primary constructor properties, so a property mutated outside the class body is what quietly breaks the contract.
A member always beats an extension, so a function you wrote for a library type can stop being called silently the day that class grows a member of the same name.
let and run pass the object as a parameter called it, while apply, also and with take it as an implicit receiver called this, and that choice decides which one reads better.
A collection operation runs immediately and returns a new collection, whereas a sequence operation records a step and nothing is computed until a terminal function is called.
A coroutine is a suspendable computation whose lifetime is bound to a scope, so cancelling the scope cancels everything launched inside it, and that is the whole of structured concurrency.
Questions this pack covers
What does the question mark in a Kotlin type actually mean?
How does the safe call operator differ from an ordinary call?
What does the data keyword actually generate for you?
How do you produce a modified copy of a data class?
How do you declare an extension function on a type of your own?
What does the receiver type actually do inside the body?
Which scope functions return the receiver instead of the lambda result?
How do you write a block that runs only when the value is present?
Each one is answered in full in the pack, with the reasoning written out rather than a bullet list.
