Build Modern Android Apps with Kotlin, Compose & MVVM

Discover how Kotlin is a statically typed, concise language fully interoperable with Java, enabling mixed Kotlin and Java code in one project and multiplatform targets Android, iOS, desktop, and web.

Start a new Kotlin project, name it hello world, and choose a location. Select a build system like Maven, Gradle, or IntelliJ, and use the bundled JDK, then click create.

Learn to write your first Kotlin program by creating a main function, using fun, printing hello world, and running the code in an editor.

Explore how print and println behave in Kotlin; compare printing on the same line versus a new line, using examples and escape sequences.

Learn how to use single-line and multi-line comments in kotlin to document code, clarify intent, and help future developers while the compiler ignores comment text.

Learn how Kotlin uses variables to store data and declare them with the val keyword. Assign values, print results with string concatenation, and understand mutable versus immutable boxes.

Explore immutable and mutable variables in Kotlin, using val for values that cannot change and var for reassignable ones, illustrated by naming and aging examples.

Explore Kotlin data types such as int, long, double, float, string, boolean, and char, with CamelCase naming, println usage, and examples of arithmetic and concatenation.

Learn to convert between data types in Kotlin, from int to long and long to int, with min and max values guiding safe casting and possible truncation or exceptions.

Explore the null data type and the billion-dollar mistake, and learn how Kotlin enforces nullability with nullable types. See how first name and middle name can be null or non-null.

Learn the classical approach to handling null values in Kotlin by checking for null with if-else, using non-null checks, and safely converting strings to uppercase.

Explore Kotlin's safe call operator for handling null values without crashes. Use the question mark and dot operator to conditionally uppercase a nullable middlename and print the result.

Master how the Elvis operator handles null values in Kotlin, returning a fallback such as no name or empty, and emphasize meaningful variable names alongside the safe call operator.

Discover how the non-null assertion operator (!!) in Kotlin can crash the program with a null pointer exception, and why you should avoid it unless values are never null.

Explore Kotlin strings, using type inference to declare string variables, compare concatenation with string templates that use the dollar sign syntax, and build messages with firstName, lastName, and unread messages.

Explore string templates and common string functions in Kotlin, including length, uppercase, lowercase, substring, and contains, demonstrated through print operations and boolean results.

Explore how to declare and work with multiline strings in Kotlin, using triple quotes and trimIndent to manage indentation, and apply string templates to compose dynamic messages.

Explore booleans in Kotlin, using true or false to drive logical decisions with comparison operators—greater than, less than, greater than or equal, less than or equal, and equal—plus negation.

Combine multiple conditions using logical operators such as and, or, and negation to control decisions in your app, as shown through vote, ticket, and stadium scenarios.

Learn how Kotlin's if statements drive conditional execution to grade scores, using booleans, logical operators, and else-if chains for A to F grades and nested checks.

Learn to use an if statement as an expression in Kotlin to assign the score result to a variable, enabling cleaner, reusable grid logic with string templates.

Combine conditions with logic operators in if statements to require a score threshold and perfect attendance for earning a certificate, and handle alternate outcomes with an else block.

Learn how the Kotlin when statement replaces long if-else chains by testing values, ranges, and conditions with concise, readable code and a default else.

Explore how Kotlin when statements handle ranges, using score examples from 82 and 90 to 100 and 80 to 89 to print grid B or invalid score.

Learn how the when statement handles multiple conditions, replacing complex if chains with concise grid checks to print passed, failed, or invalid outcomes.

Explore using if statements without an argument and the with construct to conditionally execute code, and see score thresholds determine outputs like very good or excellent.

Explore using when as an expression in Kotlin within Android app development with Kotlin, Compose, and MVVM. Learn refactoring techniques, variable initialization, printing with string templates, and type inference.

For loops in Kotlin show how to repeat code automatically using a range, reducing manual duplication when grading many students.

Explore Kotlin for loops with ranges, steps, and downTo to print even numbers, count down to new year, and process student scores with if statements in a collection.

Explore nested for loops by iterating i and j from 1 to 3 to print a simple 3x3 table, illustrating how nested loops support grid layouts in programming.

Explore break and continue in loops by using range 1 to 10, stopping at five with break and skipping iterations with continue, and observing their effect on loop execution.

Learn how to replace hardcoded values with user inputs in Kotlin by using readLine and println, converting input to integers, and applying conditional logic.

