Compose is a declarative UI toolkit about to kick-off for Android. It's the future of Android UI, and provides declarative APIs to create layouts of any complexity, manage and observe state changes automatically. Its API surface leverages immutable view state and its compiler is oriented to unlock efficient UI rendering and updates. Many architectures nowadays are based on the concept of immutable view state, like MVI or any other implementation of unidirectional data flow.
In this course, you will learn how to blend the two to achieve a functional approach to Android UI.
- Previous experience with Kotlin and knowledge of Android.
- Familiarity with other declarative UI frameworks like React, Flutter or similar would be helpful, but not required.
- A computer with Android SDK and Android Studio or IntellIJ.
- Highly suggested: the Jetpack Compose in-depth course.
What you'll learn
- Benefits of declarative UI frameworks.
- Libraries within Jetpack Compose.
- Compose compiler: code generation to improve the runtime. Works over the new IR.
- Runtime: rendering optimizations / skip rendering where required.
- Where declarative UI fits into Android modern architecture (MVI, unidirectional data flow).
- Modeling immutable app state. Introducing refined types for a more solid domain.
- Modifying our immutable app state using Arrow Optics.
- Making errors part of our state.
- Updating state. Making state updates pure.
- Observing state changes only where required.
- How state flows (top to bottom for state / bottom to top to callbacks).
- Exposing view state (state hoisting).
- Making our composable functions pure.
- Managing user input and other UI events in a functional way.
- Navigation as part of the application state (Router).
- Functional approach for Injecting dependencies in a Compose app.
- Unidirectional data flow architecture. UI inputs, actions, state reduction, observing new state. Sneak peek into Arrow's Stream.
- Writing UI tests for our composable tree.
- Sneak peek into property based testing for UI.
- Ideas on how to test our Arrow + Compose architecture.
- Scoping our background tasks to a composable lifecycle.
- Surviving configuration changes.
- Similarities / key differences between Jetpack Compose and Functional Programming (composable functions as side effects).