Kotlin and Android: books to build modern mobile apps
This curriculum takes a beginner from zero Kotlin knowledge to building production-ready Android applications across four tightly sequenced stages. Each stage builds directly on the last — mastering the language first, then the Android platform, then modern UI with Jetpack Compose, and finally the architecture and concurrency patterns that separate hobby projects from professional ones.
Kotlin Language Foundations
BeginnerGain a solid, confident grasp of Kotlin syntax, idioms, null safety, collections, lambdas, and object-oriented/functional programming concepts before touching Android at all.
▸ Study plan for this stage
Pace: 8–10 weeks, ~40–50 pages/day (mix of reading and active note-taking). Weeks 1–3: "Kotlin Programming" (foundational syntax, types, null safety); Weeks 4–7: "Kotlin in Action" (deeper idioms, collections, lambdas, OOP/FP patterns); Week 8–10: Review, exercises, and mini-projects.
- Kotlin's type system: nullable vs. non-nullable types, smart casts, and the null safety guarantees that eliminate NullPointerExceptions
- Functions as first-class citizens: function types, lambdas, higher-order functions, and function literals with receivers
- Collections API: sequences, list/set/map operations, and functional transformations (map, filter, fold, reduce)
- Object-oriented programming in Kotlin: classes, inheritance, interfaces, sealed classes, data classes, and delegation
- Functional programming paradigms: immutability, pure functions, function composition, and when to use FP vs. OOP
- Kotlin idioms and conventions: extension functions, infix notation, scope functions (let, run, apply, with, also), and DSL basics
- Coroutines fundamentals: async/await patterns and structured concurrency (essential for Android, introduced here)
- Generics and type variance: in/out variance, reified type parameters, and how they differ from Java
- Explain the difference between nullable and non-nullable types in Kotlin, and describe three ways to safely handle nullable values (e.g., safe call, Elvis operator, let).
- What is a lambda expression in Kotlin, and how do function types enable higher-order functions? Give an example of a function that takes another function as a parameter.
- Describe the key differences between collections (List, Set, Map) and sequences in Kotlin. When would you use a sequence instead of a list?
- What are scope functions (let, run, apply, with, also), and when should you use each one? Provide a practical example for at least two.
- Explain the difference between object-oriented and functional programming approaches in Kotlin. How do data classes and sealed classes support these paradigms?
- What is an extension function, and how does it differ from inheritance or composition? Write a simple extension function example.
- Describe what a coroutine is and how async/await patterns work in Kotlin. Why are they important for Android development?
- Complete all code examples in 'Kotlin Programming' chapters 1–6 by typing them out and experimenting with variations (don't copy-paste).
- Build a small command-line application (e.g., a to-do list manager or expense tracker) that uses classes, inheritance, and collections to reinforce OOP concepts.
- Write 5–10 small functions that demonstrate lambda expressions and higher-order functions; practice using map, filter, fold, and reduce on real data.
- Refactor an existing Java class into Kotlin using idioms: convert getters/setters to properties, add extension functions, and use scope functions to simplify initialization.
- Create a sealed class hierarchy (e.g., for API responses: Success, Error, Loading) and write a when expression to handle each case safely.
- Implement a simple DSL (Domain-Specific Language) using function literals with receivers; for example, a builder for HTML or a configuration object.
- Work through all exercises in 'Kotlin in Action' (Chapters 4–8 especially) and write solutions without peeking at answers first.
- Build a small data-processing pipeline using sequences and functional transformations; measure performance differences vs. eager collections.
Next up: With solid command of Kotlin's syntax, type system, functional and object-oriented patterns, and coroutine basics, you are now ready to learn Android-specific frameworks (Activities, Fragments, lifecycle, UI toolkits) and how to apply Kotlin idioms within the Android ecosystem.
The most beginner-friendly entry point to Kotlin, using hands-on exercises to build intuition for the language's core features. Reading this first ensures you're not learning Kotlin and Android simultaneously, which is a common beginner trap.
Written by two JetBrains engineers who built Kotlin, this book goes deeper into the 'why' behind language design — covering extension functions, sealed classes, delegation, and DSLs. Read it second to solidify and expand what the first book introduced.
Android Platform Essentials
BeginnerUnderstand the Android platform fundamentals — Activities, Fragments, the app lifecycle, navigation, data persistence, and the View system — so you have a mental model of how Android apps are structured.
▸ Study plan for this stage
Pace: 8–10 weeks, ~40–50 pages/day (mix of reading and hands-on coding)
- The Activity lifecycle (onCreate, onStart, onResume, onPause, onStop, onDestroy) and how the system manages app state
- Fragments as reusable UI components and their lifecycle in relation to Activities
- Navigation patterns: intents, intent filters, back stack, and Fragment transactions
- Data persistence: SharedPreferences, SQLite databases, and file storage for local data
- The View system: layouts, views, ViewGroups, and how to build UI hierarchies declaratively
- App structure: the manifest file, resources, and how Android packages and deploys applications
- Event handling and user interaction: click listeners, touch events, and lifecycle-aware UI updates
- Configuration changes and state restoration: handling rotation and other device reconfigurations
- Explain the complete Activity lifecycle and what happens to your app when the user rotates the device or receives a phone call.
- What is the difference between a Fragment and an Activity, and when would you use each one?
- How do you pass data between Activities using Intents, and what are the limitations of this approach?
- Describe three ways to persist data in Android and the trade-offs between SharedPreferences, SQLite, and file storage.
- How does the View system work in Android, and what is the relationship between layouts, Views, and ViewGroups?
- What is the back stack, and how does it affect navigation and app behavior when the user presses the back button?
- Build a simple single-Activity app with multiple Fragments that navigate between screens using Fragment transactions (following Big Nerd Ranch's CriminalIntent project structure).
- Create an app that passes data between two Activities using Intents and Intent extras; verify data arrives correctly.
- Implement SharedPreferences to save user preferences (e.g., theme, language) and restore them on app restart.
- Build a SQLite database-backed app that performs CRUD operations (create, read, update, delete) on a simple data model (e.g., a to-do list or crime log).
- Create a layout hierarchy using LinearLayout, FrameLayout, and RecyclerView; practice nesting and understanding view measurement and layout.
- Rotate your device (or use the emulator's rotation) while running an app and verify that state is preserved correctly using onSaveInstanceState and ViewModel (or Bundle restoration).
- Implement a multi-screen navigation flow with proper back stack behavior; test that back button works as expected.
- Build a master-detail UI pattern with a list Fragment and a detail Fragment that communicate via a shared ViewModel or callback interface.
Next up: This stage establishes the foundational mental model of how Android apps are structured and how the system manages their lifecycle; the next stage will build on this by introducing modern architectural patterns (MVVM, LiveData, Room ORM) and Kotlin-specific features (coroutines, extension functions) to write more robust, testable, and maintainable code.
The most widely recommended beginner Android book, it walks through building real apps step by step using Kotlin. Starting here grounds you in the platform before moving to modern toolkits.
Uses a visually rich, example-driven style to reinforce Android concepts like intents, permissions, and RecyclerView. Reading it after Big Nerd Ranch fills in gaps and cements understanding through a different teaching lens.
Modern UI with Jetpack Compose
IntermediateLearn to build declarative, reactive UIs with Jetpack Compose — including state management, theming, navigation, and composable architecture — replacing the legacy View system with Google's modern standard.
▸ Study plan for this stage
Pace: 4–5 weeks, ~40–50 pages/day, with 2–3 days per week dedicated to hands-on coding projects
- Composable functions as the fundamental building block of Jetpack Compose UIs
- State management in Compose: remember, mutableState, and state hoisting patterns
- Reactive data flow and recomposition: how Compose automatically updates the UI when state changes
- Theming and styling: Material Design 3 integration, custom themes, and design tokens
- Navigation in Compose: using Compose Navigation library to manage screen transitions and back stacks
- Composable architecture and best practices: breaking down complex UIs into reusable, testable components
- Interoperability between Compose and the legacy View system for gradual migration
- Performance optimization: understanding recomposition scopes and avoiding unnecessary recomposes
- What is a Composable function and how does it differ from traditional Android View-based layouts?
- How does state management work in Jetpack Compose, and what is the difference between remember and mutableState?
- Explain the concept of recomposition and how Compose determines when to update the UI.
- How do you implement theming in Jetpack Compose, and what role does Material Design 3 play?
- What is state hoisting and why is it important for building composable architectures?
- How does the Compose Navigation library work, and what are the key components for managing navigation flows?
- Build a simple counter app using Composable functions and mutableState to understand basic state management
- Create a reusable custom Composable component (e.g., a styled button or card) and use it across multiple screens
- Implement a multi-screen app using Compose Navigation, including back stack handling and argument passing
- Design and apply a custom Material Design 3 theme to an existing Compose app, including custom colors and typography
- Refactor a View-based layout into Compose to practice interoperability and understand the migration path
- Build a list-based UI (e.g., a to-do list or product catalog) with proper state hoisting and composable decomposition
- Implement a form with multiple input fields, validation, and state management using Compose best practices
Next up: Mastering Jetpack Compose's declarative paradigm and state management establishes the foundation for advanced topics like complex animations, custom layouts, and performance tuning that will be explored in the next stage.
The most comprehensive hands-on guide to Jetpack Compose, published by the team behind raywenderlich.com. It covers everything from basic composables to animations and custom layouts in a project-driven format ideal at this stage.
Discussion
Keep reading
Paths that share books, cover the same subject, or open a related topic.