Master the Kotlin while loop to execute code while a condition holds, prevent infinite loops, and implement a countdown using a decrement operator in Android apps.

Shows how a while loop controls a simulated download from 0 to 100 MB, updates downloaded size with speed, prevents infinite loops, and uses sleep to mimic progress.

Build a number guessing game that uses a while loop to repeatedly prompt for a secret number between 1 and 10, give hints, and celebrate when the guess is correct.

Demonstrate how a do while loop runs the code once before evaluating the condition, contrasting it with a while loop and showing its syntax and use cases.

Create a simple in-memory contact book in Kotlin that lets you view all contacts and add new ones, using an immutable list, when statements, and input validation.

Refactor the main function by extracting tax calculation, tip calculation, and bill printing into dedicated Kotlin functions, and format outputs to two decimals for easier reuse and maintainability.

Learn how Kotlin functions manage parameters with default values, such as a fixed tax rate of 0.08. See how to omit arguments and use syntactic sugar to simplify function calls.

Explore how arrays in Kotlin store multiple values of the same type in one variable, with a scores example, 0-based indexing, and mutability of a fixed-size collection.

Learn how Kotlin lists work as ordered collections that can contain duplicates, and master immutable versus mutable lists, indexing, and the get operator to access and modify items.

Explore sets in Kotlin to ensure unique items and avoid duplicates, using immutable and mutable sets to track visitors or students, with examples showing unordered collections.

Build maps in Kotlin as key-value data structures with unique keys, enabling value retrieval by key and distinguishing immutable from mutable maps through practical examples.

Refactor your Kotlin project by organizing code into a new Basics package, using IntelliJ for moving and restructuring, and creating additional packages to explore object oriented concepts.

Explore how object oriented programming groups related data and behavior into classes and objects, using a student class with name, age, and grade, plus a display information function in Kotlin.

Define a Kotlin class with primary and secondary constructors to initialize data such as name and age. Use init blocks for post-construction validation and default values to simplify creation.

Use the super keyword to call the parent's greeting from a child function, providing the parent code before or after the child's custom logic.

Learn encapsulation in Kotlin by hiding internal data, making balance private, and exposing safe deposit and withdraw methods to prevent invalid states in a bank account example.

Explore how Kotlin custom setters enforce validation and encapsulation by using private and private set modifiers to guard properties like account name, ensuring non-empty values and clear error handling.

Learn how to implement a custom getter in Kotlin to return a formatted balance with two decimal places, showcasing encapsulation and data formatting within a class.

Explore inheritance in Kotlin by using a base class like person to share properties with derived classes such as teacher and student, avoiding code duplication.

Explore inheritance in Kotlin by overriding methods with the open and override keywords, and implement a custom greeting while leveraging the subclass variables.

Define a generic Kotlin function that prints any type using a type parameter T, showing how a standalone function can handle strings, numbers, and other types without duplication.

learn how polymorphism lets student and teacher be treated as a common type, with runtime dispatch of the introduce method through a shared base class.

Examine abstraction in Kotlin by defining abstract classes and methods, showing only what's necessary and hiding complexity under the hood, while enforcing subclass implementations.

Discover how interfaces in Kotlin define a contract for account operations—deposit, withdraw, and show balance—without storing data, and contrast them with abstract classes through savings and current accounts.

Explore generics in Kotlin through a bank vault example that stores data types with preserved type safety using a generic type parameter T, and supporting get item and update item.

Apply type constraints to generics to enforce type safety, using a generic type T with an account operations interface to show balances and details for saving and current accounts.

Explore why generics matter in Kotlin, enabling code reuse across data types and compile-time error checking. Learn how generics make APIs cleaner and more flexible.

Learn how Kotlin's object keyword creates a singleton utility class, bank utils, to generate account numbers with a prefix and four-digit padding, without instantiation.

Leverage a companion object to provide static-like behavior inside a class, enabling register bank account and total accounts without instantiation, while managing shared data and reducing code duplication.

Define an enum class for bank account types, like savings, current, and fixed deposit, each with a monthly fee rate, then loop and print all account type values.

Introduce sealed classes as an advanced enum alternative that models distinct states with data, such as success, failure, and pending, in a bank transaction, using when expressions in Android Kotlin.

Learn functional programming in kotlin, contrasting it with imperative style, and discover how to describe outcomes using first class functions, immutability, pure functions, and avoiding side effects.

Explore Kotlin lambda functions and anonymous functions in functional programming, learning how to declare, assign, and invoke lambdas as first-class citizens in Kotlin.

