Glossary — Pocket Studio Academy

AAB: Android App Bundle. A newer package format that Google Play requires for publishing. Play uses it to build a smaller APK tailored to each device.
AAPT2: Android Asset Packaging Tool 2 — the program that compiles your res folder into the fast lookup table inside the APK and gives every resource a number.
ABI: The instruction set a phone's processor understands. Native code must be built once per ABI, which is why lib/ has several folders.
Abstract class: A class with holes in it. It declares functions but does not write their bodies, so something else must fill them in. Room fills in NotesDatabase for you.
Accessibility: Designing so that people using a screen reader, larger text, or one hand can still use your app. On Android, mostly content descriptions, touch target sizes and contrast.
Accessibility Scanner: A free Google app that looks at whatever is on your screen and lists the problems it finds: touch targets under 48dp, missing labels, weak contrast.
Activity: One screen of an Android app, and the entry point the system launches when you tap the icon. Modern Compose apps often have just one.
Activity Manager: The Android system service that keeps the list of installed apps and running screens, and decides what starts, what stops, and what gets killed.
Activity result launcher: The object that starts something outside your screen — a permission dialog, a file picker — and calls you back with the answer.
Adaptive icon: An Android app icon supplied as two layers — a background and a foreground — so the launcher can mask it into whatever shape the phone uses.
adjustResize: A manifest setting telling Android to shrink the app's window when the soft keyboard appears, rather than sliding the whole screen up out of view.
AGP: The Android Gradle Plugin — the piece that teaches Gradle how to build Android apps: merging manifests, compiling resources, making dex, packaging APKs.
Alpha: How see-through a colour is, from 0 (invisible) to 1 (solid). Lowering alpha is how you get a tint of a colour without inventing a new one.
also: A scope function for doing something on the side, usually printing or logging, without changing the value being passed along.
AndroidViewModel: A ViewModel that is handed the app's Application object when it is built. Use it when the ViewModel needs a Context — to open a database, say — and nothing else.
Animatable: The low-level animation holder, driven from a coroutine rather than from a target value. Reach for it when you need to wait for an animation to finish, or to interrupt one deliberately.
animateColorAsState: The colour version of animateFloatAsState. Change the target colour and it fades from the old one to the new one instead of switching.
animateContentSize: A modifier that makes a container grow or shrink smoothly when what is inside it changes size. The standard way to build a card that expands when tapped.
animateDpAsState: The dp version of animateFloatAsState, for sizes, offsets and padding. Remember that animating a size re-lays-out the screen every frame, so prefer graphicsLayer where you can.
animateFloatAsState: Give it a target number and it hands back a number that slides towards that target over time. Change the target and the slide starts again from wherever it had got to.
animateItem: A modifier for a row inside a lazy list. When the list changes, the row slides to its new position instead of jumping. It only works if the items have keys.
AnimatedVisibility: Wraps a composable so it fades and expands in when it appears, and shrinks and fades out when it goes, instead of popping on and off the screen.
Annotation: A label starting with @ attached to code, giving a tool extra instructions. It does not run by itself; something else reads it.
ANR: Application Not Responding — the dialog Android shows when the main thread has been blocked for about five seconds. It is the worst possible thing a slow database read can cause.
anydpi-v26: A resource folder suffix meaning "use this at any screen sharpness, on Android 8.0 and newer". It is where the XML adaptive icon lives, which is why no folder full of PNGs is needed.
API level: The version number Android gives each of its releases, counting upwards. Code talks in API levels; people talk in names and years.
API reference: The official page-per-function documentation for a library. Less friendly than a tutorial, always correct, and the thing experienced developers actually read.
APK: The finished file that IS your app — a single package holding your compiled code, pictures and text. Installing an APK puts the app on a phone.
apksigner: The Android tool that attaches a signature to a built APK, and the one that can tell you which key an existing APK was signed with.
App: A program you can open on a phone. It has an icon, a screen, and it does one job well. Everything you tap on your phone is an app.
App signing key: The key that signs every copy of your app a user actually downloads. Under Play App Signing, Google holds this one, which is why losing your own key stopped being fatal.
applicationContext: The Context that belongs to the whole app rather than to one screen. Hold on to this one for long-lived things like a database, so a closed screen cannot be kept alive by accident.
Application ID: The permanent, globally unique name of your app on a device and on Google Play. Once published it can never change.
apply: A scope function for setting several things on one object at once. Inside the block you name its properties directly, and it hands the same object back.
ARGB: How a colour is written as one number: alpha (how solid it is) first, then red, green and blue, two hex digits each.
Argument: The actual value you hand to a function when you call it, filling in a parameter.
ART: The Android Runtime — the engine inside every phone that actually executes your compiled code, manages memory, and cleans up values you have finished with.
Aspect ratio: The relationship between something's width and its height. Keeping a picture's aspect ratio is what stops faces looking squashed or stretched.
Asynchronous: Work that is started now and finishes later, while other things keep happening in the meantime.
autoGenerate: Tells the database to invent the primary key itself. You save a row with id 0 meaning "I do not have one", and SQLite hands back a fresh number.
BackHandler: A composable that catches the system back gesture while a screen is showing, so your code runs before the screen goes away.
Back stack: The pile of screens you have opened, newest on top. Pressing Back removes the top one and reveals the one underneath.
Bind variable: A named hole in a SQL query that gets filled from a function parameter. Written with a colon, and the parameter must have exactly the same name.
Block: A group of lines wrapped in curly brackets and treated as one unit. Bodies of functions, ifs and loops are all blocks.
Blocking: Holding on to a thread while doing nothing but waiting. Blocking the main thread is exactly what freezes an app.
Boilerplate: Repetitive code you must write that carries no real meaning. Good tools and languages exist largely to delete it.
BOM: Bill of Materials — one line that pins a matching set of library versions, so you never have to name a version for each of them individually.
Boolean: A value that is either true or false. Nothing else. It is how code answers yes/no questions.
Box: A layout that stacks its children on top of each other, in the order written. Use it when one thing must sit over another, like a banner over a game board.
Brush: A recipe for filling an area with more than one colour — a gradient. Anywhere Compose accepts a colour it usually also accepts a brush.
Build: The process of turning the code you wrote into an app the phone can actually install and run. You press Run; the build happens; an APK comes out.
Build cache: A store of results from work Gradle has already done. If the inputs to a task have not changed, Gradle reuses the old output instead of redoing it.
Build type: A named recipe for building your app. Every project starts with two: debug for testing on your own phone, release for the version other people get.
Bundle: A small container of simple values (numbers, text, booleans) that Android can write down and hand back later. It is how saved state travels through a restart.
Bytecode: A halfway language: not the words you typed, not raw processor instructions. Compact, fast to load, and what a runtime like ART executes.
Call: To actually run a function by writing its name followed by brackets.
Callback: A function you hand to something else so that it can run it later, when an event happens.
Canvas: A blank drawing surface where you place shapes, lines and arcs yourself. It is how this course draws dice pips and charts without any extra library.
Card: A Material container that groups related content into one tappable rectangle with rounded corners, its own fill colour and optional shadow.
Certificate: The public half of your key pair, plus a short description of who you say you are. It travels inside the APK so any phone can check the signature without asking anyone.
Chaining: Joining several steps one after another with dots, so the result of each step flows straight into the next.
Char: A single character, written between single quotes. A String is text of any length; a Char is exactly one.
checkSelfPermission: Asks whether your own app currently holds a permission. Always ask before doing the protected thing, because the user can take a permission away at any time.
CircleShape: A shape that rounds every corner by half the shorter side. On a square that gives a circle; on a wide box it gives a lozenge.
Class: A blueprint describing a kind of thing: what information it holds and what it can do. You then make objects from that blueprint.
clickable: A modifier that makes any composable respond to taps, and gives it the ripple, the touch feedback and the accessibility behaviour of a real button.
Closed testing: A release only invited testers can install. New personal developer accounts must run one — with a required number of testers, for a required number of days — before publishing publicly.
Code: Written instructions that tell a computer exactly what to do, step by step, in a language it understands.
Code completion: The editor offering to finish a name as you type it. Tap the suggestion instead of typing the rest — it is faster, and it cannot misspell.
Code generation: A tool writing source code for you at build time, from something short you wrote. Room reads your DAO and generates the class that actually runs the SQL.
Codelab: A free step-by-step tutorial published by Google, building one small thing from start to finish. The official Android ones are genuinely good.
coerceIn: Squashes a number into a range. Anything below the bottom becomes the bottom, anything above the top becomes the top, everything else is left alone.
Cold flow: A Flow that does nothing until somebody starts watching, and starts again from scratch for each new watcher. A Room query is cold.
Cold start: Starting an app when no process for it exists yet, so Android has to create everything. The slowest kind of launch — a warm start reuses a process that is still alive.
collectAsState: The bridge from a Flow to Compose. It watches the flow and turns each new value into state, so the screen redraws whenever the value changes.
Collection: Any container that holds several values under one name. Lists, maps and sets are all collections.
Colour scheme: The full set of colour slots Material 3 uses — primary, secondary, background, surface and their matching 'on' colours. You fill in the slots once and every component reads from them.
combine: Watches two or more Flows at once. Whenever any of them produces a new value, combine runs your block again with the newest value from each.
Comment: A note in the code written for humans. The compiler ignores it completely. Use comments to explain WHY, not what.
Commit: One saved snapshot of your whole project, with a short message saying what changed. Commits are how Git lets you look back, and how you get back when something breaks.
Companion object: A block inside a class holding things that belong to the class itself rather than to any one instance. It is where Kotlin puts what other languages call static members.
Comparison operator: An operator that compares two values and produces true or false: greater than, less than, equal to, not equal to.
Compile: To translate the code you wrote into a form the phone's processor can actually execute. If your code has a mistake, compiling is where it gets caught.
Build error: A mistake the compiler catches before your app is built, so no APK is produced and nothing is installed. The friendly kind of error — it comes with a file name and a line number.
Compiler: The program that does the compiling. It is also your first and best proofreader — it refuses to build code it does not understand, and tells you which line is wrong.
compileSdk: The version of the Android code library you compile against. It decides which functions you are allowed to type — it does not affect which phones can install the app.
Composable: A function marked @Composable that describes a piece of user interface. Composables are the building blocks of a Compose screen.
Jetpack Compose: The modern way to build Android screens. You write functions that describe what the screen should look like, and Android draws it and keeps it up to date for you.
Composition: The tree of composables Compose is currently keeping on screen, plus the values remembered inside it. Leaving the screen throws that part of the composition away.
CompositionLocal: A value published at one point in the screen tree and readable by everything below it, without being passed down as a parameter. Compose uses it for the few things every composable needs, like the theme.
Computed property: A property with a get() instead of a stored value. It works the value out fresh every time it is read, so it can never drift out of step with the data it comes from.
Concatenation: Gluing two pieces of text together end to end with a plus sign. String templates are usually easier to read.
Condition: The true-or-false test an if or a while asks before deciding what to do next. It must produce a Boolean — nothing else counts.
Configuration change: Something about the device changing while your app is open — rotation, dark mode, text size, language. Android destroys and rebuilds the screen so it can pick the right resources.
confirmValueChange: A gate you supply to a swipe or drag state. Return true to accept the gesture, false to spring the row back where it came from.
const val: A value fixed at build time and baked straight into the compiled code. Use it for a number that names a rule, like a winning score.
Constructor: The part of a class that runs when you make a new object from it. It takes the starting values and stores them on the object.
Content description: A short text label attached to an icon or image so a screen reader can announce what it is.
Content rating: An age rating produced by answering a questionnaire about your app's content. Play assigns the official rating from your answers.
ContentScale: How a picture fills the box it is given. Crop fills the box and trims the overflow; Fit shows all of it with gaps; FillBounds stretches and distorts.
Context: An object that gives your code a way to reach the app around it — its resources, its files, its settings. An Activity is a Context.
Contrast ratio: A number saying how different two colours are in brightness, from 1:1 (identical) to 21:1 (black on white). Body text should reach at least 4.5:1.
copy: A function every data class gets for free. It builds a new object just like the old one, with only the fields you name changed.
CornerRadius: How rounded one corner is, given as a radius. CornerRadius.Zero is a sharp corner.
Coroutine: A piece of work that can pause and resume without freezing the app. It is how Android does slow things — reading a database, waiting a second — while the screen stays smooth.
Coroutine scope: A boundary that owns a group of coroutines. Cancel the scope and every coroutine inside it stops — which is how Android avoids work outliving the screen that started it.
Crash: An app closing suddenly because it hit a problem it had no answer for. The reason is always written into Logcat, starting with the words FATAL EXCEPTION.
Crossfade: Fades from one composable to another as a value changes, so a screen swap is a dissolve rather than a jump.
CutCornerShape: A shape whose corners are sliced off flat instead of curved. Cut all four by the same amount and a square becomes an octagon.
D8: The tool that turns compiled Java and Kotlin bytecode into the dex format Android runs.
Damping ratio: In a spring animation, how much it wobbles before settling. NoBouncy stops dead on the target; HighBouncy overshoots several times first.
DAO: Data Access Object — an interface listing the database operations you want (get all notes, insert one, delete one). Room writes the actual code for you.
Dark theme: A second set of colours for when the phone is in dark mode. It is a redesign, not an inversion: light surfaces become dark greys, and bright accents become softer.
Data class: A class whose job is simply to hold data. Kotlin writes the tedious parts for you — comparing, copying and printing it.
Data safety form: A questionnaire in the Play Console about what your app collects and shares. Your answers become the Data safety card on your store page, so they must be true.
DataStore: Android's way to save small settings — a toggle, a chosen length, a name. Simpler than a database, and safe to read and write from coroutines.
Debug build: A build meant for testing. It is signed automatically with a throwaway key, so it installs on your own phone instantly but cannot be published.
Debug keystore: A throwaway key Android generates for you so debug builds can install without any setup. Every debug build on your phone shares it, and Play will never accept it.
debuggable: A flag on a build that lets another program attach to your running app and look inside it. Debug builds have it switched on; Google Play refuses any upload that does.
Debugger: A tool that pauses your running app so you can inspect what every value actually is at that moment. In Pocket Studio the on-device debugger is a paid-tier feature.
Deep link: A web-style address that opens one particular screen inside an app instead of the home screen. Navigation can attach one to any route.
Default argument: A value a parameter falls back on when the caller leaves it out, so one function can cover the simple case and the fussy one.
delay: Pauses a coroutine for a number of milliseconds without blocking the thread, so everything else carries on meanwhile.
Density bucket: One of the screen-sharpness groups Android sorts phones into: mdpi, hdpi, xhdpi, xxhdpi, xxxhdpi. A pixel picture needs one copy per bucket. A vector needs none.
Dependency: Someone else's code that your project uses. You list it in your build file and Gradle fetches it. Fewer dependencies means faster builds — which matters when building on a phone.
Dependency graph: The full tree of every library your project uses, plus everything those libraries use. The bigger the tree, the slower and hotter the build.
Dependency injection: Handing a class the things it needs from outside instead of letting it build them itself. It sounds grand; it is mostly just passing constructor arguments.
Deprecated: Still works, but officially discouraged and likely to be removed later. The compiler warns instead of failing.
Destructive migration: Telling Room to delete everything and start again when the schema changes. Fine while you are the only user; never acceptable once real people have data.
Destructuring: Pulling the parts of an object out into several separate names in a single line.
Desugaring: A build trick that rewrites newer Java features so they run on older Android versions. Setting minSdk 26 avoids needing it for dates and times.
Play developer account: The account you need before you can publish on Google Play. It costs a one-off 25 US dollar fee and requires identity verification.
DEX: Dalvik Executable — the compact code format Android actually runs. Your Kotlin ends up inside classes.dex in the APK.
DisposableEffect: A composable side effect with a clean-up half. The block runs when the screen appears, and its onDispose runs when the screen goes away or the key changes.
Double: A number that can have a decimal point.
downTo: Builds a range that counts backwards. 6 downTo 0 gives 6, 5, 4, 3, 2, 1, 0 — handy when the oldest item has to come first.
dp: Density-independent pixel — a unit of size that looks the same physical size on every screen, whether the phone is sharp or coarse.
drawArc: A Canvas instruction that draws part of an oval. Give it the box the oval fits in, where to start, and how far to sweep.
drawLine: A Canvas instruction that draws one straight line between two points, with a chosen colour, thickness and end shape.
drawText: Draws an already-measured piece of text onto a Canvas at a given point. Canvas has no idea about fonts on its own, so the text must be measured first.
Drawable: Anything Android can draw: a picture, a shape, a gradient. They live in res/drawable and can be XML rather than a photo.
DrawScope: The little world you are inside when drawing on a Canvas. It knows the exact size you were given and provides every drawing command — drawCircle, drawRoundRect and the rest.
Dynamic colour: Android 12 and newer can build a colour scheme from the user's wallpaper. Lovely when it fits your app, wrong when your colours carry meaning.
Easing: The shape of an animation's speed over time. Nothing in the real world starts and stops instantly, so easing makes motion leave fast and arrive gently, or the reverse.
Edge to edge: Letting your app draw behind the status bar and navigation bar so the screen looks continuous. Android 15 turns this on for apps that target it.
elapsedRealtime: A count of milliseconds since the phone last booted. It only ever goes forwards, so it is the right clock for measuring how long something took. The wall clock can jump; this cannot.
Element: One single item inside a list or other collection.
Elevation: How far a surface appears to sit above the one behind it. In light mode that is a shadow; in dark mode Material lifts the surface colour instead.
else: The other path of an if — what to do when the condition was false.
Elvis operator: The two characters ?: meaning "use the value on the left, but if it is null use the one on the right instead". It is how you supply a fallback.
Empty state: What a screen shows when there is nothing to show yet. A good one explains what will appear here and how to add the first item.
Emulator: A simulated Android phone running on a computer. You will not need one — you have a real phone, which is better.
Entity: A class marked @Entity that describes one table in the database. Each property becomes a column.
Enum: A type with a small fixed set of named options. Perfect when something can only be one of a few things.
Epoch milliseconds: The standard way computers write a moment in time: how many milliseconds have passed since midnight on 1 January 1970, UTC. One plain number, easy to store and compare.
Error state: What a screen shows when something went wrong. A good one says what failed in plain words and offers a button that tries again.
Escape sequence: A backslash plus a letter or symbol inside a string, standing for a character you cannot type directly — a new line, a tab, or a quote mark.
Exception: Android's way of saying something went wrong at runtime. Unhandled, it closes the app.
Exhaustive: Covering every possible case. Kotlin can prove a when is exhaustive over an enum or a sealed class, and refuses to build if a case is missing.
Expression: A piece of code that produces a value. In Kotlin even if and when are expressions, so they can be assigned to a name.
Extension function: A function you write that attaches to an existing type, so it can be called with a dot as though it had always been part of it.
Floating action button: The round button that hovers over the content, bottom right, for the one most important action on a screen. Usually a plus.
Feature graphic: The wide banner image Play shows at the top of your store listing. It is required, and its size is fixed at 1024 by 500 pixels.
filter: A collection function that keeps only the items passing a test you supply, and hands back a new collection. The original is untouched.
Certificate fingerprint: A short hash that identifies a signing key without revealing it. Android compares fingerprints when deciding whether an update really came from you.
FLAG_IMMUTABLE: A required flag on a PendingIntent saying that whoever holds it may fire it but may not change what it does. From Android 12 you must state this explicitly.
Flash of empty: The bug where a screen shows its empty state for one frame on every launch, before the data arrives. Fixed by treating "not asked yet" and "genuinely empty" as two different states.
Float: A number with a decimal point, stored in less space than a Double. Compose uses Float for sizes, angles and animation values, so you will see the f suffix a lot.
Flow: A stream of values that arrive over time, one after another. Code can watch a Flow and react each time a new value shows up.
catch: A flow operator that intercepts an error coming down the pipe. You can look at what went wrong and emit a stand-in value instead of letting the whole flow die.
collect: Subscribing to a Flow. The block you pass runs once for every value the flow emits, and the call waits for more until the coroutine is cancelled.
FocusRequester: A handle you attach to a text field so code can move the cursor into it. Asking for focus is also what makes the soft keyboard appear.
Font scale: The text-size multiplier the user chose in their phone settings, from about 0.85 up to 2.0. Sizes written in sp are multiplied by it; sizes in dp are not.
for: A loop that walks through every item of a range or a list, one at a time, and stops on its own at the end.
forEachIndexed: Walks a list and hands you both the position and the item. Use it when where something sits matters as much as what it is.
Force dark: An Android feature that machine-inverts an app which has no dark theme of its own. The results are unpredictable, which is exactly why writing a real dark scheme is better.
Function: A named set of steps you can run whenever you like. Write it once, use it as many times as you want. Like a recipe with a name.
Function reference: A way to pass an existing function where a lambda is expected, written with two colons. It means the same thing as wrapping it in braces, with less typing.
Function type: The type of a function value: what it takes in, an arrow, then what it gives back.
Git: A system that records snapshots of your project over time, so you can see what changed and go back if you break something.
Repository (Git): The hidden folder where Git stores every snapshot of a project. Creating one is called initialising, and you do it once per project.
Go to definition: Jumping from a name in your code to the place where that name was created. It is how you read code you did not write without guessing what it does.
Gradle: The build tool. It reads your project's settings, downloads the libraries you asked for, compiles your code, and packages the result into an APK. It is the machine that turns text into an app.
Gradle daemon: A background helper that stays running between builds, already warmed up, so the next build does not pay the startup cost again.
Gradle plugin: A bundle you add to a build file that teaches Gradle a new skill. Gradle knows nothing about Android until a plugin tells it.
Gradle task: One named unit of work in a build, like compiling Kotlin or packaging the APK. Tasks depend on other tasks, and Gradle runs them in the right order.
graphicsLayer: A modifier that moves, rotates, scales or fades a composable's pixels without disturbing the layout around it. Animation's favourite tool, because nothing else has to be measured again.
Path: A shape built up out of lines, curves and rectangles, then drawn in one go. Use it when the shape you want is not a plain circle or rectangle.
Size: A width and a height kept together as one value. Drawing commands that need a box take one of these rather than two separate numbers.
groupBy: Sorts a list into buckets. You say what the label of each item is, and you get back a map from label to the list of items that carried it.
heading(): A semantics marker saying "this line is a heading". Screen reader users can then jump from heading to heading instead of listening to a whole screen.
Higher-order function: A function that takes another function as an input, or hands one back. It is how you say "run this bit of code, whatever it is, for me".
Hot flow: A Flow that is already running and always holds a current value, whether anybody is watching or not. StateFlow is the common one.
Icon mask: The shape the launcher cuts your adaptive icon into — a circle, a squircle, a rounded square or a teardrop. The phone chooses it, not you.
Icon parallax: The small slide some launchers give the foreground layer of an adaptive icon against its background when you drag or press it. It only works because the two layers are separate.
IDE: Short for Integrated Development Environment: one program that holds everything you need to make an app — an editor, a builder, and a way to run it. Pocket Studio is an IDE that runs on your phone.
Identity verification: The step where Google checks that a personal developer account belongs to a real named person, using an identity document and an address. It happens before you can publish.
if: Runs a block of code only when a condition is true. The way code makes a decision.
ImageVector: A picture held as lines and curves rather than pixels, ready to be drawn at any size without going fuzzy. Every Material icon is one.
IME action: The label and behaviour of the bottom-right key on the soft keyboard. Setting it to Search puts a magnifier there instead of a newline key.
imePadding: A modifier that adds bottom padding equal to the height of the soft keyboard, so the keyboard pushes your content up instead of covering it.
Immutable: Cannot be changed after it is created. Immutable data is easier to reason about because nothing can quietly alter it behind your back.
import: A line at the top of a file that brings in code written somewhere else, so you can use its names without writing the full path every time.
Incremental build: A build that only redoes the parts affected by what you changed, instead of starting from nothing.
Index: The position of an item in a list. Counting starts at 0, not 1 — the first item is at index 0.
IndexOutOfBoundsException: The crash you get for asking a list for a position it does not have. A list of 3 items has positions 0, 1 and 2 — never 3.
Infinite loop: A loop whose condition never becomes false, so it never stops. The program appears to freeze because it is busy going round forever.
Infinite transition: An animation with no end, used for loading spinners and pulsing dots. It runs until the composable leaves the screen.
init block: A chunk of setup code that runs when an object is built, after the properties written above it. Use it for work that is more than one line.
Instance: One actual thing built from a class. Two instances of the same class each hold their own separate values.
Instant: One exact moment on the world clock, with no time zone attached. Give it a zone and it becomes a date and a time somebody could read off a wall.
Int: A whole number, positive or negative, with no decimal point.
Integer division: What happens when you divide one whole number by another: Kotlin throws away the fraction instead of rounding. 7 / 2 is 3, not 3.5.
Intent: A message handed to Android saying what you want done — open this screen, share this text, take a photo. Android works out who should receive it.
Intent filter: A block in the manifest advertising which intents a screen can handle. It is how an app says "send those to me".
Interface: A list of function names with no bodies — a contract. Any class can promise to fulfil it, and code written against the contract works with all of them.
Internal testing: The fastest Play track. A small list of named testers gets the build within minutes, and it skips the full review, which makes it the sane place to start.
isActive: True while the coroutine you are inside is still wanted, false once it has been cancelled. Looping while (isActive) means the loop stops itself the moment someone cancels it.
isSystemInDarkTheme: Asks the phone whether it is currently in dark mode and hands back true or false. Used as a default argument so an app follows the system but can still be forced either way.
it: The automatic name for the single item a small inline function is working on, so you do not have to invent a name for it.
java.time: The date and time library built into Android from API 26. It knows about calendars, time zones and daylight saving, so you never do date maths by dividing milliseconds.
Job: The handle launch hands back for the coroutine it just started. Keep it and you can cancel that one piece of work later without touching anything else.
JVM: The Java Virtual Machine — the program that runs Java and Kotlin bytecode. Gradle and the Kotlin compiler both run inside one.
keepScreenOn: A flag on an Android View that asks the system not to dim and lock the display while that view is on screen. Turn it off again when you leave, or the phone never sleeps.
Key: The label you look something up by in a map. Each key appears once and points at one value.
Key alias: The name of one key inside a keystore. A keystore can hold several keys, so signing needs both the file's password and the alias you want.
Key pair: Two matching keys made at the same moment: a private one you keep secret and sign with, and a public one anybody may hold and use to check your signature.
keyframes: An animation recipe with named waypoints — be 70% of the way there at 200 milliseconds, then ease into the finish. Use it when tween and spring cannot describe the movement you want.
Keystore: The password-protected file holding the private key you sign your app with. Lose it and you can never update your published app again.
keytool: The command-line program that creates a keystore and generates the key inside it. Tools with buttons, Pocket Studio included, run it for you behind the scenes.
Keyword: A word that belongs to the language itself and always means the same thing. You cannot use one as a name of your own.
Kotlin: The programming language this course uses. It is the language Google recommends for building Android apps — clear to read and hard to get wrong.
Kotlin Playground: A Kotlin editor on kotlinlang.org that compiles and runs code straight in a browser. Handy for testing a language idea without making a whole Android project.
KSP: Kotlin Symbol Processing — the tool that reads annotations like @Entity and generates the boring code for you at build time. Room uses it.
Lambda: A small nameless function written inline, usually handed to another function to say "do this for each item" or "do this when tapped".
launch: Starts a coroutine that runs alongside the code that started it. It returns straight away instead of waiting for the work to finish.
launchSingleTop: Tells navigation not to add a second copy of a screen that is already on top. Tapping the Timer tab twice leaves one Timer screen, not two.
LaunchedEffect: Runs a coroutine when a composable appears, and cancels it when the composable leaves. It is how you start one-off work — a delay, a database read — from inside a screen.
Launcher: The home screen itself, which is just another app. It draws your icons and asks Android to start whichever app you tap.
Layout: The arrangement of things on a screen — what sits above, beside or inside what.
LazyColumn: A scrolling vertical list that only builds the rows currently on screen. Use it for lists that could be long — it stays fast with thousands of items.
Legacy icon: The old style of app icon: one flat picture per screen density with its own shape baked in, so it could not be masked. Replaced by adaptive icons in Android 8.0.
lerp: Short for linear interpolation: give it two values and a fraction, and it hands back the point that far between them. With colours it mixes them.
let: A scope function. It hands the object to your block as it, and gives back whatever your block produces. Paired with a safe call it runs a block only when a value is not null.
Library: A ready-made bundle of code that solves a problem so you do not have to. Room and Compose are libraries.
Lifecycle: The sequence of states a screen passes through: created, visible, in front, hidden, destroyed. Android tells your code when each happens so it can react.
lightColorScheme: Builds the set of colours used in daylight. Every slot you leave out keeps a sensible Material default. Its twin, darkColorScheme, does the same job for dark mode.
Lint: Android's built-in inspector. It flags things the compiler allows but that hurt real apps: missing text descriptions, suspicious version numbers, likely crashes.
List: An ordered collection of items held under one name. Position 0 is the first item.
Live query: A database question that answers again by itself. A Room query returning a Flow re-runs whenever a row in the tables it touches changes, and pushes the new answer out.
Loading state: What a screen shows while it is waiting for data. Done well it is brief and calm; done badly it is a blank screen the user mistakes for a broken app.
LocalDate: A calendar date with no time and no time zone attached — just "15 August 2026". Perfect for grouping things into days.
Local function: A function declared inside another function. It can see the names around it, and nothing outside can call it — perfect for one screen's private rules.
LocalView: A way for a composable to reach the old-style Android View it is being drawn inside. Needed for the few window-level switches Compose has no wrapper for.
Logcat: The live stream of messages Android prints while your app runs, including your own println output and the details of any crash.
Logical operator: Combines yes/no answers. && means both must be true, || means at least one must be true, ! flips true to false.
Long: A whole number type with far more room than Int. Use it for counts that could pass about two billion, like milliseconds since 1970.
Loop: Code that repeats. Instead of writing the same line 100 times, you write it once and tell the computer how many times to run it.
Luminance: How much light a colour gives off, from 0 for black to 1 for white. Contrast ratios are worked out from the luminance of two colours, not from how different they look to you.
main: The function a plain Kotlin program starts at. When you press Run, Kotlin looks for main and runs the lines inside it, top to bottom.
Main thread: The single line of work that draws your screen and handles taps. Anything slow you do on it freezes the app, so slow work belongs elsewhere.
Manifest: The AndroidManifest.xml file: your app's ID card. It tells Android the app's name, icon, which screen to open first, and what permissions it needs.
Manifest merger: The build step that combines your AndroidManifest.xml with the manifest inside every library you use, producing the single one that ships.
Map: A collection of key-and-value pairs, like a dictionary: you look something up by its key and get its value back.
map (the function): A collection function that runs the same small piece of code on every item and hands back a new collection of the results. Same number of items, new values.
mapping.txt: The translation table R8 writes down when it renames things, so an obfuscated crash report can be turned back into real names. Keep the one for every version you publish.
Material Icons: Google's ready-made icon set, available in five styles. About forty everyday icons ship with Material 3; the other few thousand come from a separate library.
MaterialTheme: The composable you wrap your whole app in. It publishes one colour scheme, one type scale and one shape scale so every composable below can read them without being handed anything.
Material 3: Google's current design system: a ready-made set of buttons, cards, colours and type that already look right on Android and handle dark mode for you.
Maven repository: A server holding published libraries, organised by group, name and version. Gradle downloads from these.
maxOf: Picks the largest value in a list after turning each item into a number. It throws if the list is empty, so guard it.
mergeDescendants: A semantics setting that tells a screen reader to treat a group of things as one announcement instead of four separate stops.
Method: A function that belongs to a class. You call it on an object with a dot, and inside it can see that object's own values.
Migration: Written instructions for turning an old database shape into a new one without throwing away the user's data. Required whenever you change the schema of an app people already have.
minDimension: The smaller of a Size's width and height. Use it when a shape has to fit inside a box that might not be square.
isMinifyEnabled: The build setting that turns R8 on. False ships every line you compiled; true deletes the code nothing uses and shortens the names that are left.
minSdk: The oldest version of Android your app will install on. Set it lower to reach more phones; set it higher to use newer features without extra work.
Mipmap: A special resource folder used only for launcher icons. It exists so the icon survives when unused sizes are stripped out of an app.
Modifier: A chain of instructions attached to a composable that changes how it looks or behaves — its size, padding, background, or what happens when tapped.
Module: A part of a project that is built into one thing. Small apps have exactly one, called :app. Large apps split into several so each can be built separately.
Remainder (%): The percent operator gives what is left over after a division. It is how you check whether a number divides evenly, or wrap a counter round.
Monochrome layer: A third, single-colour layer in an adaptive icon. Android 13 and newer uses it for themed icons, tinting your shape to match the user's wallpaper.
Monospace: A typeface where every character is exactly the same width. Digits in a countdown do not shuffle sideways as they change, which is why clocks use it.
Mutable: Able to be changed after it is created. Kotlin collections come in two flavours: read-only ones, and mutable ones you can add to and remove from.
MutableList: A list you are allowed to add to, remove from and change after creating it. A plain List refuses all three.
MutableStateFlow: The writeable version of StateFlow. A ViewModel keeps this one private and hands the screen the read-only StateFlow, so only the ViewModel can change it.
mutableStateOf: Creates a value holder that Compose watches. Change what is inside it and every composable that read it is redrawn — automatically, with no work from you.
Named argument: Writing a parameter's name at the call site so the reader can see what each value means, and so order stops mattering.
Namespace: The unique name that identifies your app's code to the build system, usually matching your package.
Native library: Code compiled for the processor directly rather than run by ART. It ships as a .so file in the APK's lib folder.
Navigation argument: A value carried inside a route so the next screen knows what to show. It is declared with a type, so a route expecting a number cannot receive a word.
NavController: The object that actually moves between screens and remembers how you got there. You ask it to navigate; it handles Back for you.
NavHost: The composable that holds every screen in the app and swaps in whichever one the current route names. Think of it as the frame the screens slide through.
Navigation: Moving between screens in an app, and remembering how the user got there so Back does the right thing.
NavigationBar: The Material 3 bar of tabs pinned to the bottom of the screen. Each tab is a NavigationBarItem with an icon and a label; the selected one gets a coloured pill behind its icon.
Nested scroll: The wiring that lets a scrolling list tell its parent how far it has scrolled. It is how a large app bar knows to shrink as the list moves.
-night qualifier: Adding -night to a resource folder name gives Android a second copy to use in dark mode. It picks the right folder automatically.
Not-null assertion: The two exclamation marks !! — a promise to the compiler that a nullable value is definitely not null right now. If you are wrong, the app crashes on that line.
Notification: A message your app posts to Android, which Android then shows in the status bar and the shade. The app does not draw it — the system does, in its own style.
Notification channel: A named category your notifications belong to. Since Android 8 every notification needs one, and the user can silence a whole channel without silencing the app.
NotificationCompat: The AndroidX builder for notifications. It chooses the right behaviour for whichever Android version the phone is running, so you write one version of the code.
Importance: How loudly a notification channel is allowed to interrupt. Default makes a sound and can peek at the top of the screen; low is silent and stays in the shade.
Now in Android: A complete, open-source Android app written by Google as a worked example of how they think apps should be built today. Reading real code is the step after finishing a course.
null: The deliberate absence of a value — "there is nothing here". Kotlin tracks which things can be null so your app cannot crash by using something that is not there.
Null safety: Kotlin's rule that a value cannot be null unless you explicitly mark its type with a question mark. It removes the single most common crash in app history.
Nullable type: A type written with a question mark, meaning the value is allowed to be missing. Kotlin then forces you to handle the missing case before you use it.
NullPointerException: The crash you get when running code asks something of a value that is not there. Usually shortened to NPE.
Obfuscation: Renaming your classes and functions to short meaningless names during a release build. It saves space, and it makes the app harder to read if someone unpacks it.
Object: One actual thing made from a class. The class is the cookie cutter; the object is the cookie.
Off-by-one error: A bug where a loop or an index runs one time too many or one too few. It is the most common counting mistake in all of programming.
Offset: A single point on a drawing surface: how far across and how far down, both measured in pixels from the top-left corner.
OLED: A screen where every pixel makes its own light, so a black pixel is genuinely switched off. This is why a dark theme saves battery on some phones and not on others.
onClickLabel: A short verb attached to a clickable thing, so a screen reader says "double tap to roll" instead of the useless "double tap to activate".
"on" colour: Every Material colour slot has a partner whose name starts with on — the colour meant for text and icons drawn on top of it. The pair is chosen so it is always readable.
Operator: A symbol that does something to one or two values: add them, compare them, join them. Plus, minus, times, divide and equals are all operators.
OptIn: An annotation that says "I know this API is not final yet and may change". Without it the compiler refuses to use experimental APIs.
Optimistic update: Doing the thing straight away and offering a way back, instead of asking permission first. The screen never has to show a half-finished state.
Package: A folder-like grouping for your code, written in dots. It keeps names from clashing with other people's code.
Painter: Something that knows how to draw itself into a given space. Image takes a Painter rather than a file, which is why the same composable can draw a photo, a vector or something you made up.
painterResource: Loads a drawable out of res/drawable and turns it into something Image can draw. Because it takes an R id, a misspelled name is caught by the compiler.
Pair: Two values joined into one. Kotlin's little word to builds a pair, which is how the entries of a map are written.
Parameter: An input a function accepts, so the same function can work on different values each time you call it.
pathData: The string of letters and numbers that describes a vector shape: M moves the pen, L draws a line, A draws an arc, Z closes the shape.
PendingIntent: An action you hand to another part of the system to fire later on your behalf — for example, "open my app" when the user taps the notification.
Permission: Something an app must ask for before it can do a sensitive thing, like showing notifications or using the camera. The user can always say no.
Persistence: Keeping data after the app closes, by writing it to the phone's storage. Anything held only in memory disappears the moment the app stops.
Pip: One of the dots on the face of a die or a domino. A standard die shows one to six pips arranged on a three-by-three grid.
Placeholder: Faint text shown inside an empty text field to say what belongs there. It disappears the moment you type, so it is a hint, not a value.
Play App Signing: Google holding your app's real signing key for you and signing each download itself. It means losing your own key is recoverable — the one Android disaster that used to be permanent.
Play Console: Google's website for publishing and managing apps on Google Play. It is where you upload a build, fill in the store listing, and watch a release go out.
App review: Google's check of a submitted build against its policies. Partly automatic, partly human, and it can take anything from hours to well over a week for a first app.
Google Play: Google's official app store. Publishing there needs a developer account, a signed release build, an icon, screenshots and a privacy policy.
PNG: A picture stored as a fixed grid of coloured dots. Blow one up past its real size and it goes soft, so a PNG icon needs a separate copy for every screen sharpness.
Pocket Studio: The app you write code in. It is a full Android development environment that runs on the phone itself — it edits your code, builds a real APK with real Gradle, and installs it, with no computer involved.
Pomodoro: A way of working: a fixed stretch of focus, then a short break, then repeat. Named after a tomato-shaped kitchen timer. Focus Flow is a Pomodoro timer.
popBackStack: Removes the top screen from the back stack, revealing the one underneath. It is what Back does, written out so your own code can do it too.
popUpTo: A navigation instruction meaning "before you go there, take everything off the back stack down to this point". It stops tab taps piling up screens forever.
POST_NOTIFICATIONS: The permission an app needs before it may show a notification on Android 13 and newer. Declared in the manifest, then requested at runtime.
Predicate: A small piece of code that answers true or false about one item. It is what you hand to filter, any, all and count.
Preferences DataStore: The modern replacement for SharedPreferences. It stores small key-and-value settings in a file, never blocks the screen while it does it, and hands you a Flow that emits again on every change.
Preferences key: A typed name for one setting inside DataStore. The type is part of the key, so you can never accidentally read a number as a yes/no.
Primary key: The column that uniquely identifies each row in a database table. No two rows may share one.
println: A built-in function that prints a line of text to the output, so you can see what your program is doing. Your first debugging tool.
Privacy policy: A public web page saying what data your app collects and what you do with it. Google Play requires a link to one, even for an app that collects nothing.
private: Marks a property or function as usable only from inside its own class, so the class can keep working details to itself.
Private key: The secret half of a key pair. It is the part that actually signs, it lives inside your keystore, and nobody else may ever have a copy of it.
Process: One running program with its own private slice of memory. Each app normally gets exactly one, and Android can kill it at any time to free memory.
Process death: Android killing your whole app in the background to free memory. The user does not notice; when they return, everything in memory has gone.
Progress indicator: Material's spinner or bar that says work is happening. Circular when you cannot say how long it will take; linear with a value when you can.
ProGuard rules: A file telling R8 what it must not rename or delete. You need rules for anything found by name at runtime rather than called directly in code.
Project: A folder holding everything one app needs: your code, its pictures, its text, and the settings that describe how to build it.
Property: A piece of information that belongs to an object.
Property delegate: The Kotlin by keyword, which hands the job of reading and writing a name to something else. In Compose it lets you use a state holder as if it were a plain value.
Pure black: A dark theme painted #000000 rather than a very dark grey. It saves a little power on OLED screens but hides every edge, so Material uses near-black instead.
R class: A file the build generates listing a number for every resource you wrote, so Kotlin can refer to them safely. You never edit it.
R8: The shrinker and optimiser. On release builds it deletes code nothing uses and shortens names, often halving the app. Debug builds skip it.
Radians: The other way of measuring angles. A full turn is 2 x pi radians instead of 360 degrees. Kotlin's cos and sin only speak radians, so degrees must be converted first.
Random: Kotlin's source of unpredictable numbers. You ask for a range and it picks one, differently every time the program runs.
Range: A span of numbers from one value to another, written with two dots. Handy for loops.
Receiver: The object on the left of the dot — the thing a function is being called on. Inside an extension function you refer to it as this.
Recomposition: Compose re-running the parts of your screen whose data changed, so the display matches the new state. You never redraw by hand.
Refactor: To restructure code without changing what it does, usually to make it clearer or easier to extend.
Release build: The optimised build you publish. It must be signed with your own private key. In Pocket Studio, signed release builds are a paid-tier feature.
Release notes: The published list of what changed in a new version of a library. Reading them is the cheapest way to keep up once a course has ended.
Release track: One of the lanes a Play release goes down: internal, closed, open, then production. A build is promoted up the lanes rather than uploaded again each time.
remember: Tells Compose to hang on to a value between redraws. Without it, your value would be reset every time the screen updated.
rememberSaveable: Like remember, but the value is also written into the saved-state Bundle. It survives rotation AND the app being killed in the background.
repeat: Kotlin's shortest loop. It runs a block a fixed number of times and hands you the count, starting at zero.
Repository: The one class allowed to fetch and save data. Everything above it asks for notes, not for database rows, so the rest of the app never learns where data comes from.
Resource: Anything in your app that is not code: text, colours, pictures, icons. Android keeps them in the res folder so they can be swapped per language or per screen size.
Resource qualifier: A suffix on a res folder name saying when to use it — dark mode, a language, a screen size. Android picks the best matching folder at runtime.
resources.arsc: The compiled resource table inside an APK: one big lookup listing every string, colour and dimension, with a row per language and per qualifier.
Return: The value a function hands back to whoever called it, so the answer can be used somewhere else.
Return type: The kind of value a function promises to hand back, written after a colon at the end of its first line.
Ripple: The circle of colour that spreads out from your fingertip when you tap something on Android. It is Material's way of confirming the touch landed.
Room: Android's database library. It stores your data on the phone so it is still there after the app closes, and checks your queries at build time.
roundIcon: A second launcher icon Android may ask for on phones that always draw circles. It is declared separately in the manifest and is usually the same adaptive icon.
RoundRect: A rectangle whose four corners can each have their own roundness. Round two and leave two square and you get a bar that sits flat on its baseline.
RoundedCornerShape: A shape with rounded corners, described by the radius of the curve. Compose uses shapes for clipping, borders and shadows.
Route: The piece of text that names one screen, like a tiny address. Values can be baked into it, so "editor/7" means the editor showing note 7.
RowScope: The little world you are inside when you are a direct child of a Row. It is what makes Modifier.weight legal; outside it, weight does not exist.
Run: To actually start your app so you can use it. In Pocket Studio this builds the APK, installs it, and opens it.
runCatching: A Kotlin function that runs a block and hands back a Result — either the value or the exception that was thrown — instead of letting the app crash.
runBlocking: A bridge that lets ordinary code wait for coroutines to finish. Right for tiny practice programs and tests, wrong inside a real app.
Runtime error: A failure that happens while the app is actually running, after it built and installed perfectly. The compiler could not have predicted it because it depends on what really happens.
Runtime permission: A permission the user must agree to in a dialog while the app is running, not just one declared in the manifest. Declaring it is you asking Android; granting it is the user answering.
Safe call: A dot with a question mark in front of it. If the thing on the left is null, the whole expression quietly becomes null instead of crashing.
Safe zone: The middle circle of an adaptive icon that no launcher shape ever crops. The canvas is 108 units wide; only the central 66 are guaranteed to survive.
Saved instance state: A small Bundle that Android hands back to a screen it had to destroy and rebuild, so it can restore roughly where the user was.
SavedStateHandle: A small map a ViewModel can be handed that survives process death, not just rotation. Put the few values you could not bear to lose in it — nothing large.
Scaffold: A Material layout that reserves the standard slots of a screen — app bar, floating button, snackbar, content — and works out the padding between them.
Schema: The shape of a database: which tables exist, which columns each one has, and what type each column holds. Change the shape and you have changed the schema.
Scope: The region of code where a name exists. A value declared inside { } usually cannot be seen outside it.
Scope function: One of five short Kotlin functions — let, run, with, apply and also — that hand you a block of code working on one object.
Screen reader: Software that speaks the screen aloud, so someone who cannot see it can still use the app. TalkBack is Android's, and it is already on every phone.
Scrim: A translucent sheet laid over a screen to push it into the background, so whatever sits on top is clearly the thing to deal with now.
SDK: Software Development Kit — the bundle of tools and Android code libraries you build against.
Sealed class: A class whose complete list of possible subclasses is fixed and known at build time, which lets the compiler check that you have handled every case.
Semantics: The invisible description Compose builds alongside the pixels: what each thing IS, what it says, whether it can be tapped. Screen readers and tests read this, not the picture.
Role: The kind of thing something is — Button, Checkbox, Tab, Image. A screen reader uses it to tell the user what they can do with it.
Set: A collection that holds each item at most once and is used for membership rather than position. Adding something already in the set changes nothing.
SharedPreferences: The old Android way to save small settings. It works, but reading it can block the main thread and mistakes are silent — which is exactly why DataStore replaced it.
SharingStarted: The rule that decides when a shared flow is actually running. WhileSubscribed(5_000) keeps it alive for five seconds after the last screen stops watching, so a rotation does not restart the query.
isShrinkResources: A companion setting that also strips out pictures, strings and layouts nothing refers to. It only works when minifying is already on.
Sideload: Installing an APK directly instead of through a store. It is exactly what Pocket Studio does when it installs your app, and it is completely legitimate.
Signing: Attaching a cryptographic signature to your app that proves it came from you. Android refuses to install an unsigned app, and updates must be signed with the same key.
signingConfig: The block in your build file naming which keystore to open, which key inside it to use, and which passwords unlock both. A build type points at one by name.
cos and sin: Two maths functions that turn an angle into a position on a circle of radius one. cos gives how far across, sin gives how far down. Both want radians.
Single source of truth: The rule that one piece of information lives in exactly one place. Everything else reads it from there instead of keeping its own copy, so nothing can disagree.
Singleton: A thing there is exactly one of in the whole app. Databases are singletons because opening a second copy of the same file is slow and can corrupt it.
Skeleton: A grey outline of the content that is coming — bars where the text will be, blocks where the cards will be. It tells the eye what to expect instead of showing a blank page.
Slot: A hole in a composable that the caller fills with whatever they like. The composable decides where the content goes; the caller decides what it is.
Smart cast: When the compiler notices a check you already made and lets you use the value without repeating the check.
Snackbar: A short message that slides up from the bottom of the screen, optionally with one action button, and goes away on its own after a few seconds.
sp: Scale-independent pixel — like dp, but it also grows when the user has chosen larger text in their phone settings. Always use sp for text.
Spacer: An empty composable whose only job is to take up room. It is how you put a deliberate gap between two things.
spring: An animation recipe based on physics rather than a duration. It can overshoot the target and wobble back, which is why it feels alive instead of mechanical.
SQL: The language databases understand. You describe what you want rather than how to fetch it, and the database works out the rest.
SQLite: The small, fast database that is built into every Android phone. Room is a friendly layer on top of it — SQLite does the actual storing.
Stack trace: The list of function calls that led to a crash, most recent first. The top line naming YOUR file is almost always where to look.
Staged rollout: Releasing an update to a small share of users first, watching for crashes, then raising the share. It turns a bad release into a small bad release.
Star import: An import ending in .*, which pulls in every public name from a package instead of one named thing. Usually worth avoiding, because it hides where a name came from.
startAngle: Where an arc begins, in degrees. In Compose zero degrees points to the right — 3 o'clock — so twelve o'clock is minus ninety.
Start destination: The route a NavHost shows first, and the bottom of its back stack. Everything else is stacked on top of it.
State: Information that can change while the app is running, and that the screen depends on. When state changes, Compose redraws whatever used it.
stateDescription: A semantics property that says what state a control is in, in your own words, instead of the generic "on" or "off".
State hoisting: Moving a piece of state up out of a composable, so the composable just displays what it is given and reports events back. It makes pieces reusable and testable.
stateIn: Turns a cold Flow into a StateFlow that remembers its latest value, so a screen that arrives late still gets something to draw immediately.
StateFlow: A holder for a value that always has a current value and notifies watchers whenever it changes. The standard way a ViewModel exposes state to a Compose screen.
Stiffness: In a spring animation, how hard the spring pulls towards the target. Higher stiffness arrives sooner; StiffnessLow is a slow, heavy movement.
Store listing: The page people see before installing: title, short and full description, icon, screenshots and a feature graphic. Play will not publish without all of it.
String: Text. Any run of characters — a word, a sentence, an emoji — written between double quotes.
format: Builds a string by filling placeholders in a pattern. %02d means "a whole number, padded with a zero to two digits", which is how 5 becomes 05.
String template: A way to drop a value straight into a piece of text using a dollar sign, instead of gluing strings together by hand.
Stroke: Drawing only the outline of a shape rather than filling it in, with a chosen line thickness. The opposite of a fill.
StrokeCap: What the two ends of a drawn line look like. Butt chops them off square, Round puts a half-circle on each end.
Structural equality: Comparing two things by what they contain rather than by whether they are the very same object. In Kotlin that is what == does.
Subclass: A class built on top of another one, which counts as being that other kind of thing as well.
sumOf: Adds up one number taken from every item in a collection and hands back the total.
Surface: The Material container. Give it a colour and a shape and it paints the background, clips its contents to that shape, and sets the right "on" colour for everything inside.
Surface container: A family of five graded background colours — from surfaceContainerLowest to surfaceContainerHighest — used to show that one panel sits in front of another. It is how depth is expressed in dark mode, where shadows are invisible.
suspend: Marks a function that is allowed to pause partway through. Suspend functions can only be called from a coroutine.
sweepAngle: How far an arc travels from its start angle, in degrees. Positive sweeps clockwise, negative anticlockwise. 360 is a complete circle.
Swipe to dismiss: A gesture where dragging a row sideways removes it. The panel revealed underneath shows what letting go will do.
Switch: The Material toggle: a track with a thumb that slides between off and on. It never holds its own state — you pass it a value and a function to call when it is tapped.
synchronized: Puts a lock around a block of code so only one thread can be inside it at a time. It stops two threads doing the same setup twice.
Syntax: The grammar rules of a programming language — where the brackets, quotes and dots go. Get it wrong and the code will not compile.
getSystemService: How an app reaches one of Android's own managers — for notifications, alarms, clipboard and so on. You ask the Context for the class you want.
Table: A grid inside a database: named columns across the top, one row per thing stored. An @Entity class describes exactly one table.
TalkBack: Android's built-in screen reader. It speaks whatever is under the user's finger, so people who cannot see the screen can still use the app.
targetSdk: The Android version you have tested against and promise to behave correctly on. Android uses it to decide which modern rules to apply to your app.
Project template: A ready-made starting skeleton for a new project, so you begin with a working app instead of an empty folder. This course always picks the empty Jetpack Compose one.
Terminal: A place to type commands directly instead of tapping buttons. Pocket Studio has one built in, running on the phone.
TextField: The Compose component people type into. It draws whatever value you hand it and reports each keystroke back through onValueChange.
TextMeasurer: A helper that works out how wide and tall a piece of text will be before it is drawn. On a Canvas you need that number to centre a label over a bar.
TextOverflow: What to do when text is longer than the space allowed. Ellipsis cuts it off and adds a … so the layout never grows unexpectedly.
TextStyle: One bundle of text appearance: size, weight, colour, spacing. Hand it to a measurer or a Text so everything using it looks the same.
Theme: The single place your app's colours, fonts and shapes are defined, so every screen matches and dark mode works everywhere at once.
this: Inside a class or an extension function, the word for "the object this code is running on right now".
Thread: One line of work a program is doing. A program can have several threads, but each one carries out its own steps strictly in order.
ZoneId: Which part of the world a time belongs to. The same instant is a different calendar day in Tokyo and in London, so turning a moment into a date always needs a zone.
Tint: A single colour painted over every part of a symbol. Icon tints whatever it draws, which is why a one-colour icon follows your theme and a full-colour logo comes out as a silhouette.
TIRAMISU: Android's internal name for API level 33, which is Android 13. Version codes get dessert names; comparing against this one is how you ask "is this phone Android 13 or newer?"
toPx: Turns a dp measurement into the number of real pixels it comes to on this particular screen. It only works where the screen's density is known — inside a DrawScope, for instance.
Tonal elevation: How Material 3 shows that a surface is raised when the app is dark. A shadow is invisible on a near-black background, so the surface is given a slightly lighter colour instead.
Top app bar: The strip across the top of a screen holding its title and a few actions. A large one starts tall and shrinks to a normal bar as you scroll.
toString: The text form of an object, used whenever it is printed. Ordinary classes give a useless one; data classes give a readable one.
Touch target: The area that actually responds to a tap. Material asks for at least 48dp by 48dp, because fingertips are much bigger than icons.
Trailing lambda: Kotlin's rule that when the last input to a function is a small inline function, you can move it outside the round brackets. It is why so much Kotlin looks like braces.
Transaction: A group of database changes that either all happen or none do. It stops a crash halfway through leaving your data in a nonsensical half-state.
Transitive dependency: A library your library needs. You asked for one thing; Gradle quietly fetches everything that thing depends on too.
tween: An animation recipe defined by a duration: go from here to there in exactly this many milliseconds. The plainest kind of animation, and usually the right one.
Type: What kind of thing a value is: a whole number, text, a yes/no, a list. Kotlin tracks types so it can stop you doing something nonsensical, like subtracting a word from a number.
Type converter: A pair of small functions that tell Room how to store a type it does not understand, by turning it into something simple like text or a number, and back again.
Type inference: Kotlin working out a value's type for you from what you wrote, so you rarely have to spell it out. The type is still fixed and still checked.
UI state: One object holding everything a screen needs to draw itself right now. One object instead of five loose values means the screen can never show a half-updated mixture.
Unidirectional data flow: A one-way loop: state flows down to the screen, events flow back up. The screen never edits state directly — it asks, and the owner decides.
Unit: Kotlin's way of saying "this function hands nothing back". If you write no return type, Unit is what you get.
Unit test: A small program that runs one piece of your code and checks it does the right thing, without launching the app. Code with no Android parts in it is the easiest kind to test.
Install unknown apps: An Android permission that lets one app install another. You grant it to Pocket Studio so it can install the APK it just built for you.
Unsigned APK: A finished release APK built before any key was attached. It is a complete app that no phone will install, because Android checks for a signature first.
until: Builds a range that stops just BEFORE the last number, unlike two dots which includes it. 0 until 5 gives 0, 1, 2, 3, 4.
Upload key: The key you sign an app bundle with before sending it to Google Play. Play checks it, strips it, and re-signs with the real app key it holds for you.
Upsert: One operation that inserts a row if it is new and updates it if it already exists. It removes the tedious "does this exist yet?" check.
useCenter: An option on drawArc. When true the arc is closed back to the middle, giving a pie slice; when false you get a bare curve, which is what a ring needs.
val: Declares a name whose value never changes after it is set. Use it by default — it stops a whole category of bugs before they happen.
Value: A single piece of information: a number, some text, or a yes/no. Values are what your code moves around and works on.
var: Declares a name whose value CAN be changed later. Use it only when the thing genuinely needs to change, like a score.
Variable: A name you give to a value so you can use it later. Think of it as a labelled box: the label is the name, the contents are the value.
Vector drawable: A picture described as shapes and lines rather than pixels, so it stays sharp at any size and costs almost nothing in file size.
Version catalog: A single file (libs.versions.toml) listing every library and version your project uses, so they are declared in one place instead of scattered.
versionCode: A whole number that must go up with every release. Android uses it to tell which build is newer; the user never sees it.
versionName: The version people see, written however you like. It has no effect on updates at all — that job belongs to versionCode.
ViewModel: An object that holds a screen's state and logic, and survives things like rotating the phone. The screen can be destroyed and rebuilt; the ViewModel keeps going.
ViewModel factory: A small object that tells Android how to build a ViewModel that needs constructor arguments. Without one, Android can only build ViewModels it can create with no arguments.
viewModelScope: The coroutine scope built into every ViewModel. Work launched in it is cancelled automatically when the ViewModel is cleared, so nothing keeps running after the screen is gone.
viewport: The invisible grid a vector drawable is drawn on. viewportWidth="108" means every shape in the file is described in units from 0 to 108, whatever physical size it is later drawn at.
@Volatile: Marks a property so that a write by one thread is immediately visible to every other thread, instead of sitting in a per-thread cache.
Warning: The compiler saying "this is legal, but are you sure?". Warnings start with w: and never stop a build — only errors, marked e:, do that.
WCAG: The Web Content Accessibility Guidelines — the international rules most accessibility advice comes from, including the 4.5:1 contrast figure.
weight: A modifier used inside a Row or Column that says 'give me a share of whatever space is left'. Two children with weight 1f each get half.
when: Kotlin's clean way to choose between many options at once, instead of a long chain of if/else.
while: A loop that keeps repeating for as long as its condition stays true. Use it when you do not know in advance how many times to go round.
Window insets: The strips of screen the system owns: the status bar at the top, the gesture bar at the bottom, a camera notch. Insets tell your layout how far to stay clear.
Gradle wrapper: A small script and file inside the project that pins the exact Gradle version, so the project builds identically everywhere without anyone installing Gradle first.
ZIP: The ordinary compressed-archive format — a folder of files squashed into one file. An APK is a ZIP with a fixed set of contents.
zipalign: A final tidy-up that lines files inside the APK up to neat boundaries, so Android can read them straight from storage without copying.
Zygote: A process Android starts at boot with all the common app machinery already loaded. Every new app is forked from it, so nothing starts from scratch.