Mastering Kotlin - What's Inside My Book?

I wrote a book about Kotlin.

Mastering Kotlin: Learn advanced Kotlin programming techniques to build apps for Android, iOS, and the web

But, Kotlin is a large topic. So what exactly does this book cover?

Is it for beginners?

Is it for experts?

Does it each you how to build Android apps with Kotlin?

In this post, I want to answer some of these questions by telling you what the book is about, what I think makes it unique, and finally by giving a quick, chapter by chapter, review of what’s actually inside.

What is the goal of Mastering Kotlin?

Mastering Kotlin is aimed at helping developers become proficient with the Kotlin programming language. This proficiency comes from two sources;

1. Reading through the text and examples in the book
2. Hands-on experience with the sample code available via GitHub

Throughout the book, readers will learn to leverage Kotlin language features to start solving practical problems.

Who is Mastering Kotlin for?

The audience for Mastering Kotlin is primarily split into two groups:

1. Beginner and intermediate Kotlin developers looking to move beyond language syntax and start using Kotlin in practical applications
2. Experienced Java developers that want to apply existing expertise towards development with Kotlin

The book does assume familiarity with basic programming fundamentals and with concepts like object oriented programming. However, examples are built up to slowly, to help guide the reader without presenting too much information all at once.

Is Mastering Kotlin the right book for you?

That’s difficult to say definitively as it depends on your needs and motivations. Here are a few questions that might help guide your answer:

• Do you want to learn a modern programming language that can be used across multiple domains?
• Do you want to learn how to apply object-oriented, functional, and reactive programming patterns to your Kotlin codebase?
• Do you want to write more Kotlin-idiomatic code?
• Are you curious and how and where Kotlin can be used for modern application development?

If you answered yes to one, or more, of these questions, Mastering Kotlin can likely help you in your learning path.

What will readers gain from Mastering Kotlin?

The book was written with five high-level outcomes in mind:

1. Understand the history of the language, why it’s popular, and what features help it stand out.
2. Learn to apply and express common programming patterns and constructs using Kotlin syntax and conventions.
3. Explore the integration of Kotlin with existing Java codebases to provide a seamless interop and developer experience.
4. Discover advanced language features such as coroutines and custom DSLs.
5. Build several starter applications to understand how Kotlin can be used in different types of applications.

How is Mastering Kotlin structured?

The book is broken up into five parts; each with a specific focus:

1. Kotlin: A Modern Solution to Application Development
2. Putting the Pieces Together: Modeling Data, Managing State, and Application Architecture
3. Play Nice: Integrating With Existing Code
4. Go Beyond: Exploring Advanced and Experimental Language Features
5. The Wide World of Kotlin: Using Kotlin Across the Entire Development Stack

The overall flow of the book is meant to go from basics/theory to advanced/practical usages. It starts with why Kotlin was created and the motivations that are behind it. The book then moves on to building up the readers’ understanding of the language and and how to apply common software engineering concepts to Kotlin.

Next, the book focuses on the Kotlin & Java interop experience and how to integrate Kotlin into an existing project. The book then jumps between some of the more advanced and/or experimental language features such as custom DSLs and coroutines to help give readers a sense for where the language is going.

And finally, Mastering Kotlin demonstrates to readers how to practically start using Kotlin to build several different types of projects including an Android app, a very basic webpage, a simple backend server, and a Kotlin Multiplatform project.

Part 1 – Kotlin: A Modern Solution to Application Development

Kotlin is a modern language for modern day application development. It builds upon decades of experience with Java, and modern influences, to provide a programming experience that is powerful, flexible, and delightful. In this part, you’ll learn about the Kotlin programming language, its goals, its features, and why it’s one of the fastest growing programming languages in the world.

Chapter 1 – A New Challenger Approaches

This chapter will provide the context for what Kotlin is, how it came about, and why it is gaining popularity. It will provide a high-level overview of where the book is headed and lay the foundations for following chapters’ focus on language features, patterns, best practices, and the ability to target multiple domains and platforms.

Chapter 2 – Programmer’s Multi-Tool: Flexible, Expressive, Concise

This chapter will dive into the basic details of the language. It will build a foundation upon which the rest of the book can build. It will highlight some of the most popular language features such as first-class functions, non-null types, and multiple programming paradigms. For each of these features, the reader will begin to understand how to take advantage of the feature, and what impact it can have on the overall application architecture.

Part 2 – Putting the Pieces Together: Modeling Data, Managing State, and Application Architecture