Explore Kotlin lambdas with two or more parameters, adding numbers with type inference, lambda syntax, and direct invocation to compute sums.

Discover how Kotlin handles lambda functions with a single parameter using the implicit it name, and implement a square function through type inference and parameter usage.

Explore higher order functions in Kotlin by passing lambdas into other functions, use trailing lambda syntax, and implement reusable operations like discount calculations in Android apps using Jetpack Compose.

Explore how higher-order functions take a function as a parameter and return a function, using a multiplier factory that returns an int-to-int function and yields 10 and 15 when invoked.

Explore Kotlin's built-in higher-order functions and use a trailing lambda to iterate a names list with foreach, illustrating a shift from imperative loops to functional programming patterns.

Explore how to use the Kotlin map function to transform a list of numbers by squaring each element, then chain a foreach to print the results.

Filter the list of numbers to extract even numbers using a higher-order function and the mod operator, resulting in the even numbers 2 and 4.

Explore how to use Kotlin's any and find to search lists with predicates, combine filter, map, and foreach to process data, and verify results with conditional checks.

Explore Kotlin scope functions such as let, apply, run, also, and with to execute code within an object's context, enabling cleaner, expressive code and improved nullable handling.

Unlock Kotlin extension functions to add new behavior to existing classes without modifying their source, using concise syntax and examples like appending exclamations to strings and calculating list averages.

Advance from variables and control flows to mastering object oriented features like classes, inheritance, polymorphism in Kotlin, using generics, higher-order functions, and extension functions. Explore coroutines and asynchronous programming next.

Explore Jetpack Compose, a declarative Kotlin-based UI toolkit that replaces XML, simplifies state-driven interfaces, reduces boilerplate, and delivers fast, reusable Android app UI.

Master the foundations of Jetpack Compose, from environment setup and app anatomy to layouts, state management, navigation, and a capstone using MVVM, Room, Retrofit, and coroutines.

Install Android Studio, create your first compose project with the empty activity template, run a hello compose app, and explore Android Studio’s folders, files, and SDK settings.

Navigate Android Studio’s interface, including the toolbar, run and debug actions, Gradle sync, and the Android view project panel, to write code and manage resources for compose basics.

Build user interfaces in Jetpack Compose with composable functions, like text, and preview them in Android Studio using the preview annotation.

Learn how modifiers decorate composables with padding and background colors, how their order affects layout, and how to create interactive buttons with onClick in compose.

Arrange lightweight composables into clean layouts using column and row, control spacing with vertical arrangement and horizontal alignment, and enhance UI with modifiers, previews, and icons in Compose.

Master the box layout in compose to stack and overlay elements, using surface and scaffold, and align modifiers to position text and icons precisely.

Explore text fields in compose as controlled components, manage input state with remember and mutableStateOf, and use label, placeholder, leading icon, and outlined text fields for unidirectional data flow.

Create a practical tip calculator with a composable function, manage bill amount state, compute 15% tip and total in real time, and format output with a dollar sign.

Implement compose navigation using a nav controller, a navigation host, and routes to create a two-screen app, manage backstack with popUpTo and inclusive, and reduce typos with a routes enum.

Navigate between screens using dynamic routes and arguments in Jetpack Compose, passing a contact id through an int argument to a detail screen from a contact list.

Learn type safe navigation in Jetpack Compose by modeling destinations as serializable Kotlin data classes or objects under a sealed interface, enabling compile-time safety and avoiding string routes.

Learn to centralize styling with a material theming system in Jetpack Compose, using semantic color schemes, typography, and dynamic color for light and dark modes.

Explore how Jetpack Compose animates state rather than properties, delivering smooth transitions with animate as state, animated visibility, and crossfade to create polished, responsive user interfaces.

Learn modern Android development with clean architecture, Jetpack Compose, Room, Retrofit, and WorkManager, building a five-screen task app featuring a dashboard, calendar, analytics, and a new task screen.

Create and configure a new Android project, add and manage dependencies in Gradle, and set up plugins and bundles for Room, Retrofit, Navigation, and Compose using a starter template.

Create a room type converter to save LocalDate as a long and convert back to LocalDate, enabling seamless persistence in the Room database.

Define a Room data access object (DAO) to query SQLite, with tasks retrieval, due date and completion filters, analytics counts, date-range queries, and CRUD operations, via a singleton database.

