Book Image

Mastering Kotlin

By : Nate Ebel

Book Image

Mastering Kotlin

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.

Preface

Who this book is for

What this book covers

To get the most out of this book

Free Chapter

Section 1: Kotlin – A Modern Solution to Application Development

Section 1: Kotlin – A Modern Solution to Application Development

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

Further reading

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

Further reading

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

Understanding Programming Paradigms in Kotlin

Understanding Programming Paradigms in Kotlin

Technical requirements

Classifying programming languages

Understanding object-oriented programming

Functional programming

Reactive programming

Further reading

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

Further reading

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

Further reading

Section 3: Play Nice – Integrating Kotlin With Existing Code

Section 3: Play Nice – Integrating Kotlin With Existing Code

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

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?

Further reading

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

Further reading

Baby Steps – Integration through Testing

Baby Steps – Integration through Testing

Technical requirements

Test-first integration

Testing interop

Improved testing with Kotlin

Further reading

Section 4: Go Beyond – Exploring Advanced and Experimental Language Features

Section 4: Go Beyond – Exploring Advanced and Experimental Language Features

Practical Concurrency

Practical Concurrency

Technical requirements

Understanding async patterns

The foundations of coroutines

Coroutines in practice

Further reading

Building Your Own Tools – Domain-Specific Languages (DSLs)

Building Your Own Tools – Domain-Specific Languages (DSLs)

Technical requirements

The building blocks of a DSL in Kotlin

Creating your first Kotlin DSL

Further reading

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

Further reading

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

Kotlin on Android

Kotlin on Android

Technical requirements

First class Kotlin for Android

Hello Android Kotlin

Building with Kotlin

First-party tooling

Further reading

Kotlin and Web Development

Kotlin and Web Development

Technical requirements

Kotlin for the web

Building a Hello Kotlin project

Integrating with existing JavaScript

Further reading

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

Further reading

Taming the Monolith with Microservices

Taming the Monolith with Microservices

Technical requirements

Understanding microservices

Writing microservices with Kotlin

Deploying your first Kotlin microservice

Further reading

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

Further reading

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

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Classifying programming languages

How do you compare programming languages? You might dive right in and examine differences in syntax or idioms. You could compare target platforms or contrast their Hello World implementations. All of these can help paint a picture of how two programming languages might differ.

But these approaches are quite specific, and don't work as well for describing groups of related languages. That is where the concept of programming paradigms becomes quite useful. Programming paradigms provide a means of classifying programming languages by common features or patterns. They provide a broad, high-level classification mechanism with which we can quickly group and compare different programming languages.

Using programming paradigms to classify languages dates back over 40 years. Robert W Floyd is thought to have been the first to use the notion of a...