Browse Library
Sign In Start Free Trial
Close icon Search icon
Account
Browse Library Advanced Search Sign In Start Free Trial

Add to playlist

Create a Playlist

Modal Close icon
You need to login to use this feature.
  • Mastering Kotlin
  • Toc
  • feedback
Mastering Kotlin

Mastering Kotlin

By : Nate Ebel
2.7 (3)
close
Mastering Kotlin

Mastering Kotlin

2.7 (3)
By: Nate Ebel

Overview of this book

Using Kotlin without taking advantage of its power and interoperability is like owning a sports car and never taking it out of the garage. While documentation and introductory resources can help you learn the basics of Kotlin, the fact that it’s a new language means that there are limited learning resources and code bases available in comparison to Java and other established languages. This Kotlin book will show you how to leverage software designs and concepts that have made Java the most dominant enterprise programming language. You’ll understand how Kotlin is a modern approach to object-oriented programming (OOP). This book will take you through the vast array of features that Kotlin provides over other languages. These features include seamless interoperability with Java, efficient syntax, built-in functional programming constructs, and support for creating your own DSL. Finally, you will gain an understanding of implementing practical design patterns and best practices to help you master the Kotlin language. By the end of the book, you'll have obtained an advanced understanding of Kotlin in order to be able to build production-grade applications.
Table of Contents (25 chapters)
close
close
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
Free Chapter
1
Section 1: Kotlin – A Modern Solution to Application Development
Section 1: Kotlin – A Modern Solution to Application Development
2
A New Challenger Approaches
A New Challenger Approaches
Technical requirements
Creating a modern language for the JVM
Moving beyond the JVM
Designing Kotlin with best practices in mind
Checking in on the current state of Kotlin
Summary
Questions
Further reading
3
Programmers' Multi-Tool – Flexible, Expressive, and Concise
Programmers' Multi-Tool – Flexible, Expressive, and Concise
Technical requirements
Picking your programming paradigm
Embracing first-class functions
Fixing the billion-dollar mistake
Integrating with Java
Summary
Questions
Further reading
4
Section 2: Putting the Pieces Together – Modeling Data, Managing State, and Application Architecture
Section 2: Putting the Pieces Together – Modeling Data, Managing State, and Application Architecture
5
Understanding Programming Paradigms in Kotlin
Understanding Programming Paradigms in Kotlin
Technical requirements
Classifying programming languages
Understanding object-oriented programming
Functional programming
Reactive programming
Summary
Questions
Further reading
6
First-Class Functions
First-Class Functions
Technical requirements
Hello functions – first-class support for functions
Flexibility by design – reducing boilerplate with effective parameters
A function for every job – understanding function variations
Summary
Questions
Further reading
7
Modeling Real-World Data
Modeling Real-World Data
Technical requirements
Object-oriented programming in Kotlin
Achieving inheritance and composition
Understanding data classes
Working with enums, sealed classes, and objects
Summary
Questions
Further reading
8
Section 3: Play Nice – Integrating Kotlin With Existing Code
Section 3: Play Nice – Integrating Kotlin With Existing Code
9
Interoperability as a Design Goal
Interoperability as a Design Goal
Technical requirements
Understanding why Kotlin was designed with interop in mind
Adding Kotlin to an existing Java project
Converting Java into Kotlin
Summary
Questions
10
Crossing Over – Working across Java and Kotlin
Crossing Over – Working across Java and Kotlin
Technical requirements
Working with Kotlin from Java
Working with Java from Kotlin
Embracing Kotlin idioms
Are two languages better than one?
Summary
Questions
Further reading
11
Controlling the Story
Controlling the Story
Technical requirements
Improving generated class names
Leveraging default values in Java
Better companions
Bringing static to Kotlin
Use-site annotation targets
Summary
Questions
Further reading
12
Baby Steps – Integration through Testing
Baby Steps – Integration through Testing
Technical requirements
Test-first integration
Testing interop
Improved testing with Kotlin
Summary
Questions
Further reading
13
Section 4: Go Beyond – Exploring Advanced and Experimental Language Features
Section 4: Go Beyond – Exploring Advanced and Experimental Language Features
14
Practical Concurrency
chevron up
Practical Concurrency
Technical requirements
Understanding async patterns
The foundations of coroutines
Coroutines in practice
Summary
Questions
Further reading
15
Building Your Own Tools – Domain-Specific Languages (DSLs)
Building Your Own Tools – Domain-Specific Languages (DSLs)
Technical requirements
What is a DSL?
The building blocks of a DSL in Kotlin
Creating your first Kotlin DSL
Summary
Questions
Further reading
16
Fully Functional – Embracing Functional Programming
Fully Functional – Embracing Functional Programming
Technical requirements
Understanding functional programming
Understanding advanced functions
Leveraging the standard library
Functional programming with Arrow
Summary
Questions
Further reading
17
Section 5: The Wide World of Kotlin – Using Kotlin across the Entire Development Stack
Section 5: The Wide World of Kotlin – Using Kotlin across the Entire Development Stack
18
Kotlin on Android
Kotlin on Android
Technical requirements
First class Kotlin for Android
Hello Android Kotlin
Building with Kotlin
First-party tooling
Summary
Questions
Further reading
19
Kotlin and Web Development
Kotlin and Web Development
Technical requirements
Kotlin for the web
Building a Hello Kotlin project
Integrating with existing JavaScript
Summary
Questions
Further reading
20
Introducing Multiplatform Kotlin
Introducing Multiplatform Kotlin
Technical requirements
Introducing Kotlin multiplatform
Creating your first Kotlin multiplatform project
Building a Kotlin multiplatform project
Understanding the limitations of Kotlin multiplatform
Summary
Questions
Further reading
21
Taming the Monolith with Microservices
Taming the Monolith with Microservices
Technical requirements
Understanding microservices
Writing microservices with Kotlin
Deploying your first Kotlin microservice
Summary
Questions
Further reading
22
Practical Design Patterns
Practical Design Patterns
Technical requirements
Understanding design patterns
Revisiting the Singleton pattern in Kotlin
Revisiting the Factory pattern in Kotlin
Revisiting the Builder pattern in Kotlin
Revisiting the Strategy pattern in Kotlin
Summary
Questions
Further reading
23
Assessments
Assessments
Chapter 1: A New Challenger Approaches
Chapter 2: Programmer's Multi-Tool
Chapter 3: Understanding Programming Paradigms in Kotlin
Chapter 4: First-Class Functions
Chapter 5: Modeling Real-World Data
Chapter 6: Interoperability by Design
Chapter 7: Crossing Over – Working across Java and Kotlin
Chapter 8: Controlling the Story
Chapter 9: Baby Steps – Integration through Testing
Chapter 10: Practical Concurrency
Chapter 11: Building Your Own Tools – Domain-Specific Languages (DSLs)
Chapter 12: Fully Functional – Embracing Functional Programming
Chapter 13: Kotlin on Android
Chapter 14: Kotlin and Web Development
Chapter 15: Introducing Multiplatform Kotlin
Chapter 16: Taming the Monolith with Microservices
Chapter 17: Practical Design Patterns
24
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

Coroutines in practice

Now that we understand the foundations of coroutines, let's learn how to leverage coroutines with a view to handling async operations.

In this section, we'll explore the practical usage of coroutines in Kotlin. We'll examine the available primitives and we'll work through several examples. Finally, we'll examine some more advanced concepts, such as proper error handling and controlling coroutine scope.

Coroutine primitives

There are several fundamental concepts to understand when working with Kotlin coroutines. To highlight these, we can look at our example from the previous section:

fun main() {
    GlobalScope.launch {
        delay(500)
        println("Coroutines"...
End of Section 5
Next Section
bookmark search playlist download
font-size

Change the font size

margin-width

Change margin width

day-mode

Change background colour

Close icon Search
Country selected
Close icon Your notes and bookmarks

Delete Bookmark

Modal Close icon
Are you sure you want to delete it?
Cancel
Yes, Delete