Dave Leeds on Kotlin

✨ Illustrated Guide Print Edition - Now on Amazon! ✨

Book cover of Kotlin: An Illustrated Guide

The paperback edition of Kotlin: An Illustrated Guide is finally here! I’ve been working on this book for about 5 years, and it’s exciting to finally see it in print!

Get it in paperback!

To celebrate, we’ve got a special downloadable bonus in the works for those who purchase the paperback edition during the month of April - the Kotlin Adventure Pack!

🎒 The Kotlin Adventure Pack

The Adventure Pack includes some additional fantastic resources:

The Kotlin Trail Map - Lists the most popular libraries for Kotlin, and when to consider using them in your project.
Field Guide to Kotlin Terms - When you see a Kotlin programming term in the wild, quickly look it up in this handy PDF!
Field Guide Quiz Cards - Anki deck of the Field Guide, so you can easily review and study while you’re on the go.
Livestream “Campfire” Hangout - Join me for an exclusive “ask me anything” livestream at the end of April.
Bonus Cheat Sheets - You’ll also get the three popular cheat sheets from the TypeAlias Shop.

To get the Adventure Pack bonus, just order the book on Amazon between April 8-30, and then fill out this form with the order number from your purchase. The link to download the Adventure Pack files will be sent out as soon as they’re ready!

Latest Articles and Videos

New!

Applying the
Observer Pattern

Is the Observer Pattern relevant in Kotlin? Let's see what library features can be used instead.

Can Junie write Kotlin from UML?

Let's see if it can implement functions and properties based on context, notes, and other clues!

Junie - JetBrains'
New AI Coding Agent

JetBrains' new AI coding agent is in EAP. Let's see if we can use it to build a Compose app!

Junie - JetBrains'<br />New AI Coding Agent

Multi-Cursors in 5 Minutes (Livestream Clip)

Use multi-cursor edits to speed up your development in IntelliJ and Android Studio.

TypeAlias Show #5:
Arrow for Everyone

Alejandro Serrano Mena joins me to show off some of Arrow's exciting features.

TypeAlias Show #5:<br />Arrow for Everyone

What are all those Kotlin function types for?

Kotlin's got a surprising number of function types - what are they used for?

Guards and Pattern Guards (Livestream Clip)

Let's see what guards and pattern guards are in Kotlin 2.1.

TypeAlias Show #4:
Kotlin 2.1

Let's check out pattern guards, direct Swift export, and more!

Immutable and Persistent Lists (Livestream Clip)

Let's check out the kotlinx.collections.immutable library, and why you might want to use it.

Anonymous Functions Aren't Lambdas

In Kotlin, anonymous functions have a distinct syntax from lambdas. Let's check it out!

Fun with Function Types

Let's see how we can call regular functions and property setters as if they were extension functions.

Subtyping Composables (Livestream Clip)

One idea about how you could create a slot API with Compose.

TypeAlias Show #3:
Immutable Lists

Compose Multiplatform 1.7, Immutable Collections, subtyping Composables

Builder Pattern
in Kotlin

Do we need the Builder Pattern in Kotlin? Let's find out.

Factory Patterns in Kotlin

Let's look at the Factory Method and Abstract Factory patterns to see how we can use them in Kotlin.

TypeAlias Show #2:
Multi-Cursor Magic

Kotlin Roadmap updates, StackOverflow survey results, and accelerated development in JetBrains' IDEs.

TypeAlias Show #2:<br/>Multi-Cursor Magic

State Pattern in Kotlin

The design pattern series continues. Let's see how we can modernize the State Pattern.

Decorator Pattern in Kotlin

In this video, we'll modernize the Decorator Pattern using some of Kotlin's language features.

Strategy Pattern in Kotlin

Let's see how Kotlin can modernize the Strategy Pattern from the original Gang of Four book.

Coroutines: Concurrency in Kotlin

A live presentation covering the main concepts from Chapter 20, in about 30 minutes.

TypeAlias Show #1: kotlinx.rpc

It's the very first episode of the TypeAlias Show Livestream!

Composing Like You're Inheriting

Composition vs. Inheritance... or can we get the best of both worlds?

Coroutine Essentials

Discover the power of coroutines in Kotlin and learn how to make your applications perform tasks concurrently and in parallel. Join Rusty and his construction crew as they streamline construction projects – and see how you can apply these same techniques to your Kotlin code!

