Kotlin Design Patterns and Best Practices: Build scalable applications using traditional, reactive, and concurrent design patterns in Kotlin, 2nd Edition

Length: 356 pages
Edition: 2
Language: English
Publisher: Packt Publishing
Publication Date: 2022-01-21
ISBN-10: 1801815720
ISBN-13: 9781801815727
Sales Rank: #1075978 (See Top 100 Books)

Improve the scalability and maintainability of your applications by implementing a variety of design patterns using Kotlin

Key Features

Understand traditional and modern design patterns to improve the design of your application
Combine the benefits of object-oriented, functional, reactive, and concurrent programming
Choose the best microservices architecture and frameworks for your web application

Book Description

Design patterns are well-known solutions to common architectural problems as they allow you to solve many problems efficiently and create a shared vocabulary between developers. This book shows you how easy it can be to implement traditional design patterns in the modern multi-paradigm Kotlin programming language, and takes you through the new patterns and paradigms that have emerged.

This second edition is updated to cover the changes introduced from Kotlin 1.2 up to 1.5 and focuses more on the idiomatic usage of coroutines, which have become a stable language feature. You’ll begin by learning about the practical aspects of smarter coding in Kotlin, and will understand basic Kotlin syntax and the impact of design patterns on your code.

The book also provides an in-depth explanation of the classical design patterns, such as Creational, Structural, and Behavioral families, before moving on to functional programming. You’ll go through reactive and concurrent patterns, and finally, get to grips with coroutines and structured concurrency to write performant, extensible, and maintainable code.

By the end of this Kotlin book, you’ll have explored the latest trends in architecture and design patterns for microservices, as well as understanding the tradeoffs when choosing between different architectures.

What you will learn

Implement all the classical design patterns using the Kotlin programming language
Apply reactive and concurrent design patterns to make your application more scalable
Discover best practices in Kotlin and explore its new features
Understand the key principles of functional programming and learn how they apply to Kotlin
Find out how to write idiomatic Kotlin code and learn which patterns to avoid
Harness the power of Kotlin to design concurrent and reliable systems with ease
Create an effective microservice with Kotlin and the Ktor framework

Who this book is for

This book is for developers looking to apply design patterns they’ve learned from other languages in Kotlin to build reliable, scalable, and maintainable applications. Prior programming knowledge is necessary to get started with this book. Experience in Java or design patterns is helpful, but not mandatory.

Kotlin Design Patterns and Best Practices Second Edition
Foreword
Contributors
About the author
About the reviewers
Preface
    Who this book is for
    What this book covers
    To get the most out of this book
    Download the example code files
    Download the color images
    Conventions used
    Get in touch
    Share Your Thoughts
Section 1: Classical Patterns
Chapter 1: Getting Started with Kotlin
    Technical requirements
    Basic language syntax and features
        Multi-paradigm language
    Understanding Kotlin code structure
        Naming conventions
        Packages
        Comments
        Hello Kotlin
    Understanding types
        Basic types
        Type inference
        Values
        Comparison and equality
        Declaring functions
    Null safety
    Reviewing Kotlin data structures
        Lists
        Sets
        Maps
        Mutability
        Alternative implementations for collections
        Arrays
    Control flow
        The if expression
        The when expression
    Working with text
        String interpolation
        Multiline strings
    Loops
        for-each loop
        The for loop
        The while loop
    Classes and inheritance
        Classes
        Interfaces
        Abstract classes
        Visibility modifiers
        Inheritance
        Data classes
    Extension functions
    Introduction to design patterns
        What are design patterns?
        Why use design patterns in Kotlin?
    Summary
    Questions
Chapter 2: Working with Creational Patterns
    Technical requirements
    Singleton
    Factory Method
        Static Factory Method
    Abstract Factory
        Casts
        Subclassing
        Smart casts
        Variable shadowing
        Collection of Factory Methods
    Builder
        Fluent setters
        Default arguments
    Prototype
        Starting from a prototype
    Summary
    Questions
Chapter 3: Understanding Structural Patterns
    Technical requirements
    Decorator
        Enhancing a class
        The Elvis operator
        The inheritance problem
        Operator overloading
        Caveats of the Decorator design pattern
    Adapter
        Adapting existing code
        Adapters in the real world
        Caveats of using adapters
    Bridge
        Bridging changes
        Type aliasing
        Constants
    Composite
        Secondary constructors
        The varargs keyword
        Nesting composites
    Facade
    Flyweight
        Being conservative
        Saving memory
        Caveats of the Flyweight design pattern
    Proxy
        Lazy delegation
    Summary
    Questions
Chapter 4: Getting Familiar with Behavioral Patterns
    Technical requirements
    Strategy
        Fruit arsenal
        Citizen functions
    Iterator
    State
        Fifty shades of State
        State of the nation
    Command
        Undoing commands
    Chain of Responsibility
    Interpreter
        We need to go deeper
        A language of your own
        Call suffix
    Mediator
        The middleman
        Mediator flavors
        Mediator caveats
    Memento
    Visitor
        Writing a crawler
    Template method
    Observer
        Animal choir example
    Summary
    Questions
