Kotlin 2.0 Crash Course: Build, test, and secure Android and web applications including Functional patterns, JSON handling, and RESTful endpoints

Kotlin 2.0 Crash Course

Build, test, and secure Android and web applications including Functional patterns, JSON handling, and RESTful endpoints

Elara Drevyn

Preface

If you're looking to write responsive Android and web applications using Kotlin 2.0, this book's got you covered with some great examples. The book starts by showing you how to install Kotlin 2.0 on Linux and configure IntelliJ IDEA so that your Task Tracker project compiles and runs without hiccups. In the early chapters, you'll dive into the basics of variables, data types, and control structures like if-else, when, while, and do-while. This'll lay a solid foundation of logic, while also giving you hands-on experience storing and manipulating task entries.

There's a chapter on functions that'll teach you to write reusable code, use higher-order functions, and adopt lambda expressions to streamline operations in the project. As you move into object-oriented constructs, you'll learn to define classes, primary and secondary constructors, inheritance, interfaces, and encapsulation practices that keep internal task details safe and modular. Then, we'll dive into collection handling, where we'll use lists, arrays, sets, and maps along with some handy code that'll filter, transform, and iterate through tasks like a pro.

In the state management section, you'll see how immutable snapshots and mutable services work together using observers to sync components in real time. The chapters on functional programming will walk you through chaining, mapping, and flattening data pipelines. This replaces manual loops with concise, expressive code. The error handling and type casting chapters will show you how to catch and log exceptions, apply safe casts, and recover from unexpected conditions without crashing.

If one wants to get really into JSON serialization, it's possible to learn how to parse JSON into Kotlin objects, serialize tasks back into JSON, and use libraries like kotlinx.serialization or Moshi for nested structures. In the RESTful API design segment, you'll learn about resource-oriented endpoints, HTTP methods, versioning, and content negotiation. Finally, Ktor integration teaches you to initialize a coroutine-based server, define routes, install middleware, secure endpoints with authentication, and test your components thoroughly.

This book won't turn you into a Kotlin master overnight, but it'll give you the confidence and hands-on experience you need to build real-world Android and web apps with Kotlin 2.0 right from the start.

In this book we will learn to:

Build strong foundation in Kotlin 2.0 syntax to write clear, concise code.

Absorb strong designing principles including classes, constructors, inheritance, and encapsulation for robust design.

Gain practical mastery in using lists, arrays, sets, and maps to store, filter, and transform the data efficiently.

AStrong hold on coroutine-based state management and observer patterns for responsive, synchronized application behavior.

Develop fluency in functional programming alongwith lambdas to process data pipelines succinctly.

Manage error handling and safe casts, ensuring your application recovers gracefully from runtime issues.

Perform JSON parsing and serialization using kotlinx.serialization, Moshi, and Jackson.

Practical implementation of Ktor’s routing, plugins, middleware, and testing for web server development.

Streamlined testing and debugging workflow, combining in-memory tests, logging, and profiling to catch issues.

Prologue

From the very start of my professional journey, I have been amazed by how rapidly technology advances, and how frequently developers are compelled to master fresh tools without compromising their expertise. The latest version of Kotlin is packed with cutting-edge features, and it's incredible how much progress has been made. Many books on the subject could benefit from a bit of a speed boost. They tend to start off slow, going over basic syntax, and it takes them a while to dive into real-world applications. You're going to love this book! It's a fast-paced journey that covers every essential aspect of Kotlin 2.0. My goal is to present each topic so you can immediately apply it to a working sample project—no waiting until the end to see code come alive!

I built my own tooling and projects using Kotlin, and I saw that practitioners want both conceptual clarity and hands-on implementation without pages of dry theory. In Kotlin 2.0 Crash Course, I speak directly to you, the developer who needs to solve problems today while laying a solid foundation for tomorrow. As you follow along, you'll learn how to install Kotlin on Linux, configure your development environment, and start writing code that compiles without hiccups. I'm thrilled to guide you through the fascinating world of variables, data types, and control structures. I'll use clear examples that immediately demonstrate how Task Tracker stores and manipulates tasks.

Next, I'm thrilled to introduce functions, where you'll discover how to avoid repetitive code by writing reusable helpers, embracing lambdas, and leveraging higher-order patterns. We're thrilled to dive into object-oriented constructs, where you'll witness the incredible power of classes and constructors as they beautifully model real entities. With interfaces and inheritance, we'll explore the amazing way they streamline our work, reducing duplication and enhancing efficiency. I'm thrilled to explain access modifiers and encapsulation so you can maintain strong boundaries between your core logic and external components. I'm thrilled to share the details of collection handling, which showcases the incredible power of lists, arrays, sets, and maps. These essential tools become the foundation for storing, filtering, and traversing data in your applications.

