Stuff I've learned recently…

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 the Pair 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 dreaded Nothing 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, and also 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, and vetoable.
• 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 the replace function with regular expressions are covered. In addition, the TODO function and the Random 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.

1. 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
2. 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 Creating Pair Instances with to
3. Object-Oriented Programming in Kotlin
   3.1 Understanding the Difference Between const and val
   3.2 Creating Custom Getters and Setters
   3.3 Defining Data Classes
   3.4 The Backing Property Technique
   3.5 Overloading Operators
   3.6 Using lateinit for Delayed Initialization
   3.7 Using Safe Casting, Reference Equality, and Elvis to Override equals
   3.8 Creating a Singleton
   3.9 Much Ado About Nothing
4. Functional Programming
   4.1 Using fold in Algorithms
   4.2 Using the reduce Function for Reductions
   4.3 Applying Tail Recursion
5. 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
6. Sequences
   6.1 Using Lazy Sequences
   6.2 Generating Sequences
   6.3 Managing Infinite Sequences
   6.4 Yielding from a Sequence
7. Scope Functions
   7.1 Initializing Objects After Construction with apply
   7.2 Using also for Side Effects
   7.3 Using the let Function and Elvis
   7.4 Using let with a Temporary Variable
8. Kotlin Delegates
   8.1 Implementing Composition by Delegation
   8.2 Using the lazy Delegate
   8.3 Ensuring That a Value Is Not Null
   8.4 Using the observable and vetoable Delegates
   8.5 Supplying Maps as Delegates
   8.6 Creating Your Own Delegates
9. 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
10. Input/Output
    10.1 Managing Resources with use
    10.2 Writing to a File
11. Miscellaneous
    11.1 Working with the Kotlin Version
    11.2 Executing a Lambda Repeatedly
    11.3 Forcing when to Be Exhaustive
    11.4 Using the replace 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 with TODO
    11.10 Understanding the Random Behavior of Random
    11.11 Using Special Characters in Function Names
    11.12 Telling Java About Exceptions
12. The Spring Framework
    12.1 Opening Spring-Managed Bean Classes for Extension
    12.2 Persisting Kotlin Data Classes
    12.3 Injecting Dependencies
13. Coroutines and Structured Concurrency
    13.1 Choosing Coroutine Builders
    13.2 Replacing async/await with withContext
    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.