7 Overlooked Stdlib Features

Let's look at seven features in the standard library that you might have missed.

Reified Type Parameters

What is type erasure, and how does the reified keyword help?

The Essence of Coroutines

What makes a coroutine a coroutine?

Looking Forward to Kotlin 2.0

Kotlin 2.0 is just around the corner!

Three Simple Rules for Subtypes

Inheritance and variance are based on three simple rules.

Generic Variance

Create subtypes from your parameterized types using Kotlin's generic variance. In this chapter, we'll learn about covariance, contravariance, and how they can be applied in declaration-site variance and use-site variance, based on three simple rules of subtypes.

Inline Functions

Let's look at inline functions, and the crossinline and noinline modifiers.

Every Kind of Class

Inner classes, value classes, sealed classes, and many others... let's look at them all!

Generics

Perk up your understanding of generics in Chapter 18 of Kotlin: An Illustrated Guide! Through the engaging examples of Jennifer's bakery café and its ever-evolving beverage menu, you'll learn all about generics, type parameters, type arguments, upper-bound constraints, and lots more.

Type Projections

Type projections give us generic subtypes when declaration-site variance isn't an option!

Variance... without Generics!

Unlock the mental model of variance. No generics required!

Handling Runtime Exceptions

Catch some new knowledge about exception handling with Chapter 17 of 'Kotlin: An Illustrated Guide.' This chapter demystifies runtime errors, offering readers a blend of technical depth and relatable examples to master exception handling in Kotlin. Through vivid illustrations and clear, approachable explanations, learn how to navigate unexpected issues in your code gracefully. Whether you're a beginner eager to solidify your understanding or an experienced developer looking to refresh your knowledge, this chapter turns the complex topic of exceptions into an enjoyable learning experience.

Introduction to HexFormat

Let's check out HexFormat and its related functions!

Intersection Types in Kotlin

Intersection types are not denotable, but we can still use them!

try-catch vs runCatching

Let's talk about try-catch, runCatching(), and those poll results!

Sealed Types

In Kotlin, we can used sealed interfaces and sealed classes to make the compiler even more helpful! In this chapter, we'll learn how to get exhaustive matching with sealed types.

Leanpub Frontmatter Podcast: Dave Leeds

Len Epp and I talk about Kotlin, learning how to code, publishing on Leanpub, and lots more!

A Tour Through Konsist with Igor Wojda

I team up with special guest Igor Wojda to demonstrate how the Konsist static code analysis tool can be used to ensure consistency in a Kotlin codebase!

Data Classes and Destructuring

It's easy to use data classes to give your objects superpowers like value equality, a readable toString() implementation, the ability to easily copy values, and the ability to be destructured. In this chapter, we'll learn what they are, how to declare them, and when to use them!

How to Use Kotlin's Timing API

Kotlin's Timing API is stable as of Kotlin 1.9, and it offers some great ways to both measure and specify time. In this video, we'll take a tour through the main features of this API so that you can start using durations and time marks like a pro!

Wall Clock vs. Monotonic Clock

As a prelude to exploring the newly-stable Timing API in Kotlin 1.9, let's check out the difference between a wall clock and a monotonic clock!

Abstract and Open Classes

In this chapter, we'll see how we can create subtypes from abstract classes and open classes. Impress your friends with big words like inheritance and polymorphism!

Introduction to Collection Builders

Use Collection Builders to dynamically build out a collection's contents, without leaving it open to modifications.

Smart Casts with Kotlin Contracts

Use the experimental Contracts feature to create a Smart Cast from your own function.

Introduction to Class Delegation

Use Kotlin’s class delegation feature to forward function calls from one object to another - without all the usual boilerplate!

Easy SharedPreferences with Delegated Properties

Learn how Kotlin's delegated properties work by turning Android's SharedPreferences into a delegate.

5 Fun Ways to Use Extension Functions

Let's put extension functions together with operator function conventions to do some crazy things!

5-Year Celebration: Peek Behind the Scenes!

Get a peek behind the scenes, including my art setup, my writing tooling, and even my cute dog!

Introduction to Interfaces

In Kotlin, interfaces are one way to give a class more than one type at the same time. In this chapter, learn about interfaces and implementations, plus smart casts, interface inheritance, multiple interfaces, and default implementations.