And the best part is that state management receives special attention because real applications must respond to user actions, background processes, and asynchronous events. I'm thrilled to show you how to blend immutable snapshots with mutable references and use observer patterns to keep every component in sync. And then, we'll dive into the exciting world of functional programming with lambdas! You'll learn to chain operations, compose transformations, and write declarative data pipelines that replace boilerplate loops.

There's nothing more critical than handling errors, and I devote a whole chapter to the most effective techniques: try-catch patterns, safe casts, and centralized logging. You'll learn how to catch exceptions early, log them consistently, and recover from failures without crashing. Once we dive into JSON serialization, I'll guide you on how to parse and encode data using Kotlinx.serialization, Moshi, or Jackson, and how to map nested JSON structures into Kotlin types.

After that, I'll guide you through the exciting world of RESTful API design, where I'll reveal how resource-oriented URIs, HTTP methods, and versioning team up to deliver endpoints that you can count on. You'll build incredible endpoints that will allow you to create, read, update, and delete tasks with ease. And you'll learn to integrate with a database via Exposed and H2 — sounds exciting, right? By the time you reach chapter twelve, you'll be ready to dive into the exciting world of Ktor server setup, defining routes, and installing middleware for logging and validation. And of course, you'll be testing every component systematically, ensuring everything is up to par.

With this book, I'm making a single, streamlined path from zero to a production-ready Kotlin application. Prepare to be amazed, because you won't find unrelated detours here! Instead, you'll see an exciting, focused progression of chapters, each building on what came before, all tied to a practical Task Tracker project. I wrote every sentence as if I were sitting beside you, pointing out key details and common pitfalls. By the time you finish, you'll have not only a solid understanding of Kotlin 2.0 but also a real, working web and Android-capable service that you can extend, customize, and deploy!

Copyright © 2025 by GitforGits

All rights reserved. This book is protected under copyright laws and no part of it may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording, or by any information storage and retrieval system, without the prior written permission of the publisher. Any unauthorized reproduction, distribution, or transmission of this work may result in civil and criminal penalties and will be dealt with in the respective jurisdiction at anywhere in India, in accordance with the applicable copyright laws.

Published by: GitforGits

Publisher: Sonal Dhandre

www.gitforgits.com

[email protected]

Printed in India

First Printing: Janurary 2025

Cover Design by: Kitten Publishing

For permission to use material from this book, please contact GitforGits at [email protected].

Content

Preface

GitforGits

Acknowledgement

Chapter 1: Up and Running with Kotlin 2.0

Chapter Overview

Kotlin 2.0 Overview

What makes Kotlin 2.0 Different?

Introducing Task Tracker Sample Project

Installing Kotlin Toolkit and Dependencies

Installing JDK

Managing Kotlin Versions with SDKMAN!

Exploring Environment Variables

Installing IntelliJ IDEA Community Edition via Snap

Configuring IntelliJ

Importing Task Tracker Starter Code

Examining Project Structure

Troubleshooting Common Issues

Configuring IDE

Kotlin Plugin

Gradle Kotlin DSL Support

.editorconfig Support

Arrow Meta

RESTful Toolkit / Swagger UI Integration

Code Quality and Linting Plugins

Detekt

Ktlint

Database and Serialization Helpers

Modern Kotlin Syntax and Enhancements

Context‑Receivers

Value Classes

Enhanced When Expressions

Stronger Exhaustiveness Checking

Pattern‑Based Matching

Refactoring Task Tracker Loop

Contracts and Improved Flow Analysis

What Are Contracts?

Custom Contract in Task Tracker

Sealed Interfaces and Hierarchies

Standard‑Library Extensions

Summary

Chapter 2: Variables, Data Types, and Basic Operations

Chapter Overview

Variable Declarations and Mutability

Understanding ‘val’ and ‘var’

Immutable vs. Mutable Collections

Establishing Task Store

Mutability in Action

Refactoring with Immutable Interfaces

Converting to Value Classes

Primitive and Complex Data Types

Number Types

Characters and String Interplay

Arrays

Lists, Sets, and Maps

Pairs and Triples for Compound Values

