Appendix C: Glossary — Learning Kotlin by Building Android Games

Key terms from the book, defined for quick reference.

alpha: How opaque a color is, from 0 (fully transparent) to 255 (fully solid). Used to fade sprites and particles.
argument: The actual value you pass into a function when you call it (e.g. the 5 in add(5, 3)). Compare parameter.
array: A fixed-size collection of values of the same type, accessed by an index. Once created, its size never changes.
abstract class: A class that cannot be created on its own and exists only to be inherited from. It may declare abstract methods that every subclass must provide.
atlas (texture atlas): A single image holding many sprites, plus a list of where each sprite sits inside it. Faster than loading many separate images.
bitmap: An image held in memory as a grid of colored pixels.
Boolean: A type that holds only true or false.
camelCase: The naming style used for variables and functions: lowercase first word, uppercase each word after, e.g. playerScore.
Canvas: Android's drawing surface. You call methods on it (drawCircle, drawText, etc.) to paint a frame.
class: A blueprint that bundles data (properties) and behavior (methods) together. Objects are built from it.
collection: A container holding multiple values: an array, list, set, or map.
compile: Turning your written code into a program the device can run. The compiler also reports errors.
constructor: The part of a class that sets up a new object, written in the class header in Kotlin.
delta time: The time elapsed since the last frame. Multiplying movement by it keeps speed the same on fast and slow devices.
encapsulation: Hiding a class's internal data (with private) and exposing only controlled methods.
enum: A type whose value must be one of a fixed, named set of options (e.g. MENU, PLAYING, GAME_OVER).
extension function: A function added to an existing type (even one you don't own) without subclassing it.
Float: A type for decimal numbers. Written with a trailing f (e.g. 3.5f). Used for nearly all on-screen coordinates.
frame: One single drawn image. Games redraw many frames per second (we target ~60).
game loop: The cycle a game repeats every frame: handle input, update state, draw. In this book it runs on its own thread.
generics: The angle-bracket types like List<Particle> that let one class work with any type while staying type-safe.
immutable: Unable to be changed after creation. val variables and read-only Lists are immutable.
index: A value's position in a collection, starting at 0. The first element is at index 0.
inheritance: Building a class on top of another, gaining its properties and methods and adding or overriding behavior.
init block: Code in a class that runs once, automatically, when an object is created.
instance (object): A concrete thing built from a class blueprint.
Int: A type for whole numbers (no decimal point).
interface: A contract: a list of methods a class promises to provide. A class can implement many interfaces.
lambda: A small, nameless block of code you can store in a variable or pass to a function, written { params -> body }.
list: A collection that can grow and shrink. MutableList can be changed; List is read-only.
logcat: Android Studio's window showing messages and errors from a running app. You can print to it with Log.d.
map: A collection of key–value pairs; you look up a value by its key. MutableMap can be changed.
method: A function that belongs to a class and acts on its object's data.
modulo (%): The remainder after division. Useful for wrapping values and "every Nth time" logic.
nullable: A type marked with ? that is allowed to hold null ("nothing"). Kotlin forces you to handle the null case.
object: See instance. Also, more loosely, any value with properties and methods.
override: Replacing an inherited method with a class's own version, using the override keyword.
parameter: A named input declared in a function's definition (e.g. amount in fun takeDamage(amount: Int)). Compare argument.
polymorphism: Treating different subclasses through their shared base type, so one call (e.g. enemy.move()) runs each object's own behavior.
property: A variable declared at the class level, shared by all the class's methods.
Rect / RectF: Rectangles. Rect uses whole-number pixels (source regions in a texture); RectF uses floats (screen positions and hit boxes).
SharedPreferences: Android's simple key-value store for saving small data (like a high score) so it survives closing the app.
SoundPool: Android's system for playing short sound effects with low delay.
sprite: A single 2D image (or animation frame) drawn in a game, usually cut from a texture atlas.
state machine: A design where the program is always in exactly one of a fixed set of states (e.g. menu, playing, game over), and behaves accordingly.
String: A type holding text, written in double quotes.
string template: Inserting a variable's value into a string with $, e.g. "Score: $score".
SurfaceView: A special view that a background thread can draw to directly and quickly; the foundation of our game engine.
thread: A separate line of execution. We run the game loop on its own thread so it doesn't block the UI.
type inference: Kotlin working out a variable's type from its value, so you often don't have to state it.
UI thread: The single main thread Android uses for the interface and input. Heavy work must not block it.
variable: A named container for a piece of data (var to allow changes, val to lock it).
vibe coding: Building software iteratively in conversation with an AI: describe, generate, review, run, refine — while reading and understanding every line.
@Volatile: A marker on a variable shared between threads, ensuring each thread always sees the latest value.