Variables, Expressions, and Types

✅ Mutable and read-only variables
✅ Expressions and statements
✅ Types and type inference
✅ Common built-in types

Functions

✅ Writing functions and function calls
✅ Using type inference with functions
✅ Positional and named arguments
✅ Default arguments
✅ Expression bodies and block bodies
✅ String interpolation

Conditionals

✅ Using the when expression
✅ How to put conditions in the right order
✅ Using a subject with a when
✅ Using the if expression
✅ Using when and if as statements

Classes, Objects, and Packages

✅ Creating our own types with classes
✅ Adding properties and functions
✅ Instantiating and using objects
✅ Creating single-instance objects
✅ Organizing code into packages
✅ Importing elements from other packages
✅ Wildcard imports and named imports

Enum Classes

✅ Limiting the range of values
✅ Creating and using enum classes
✅ Using enum classes with when expressions
✅ Adding properties and functions
✅ Using built-in properties of enum classes

Nulls and Null Safety

✅ Present and absent values
✅ Nullable and non-nullable types
✅ Nulls at compile time and runtime
✅ How to use conditionals with nullable types
✅ Using the not-null assertion operator
✅ Providing defaults with the elvis operator
✅ Calling functions with the safe-call operator

Lambdas and Function References

✅ How to indicate the type of a function
✅ How to use function references
✅ How to write and call lambdas
✅ Using lambdas with higher-order functions
✅ How to use the implicit it parameter
✅ Using multiple-line lambdas

Collections: Lists and Sets

✅ Creating a simple list of values
✅ How to work with mutable lists
✅ How to copy read-only lists with changes
✅ How to get elements out of a list
✅ Creating loops with collection operators
✅ Transforming lists with collection operators
✅ Chaining collection operators together
✅ How operator order affects performance
✅ Using sets for distinct elements

Collections: Maps

✅ Associating values with the Pair class
✅ Maps, entries, keys, and values
✅ Creating mutable and read-only maps
✅ Looking up values by keys
✅ Modifying the contents of a map
✅ How to perform operations on a map
✅ How to create default values in a map
✅ How to gracefully convert a list to a map
✅ How to group elements from a list

Receivers and Extensions

✅ Standalone functions vs. object functions
✅ Explicit receivers and member functions
✅ Receiver types and receiver parameters
✅ Extension functions and implicit receivers
✅ Nullable receiver types
✅ Extension properties

Scopes and Scope Functions

✅ Scopes and visibility of code elements
✅ Statement scopes vs declaration scopes
✅ The five scope functions
✅ How to choose the right scope function
✅ Shadowing and how it affects receivers
✅ How to use scope functions for null checks

Interfaces

✅ Subtypes and supertypes
✅ Subtypes and substitution
✅ Casting types with smart casts
✅ Casting types with safe and unsafe casts
✅ How to implement multiple interfaces
✅ How to inherit from an interface
✅ How to create a default implementation

Class Delegation

✅ Manually delegating to an object
✅ How to use Kotlin's class delegation
✅ Overriding individual functions
✅ How to resolve conflicts in delegates
✅ Delegation for general and specific types

Abstract and Open Classes

✅ What abstract classes are
✅ How to inherit from superclasses
✅ Interfaces vs. implementation
✅ Overriding functions and properties
✅ Abstract vs. open members
✅ Visibility modifiers on getters and setters
✅ Class hierarchies and the Any type

Data Classes and Destructuring

✅ Reference equality and value equality
✅ Overriding functions from the Any type
✅ How to create and use a data class
✅ How to use the copy() function
✅ Using destructuring assignments
✅ How to destructure non-data classes
✅ Limitations of data classes

Sealed Types

✅ How to use the sealed modifier
✅ Exhaustively matching types with when
✅ Limitations of sealed types
✅ When to use sealed types vs. enum classes

Handling Runtime Exceptions

✅ Understanding the call stack
✅ How to read the stack trace
✅ Throwing and catching exceptions
✅ Using try-catch as an expression
✅ Using finally to make sure work happens
✅ How to use runCatching()

Generic Types

✅ How to declare and use a generic type
✅ How to use type parameter constraints
✅ Using generic interfaces and superclasses
✅ How to declare and use generic functions
✅ Generics in the standard library
✅ The trade-offs of using generics

Generic Variance

✅ Covariance and contravariance
✅ Using the in and out variance modifiers
✅ How to create declaration-site variance
✅ How to create use-site variance
✅ Collection types and variance modifiers

Coroutine Essentials

✅ The essence of coroutines
✅ Using coroutines for concurrency
✅ Using coroutines for parallel work
✅ Using withContext() with dispatchers
✅ Structured concurrency and cancellation
✅ Structured concurrency and exceptions

Questions & Answers