Last week I received an email asking about a table Of contents for my new Kotlin Cookbook, saying they couldn’t find one either on the O’Reilly Media site or on Amazon. It’s a lot easier to make a decision about buying a recipe book if you have a list of recipes.
When I checked last week, no table of contents was available. Fortunately that’s no longer the case. If you go to the Amazon listing and click on the “Look Inside” link, the table of contents is included, along with the preface, which includes a description of each chapter.
It couldn’t hurt, however, to repeat both of those here as well. That way if anyone asks I can just give them this link, plus you can add whatever comments you like to this post and I’ll see them and potentially be able to respond.

Here is the list of chapter descriptions from the Preface.
- Chapter 1, Installing and Running Kotlin, covers the basic process of installing and running Kotlin, including using the REPL, working with build tools like Maven and Gradle, and employing the native image generator in Graal.
- Chapter 2, Basic Kotlin, covers some fundamental features of Kotlin—such as nullable types, overloading operators, and converting between types—before examining some more esoteric issues including working with bitwise shift operators or the
to
extension function on thePair
class. - Chapter 3, Object Oriented Programming in Kotlin, focuses on object-oriented features of the language that developers from other languages might find surprising or unusual. It includes how to use the
const
keyword, how Kotlin handles backing properties, delayed initialization, and the dreadedNothing
class, which is guaranteed to confuse existing Java developers. - Chapter 4, Functional Programming, has only a few recipes, which involve functional features that need their own explanations. Functional programming concepts are covered throughout the book, especially when talking about collections, sequences, and coroutines, but there are a handful of techniques included in this chapter that you may find unusual or particularly interesting.
- Chapter 5, Collections, covers arrays and collections, dealing mostly with non-obvious methods like destructing collections, sorting by multiple properties, building a window on a collection, and creating progressions.
- Chapter 6, Sequences, shows how Kotlin handles sequences of items lazily, similar to the way Java uses streams. Recipes cover generating sequences, yielding from them, and working with infinite sequences.
- Chapter 7, Scope Functions, covers another topic unique to Kotlin: functions that execute a block of code in the context of an object. Functions like
let
,apply
, andalso
are quite useful in Kotlin, and this chapter illustrates why and how to use them. - Chapter 8, Kotlin Delegates, discusses a convenient feature of Kotlin: how it implements delegation. Delegation lets you employ composition rather than inheritance, and Kotlin includes several delegates in the standard library, like
lazy
,observable
, andvetoable
. - Chapter 9, Testing, covers the important topic of testing, with a particular focus on JUnit 5. In its current version, JUnit is designed to work well with Kotlin, and that includes both its regular usage and employing it in Spring Framework applications. This chapter discusses several approaches that make writing and executing tests easier.
- Chapter 10, Input/Output, includes a couple of recipes specifically for managing resources. File I/O is covered, as is the
use
function, which has broad applicability in several contexts. - Chapter 11, Miscellaneous, covers topics that do not fit easily in any other category. Topics such as how to get the current Kotlin version, how to force the
when
statement to be exhaustive even when it doesn’t return a value, and how to use thereplace
function with regular expressions are covered. In addition, theTODO
function and theRandom
class are discussed, as well as how to integrate with Java exception handling. - Chapter 12, The Spring Framework, involves the Spring Framework along with Spring Boot, which is very friendly to Kotlin. A few recipes are included to show how to use Kotlin classes as managed beans, how to implement JPA persistence, and how to inject dependencies when needed.
- Chapter 13, Coroutines and Structured Concurrency, covers the subject of coroutines, one of the most popular features of Kotlin and the basis of concurrent and parallel programming in the language. Recipes cover the basics, like builders and dispatchers, along with how to cancel and debug coroutines, and how to run them on your own custom Java thread pool.
Hopefully those descriptions will be helpful. For the actual recipes, the following list has been (slightly) enhanced by using code formatting for Kotlin functions or keywords.
- Installing and Running Kotlin
1.1 Running Kotlin Without a Local Compiler
1.2 Installing Kotlin Locally
1.3 Compiling and Running Kotlin from the Command Line
1.4 Using the Kotlin REPL
1.5 Executing a Kotlin Script
1.6 Building a Standalone Application Using GraalVM
1.7 Adding the Kotlin Plugin for Gradle (Groovy Syntax)
1.8 Adding the Kotlin Plugin for Gradle (Kotlin Syntax)
1.9 Using Gradle to Build Kotlin Projects
1.10 Using Maven with Kotlin - Basic Kotlin
2.1 Using Nullable Types in Kotlin
2.2 Adding Nullability Indicators to Java
2.3 Adding Overloaded Methods for Java
2.4 Converting Between Types Explicitly
2.5 Printing to Different Bases
2.6 Raising a Number to a Power
2.7 Using Bitwise Shift Operators
2.8 Using Bitwise Boolean Operators
2.9 CreatingPair
Instances withto
- Object-Oriented Programming in Kotlin
3.1 Understanding the Difference Betweenconst
andval
3.2 Creating Custom Getters and Setters
3.3 Defining Data Classes
3.4 The Backing Property Technique
3.5 Overloading Operators
3.6 Usinglateinit
for Delayed Initialization
3.7 Using Safe Casting, Reference Equality, and Elvis to Overrideequals
3.8 Creating a Singleton
3.9 Much Ado AboutNothing
- Functional Programming
4.1 Usingfold
in Algorithms
4.2 Using thereduce
Function for Reductions
4.3 Applying Tail Recursion - Collections
5.1 Working with Arrays
5.2 Creating Collections
5.3 Creating Read-Only Views from Existing Collections
5.4 Building a Map from a Collection
5.5 Returning a Default When a Collection Is Empty
5.6 Restricting a Value to a Given Range
5.7 Processing a Window on a Collection
5.8 Destructuring Lists
5.9 Sorting by Multiple Properties
5.10 Defining Your Own Iterator
5.11 Filtering a Collection by Type
5.12 Making a Range into a Progression - Sequences
6.1 Using Lazy Sequences
6.2 Generating Sequences
6.3 Managing Infinite Sequences
6.4 Yielding from a Sequence - Scope Functions
7.1 Initializing Objects After Construction withapply
7.2 Usingalso
for Side Effects
7.3 Using thelet
Function and Elvis
7.4 Usinglet
with a Temporary Variable - Kotlin Delegates
8.1 Implementing Composition by Delegation
8.2 Using thelazy
Delegate
8.3 Ensuring That a Value Is Not Null
8.4 Using theobservable
andvetoable
Delegates
8.5 Supplying Maps as Delegates
8.6 Creating Your Own Delegates - Testing
9.1 Setting the Test Class Life Cycle
9.2 Using Data Classes for Tests
9.3 Using Helper Functions with Default Arguments
9.4 Repeating JUnit 5 Tests with Different Data
9.5 Using Data Classes for Parameterized Tests - Input/Output
10.1 Managing Resources withuse
10.2 Writing to a File - Miscellaneous
11.1 Working with the Kotlin Version
11.2 Executing a Lambda Repeatedly
11.3 Forcingwhen
to Be Exhaustive
11.4 Using thereplace
Function with Regular Expressions
11.5 Converting to Binary String and Back
11.6 Making a Class Executable
11.7 Measuring Elapsed Time
11.8 Starting Threads
11.9 Forcing Completion withTODO
11.10 Understanding the Random Behavior ofRandom
11.11 Using Special Characters in Function Names
11.12 Telling Java About Exceptions - The Spring Framework
12.1 Opening Spring-Managed Bean Classes for Extension
12.2 Persisting Kotlin Data Classes
12.3 Injecting Dependencies - Coroutines and Structured Concurrency
13.1 Choosing Coroutine Builders
13.2 Replacingasync/await
withwithContext
13.3 Working with Dispatchers
13.4 Running Coroutines on a Java Thread Pool
13.5 Cancelling Coroutines
13.6 Debugging Coroutines
I believe that’s 87 recipes total. I could have added at least a dozen more, but as Katie Mack (@AstroKatie on Twitter) once said, “the hardest thing about writing a book is that eventually you have to stop writing the book.” My book is done and I believe what’s there is solid. If I ever get to revisit it for a second edition, I’m sure I’ll have much more to say, but this hopefully will give you a good cross-section of what Kotlin can do and how to do it.
Leave a Reply