Introduction to Android & Jetpack Compose — Android Course

What you'll learn

Welcome to the start of your Android journey. Android powers billions of devices, and in this course you'll learn to build real apps for it using Jetpack Compose — Google's modern, recommended UI toolkit. This first module is the big picture: what Android is, why Compose exists, and how it all fits together.

By the end you'll be able to:

Explain what Android is and how the ecosystem works
Describe the roles of Kotlin and Jetpack Compose
Understand declarative UI and why it's better
Picture how an Android app is built and run

Prerequisite: Kotlin

This course assumes you're comfortable with Kotlin — variables, functions, classes, null safety, lambdas, and a little about coroutines. If any of that feels shaky, work through the Complete Kotlin Course first; everything here builds on it.

What Android is

Android is the world's most popular operating system — it runs on phones, tablets, watches, TVs, and cars, on over three billion active devices. As an Android developer you write apps: the software people install and use. Google provides the platform, the tools (Android Studio), and a huge set of libraries called Jetpack to help you build them.

Kotlin & Jetpack Compose

Android apps are written in Kotlin, the concise, safe language you already know. For years, the look of an app was defined separately in XML layout files and wired up with Kotlin — two languages, lots of boilerplate, and easy to get out of sync. Jetpack Compose changes that: you build your entire UI in Kotlin, by writing functions. A piece of UI is just a function marked @Composable:

Greeting.kt

@Composable
fun Greeting(name: String) {
    Text(text = "Hello, $name!")
}

9:41

Hello, Android!

Greeting(name = "Android") — how this renders on a device

Key idea

That's the whole idea in one line: UI is a function of data. You call Greeting("Android") and Compose draws the text. There's no XML, nofindViewById, no manual wiring — just Kotlin functions that describe what should appear on screen.

Declarative vs imperative

This is the mental shift that matters most. The old approach was imperative: you found a view and told it, step by step, how to change — "get the text label, then set its text, then change its colour." Compose is declarative: you simply describe what the UI should look like for the current data, and when the data changes, Compose figures out what to redraw for you.

Tip

An analogy: imperative is giving turn-by-turn driving directions; declarative is naming the destination and letting the navigation system work out the route. You describe the destination (what the screen should show), and Compose handles getting there. It's the same idea behind modern web frameworks like React — describe the UI, don't micromanage it.

How an app runs

When you build, your Kotlin is compiled and packaged into an APK (or AAB) — a single installable file containing your code and resources. On the device, your app runs on the Android Runtime (ART). Every app starts from an Activity (the entry point, usually MainActivity), and in a Compose app that Activity simply hands the screen over to your composable functions. You'll see exactly how in the next two modules.

Recap & quick check

Key takeaways

Android is the world's most popular OS; you build apps for it with Kotlin and the Jetpack libraries.
Jetpack Compose builds the whole UI in Kotlin using @Composable functions — no XML layouts.
The core idea: UI is a function of data — you describe what to show for the current state.
Declarative (describe the result) replaces imperative (step-by-step view manipulation).
Apps compile to an APK/AAB, run on the Android Runtime, and start from an Activity (MainActivity).

Quick check

1. What language do you write modern Android apps in?

2. What is Jetpack Compose?

3. What marks a function as a piece of UI in Compose?

4. What does 'declarative UI' mean?

5. What is the usual entry point of an Android app?

You've got the lay of the land. Next we'll install the tools and create your first project in Android Studio.