Hands-On Design Patterns with Kotlin · Build scalable applications using traditional, reactive, and concurrent design patterns in Kotlin by Soshin, Alexey -- Read -- Imperial Library of Trantor

Index

Title Page Copyright and Credits

Hands-On Design Patterns with Kotlin 

Dedication Packt Upsell

Why subscribe? PacktPub.com

Contributors

About the author About the reviewers Packt is searching for authors like you

Preface

Who this book is for What this book covers To get the most out of this book

Download the example code files Conventions used

Get in touch

Reviews

Getting Started with Kotlin

Basic language syntax and features

Multi-paradigm Code structure

No semicolons Naming conventions Packages

Types

Type inference val versus var Comparison Null safety

Declaring functions Control flow

Using the if expression Using the when expression

String interpolation Classes and inheritance

Classes Inheritance Constructors

Properties Data classes More control flow – loops

The for loop For-each loop While loop

Extension functions

Introduction to design patterns

What are design patterns?

Design patterns in real life Design process

Why use design patterns in Kotlin?

Summary

Working with Creational Patterns

Singleton Factory Method

Factory Static Factory Method

Advantages of the Static Factory Method

Caching Subclassing

Static Factory Method in Kotlin

Companion object

Abstract Factory

Abstract Factory in action

Introduction to generics in Kotlin Back to our bases Making improvements

Builder

Composing an email

Collection types in Kotlin Creating an email – first attempt Creating an email – second attempt Creating an email – the Kotlin way Creating an email – the Kotlin way – second attempt

Prototype

Building your own PC

Starting from a prototype

Summary

Understanding Structural Patterns

Decorator

Enhancing a class

Operator overloading

Dude, where's my map? The great combinator

Caveats

Adapter

Different adapters Adapters in the real world

Caveats of using adapters

Bridge

Bridging changes

Type aliases You're in the army now Constants A lethal weapon

Composite

Get together The Squad

Varargs and secondary constructors

Counting bullets

Facade

Keep it simple

Flyweight

Being conservative Saving memory

Proxy

A short detour into the RMI world A replacement

Lazy delegation

Summary

Getting Familiar with Behavioral Patterns

Strategy

Fruit arsenal Citizen function Switching sides

Iterator

One, two... many Running through the values

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

Taking a break

Call suffix

Mediator

Trouble in the Jungle The middleman

Flavors Caveats

Memento

Remembrance

Visitor

Writing a crawler

Template method Observer 

Animal Choir

Summary

Functional Programming

Why functional programming? Immutability

Tuples Value mutation Immutable collections

Functions as values

Higher-order functions Pure functions Currying Memoization

Expressions, not statements

Pattern matching

Recursion Summary

Streaming Your Data

The it notation The map() function Filter family Find family Drop family Sort family ForEach Join family Fold/Reduce Flat family Slice Chunked Zip/Unzip Streams are lazy, collections are not Sequences Summary

Staying Reactive

Reactive principles

Responsiveness Resiliency Elasticity Message-driven

Reactive extension

Hot Observable Multicast Subject

ReplaySubject BehaviorSubject AsyncSubject SerializedSubject

Flowables

Holding state

FlowableProcessor Batching Throttling

Summary

Threads and Coroutines

Threads

Thread safety Threads are expensive

Coroutines

Starting coroutines Jobs Coroutine starvation Coroutines under the hood Fixing starvation Waiting for a coroutine Canceling a coroutine Returning results Setting timeouts Parent jobs Channels Producers Actors

Summary

Designed for Concurrency

Active Object

Testing

Deferred value Barrier

CountDownLatch Data class as Barrier

Scheduler

Understanding contexts

Pipelines

Establishing a pipeline

The fan-out design pattern The fan-in design pattern

Managing workers

Buffered channels Unbiased select Mutexes Selecting on close Sidekick channel Deferred channel Summary

Idioms and Anti-Patterns

Let Apply Also Run With Instance checks Try-with-resources Inline functions Reified Constants Constructor overload Dealing with nulls Explicit async Validation Sealed, not enumerated More companions Scala functions Summary

Reactive Microservices with Kotlin

Getting started with Vert.x

Routing

Handling requests

Verticles Subrouting

Testing

Helper methods

Working with databases

Managing configuration Managing the database

EventBus

Consumer Producer More testing

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think

← Prev
Back
Next →

← Prev
Back
Next →