book

Kotlin in Action, Second Edition

Name: Kotlin in Action, Second Edition
ISBN: 9781617299605

by Svetlana Isakova, Sebastian Aigner, Roman Elizarov

May 2024

Intermediate to advanced

560 pages

16h 9m

English

Manning Publications

Audiobook available

Read now

Unlock full access

Praise for the first edition
Kotlin in Action
Copyright
contents
front matter
prefaceacknowledgmentsabout this bookWho should read this bookHow this book is organized: A road mapAbout the codeliveBook discussion forumOther online resourcesabout the authorsabout the cover illustration
Part 1 Introducing Kotlin
1 Kotlin: What and why
1.1 A taste of Kotlin1.2 Kotlin’s primary traits1.2.1 Kotlin use cases: Android, server side, anywhere Java runs, and beyond1.2.2 Static typing makes Kotlin performant, reliable, and maintainable1.2.3 Combining functional and object-oriented programming makes Kotlin safe and flexible1.2.4 Concurrent and asynchronous code becomes natural and structured with coroutines1.2.5 Kotlin can be used for any purpose: It’s free, open source, and open to contributions1.3 Areas in which Kotlin is often used1.3.1 Powering backends: Server-side development with Kotlin1.3.2 Mobile Development: Android is Kotlin first1.3.3 Multiplatform: Sharing business logic and minimizing duplicate work on iOS, JVM, JS, and beyond1.4 The philosophy of Kotlin1.4.1 Kotlin is a pragmatic language1.4.2 Kotlin is concise1.4.3 Kotlin is safe1.4.4 Kotlin is interoperable1.5 Using the Kotlin tools1.5.1 Setting up and running the Kotlin code1.5.2 Compiling Kotlin codeSummary
2 Kotlin basics
2.1 Basic elements: Functions and variables2.1.1 Writing your first Kotlin program: “Hello, world!”2.1.2 Declaring functions with parameters and return values2.1.3 Making function definitions more concise by using expression bodies2.1.4 Declaring variables to store data2.1.5 Marking a variable as read only or reassignable2.1.6 Easier string formatting: String templates2.2 Encapsulating behavior and data: Classes and properties2.2.1 Associating data with a class and making it accessible: Properties2.2.2 Computing properties instead of storing their values: Custom accessors2.2.3 Kotlin source code layout: Directories and packages2.3 Representing and handling choices: Enums and when2.3.1 Declaring enum classes and enum constants2.3.2 Using the when expression to deal with enum classes2.3.3 Capturing the subject of a when expression in a variable2.3.4 Using the when expression with arbitrary objects2.3.5 Using the when expression without an argument2.3.6 Smart casts: Combining type checks and casts2.3.7 Refactoring: Replacing an if with a when expression2.3.8 Blocks as branches of if and when2.4 Iterating over things: while and for loops2.4.1 Repeating code while a condition is true: The while loop2.4.2 Iterating over numbers: Ranges and progressions2.4.3 Iterating over maps2.4.4 Using in to check collection and range membership2.5 Throwing and catching exceptions in Kotlin2.5.1 Handling exceptions and recovering from errors: try, catch, and finally2.5.2 Using try as an expressionSummary
3 Defining and calling functions
3.1 Creating collections in Kotlin3.2 Making functions easier to call3.2.1 Named arguments3.2.2 Default parameter values3.2.3 Getting rid of static utility classes: Top-level functions and properties3.3 Adding methods to other people’s classes: Extension functions and properties3.3.1 Imports and extension functions3.3.2 Calling extension functions from Java3.3.3 Utility functions as extensions3.3.4 No overriding for extension functions3.3.5 Extension properties3.4 Working with collections: varargs, infix calls, and library support3.4.1 Extending the Java collections API3.4.2 Varargs: Functions that accept an arbitrary number of arguments3.4.3 Working with pairs: Infix calls and destructuring declarations3.5 Working with strings and regular expressions3.5.1 Splitting strings3.5.2 Regular expressions and triple-quoted strings3.5.3 Multiline triple-quoted strings3.6 Making your code tidy: Local functions and extensionsSummary
4 Classes, objects, and interfaces
4.1 Defining class hierarchies4.1.1 Interfaces in Kotlin4.1.2 Open, final, and abstract modifiers: Final by default4.1.3 Visibility modifiers: Public by default4.1.4 Inner and nested classes: Nested by default4.1.5 Sealed classes: Defining restricted class hierarchies4.2 Declaring a class with nontrivial constructors or properties4.2.1 Initializing classes: Primary constructor and initializer blocks4.2.2 Secondary constructors: Initializing the superclass in different ways4.2.3 Implementing properties declared in interfaces4.2.4 Accessing a backing field from a getter or setter4.2.5 Changing accessor visibility4.3 Compiler-generated methods: Data classes and class delegation4.3.1 Universal object methods4.3.2 Data classes: Autogenerated implementations of universal methods4.3.3 Class delegation: Using the by keyword4.4 The object keyword: Declaring a class and creating an instance, combined4.4.1 Object declarations: Singletons made easy4.4.2 Companion objects: A place for factory methods and static members4.4.3 Companion objects as regular objects4.4.4 Object expressions: Anonymous inner classes rephrased4.5 Extra type safety without overhead: Inline classesSummary