Booleans and Logical Operators

Boolean Type and Comparison Operators

Logical Operators

Null‑Safe Boolean Expressions

Boolean Logic in Task Filtering

Boolean Flags

Logical Operator Short‑Circuiting

Composing Complex Conditions

Manipulating Strings and Formatting Data

Summary

Chapter 3: Control Structures and Program Flow

Chapter Overview

If-Else Constructs

Statement vs. Expression Form

Statement Form

Expression Form

Refactoring list

Chaining Conditions with ‘Else‑If’

Nested Logic with Combined Booleans

Early Exit with ‘Elvis’

stats

‘When’ for Conditional Handling

Syntax and Expression Form

Replacing ‘If‑Else’ Chains

‘when’ with Argument for Exact Matching

‘when’ for Type and Range Checks

Sealed Class Commands and Exhaustive ‘when’

Returning Values from ‘when’

Combining Conditions in Single Branch

‘when’ without Else

‘While’ Loops for Repetition

Implementing REPL Loop

Validating Input with Nested ‘While’

Looping Over Task Collections

Responsiveness and Busy‑Waiting

‘Do-While’ Loops for Guaranteed Execution

‘do‑while’ Syntax

Implementing Confirmation Prompts

At Least One Task Display

Combining ‘do‑while’ with Context‑Receivers

Summary

Chapter 4: Functions and Modular Programming Techniques

Chapter Overview

Creating Functions for Reusable Code

Defining and Invoking Simple Functions

Extracting Input Parsing into Functions

Returning Values and Expression‑Body Functions

Functions with Default and Named Parameters

Modularizing Command Handlers

Higher‑Order Functions

Defining Parameters and Return Types

Declaring Parameters

Optional and Named Parameters

Specifying Return Types

Expression‑Body Functions

Unit Return and Side‑Effect Functions

Type Safety in Handlers

Higher‑Order Functions with Typed Parameters

Implementing Higher-Order Functions

Function Types and Syntax

Retry Mechanism with Higher‑Order Functions

Event Hooks and Callbacks

Combining Higher‑Order Functions with Lambdas

Lambda Expressions for Concise Code

Lambda Syntax and Inline Function

Applying Lambdas to Collections

Custom Inline Functions and DSL‑Like

Summary

Chapter 5: Object-Oriented Constructs and Class Design

Chapter Overview

Defining Classes and Initializing Properties

Declaring Kotlin Class with Primary Constructor

‘init’ Block for Validation

Instantiating and Managing Task Objects

Accessing and Modifying Properties

Primary and Secondary Constructors

Defining Secondary Constructor

Using Both Constructors

Chaining Multiple Secondary Constructors

Implementing Inheritance and Interfaces

Defining CommandHandler Interface

Implementing Handlers via Inheritance

Dispatching via Polymorphism

Abstract Base Classes for Shared Logic

Modeling Storage with Interfaces

Enforcing Encapsulation and Data Security

Applying ‘private’ to Guard Internal State

Exposing Read‑Only Views with Map Copies

Using ‘protected’ for Subclass‑Only Methods

Leveraging internal for Module‑Level Hiding

Summary

Chapter 6: Collection Handling and Iteration Patterns

Chapter Overview

Managing Lists and Arrays

MutableList for Dynamic Task Sequences

Arrays for Fixed-Capacity Storage

Lists and Arrays Conversion

Organizing Storage using Sets and Maps

Tracking Unique Descriptions with MutableSet

Key-Value Pairing with MutableMap

Iterating Maps with ‘forEach’

‘mapKeys’ and ‘mapValues’

Handling Missing Keys with ‘getOrDefault’ and ‘getOrPut’

‘For’ Loops for Data Traversal

Iterating over List Collections

Traversing Array Elements by Index and Slot

Numeric Ranges for Fixed Iterations

Conditions within Loops

Filtering and Mapping Data

Filtering Tasks by Conditions

Mapping Tasks to New Forms

Combining Filter and Map in Pipelines

Advanced Grouping and Flat-Mapping

Summary

Chapter 7: Managing Application State and Behavior

Chapter Overview

Understanding Mutable and Immutable States

Immutable State with Data Classes and Snapshots

Mutable State with Explicit Constructs

Blending Immutable and Mutable Approaches

Propagating State across Application Components

Defining Observer Contract

Registering Observers

Notifying Observers on State Changes

Building CLI Observer for Real-Time Display

Logging Observer for Audit Trails