What this book covers

Chapter 1, Identifying Performance Bottlenecks, covers the reasons for performance issues and how they can impact the user experience and performance of the whole software product. It is an overview of the issues this book aims to resolve, and prepares the reader for the details of these issues in subsequent chapters.

Chapter 2, Identifying Performance Issues, presents performance as one of the leading challenges you will encounter while building any software application. Response speed is one of the critical criteria to analyze performance issues, and it closely correlates with the success of that software in the market. We can use different parameters to identify problems depending on the architecture and what technology is used in the implementation.

Chapter 3, Learn How to Use Profiling Tools, introduces various techniques of troubleshooting application code. We will look at the different profiling tools that measure space of memory, the frequency and duration of function calls, and which software is included in the IntelliJ IDEA platform for this purpose.

Chapter 4, Functional Approach, introduces the functional features of Kotlin. A significant one is the lambda expression, since it allows us to write functions in a much simpler way. We will figure out the bytecode of lambda and the equivalent code in Java to get an understanding of how to use it with minimal overhead.

Chapter 5, Enhancing the Performance of Collections, covers topics related to collections, including their innerworkings and performance enhancements. We will look at the Iterator pattern and its pros and cons.

Chapter 6, Optimizing Access to Properties, covers topics that relate to fields and properties. Virtual method calls are expensive, much more so than instance field lookups. In this chapter, readers will learn how to write the code in such a way as to avoid generation getters and setters in bytecode.

Chapter 7, Preventing Unnecessary Overhead using Delegated Properties, introduces a powerful mechanism that allows us to reduce the amount of code and separate the logic of an application. But we should remember that we have the same bytecode as Java under the hood, and it can be the reason for creating extra objects.

Chapter 8, Ranges and Identifying Performance Issues, introduces ranges in Kotlin that service to represent a sequence of values. This chapter covers some performance issues that can occur while you are working on this feature.

Chapter 9, Multithreading and Reactive Programming, covers basic coroutine-related topics, including concurrency and parallelism. It shows how to invoke long-term operations sequentially in order to avoid Callback hell.

Chapter 10, Best Practices, summarizes the book and contains general tips on how to avoid performance issues in an Android application. Readers will be given general rules that will help them avoid performance issues.