5 Programming with lambdas
5.1 Lambda expressions and member references5.1.1 Introduction to lambdas: Blocks of code as values5.1.2 Lambdas and collections5.1.3 Syntax for lambda expressions5.1.4 Accessing variables in scope5.1.5 Member references5.1.6 Bound callable references5.2 Using Java functional interfaces: Single abstract methods5.2.1 Passing a lambda as a parameter to a Java method5.2.2 SAM constructors: Explicit conversion of lambdas to functional interfaces5.3 Defining SAM interfaces in Kotlin: fun interfaces5.4 Lambdas with receivers: with, apply, and also5.4.1 Performing multiple operations on the same object: with5.4.2 Initializing and configuring objects: The apply function5.4.3 Performing additional actions with an object: alsoSummary
6 Working with collections and sequences
6.1 Functional APIs for collections6.1.1 Removing and transforming elements: filter and map6.1.2 Accumulating values for collections: reduce and fold6.1.3 Applying a predicate to a collection: all, any, none, count, and find6.1.4 Splitting a list into a pair of lists: partition6.1.5 Converting a list to a map of groups: groupBy6.1.6 Transforming collections into maps: associate, associateWith, and associateBy6.1.7 Replacing elements in mutable collections: replaceAll and fill6.1.8 Handling special cases for collections: ifEmpty6.1.9 Splitting collections: chunked and windowed6.1.10 Merging collections: zip6.1.11 Processing elements in nested collections: flatMap and flatten6.2 Lazy collection operations: Sequences6.2.1 Executing sequence operations: Intermediate and terminal operations6.2.2 Creating sequencesSummary
7 Working with nullable values
7.1 Avoiding NullPointerExceptions and handling the absence of values: Nullability7.2 Making possibly null variables explicit with nullable types7.3 Taking a closer look at the meaning of types7.4 Combining null checks and method calls with the safe call operator: ?.7.5 Providing default values in null cases with the Elvis operator: ?:7.6 Safely casting values without throwing exceptions: as?7.7 Making promises to the compiler with the non-null assertion operator: !!7.8 Dealing with nullable expressions: The let function7.9 Non-null types without immediate initialization: Late-initialized properties7.10 Extending types without the safe-call operator: Extensions for nullable types7.11 Nullability of type parameters7.12 Nullability and Java7.12.1 Platform types7.12.2 InheritanceSummary
8 Basic types, collections, and arrays
8.1 Primitive and other basic types8.1.1 Representing integers, floating-point numbers, characters, and Booleans with primitive types8.1.2 Using the full bit range to represent positive numbers: Unsigned number types8.1.3 Nullable primitive types: Int?, Boolean?, and more8.1.4 Kotlin makes number conversions explicit8.1.5 Any and Any?: The root of the Kotlin type hierarchy8.1.6 The Unit type: Kotlin’s void8.1.7 The Nothing type: “This function never returns”8.2 Collections and arrays8.2.1 Collections of nullable values and nullable collections8.2.2 Read-only and mutable collections8.2.3 Kotlin collections and Java collections are deeply related8.2.4 Collections declared in Java are seen as platform types in Kotlin8.2.5 Creating arrays of objects and primitive types for interoperability and performance reasonsSummary
Part 2 Embracing Kotlin
9 Operator overloading and other conventions
9.1 Overloading arithmetic operators makes operations for arbitrary classes more convenient9.1.1 Plus, times, divide, and more: Overloading binary arithmetic operations9.1.2 Applying an operation and immediately assigning its value: Overloading compound assignment operators9.1.3 Operators with only one operand: Overloading unary operators9.2 Overloading comparison operators makes it easy to check relationships between objects9.2.1 Equality operators: equals (==)9.2.2 Ordering operators: compareTo (<, >, ⇐, and >=)9.3 Conventions used for collections and ranges9.3.1 Accessing elements by index: The get and set conventions9.3.2 Checking whether an object belongs to a collection: The in convention9.3.3 Creating ranges from objects: The rangeTo and rangeUntil conventions9.3.4 Making it possible to loop over your types: The iterator convention9.4 Making destructuring declarations possible with component functions9.4.1 Destructuring declarations and loops9.4.2 Ignoring destructured values using the _ character9.5 Reusing property accessor logic: Delegated properties9.5.1 Basic syntax and inner workings of delegated properties9.5.2 Using delegated properties: Lazy initialization and by lazy()9.5.3 Implementing your own delegated properties9.5.4 Delegated properties are translated to hidden properties with custom accessors9.5.5 Accessing dynamic attributes by delegating to maps9.5.6 How a real-life framework might use delegated propertiesSummary
10 Higher-order functions:Lambdas as parameters and return values
10.1 Declaring functions that return or receive other functions: Higher-order functions10.1.1 Function types specify the parameter types and return values of a lambda10.1.2 Calling functions passed as arguments10.1.3 Java lambdas are automatically converted to Kotlin function types10.1.4 Parameters with function types can provide defaults or be nullable10.1.5 Returning functions from functions10.1.6 Making code more reusable by reducing duplication with lambdas10.2 Removing the overhead of lambdas with inline functions10.2.1 Inlining means substituting a function body to each call site10.2.2 Restrictions on inline functions10.2.3 Inlining collection operations10.2.4 Deciding when to declare functions as inline10.2.5 Using inlined lambdas for resource management with withLock, use, and useLines10.3 Returning from lambdas: Control flow in higher-order functions10.3.1 Return statements in lambdas: returning from an enclosing function10.3.2 Returning from lambdas: Return with a label10.3.3 Anonymous functions: Local returns by defaultSummary
11 Generics
11.1 Creating types with type arguments: Generic type parameters11.1.1 Functions and properties that work with generic types11.1.2 Generic classes are declared with the angle bracket syntax11.1.3 Restricting the type a generic class or function can use: Type parameter constraints11.1.4 Excluding nullable type arguments by explicitly marking type parameters as non-null11.2 Generics at run time: Erased and reified type parameters11.2.1 Limitations to finding type information of a generic class at run time: Type checks and casts11.2.2 Functions with reified type parameters can refer to actual type arguments at run time11.2.3 Avoiding java.lang.Class parameters by replacing class references with reified type parameters11.2.4 Declaring accessors with reified type parameters11.2.5 Reified type parameters come with restrictions11.3 Variance describes the subtyping relationship between generic arguments11.3.1 Variance determines whether it is safe to pass an argument to a function11.3.2 Understanding the differences between classes, types, and subtypes11.3.3 Covariance preserves the subtyping relation11.3.4 Contravariance reverses the subtyping relation11.3.5 Specifying variance for type occurrences via use-site variance11.3.6 Star projection: Using the * character to indicate a lack of information about a generic argument11.3.7 Type aliasesSummary
12 Annotations and reflection
12.1 Declaring and applying annotations12.1.1 Applying annotations to mark declarations12.1.2 Specifying the exact declaration an annotation refers to: Annotation targets12.1.3 Using annotations to customize JSON serialization12.1.4 Creating your own annotation declarations12.1.5 Meta-annotations: Controlling how an annotation is processed12.1.6 Passing classes as annotation parameters to further control behavior12.1.7 Generic classes as annotation parameters12.2 Reflection: Introspecting Kotlin objects at run time12.2.1 The Kotlin reflection API: KClass, KCallable, KFunction, and KProperty12.2.2 Implementing object serialization using reflection12.2.3 Customizing serialization with annotations12.2.4 JSON parsing and object deserialization12.2.5 The final step of deserialization: callBy() and creating objects using reflectionSummary
13 DSL construction
13.1 From APIs to DSLs: Creating expressive custom code structures13.1.1 Domain-specific languages13.1.2 Internal DSLs are seamlessly integrated into the rest of your program13.1.3 The structure of DSLs13.1.4 Building HTML with an internal DSL13.2 Building structured APIs: Lambdas with receivers in DSLs13.2.1 Lambdas with receivers and extension function types13.2.2 Using lambdas with receivers in HTML builders13.2.3 Kotlin builders: Enabling abstraction and reuse13.3 More flexible block nesting with the invoke convention13.3.1 The invoke convention: Objects callable as functions13.3.2 The invoke convention in DSLs: Declaring dependencies in Gradle13.4 Kotlin DSLs in practice13.4.1 Chaining infix calls: The should function in test frameworks13.4.2 Defining extensions on primitive types: Handling dates13.4.3 Member extension functions: Internal DSL for SQLSummary
Part 3 Concurrent programming with coroutines and flows
14 Coroutines
14.1 Concurrency vs. parallelism14.2 Concurrency the Kotlin way: Suspending functions and coroutines14.3 Comparing threads and coroutines14.4 Functions that can pause: Suspending functions14.4.1 Code written with suspending functions looks sequential14.5 Comparing coroutines to other approaches14.5.1 Calling a suspending function14.6 Entering the world of coroutines: Coroutine builders14.6.1 From regular code into the realm of coroutines: The runBlocking function14.6.2 Creating start-and-forget coroutines: The launch function14.6.3 Awaitable computations: The async builder14.7 Deciding where your code should run: Dispatchers14.7.1 Choosing a dispatcher14.7.2 Passing a dispatcher to a coroutine builder14.7.3 Using withContext to switch the dispatcher within a coroutine14.7.4 Coroutines and dispatchers aren’t a magical fix for thread-safety concerns14.8 Coroutines carry additional information in their coroutine contextSummary
15 Structured concurrency
15.1 Coroutine scopes establish structure between coroutines15.1.1 Creating a coroutine scope: The coroutineScope function15.1.2 Associating coroutine scopes with components: CoroutineScope15.1.3 The danger of GlobalScope15.1.4 Coroutine contexts and structured concurrency15.2 Cancellation15.2.1 Triggering cancellation15.2.2 Invoking cancellation automatically after a time limit has been exceeded15.2.3 Cancellation cascades through all children15.2.4 Cancelled coroutines throw CancellationExceptions in special places15.2.5 Cancellation is cooperative15.2.6 Checking whether a coroutine has been cancelled15.2.7 Letting other coroutines play: The yield function15.2.8 Keep cancellation in mind when acquiring resources15.2.9 Frameworks can perform cancellation for youSummary
16 Flows
16.1 Flows model sequential streams of values16.1.1 Flows allow you to work with elements as they are emitted16.1.2 Different types of flows in Kotlin16.2 Cold flows16.2.1 Creating a cold flow with the flow builder function16.2.2 Cold flows don’t do any work until collected16.2.3 Cancelling the collection of a flow16.2.4 Cold flows under the hood16.2.5 Concurrent flows with channel flows16.3 Hot flows16.3.1 Shared flows broadcast values to subscribers16.3.2 Keeping track of state in your system: State flow16.3.3 Comparing state flows and shared flows16.3.4 Hot, cold, shared, state: When to use which flowSummary
17 Flow operators
17.1 Manipulating flows with flow operators17.2 Intermediate operators are applied to an upstream flow and return a downstream flow17.2.1 Emitting arbitrary values for each upstream element: The transform function17.2.2 The take operator family can cancel a flow17.2.3 Hooking into flow phases with onStart, onEach, onCompletion, and onEmpty17.2.4 Buffering elements for downstream operators and collectors: The buffer operator17.2.5 Throwing away intermediate values: The conflate operator17.2.6 Filtering out values on a timeout: The debounce operator17.2.7 Switching the coroutine context on which a flow is executed: The flowOn operator17.3 Creating custom intermediate operators17.4 Terminal operators execute the upstream flow and may compute a value17.4.1 Frameworks provide custom operatorsSummary
18 Error handling and testing
18.1 Handling errors thrown inside coroutines18.2 Error propagation in Kotlin coroutines18.2.1 Coroutines cancel all their children when one child fails18.2.2 Structured concurrency only affects exceptions thrown across coroutine boundaries18.2.3 Supervisors prevent parents and siblings from being cancelled18.3 CoroutineExceptionHandler: The last resort for processing exceptions18.3.1 Differences when using CoroutineExceptionHandler with launch or async18.4 Handling errors in flows18.4.1 Processing upstream exceptions with the catch operator18.4.2 Retry the collection of a flow if predicate is true: The retry operator18.5 Testing coroutines and flows18.5.1 Making tests using coroutines fast: Virtual time and the test dispatcher18.5.2 Testing flows with TurbineSummary
appendix A. Building Kotlin projects
Building Kotlin code with GradleBuilding projects that use annotation processingBuilding Kotlin projects with Maven
appendix B. Documenting Kotlin code
Writing Kotlin documentation commentsGenerating API documentation
appendix C. The Kotlin ecosystem
TestingCode coverageBenchmarkingDocumentationDependency injectionNetworked applications: Servers and clientsSerializationDatabase accessConcurrent programmingUser interface development
index

Content preview from Kotlin in Action, Second Edition

Part 3 Concurrent programming with coroutines and flows

By now, you have developed a deep understanding of Kotlin as a language and its conventions. In this part of the book, you’ll learn how to perform concurrent programming in Kotlin.

Concurrency is an impactful topic no matter whether you are writing server-side, mobile, or desktop applications with Kotlin. Most modern applications need to do more than one thing at once, be it serving or making network requests, keeping a responsive user interface while performing CPU-intensive tasks, or allowing users to multitask in other ways. As a Kotlin developer, you’ll come across and work with concurrent code in Kotlin sooner or later, as well.

Kotlin comes with a unique and robust approach for concurrent ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781617299605Publisher Support Publisher Website Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Kotlin in Action, Second Edition

by Svetlana Isakova, Sebastian Aigner, Roman Elizarov

Part 3 Concurrent programming with coroutines and flows

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.