Programming Kotlin

Introduction
Hello Kotlin excerpt
-Reasons to Love Kotlin
-Why Should You Choose Kotlin?
-Taking Kotlin for a Ride
-Compile to Bytecode and Run
-Compiling to Other Targets
-Which Option to Choose?
-Wrapping Up
Scripting with Kotlin
Kotlin Essentials for the Java Eyes
-Less Typing
-Sensible Warnings excerpt
-Prefer val over var
-Improved Equality Check
-String Templates
-Raw Strings
-More Expressions, Fewer Statements
-Wrapping Up
Working with Functions
-Creating Functions
-Default and Named Arguments
-vararg and Spread
-Destructuring
-Wrapping Up
External Iteration and Argument Matching
-Range and Iteration
-Iterating over Arrays and Lists
-When It’s Time to Use when
-Wrapping Up
Using Collections
-Flavors of Collections
-Using Pair and Triple
-Arrays of Objects and Primitives
-Using List
-Using Set
-Using Map
-Wrapping Up
-Type Safety to Save the Day
-Any and Nothing Classes
-Nullable References
-Type Checking and Casting
-Explicit Type Casting
-Generics: Variance and Constraints of Parametric Types
-Reified Type Parameters
-Wrapping Up
Object-Oriented Kotlin
Objects and Classes
-Objects and Singletons
-Creating Classes
-Companion Objects and Class Members
-Creating Generics Classes
-Data Classes
-Wrapping Up
Class Hierarchies and Inheritance
-Creating Interfaces and Abstract Classes
-Nested and Inner Classes
-Inheritance
-Sealed Classes
-Creating and Using Enums
-Wrapping Up
Extension Through Delegation
-When to Choose Delegation over Inheritance?
-Designing with Delegates
-Delegating to a Parameter
-Dealing with Method Collisions
-Caveats of Kotlin Delegation
-Delegating Variables and Properties
-Built-in Standard Delegates
-Wrapping Up
Functional Kotlin
Functional Programming with Lambdas
-The Functional Style
-Lambda Expressions
-Lambdas and Anonymous Functions
-Closures and Lexical Scoping
-Non-Local and Labeled return
-Inlining Functions with Lambdas
-Wrapping Up
Internal Iteration and Lazy Evaluation
-External vs. Internal Iterators
-Internal Iterators
-Sequences for Lazy Evaluation
-Wrapping Up
Elegant and Efficient Kotlin
Fluency in Kotlin
-Overloading Operators
-Injecting Using Extension Functions and Properties
-Extending Functions
-Function Fluency with infix
-Fluency with Any Object
-Implicit Receivers
-Wrapping Up
Creating Internal DSLs
-Types and Characteristics of DSLs
-Kotlin for Internal DSLs
-Challenges in Building for Fluency
-Type-Safe Builders
-Narrowing Access with Scope Control
-Wrapping Up
Programming Recursion and Memoization
-The Power and Perils of Recursion
-Tail Call Optimization
-Memoization
-Applying Memoization to Dynamic Programming
-Wrapping Up
Programming Asynchronous Applications
Exploring Coroutines
-Coroutines and Concurrency
-Running Concurrently Using Coroutines
-Coroutine Context and Threads
-Debugging Coroutines
-async and await
-A Peek at Continuations
-Creating Infinite Sequences
-Wrapping Up
Asynchronous Programming
-Programming Asynchronously
-Exception Handling
-Cancellations and Timeouts
-Wrapping Up
Interop and Testing
Intermixing Java and Kotlin
-Joint Compilation
-Calling Java from Kotlin
-Calling Kotlin from Java
-Wrapping Up
Unit Testing with Kotlin
-The Code Under Test
-Getting the Project Files
-Starting with a Canary Test
-Writing Empirical Tests
-Writing Data-Driven Tests
-Mocking Out Dependencies
-Testing Top-Level Functions
-Testing Coroutines and Asynchronous Calls
-Integrating with the Service
-Viewing the Code Coverage
-Taking the App for a Drive
-Wrapping Up
Programming Spring Applications with Kotlin
-Creating a Starter Project
-Creating a Controller
-Creating an Entity Class
-Creating a Repository Interface
-Creating a Service
-Integrating the Service with Controller
-Taking It for a Ride
-Wrapping Up
Writing Android Applications with Kotlin
-Creating a Project
-Defining Domain Objects
-Creating Layouts
-Implementing the Activity
-Updating the RecyclerView
-Seeing the App in Action
-Wrapping Up