Learn to create a hello world program in Kotlin by defining a main function as the entry point and printing output. Understand the fun keyword and simple comments.

Define variables in Kotlin and distinguish between var and val, showing how mutable and immutable values work, with examples of declaration, assignment, and print statements.

Explore Kotlin data types and type inference as you define integers, doubles, characters, booleans, and strings, and learn when to declare explicit types and how to convert between types.

Learn how to declare and call Kotlin functions using the fun keyword, define parameters and return types, and distinguish block and expression bodies for clean, reusable code.

Learn how named and default arguments simplify function calls, letting you pass parameters in any order, make some args optional, and override defaults in a two-number sum.

Learn how to use the Kotlin if expression to test conditions and print access denied or access approved, through an age restriction function and examples with or and and operators.

Explore string templates in Kotlin, including embedding variables and expressions within strings, and master triple-quoted strings for clean multi-line text with trimMargin for customizable margins.

Learn how while loops execute code while a boolean condition stays true, with examples of increments and printing. Explore the do-while variant that runs at least once and compound operators.

Explore for loops in Kotlin, iterating over lists and ranges with inclusive and exclusive forms. Learn reverse ranges, step controls, character arithmetic, and the repeat function.

Use the in keyword to test membership in numeric ranges, strings, and character ranges in Kotlin. Explore not in for negation, and validate digits and lowercase or uppercase letters.

Distinguish Kotlin statements and expressions: statements change state without a result, like for loops, while expressions produce a value, including function calls and expression bodies.

Define a class as a blueprint for objects with properties and functions. Create house objects in Kotlin using a primary constructor and a class body.

Explore Kotlin class properties, learning how each object maintains its mutable state with var, how dot notation accesses properties, and how references can point to the same memory address.

Understand how constructors initialize Kotlin objects, pass parameters, and convert them into class properties with var or val, and how to override toString, equals, and hashCode.

Explore Kotlin visibility modifiers, including public, private, protected, and internal, and learn how access controls govern classes, functions, and properties within the module.

Packages group code and define a package as the first non-comment line; imports connect files, support star imports and as aliases, and packages should match directory structure.

Explore lists in Kotlin by creating immutable and mutable lists, learn type inference, indexing, and common operations like first, last, add, remove, replace, and clear.

Explore varargs in Kotlin by building a sum function that accepts any number of integers, demonstrating how to use the spread operator and when to prefer lists over arrays.

Explore Kotlin sets, learn that they remove duplicates and support element containment. Practice operations like contains, containsAll, subtract, intersect, and union, plus creating immutable and mutable sets.

Explore maps in Kotlin, learning how key–value pairs form a map, access by key, handle missing values with null or getOrDefault, iterate entries, and convert lists to maps.

Explore Kotlin property accessors, where getters and setters auto generate with properties. Learn to use backing fields, customize getters, and control visibility with private setters and computed properties like isMinor.

Explore Kotlin extension functions to add new behavior to existing classes, such as wrapping a string in h1 tags and adding an address info extension to a person class.

Learn how Kotlin uses function signatures to implement overloading, distinguishing functions by name and parameters, not by return type; resolve conflicts with unique parameter lists and use extensions carefully.

Master Kotlin's when expression as an advanced switch, with exhaustive branches, returning results, is operator type checks, and for loops with break and continue.

Explore Kotlin enum classes, defining fixed state values with optional properties, accessing constants, using valueOf and values, iterating, and computing per-enum properties like color and number.

Learn how Kotlin data classes hold data and auto-generate useful functions like copy, toString, equals, hashCode, and componentN, with destructuring and primary constructor rules.

Explore Kotlin's null safety and nullable types to prevent null pointer exceptions by using a question mark after types, enabling compile-time checks and Java interoperability.

Explore safe calls, the Elvis operator, and non-null assertions in Kotlin to handle null values, avoid boilerplate, and implement default behavior with concise, reliable code.

Introduces generics in Kotlin with a reusable generic car class using a type parameter T, and contrasts generic types with any to preserve type information and support multiple data types.

Explore extension properties in Kotlin, including custom getters and the distinction from extension functions. Create string extensions, see generic list properties, and learn when to prefer properties for readability.

Explore Kotlin scope functions let, run, with, apply, and also to execute a block of code on an object, access the object without its name, and control the return value.

Explore lambdas in Kotlin: anonymous functions, functional literals, and how to transform collections with map and joinToString. Learn lambda syntax, parameters, return types, trailing lambdas, and type inference.

Master Kotlin collection operations with real examples on immutable and mutable lists. Apply filter, count, find, partition, and sorting variants like sorted, sortedBy, and sortedDescending, plus take and drop.

Explore member references in Kotlin, using property, function, and constructor references with double colon syntax to reduce boilerplate, with examples of data classes, filtering, mapping, and sorting.

Higher order functions in Kotlin accept or return other functions, enabling map, filter, and any with predicate lambdas. See how a lambda and the repeat function illustrate passing behavior.

Zip two lists to pair elements by index and transform pairs with a lambda, then unzip results into separate lists. Flatten a list of lists into a single list.

Master maps in Kotlin by using group by and associate with to build maps, access keys and values, and apply get or else and get or put with mutable maps.

Explore sequences in Kotlin, comparing lazy evaluation with eager list operations, and learn how filter, map, and any optimize performance.

Explore how local functions in Kotlin are defined inside other functions to reduce duplication and avoid namespace pollution, with closures and labeled loops.