Scopes and Scope Functions

Kotlin's scope functions - with(), run(), let(), also(), and apply() - introduce a new scope where an object can be easily used. Learn about two different kinds of scopes and how they affect visibility. Then, explore all five scope functions, and learn how shadowing affects implicit receivers.

Receivers and Extensions

Use Kotlin extensions to add new functions and properties to existing classes - even to classes that you didn't write! Learn all about explicit receivers, implicit receivers, extension functions, and extension properties in this chapter.

Collections: Maps

Maps in Kotlin are used to associate keys and values. In this chapter, we'll learn all about them, including mutable and immutable maps, map operations like forEach() and filter(), and how to convert lists into maps with associate() and groupBy().

Collections: Lists and Sets

Kotlin collections give you powerful control over groups of objects. In this chapter, we'll look at List and Set collection types, and we'll learn about collection operations - including mapping, filtering, and sorting.

Lambdas and Function References

In Kotlin, you can pass a chunk of code from one function to another. In this chapter, we'll learn how to do that, covering topics like function types, function references, lambdas, higher-order functions, and much more.

Nulls and Null Safety

In Kotlin, null safety is a first-class concept. In this chapter, we'll learn all about nulls, including how to manage them with tools like smart casts, elvis operators, safe-call operators, and more.

Enum Classes

Enumeration classes can improve your code by limiting values to only those that could be correct. In this chapter, we'll learn all about enum classes in Kotlin!

Examples of Classes in Kotlin

A quick reference that shows how to create classes in Kotlin, with examples that include properties, functions, inheritance, generics, and more.

Introduction to Classes and Objects

Classes and objects are everywhere in Kotlin! In this chapter, we'll put variables and functions together to create our very own types, using Kotlin classes.

Kotlin Conditionals: When and If

Kotlin has two important conditionals: when and if. They can be used either as expressions or as statements. In this chapter, we'll use illustrations and examples to demonstrate how to use them.

Functions

Learn all about Kotlin functions the fun and easy way, with lots of examples and illustrations! Expression bodies, block bodies, named arguments, default arguments, and lots more.

Variables, Expressions, and Types

So you want to be a Kotlin programmer? You've come to the right place! Your adventure starts here in Chapter 1, where you'll learn all about variables, expressions, and types.

When to Use Sequences

When should you use Kotlin sequences? And when should you use normal collections? In this article, we'll look at some of the characteristics that can have the biggest impact on performance.

Inside Sequences: Create Your Own Sequence Operations

Learn how to create your very own sequence operation by understanding how Kotlin's sequences work on the inside.

Kotlin Sequences: An Illustrated Guide

An illustrated introduction to Sequences in Kotlin - easy-to-understand diagrams that demonstrate the difference between regular collection operations and sequence operations.

Inline Classes and Autoboxing

Get the best performance out of Kotlin's Inline Classes feature by understanding when they're inlined and when they're autoboxed.

An Introduction to Inline Classes

An introduction to Kotlin's inline value classes, which can give you strong types for simple values - without sacrificing performance.

How to Enable Kotlin 1.3 Inline Classes Today

How to configure your IDE to use Kotlin 1.3 early access so that you can start exploring inline classes and other new features. Includes instructions for Gradle, Maven, IntelliJ IDEA, and Android Studio.

Parameters and Arguments: An Easy Way to Remember the Difference

Parameters and arguments aren't the same thing. Here's an easy way to remember the difference.

All About Type Aliases in Kotlin

Kotlin's type aliases give you a quick and easy way to create simple, concise, and domain-specific names for types. This guide covers all of the essential concepts, with plenty of examples to help you level up your Kotlin game.

Star-Projections and How They Work

What are star-projections in Kotlin? And why do they change your function parameter and return types? With just two easy-to-understand rules, we can illuminate star-projections and understand exactly why they work like they do.

The Ins and Outs of Generic Variance in Kotlin

The ultimate guide to understanding generics, covariance, contravariance, and type projections in Kotlin. Learn two simple subtyping rules that explain why generic variance works the way that it does.

An Illustrated Guide to Covariance and Contravariance in Kotlin

Confused about generic subtyping? With just a few simple, foundational concepts, almost everything about variance becomes clear. If you're confused about how subtyping works with generics in Kotlin, start here.