Kotlin 2.0 Crash Course. Build, test, and secure Android and web applications including Functional patterns, JSON handling, and… (Elara Drevyn) (z-library.sk, 1lib.sk, z-lib.sk)

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 support@gitforgits.com Printed in India First Printing: Janurary 2025 Cover Design by: Kitten Publishing For permission to use material from this book, please contact GitforGits at support@gitforgits.com.

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 Background Reminder Observer State-Based Logic for Operational Control Modeling Operational Modes with Sealed Classes Guarding Handlers with State Checks Toggling Modes via Commands Combining Feature Flags and State Checks Centralizing Preconditions in Helper Dynamic UI Prompts Based on State Summary Chapter 8: Functional Programming with Lambdas Chapter Overview Lambda Syntax and Structure Basic Lambda Syntax

Omitting Parentheses for Trailing Lambdas Inline Lambdas and Performance Benefits Destructuring Lambdas for Clarity Quick Hands-On with Lambdas Filtering and Mapping in One Line Sorting with Lambdas Inline Callbacks for Event Handling Collection Manipulation using Lambdas Integrating Inline Functions with Lambdas Filtering Tasks with Lambdas Mapping and Transforming Collections Reducing and Aggregating with Lambdas Crafting Pipelines for Batch Operations Function Chaining and Composition Techniques Building a Simple Pipeline Composing Custom Transformations Flattening Nested Structures with ‘flatMap’ Injecting Side-Effects with ‘onEach’ Combining Multiple Pipelines Parallelizing Pipelines Safely Safe Composition with Null-Aware Functions Optimizing Event Handling Registering Lambda-Based Observers Asynchronous Updates with Lambdas and Flows Integrating Lambdas in Reminder System Composing Event-Driven Pipelines Summary Chapter 9: Error Handling and Type Casting Chapter Overview Exception Management with ‘Try-Catch’ ‘try-catch’ Syntax and Flow Handling User Input Safely Protecting File I/O and JSON Serialization

Using ‘finally’ for Resource Cleanup Catching Multiple Exception Types Utilizing Safe Cast Operators Applying Safe Casts to User Input Parsing Safe Casting in Collection and JSON Centralized Error Logging and Recovery Designing Central Error Logger Wrapping Risky Operations Integrating with Command Dispatch Recovery Strategies Alerting Observers on Fatal Errors Harmonizing Logs with Monitoring Tools Summary Chapter 10: Handling JSON and Data Serialization Chapter Overview Parsing JSON JSON Strings into Objects Serializing Kotlin Objects into JSON Format Encoding Objects with ‘kotlinx.serialization’ Writing JSON to Disk and External Endpoints Integrating Default and Custom Serializers Using Serialization Libraries Integrating Moshi Configuring Jackson with Kotlin Module Selecting and Benchmarking Serializer Managing Complex JSON Structures Defining Nested Data Classes Parsing Nested Structure into Domain Models Handling Dynamic Structures Custom Serializers Validating Nested Data at Runtime Summary

Chapter 11: Designing RESTful APIs Chapter Overview RESTful API Overview HTTP Methods for CRUD Designing Consistent URI Structures and Versioning Handling Representations and Content Negotiation Status Codes and Error Responses Enabling Filtering, Pagination, and Sorting Designing Endpoint and Route Mapping Defining Resource Routes Extracting Path and Query Parameters Handling Request Bodies Organizing Routes into Feature Modules Applying Consistent Error and Response Model Integrating Database Operations into APIs Adding Exposed and H2 Dependencies Defining Tasks Table and Entity Initializing Database Connection Implementing CRUD in Service Layer Wiring Repository into Ktor Routes Endpoint Security and API Communication Securing Access Encrypting Traffic with HTTPS and TLS Validating and Sanitizing Input Rate Limiting and Throttling Configuring CORS and CSRF Protections Logging, Monitoring, and Auditing Calls Summary Chapter 12: Building Web Server with Ktor Chapter Overview Initializing Ktor Project Configuring Build with Ktor and Serialization Plugins Generating Project Skeleton

Defining Application Entry Point and JSON Support Writing Initial Tests Defining Routing and HTTP Handlers Wiring TaskService into Ktor Organizing Routes in Feature Functions Implementing GET /tasks and GET /tasks/{id} Handling POST /tasks to Create Task Implementing PUT /tasks/{id} for Full Replacement Implementing PATCH /tasks/{id} for Partial Updates Handling DELETE /tasks/{id} Grouping and Versioning Routes Incorporating Middleware and Essential Plugins JSON Serialization via Content Negotiation Capturing Traffic with Call Logging Validating Requests with Interceptor Plugin Combining Plugins for Robust Operation Testing and Debugging Ktor Components Unit Testing with TestApplication and TestClient Integration Testing with Test Databases Debugging with Logging and Breakpoints Verifying Middleware Order and Plugin Effects Performance Profiling and Stress Testing Manual Testing with cURL and Postman Collections Summary Index

GitforGits Prerequisites This book is a fast-paced practical learning for developers, programmers, application engineers who demands a fast learning and that too practical touchbase to every aspect of Kotlin that can be put into use. Prior knowledge of object oriented programming is all you need to begin with this book. Codes Usage Are we in need of some helpful code examples to assist we in our programming and documentation? Look no further! Our book offers a wealth of supplemental material, including code examples and exercises. Not only is this book here to aid we in getting our job done, but we have our permission to use the example code in our programs and documentation. However, please note that if we are reproducing a significant portion of the code, we do require we to contact us for permission. But don't worry, using several chunks of code from this book in our program or answering a question by citing our book and quoting example code does not require permission. But if we do choose to give credit, an attribution typically includes the title, author, publisher, and ISBN. For example, "Kotlin 2.0 Crash Course by Elara Drevyn". If we are unsure whether our intended use of the code examples falls under fair use or the permissions outlined above, please do not hesitate to reach out to us at support@gitforgits.com.  We are happy to assist and clarify any concerns.

CHAPTER 1: UP AND RUNNING WITH KOTLIN 2.0

Chapter Overview We'll start by taking a look at why Kotlin 2.0 has become so important in modern development. First, we will start with its roots at JetBrains, then see how it made its way into Android, and finally, how big companies like Pinterest and Uber used it to great success. Then, we will see how features like null-safety, coroutines, and concise syntax really shine in the real world. We then get our Linux workstation ready for Kotlin development, starting with installing the OpenJDK `17, set up SDKMAN to handle the Kotlin `2.0.20 compiler, and then making sure our environment can reliably compile and run Kotlin code. Once you've set up the environment, we will need to configure IntelliJ IDEA Community Edition as our main development hub. We will be integrating essential plugins like Gradle Kotlin DSL support for building scripts, EditorConfig for consistent styling, Detekt and Ktlint for static analysis and formatting, and optional tools like Arrow Meta and Swagger/OpenAPI for advanced metaprogramming and API documentation. For each plugin installation, we'll walk we through the process step-by-step, and we will get to confirm that everything's working by importing and running the TaskTracker starter project. After all the necessary tools in place, we will dive into Kotlin 2.0's modern syntax enhancements. We will apply context-receivers to get rid of repetitive parameters, define value classes to model domain types without runtime cost, and refactor our REPL loop to use sealed interfaces and exhaustive when-expressions. We will use contracts to improve flow analysis and adopt new standard library extensions for collection transformations. Throughout, we will be refactoring the Task Tracker code base as it happens, and we will see how each improvement makes the code cleaner, safer, and easier to maintain.