Learn how folding lists uses an initial value and a lambda to accumulate results from left to right; explore fold, fold right, reduce, and running fold with examples.

Discover how Kotlin interfaces declare what a class can do, with abstract and concrete members, properties, override, single abstract method, functional interfaces, and SAM conversions with lambdas.

Master Kotlin initialization by understanding primary constructors, init blocks, and secondary constructors, including how to overload with different parameter lists and use default arguments.

Discover how Kotlin inheritance builds a base class and derived classes using open and final modifiers, overriding members, and understanding base and subclass initialization.

Explore abstract classes in Kotlin, defining abstract properties and functions with the abstract keyword, and contrast with interfaces, including state in abstract classes, inheritance rules, and overriding behavior.

Learn how upcasting stores child objects in a parent type, and how downcasting restores the specific child type using smart casts and the as keyword in Kotlin.

Explore composition in Kotlin as an alternative to inheritance, using interfaces and object composition to build flexible, extendable game characters and modular design.

Explore Kotlin class delegation, using the by keyword to delegate interface implementation to a collaborator, enabling composition over inheritance and reusable, flexible design.

Explore sealed classes in Kotlin, a restricted class hierarchy with compile-time known subclasses. See how they make when expressions exhaustive and require adding branches when new subclasses appear.

Explore Kotlin nested classes within an outer airport class, where the inner plane accesses the airport code, and learn about private, local, and enum nesting and ordinal upgrades.

Learn how inner classes in kotlin maintain a reference to their outer class, how to define, instantiate, and access outer properties, including nested inner classes and inheritance.

Explore Kotlin's object keyword and singleton pattern, learning how to declare single instances, call functions, and apply visibility modifiers. Discover inheritance and interfaces in objects, plus nesting within classes.

Place a companion object inside a class to provide functions and properties accessible without an instance. It initializes with the class, is single per class, and shares storage across instances.

Discover sealed interfaces in Kotlin, which restrict implementations to the same file or package to improve type safety, enable exhaustive when blocks, and complement enums and data objects.

Learn how Kotlin exceptions work, when to throw or handle them, distinguish exceptional conditions from normal problems, use try blocks or orNull variants, and craft clear messages with stack traces.

Learn how to handle runtime exceptions in Kotlin by reporting errors, recovering gracefully, and cleaning up resources using try, catch, and finally, with custom exceptions and a robust, reusable design.

Explore Kotlin check instructions like require, require not null, and check to validate preconditions and postconditions, using lazy messages and exceptions such as illegal argument exception and illegal state exception.

Explore unit testing in Kotlin, learn how to write small, isolated tests using Kotlin test frameworks and assert functions, and validate class behavior like a power switch.

Begin the final Kotlin project by building a console tic tac toe game against the computer. Learn the game rules, board positions, and user input to implement your Kotlin version.

Access the complete tic tac toe project source code on my GitHub, including the Kotlin file that showcases our earlier video’s implementation, with the link in the description.

Move the checkerboard function above the generate computer move function to ensure the game exits on win, preventing the computer from making an extra move in tic tac toe.

Explore the challenges of traditional asynchronous programming, why callbacks create callback hell, and how Kotlin coroutines enable non-blocking, sequential code on the main thread.

Explore how Kotlin coroutines enable non blocking, asynchronous code by suspending and resuming within a structured concurrency model, using continuation and suspending functions to keep apps responsive.

Explore coroutine builders in Kotlin, including launch, async, and run blocking, and learn how contexts, scopes, and dispatchers control execution, lifecycle, and cancellation. Understand structured concurrency and await a value.

Learn how Kotlin coroutines use a job to manage life cycle and cancellation, how deferred returns a result, and how structured concurrency links parent and child jobs to ensure cancellation.

Explore cooperative cancellation in Kotlin coroutines, how cancel triggers at suspension points, and how to use join, non-cancelable blocks, ensureActive, and yield for safe cleanup and responsive cancellation.

Explore how Kotlin coroutines handle exceptions within structured concurrency, including cancellation propagation, supervisor scope for independent failures, and exception handlers, plus timeout behavior and local error handling strategies.

Explore cold Kotlin flows, a lazy coroutine-based stream, created with a flow builder and emitted via emit, collected with collect or collectLatest.

Learn how flow builders create cold flows that emit values with emit or emitAll, and choose among flow, flowOf, channelFlow, and callbackFlow, while understanding cancellation and lifecycle.

Explore Kotlin flow operators, including terminal operators like collect and first or null, and core operators such as map, filter, take, and distinct until changed, plus snapshot flow.

Explore exception handling in Kotlin flows, using catch, retry, and on completion to manage errors, retries, fallbacks, and cleanup within coroutine-based streams.

Introduce hot kotlin flows and contrast them with cold flows, emphasizing real-time ui updates and shared latest values via state flow and statin in viewmodels.

Discover hot flow sharing strategies in Kotlin, using statin to convert cold flows, and compare while subscribed, eagerly, lazily, with collect as state and collect as state with lifecycle.

Explore the differences between cold and hot flows and compare compose state with state flow. Understand how save state handle preserves state across process death and aligns with Android lifecycles.

Explain how StateFlow and SharedFlow differ as hot flows, focusing on replay and initial value, multiple collectors, and use cases like one-time events and event buses.

Explore channels in Kotlin flows as hot queues enabling producer and consumer patterns, using send and receive, and convert to flow via receive as flow or consume as flow.