Create a Room database class with entities and version, add a date type converter, expose a Task DAO, and implement a singleton using a companion object and Room builder.

Use a mock api to simulate a server and learn networking by creating a tasks resource with fields and crud endpoints.

Create remote api data transfer objects by converting json responses to kotlin data classes. Use json to kotlin tooling and kotlin serialization to generate task dto and item with nullability.

Define a retrofit api service for tasks with get, post, update, and delete endpoints; use suspend functions, handle task dto items, and map dto to entity via a mapper.

Create a task mapper to convert between the network DTO and the app task entity, with due date handling and error resilience for stable syncing.

Implement the repository pattern to abstract data origins and provide a clean data access API, establishing a single source of truth with local storage and offline-first syncing via WorkManager.

Create and manage foreground notifications for a data sync worker, building progress and final updates, handling server and client errors, and introducing one-time and periodic work requests.

Implement offline-first task repository using a local room database, marking changes as created, updated, or deleted, and schedule a background sync with WorkManager to sync with the server.

Learn to implement a simple service locator graph that creates singleton dependencies like a task repository, API service, and WorkManager for periodic sync using manual dependency injection.

Create the home screen as a daily dashboard showing completed and remaining tasks, while wiring UI to the repository through a MVVM ViewModel and reactive state updates with Jetpack Compose.

Create a home view model to prepare data, decouple UI from data sources, and expose a combined home UI state via state flows for syncing, sorting, and counts.

Create an overview card composable in Jetpack Compose to display a title and count, using modifiers, a rounded 12 dp shape, padding, typography, and a live preview.

Build a today task component for the home screen with a card, row layout, a checkbox, the title, a due date, and an action chip.

Create an action chip as a composable with a surface, modifier, onclick, text, and icon, set the icon width to 80 dp, arrange in a padded column, and preview it.

Create a home screen composable linked to a view model, using state hoisting and collect as state to render the today overview with tasks and pull-to-refresh.

Build the my task screen to display all tasks and filter by category with tabs, using in-memory filtering in the view model and enums with UI colors.

Create a my tasks UI state with tasks and a selected tag. Build a my task view model that combines all tasks with the selected tag and filters the list.

Build a My Task screen composable using a view model and UI state, with tab navigation, a lazy column of tasks, and in-memory filtering in an MVVM pattern.

Build a new task screen with a form, manage its state in a view model, validate user input, and trigger a one-shot navigation back after saving the task.

Create a reusable task component in Jetpack Compose by building task tag and priority chips with selection handling, animated color, and elevated item containers.

Build a new task screen with a view model and user interface state. Navigate back after saving using a one-time launch defect, and explore date picker and input handling.

Build a reactive calendar screen that shows tasks for a selected date, using state flow, combine, and lazy vertical grids, with month and week views.

Design a calendar view model that manages selected date, current month, and month or week view; fetches tasks for dates and marks dates in the month using mutable state flows.

Create a calendar screen composable bound to a calendar viewmodel and ui state, enabling month and week views with next/previous navigation and a task list for the selected date.

Create an analytics screen showing daily task completions and category breakdowns with a custom canvas line graph, using flow map for aggregation and loading empty state handling.

Set up an analytic screen in compose, wire the view model to manage UI state, show a loading indicator, and display an overview plus a task completion card.

Create a line graph with the compose canvas api by normalizing data and mapping to x and y coordinates. Draw a smooth cubic bezier path with a vertical gradient fill.

Create a productivity by category interface with a 'task by category' card, dynamic category data, and a progress bar that visualizes each category’s completion percentage.

Create a completion rate card in a compose screen using material theme, with a linear progress indicator, padding, typography, and a preview of analytics states to visualize task progress.

Connect screens with a Jetpack Compose navigation graph and a typesafe route, and build a scaffolded UI with a top app bar, bottom navigation, and a floating action button.

Define and organize multiple top app bars for different screens using composable bars such as home, my task, calendar, analytics, and new task, wired through a scaffold and nav controller.

Create a utils package and an object with a create notification channel function that initializes a notification manager and registers a low importance channel for task synchronization in main activity.

Test run exposes navigation issues and crashes across calendar and analytics screens; fix by calling screens directly and updating state, and implement manifest permissions and foreground service configuration for stability.

Build a complete modern Android app with Room database, Retrofit networking, repository pattern, and WorkManager, delivering a reactive Jetpack Compose UI under MVVM with unidirectional data flow and navigation.