Please note that this list of topics is based on our standard course offering, evolved from typical industry uses and trends. We’ll work with you to tune this course and level of coverage to target the skills you need most. Topics, agenda and labs are subject to change, and may adjust during live delivery based on audience skill level, interests and participation.
1. Your First Kotlin Application
- Installing IntelliJ IDEA
- Your First Kotlin Project
- Creating your first Kotlin file
- Running your Kotlin file
- The Kotlin REPL
2. Variables, Constants, and Types
- Types
- Declaring a Variable
- Kotlin’s Built-In Types
- Read-Only Variables
- Type Inference
- Compile-Time Constants
- Inspecting Kotlin Bytecode
3. Conditionals
- if/else Statements
- Adding more conditions
- Nested if/else statements
- More elegant conditionals
- Ranges
- when Expressions
- when expressions with variable declarations
- when expressions without arguments
4. Functions
- Extracting Code to Functions
- Anatomy of a Function
- Function header
- Function body
- Function scope
- Calling a Function
- Writing Your Own Functions
- Default Arguments
- Single-Expression Functions
- Unit Functions
- Named Function Arguments
5. Numbers
- Numeric Types
- Integers
- Floating Point Numbers
- Formatting a Double
- Converting Between Numeric Types
6. Strings
- String Interpolation
- Raw Strings
- Reading Console Input
- Converting Strings to Numbers
- Regular Expressions
- String Manipulation
- Strings are immutable
- String Comparison
7. Null Safety and Exceptions
- Nullability
- Kotlin’s Explicit Null Type
- Compile Time vs Runtime
- Null Safety
- Exceptions
- Throwing an exception
- Handling exceptions
- Try/catch expressions
- Preconditions
8. Lambda Expressions and the Function Type
- Introducing NyetHack
- Anonymous Functions
- Lambda Expressions
- The function type
- Implicit returns
- Function arguments
- The it identifier
- Accepting multiple arguments
- Type Inference Support
- More Effective Lambdas
- Defining a Function That Accepts a Function
- Trailing lambda syntax
- Function Inlining
- Lambdas and the Kotlin Standard Library
9. Lists and Sets
- Lists
- Accessing a list's elements
- Changing a list's contents
- Iteration
- Reading a File into a List
- Destructuring
- Sets
- Creating a set
- Adding elements to a set
- while Loops
- Collection Conversion
10. Maps
- Creating a Map
- Accessing Map Values
- Adding Entries to a Map
- Modifying Map Values
- Converting Between Lists and Maps
- Iterating Through a Map
11. Functional Programming Basics
- Transforming Data
- Map; Associate
- Destructuring with functional programming
- flatMap
- Filtering Data
- Combining Data
- Why Functional Programming?
- For the More Curious: Profiling
- For the More Curious: Aggregating Data
- reduce
- fold
- sumBy
12. Scope Functions
- apply
- let
- run
- with
- also
- takeIf
- Using Scope Functions
13. Classes
- Defining a Class
- Constructing Instances
- Class Functions
- Visibility and Encapsulation
- Class Properties
- Property getters and setters
- Property visibility
- Computed properties
- Using Packages
14. Initialization
- Constructors
- Primary constructors
- Defining properties in a primary constructor
- Secondary constructors
- Default arguments
- Named arguments
- Initializer Blocks
- Initialization Order
- Delaying Initialization
- Late initialization
- Lazy initialization
15. Inheritance
- Defining the Room Class
- Creating a Subclass
- Type Checking
- The Kotlin Type Hierarchy
- Type casting
- Smart casting
- Refactoring the Tavern
16. Objects, Data Classes, and Enums
- The object Keyword
- Object declarations
- Object expressions
- Companion objects
- Nested Classes
- Data Classes
- toString
- equals and hashCode
- copy
- Destructuring declarations
- Enumerated Classes
- Operator Overloading
- Exploring the World of NyetHack
17. Interfaces and Abstract Classes
- Defining an Interface
- Implementing an Interface
- Default Implementations
- Abstract Classes
- Combat in NyetHack
18. Generics
- Defining Generic Types
- Generic Functions
- Generic Constraints
- in and out
- Adding Loot to NyetHack
19. Extensions
- Defining Extension Functions
- Defining an extension on a superclass
- Generic extension functions
- Operator extension functions
- Extension Properties
- Extensions on Nullable Types
- Extensions, Under the Hood
- Extension Visibility
- Extensions in the Kotlin Standard Library
- For the More Curious: Function Literals with Receivers
- Challenge: Frame Extension
20. Coroutines
- Blocking Calls
- Enabling Coroutines
- Coroutine Builders
- Coroutine Scopes
- Structured Concurrency
- Using an HTTP Client
- async and await
- For the More Curious: Race Conditions
- For the More Curious: Server-
- Side Kotlin
- Challenge: No Cancellations
21. Flows
- Setting Up a Flow
- MutableStateFlow
- Flow Termination
- Flow Transformations
- Error Handling in Flows
- For the More Curious: SharedFlow
22. Channels
- Dividing Work with Channels
- Sending to a Channel
- Receiving from a Channel
- Closing a Channel
- Joining Jobs
- For the More Curious: Other Channel Behaviors
- Rendezvous channels
- Buffered channels
- Unlimited channels
- Conflated channels
- Interoperation and Multiplatform Applications
23. Java Interoperability
- Interoperating with a Java Class
- Interoperability and Nullity
- Type Mapping
- Getters, Setters, and Interoperability
- Beyond Classes
- Exceptions and Interoperability
- Function Types in Java
24. Introduction to Kotlin Multiplatform
- What Is Kotlin Multiplatform?
- Planning Your Multiplatform Project
- Your First Multiplatform Project
- Defining a Kotlin/JVM Target
- Defining Shared Code
- expect and actual
25. Kotlin/Native
- Declaring a macOS Target
- Writing Native Code with Kotlin
- Launching a Kotlin/Native application
- Kotlin/Native Outputs
- For the More Curious: Kotlin Multiplatform Mobile
- For the More Curious: Other Native Platforms
26. Kotlin/JS
- Declaring Support for Kotlin/JS
- Interacting with the DOM
- The external Keyword
- Executing Raw JavaScript
- Dynamic Types
- For the More Curious: Front-End Frameworks
