Manifest Android Interview presents practical challenges framed as questions and offers a structured roadmap for learning and refreshing Android and Jetpack Compose knowledge. It’s designed to benefit developers at every level, from juniors building a foundation to seniors exploring internal APIs and advanced concepts.

The content spans the core Android framework, UI architecture, Jetpack libraries, and business logic, while also giving significant attention to Jetpack Compose, from fundamentals and runtime behavior to UI composition and design practices. This balance ensures that you strengthen your knowledge of both classic Android and modern declarative development.

Every question is followed by a step-by-step walkthrough that not only explains how to solve it but also explores why the solution works. To simulate real hiring conditions, many sections end with follow-up challenges that mirror on-site interview tasks, helping you practice deeper problem-solving and technical reasoning.

To support continuous growth, the book includes curated references and additional resources so you can keep exploring beyond its pages. Complex or less common terms are explained with accessible footnotes, making advanced material approachable for newcomers while offering fresh insights to seasoned developers.

The "Pro Tips for Mastery" chapters go beneath the surface, covering internal API design, performance trade-offs, and architectural decisions that matter in real-world projects. Senior engineers will find thought-provoking details to sharpen their expertise, while mid-level developers gain a toolkit for leveling up their Android skills and building a stronger analytical mindset.

Whether you’re preparing for an interview, transitioning to Compose, or simply deepening your Android expertise, this book challenges you to go beyond memorizing APIs. Learn to reason about design choices, experiment with different solutions, and approach Android development with clarity, curiosity, and confidence.

— Jaewoong Eum (skydoves)

For fun facts, who it's for, what it covers, and what it doesn’t, check out the Manifest Android Interview: The Ultimate Guide to Cracking Android Technical Interviews blog post.

Practical Kotlin Deep Dive unpacks the “how” and “why” behind Kotlin from core language fundamentals and internal mechanisms to the design of its APIs. It spans Kotlin basics, the standard library, coroutines, kotlinx libraries, compiler internals, and Kotlin Multiplatform.

This book goes beyond surface-level APIs by diving into Kotlin’s internals: it walks through real Kotlin function implementations, demystifies generated bytecode, and explains how the Kotlin compiler interprets the language. It also draws directly from KEEP proposals, JetBrains YouTrack discussions, and compiler source code to connect concepts to their origins and design rationale. The result is an approach that helps you reason about Kotlin instead of simply memorizing APIs.

This progression ensures that you understand not only how to use Kotlin effectively, but also why the language was designed the way it is, giving you insights that translate directly into better code.

For continuous growth, the book includes curated references and additional resources so you can keep exploring beyond its pages. Complex or less common terms are explained with accessible footnotes, making advanced material approachable for newcomers while offering fresh insights to seasoned developers.

The "Pro Tips for Mastery" sections go beneath the surface, covering internal structures of Kotlin functions, algorithms, how the Kotlin compiler behaves, and implementation details that matter in real-world projects. Senior engineers will find thought-provoking details to sharpen their expertise, while mid-level developers gain insights for leveling up their Kotlin knowledge and building a stronger analytical mindset.

Whether you're optimizing performance-critical code, handling complex coroutine tasks, or exploring multiplatform development, this book challenges you to go beyond tutorials. Learn to reason about language design, understand internal mechanisms, and approach Kotlin development with clarity, curiosity, and confidence. You can read previews of Practical Kotlin Deep Dive.

— Jaewoong Eum (skydoves)

You write @Composable functions every day. Do you actually know what happens under the hood?

Most resources teach you how to use Compose. Jetpack Compose Mechanisms explains why it behaves the way it does, traced line by line through the AOSP source: from @Composable transformations to the gap buffer that stores your composition, to the single-pass pipeline that turns declarations into pixels. And rather than a dry, encyclopedic tour of internal APIs, it draws on the author's hands-on experience to pair every mechanism with highly practical, production-ready examples, so you fully internalize how Compose works instead of just memorizing it. Fully updated for the latest Kotlin 2.4.0 and Compose Compiler 2.4.0.

Here is the thing almost no one tells you: the @Composable function you wrote is not the function that runs. By the time the compiler is finished, a second, hidden function has taken its place, with a $composer threaded through every call, a $changed bitmask deciding whether to skip, a slot table quietly remembering your state by position, and a LayoutNode tree measured in a single pass and recorded into hardware layers. You have felt this machinery every time a recomposition fired when you did not expect it, every time a list scrolled with jank you could not explain, every time a compiler report flagged a composable as "not skippable" and left you guessing why. This book is the manual for all of it.

You will learn why @Composable is not an annotation but a change to the function's type, how the compiler rewrites your code into something closer to a state machine, why mutableStateOf triggers recomposition while a plain var silently does not, how the snapshot system hands you multithreaded state with no locks, why a single unstable List field can quietly tank an entire screen, and how the layout system measures everything in one pass without the exponential blowup that haunted the View world. Every chapter opens where any Compose developer can follow and ends somewhere you did not know the rabbit hole reached.

Just as importantly, this book is not based on Compose internal source reading alone. It is grounded in my own hands on experience building Compose tooling and libraries, such as Compose Stability Analyzer, Compose Stability Inference, Compose Navigation Graph, Compose HotSwan, and Compose Performance Skills. Every mechanism in these pages is something the author have used, debugged, and shipped in production, even the Composer/Kotlin compilers and Compose runtime.

The book follows Compose down through its three layers, then back up into practice. Chapter 1 opens the compiler and watches your @Composable functions get rewritten: the $composer and $changed parameters, the stability inference that decides what can skip, lambda memoization, and the dozen IR passes that produce the code that actually runs. Chapter 2 moves into the runtime: the gap buffer slot table that remembers your composition by position, the snapshot system that hands you lock-free, multithreaded state, the Recomposer that schedules work at frame boundaries, and the Applier seam that lets the same engine drive any tree. Chapter 3 turns that tree into pixels: the LayoutNode, the modern Modifier.Node system and its coordinator chain, single-pass measurement, graphics layers, input, semantics, lookahead and shared element transitions, and SubcomposeLayout, ending by building a tiny working Compose UI from scratch.

Chapter 4 is where it all comes together. It pulls everything from the first three chapters into a practical, battle-tested performance playbook, drawn directly from the author's experience shipping Compose libraries and tooling. You will walk the stability inference algorithm phase by phase, watch the runtime make its skip decision for a real composable, learn to scope state reads to the right rendering phase, fix the lambda and ViewModel patterns that quietly trigger rebuilds, and measure it all with compiler reports, recomposition tracing, the Layout Inspector, and Macrobenchmark. It names the handful of anti-patterns that silently cost you frames, and closes with a full case study that takes a janky chat screen from 47 recompositions a second down to zero. By the end, you are not just reading about performance, you can diagnose and fix it straight from the source.

By the last page, Compose stops being a set of APIs to memorize and rules to follow on faith. It becomes a system you can reason about from first principles, predict before you press Run, and debug straight from the source. If you have ever wanted to stop guessing and actually see what runs beneath your UI, this is the book you have been looking for.

— Jaewoong Eum (skydoves)