This chapter will dive into the basic details of the language. It will build a foundation upon which the rest of the book can build. It will highlight some of the most popular language features such as first-class functions, non-null types, and multiple programming paradigms. For each of these features, the reader will begin to understand how to take advantage of the feature, and what impact it can have on the overall application architecture.

Chapter 3 – Understanding Programming Paradigms In Kotlin

A detailed overview and explanation of the differences in each programming paradigm and how Kotlin supports, but does not enforce, all three.

Chapter 4 – First Class Functions

The chapter will introduce the reader to Kotlin’s support for first-class functions. It will describe, in detail, how Kotlin functions are flexible, concise, and powerful. They will learn how to leverage Kotlin features such as default parameter values, infix functions, extension functions and higher-order functions.

Chapter 5 – Modeling Real-World Data

This chapter will expose the reader to the fundamentals of inheritance and composition in Kotlin. They will learn the differences between Enums, Data Classes, Sealed and Type classes and understand when and why to choose one over the other.

Part 3 – Play Nice: Integrating With Existing Code

Kotlin’s ability to cleanly integrate with Java is one of it’s biggest features. The possible or perceived challenges to this integration is also a potential blocker to teams incorporating Kotlin into their codebases. This section will dive into the Java/Kotlin interop story, detail how interoperability is achieved, how it can be customized to suit your needs, and how to begin integrating Kotlin into an existing codebase.

Chapter 6 – Interoperability As A Design Goal

This chapter will provide background as to the design goals behind interoperability in Kotlin and teach the user how to quickly add Kotlin to an existing project.

Chapter 7 – Crossing Over: Working Across Java and Kotlin

This chapter will explore the practical ramifications of adding Kotlin to an existing Java codebase. It will detail how to work with each language from the other, and about some of the challenges associated with adding a second language to a project.

Chapter 8 – Controlling the Story

While Kotlin/Java interop works will out of the box, the experience can be controlled and modified to suit the needs of each individual project. This chapter will detail how Kotlin code can be modified to provide a better interop experience with Java.

Chapter 9 – Baby Steps: Integration Through Testing

This chapter will explore how to integrate Kotlin into an existing project through testing, and will show the reader how the testing experience can be improved using Kotlin and available tooling.

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

This part will explore advanced Kotlin features and concepts which are applicable over multiple domains.

Chapter 10 – Practical Concurrency

This chapter will introduce the reader to advanced threading concepts by starting from basic Threads and working up to the newly released Coroutines.

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

This chapter will introduce the reader to the concept of custom DSLs written in Kotlin and how they can be used as a powerful tool to solve a variety of challenges. We walk through how to build up the common HTML example DSL, and then build our own simple DSL for a pizza delivery system.

Chapter 12 – Fully Functional: Embracing Functional Programming

This chapter will provide the reader with a deep dive into achieving functional programming with Kotlin; using both the Kotlin Standard Library and Arrow.

Part 5 – The Wide World of Kotlin: Using Kotlin Across the Entire Development Stack

This part will explore the different domains in which Kotlin can be applied. It will serve to expose the reader to how they can start using Kotlin within each domain, and help them understand why Kotlin is a viable approach.

Chapter 13 – Kotlin on Android

This chapter will explore Kotlin for Android. It will detail why Kotlin is so popular for Android development, how it makes developers’ lives easier, and what Kotlin tooling is available.

Chapter 14 – Kotlin and Web Development

This chapter will explore the use of Kotlin for front-end web development. It will help the user understand where Kotlin can be used, how to get started, and where the limitations are.

Chapter 15 – Introducing Multiplatform Kotlin

This chapter will explore the use of Kotlin for multi-platform projects. It will describe how the Kotlin multi-platform approach is different than other cross-platform solutions, how to package and write code that targets multiple platforms, and where the current limitations exist.

Chapter 16 – Taming the Monolith With Microservices

This chapter will explore the use of Kotlin for backend services. It will describe how and where Kotlin can be used to write backend services and how those can interoperate with other services.

Chapter 17 – Practical Design Patterns

In this chapter, the reader will revisit familiar Java patterns and learn how to reimagine those patterns using what they’ve learned from the previous chapters in this part. We will take an in-depth look at design patterns. We will also take a look at some some of the major design patterns like Factory Method, Bridge, Builder, Strategy and Singleton patterns.

Mastering Kotlin

I hope that this post has helped give you a better understanding of what’s been covered in Mastering Kotlin, and whether it might be a good resource for you.

It’s currently available in several forms:

• Amazon Paperback
• Amazon Kindle
• Packt e-book and/or Paperback

I’d love for you to check out the book, and to let me know what you think.

Love it?

Hate it?

Did you learn something new?

If you have more questions about the book, Kotlin, or anything else please feel free to reach out!