Section 2: Reactive and Concurrent Patterns
Chapter 5: Introducing Functional Programming
    Technical requirements
    Reasoning behind the functional approach
    Immutability
        Immutable collections
        The problem with shared mutable state
        Tuples
    Functions as values
        Learning about higher-order functions
        Higher-order functions in a standard library
    The it notation
        Closures
        Pure functions
        Currying
        Memoization
    Using expressions instead of statements
        Pattern matching
    Recursion
    Summary
    Questions 
Chapter 6: Threads and Coroutines
    Technical requirements
    Looking deeper into threads
        Thread safety
        Why are threads expensive?
    Introducing coroutines
        Starting coroutines
        Jobs
        Coroutines under the hood
        Setting timeouts
        Dispatchers
        Structured concurrency
    Summary
    Questions
Chapter 7: Controlling the Data Flow
    Technical requirements
    Reactive principles
        Responsive principle
        Resilient principle
        Elastic principle
        Message-driven principle
    Higher-order functions on collections
        Mapping elements
        Filtering elements
        Finding elements
        Executing code for each element
        Summing up elements
        Getting rid of nesting
    Exploring concurrent data structures
        Sequences
        Channels
        Flows
    Summary
    Questions
Chapter 8: Designing for Concurrency
    Technical requirements
    Deferred Value
    Barrier
        Using data classes as barriers
    Scheduler
        Creating your own schedulers
    Pipeline
        Composing a pipeline
    Fan Out
    Fan In
    Racing
        Unbiased select
    Mutex
    Sidekick channel
    Summary
    Questions
Section 3: Practical Application of Design Patterns
Chapter 9: Idioms and Anti-Patterns
    Technical requirements
    Using the scope functions
        Let function
        Apply function
        Also function
        Run function
        With function
    Type checks and casts
    An alternative to the try-with-resources statement
    Inline functions
    Implementing Algebraic Data Types
    Reified generics
    Using constants efficiently
    Constructor overload
    Dealing with nulls
    Making asynchronicity explicit
    Validating input
    Preferring sealed classes over enums
    Summary
    Questions
Chapter 10: Concurrent Microservices with Ktor
    Technical requirements
    Getting started with Ktor
    Routing requests
    Testing the service
    Modularizing the application
    Connecting to a database
    Creating new entities
    Making the tests consistent
    Fetching entities
    Organizing routes in Ktor
    Achieving concurrency in Ktor
    Summary
    Questions
Chapter 11: Reactive Microservices with Vert.x
    Technical requirements
    Getting started with Vert.x
    Routing in Vert.x
    Verticles
    Handling requests
        Subrouting the requests
    Testing Vert.x applications
    Working with databases
        Managing configuration
    Understanding Event Loop
    Communicating with Event Bus
        Sending JSON over Event Bus
    Summary
    Questions
Assessments
    Chapter 1, Getting Started with Kotlin
    Question 1
    Answer
    Question 2
    Answer
    Question 3
    Answer
    Chapter 2, Working with Creational Patterns
    Question 1
    Answer
    Question 2
    Answer
    Question 3
    Answer
    Chapter 3, Understanding Structural Patterns
    Question 1
    Answer
    Question 2
    Answer
    Question 3
    Answer
    Chapter 4, Getting Familiar with Behavioral Patterns
    Question 1
    Answer
    Question 2
    Answer
    Question 3
    Answer
    Chapter 5, Introducing Functional Programming
    Question 1
    Answer
    Question 2
    Answer
    Question 3
    Answer
    Chapter 6, Threads and Coroutines
    Question 1
    Answer
    Question 2
    Answer
    Question 3
    Answer
    Chapter 7, Controlling the Data Flow
    Question 1
    Answer
    Question 2
    Answer
    Question 3
    Answer
    Chapter 8, Designing for Concurrency
    Question 1
    Answer
    Question 2
    Answer
    Question 3
    Answer
    Chapter 9, Idioms and Anti-Patterns
    Question 1
    Answer
    Question 2
    Answer
    Question 3
    Answer
    Chapter 10, Concurrent Microservices with Ktor
    Question 1
    Answer
    Question 2
    Answer
    Question 3
    Answer
    Chapter 11, Reactive Microservices with Vert.x
    Question 1
    Answer
    Question 2
    Answer
    Question 3
    Answer
    Why subscribe?
Other Books You May Enjoy
    Packt is searching for authors like you
    Share Your Thoughts

Functional Java Programming & App Development Programming Languages Software Design Software Design & Engineering Software Development Structured Design Testing & Engineering

Donate to keep this site alive

To access the Link, solve the captcha.

How to download source code?

1. Go to: https://github.com/PacktPublishing

2. In the Find a repository… box, search the book title: Kotlin Design Patterns and Best Practices: Build scalable applications using traditional, reactive, and concurrent design patterns in Kotlin, 2nd Edition, sometime you may not get the results, please search the main title.