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
toextension function on the
- 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
constkeyword, how Kotlin handles backing properties, delayed initialization, and the dreaded
Nothingclass, 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
alsoare 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
- 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
usefunction, 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
whenstatement to be exhaustive even when it doesn’t return a value, and how to use the
replacefunction with regular expressions are covered. In addition, the
TODOfunction and the
Randomclass 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
- Object-Oriented Programming in Kotlin
3.1 Understanding the Difference Between
3.2 Creating Custom Getters and Setters
3.3 Defining Data Classes
3.4 The Backing Property Technique
3.5 Overloading Operators
lateinitfor Delayed Initialization
3.7 Using Safe Casting, Reference Equality, and Elvis to Override
3.8 Creating a Singleton
3.9 Much Ado About
- Functional Programming
4.2 Using the
reduceFunction for Reductions
4.3 Applying Tail Recursion
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
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 with
alsofor Side Effects
7.3 Using the
letFunction and Elvis
letwith a Temporary Variable
- Kotlin Delegates
8.1 Implementing Composition by Delegation
8.2 Using the
8.3 Ensuring That a Value Is Not Null
8.4 Using the
8.5 Supplying Maps as Delegates
8.6 Creating Your Own Delegates
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
10.1 Managing Resources with
10.2 Writing to a File
11.1 Working with the Kotlin Version
11.2 Executing a Lambda Repeatedly
whento Be Exhaustive
11.4 Using the
replaceFunction 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 with
11.10 Understanding the Random Behavior of
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.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.