Book Image

Hands-On Design Patterns with Kotlin

By : Alexey Soshin

Book Image

Hands-On Design Patterns with Kotlin

By: Alexey Soshin

Overview of this book

Design patterns enable you as a developer to speed up the development process by providing you with proven development paradigms. Reusing design patterns helps prevent complex issues that can cause major problems, improves your code base, promotes code reuse, and makes an architecture more robust. The mission of this book is to ease the adoption of design patterns in Kotlin and provide good practices for programmers. The book begins by showing you the practical aspects of smarter coding in Kotlin, explaining the basic Kotlin syntax and the impact of design patterns. From there, the book provides an in-depth explanation of the classical design patterns of creational, structural, and behavioral families, before heading into functional programming. It then takes you through reactive and concurrent patterns, teaching you about using streams, threads, and coroutines to write better code along the way By the end of the book, you will be able to efficiently address common problems faced while developing applications and be comfortable working on scalable and maintainable projects of any size.

Preface

Who this book is for

What this book covers

To get the most out of this book

Free Chapter

Getting Started with Kotlin

Getting Started with Kotlin

Basic language syntax and features

Introduction to design patterns

Working with Creational Patterns

Working with Creational Patterns

Abstract Factory

Understanding Structural Patterns

Understanding Structural Patterns

Getting Familiar with Behavioral Patterns

Getting Familiar with Behavioral Patterns

Chain of responsibility

Template method

Functional Programming

Functional Programming

Why functional programming?

Functions as values

Expressions, not statements

Streaming Your Data

Streaming Your Data

The it notation

The map() function

Streams are lazy, collections are not

Staying Reactive

Staying Reactive

Reactive principles

Reactive extension

Threads and Coroutines

Threads and Coroutines

Designed for Concurrency

Designed for Concurrency

The fan-out design pattern

The fan-in design pattern

Buffered channels

Unbiased select

Selecting on close

Sidekick channel

Deferred channel

Idioms and Anti-Patterns

Idioms and Anti-Patterns

Instance checks

Try-with-resources

Inline functions

Constructor overload

Dealing with nulls

Sealed, not enumerated

More companions

Scala functions

Reactive Microservices with Kotlin

Reactive Microservices with Kotlin

Getting started with Vert.x

Handling requests

Working with databases

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Flyweight

Flyweight is an object without any state. The name comes from being very light.

If you've been reading either one of the two previous chapters, you may already think of a type of object that should be very light: a data class. But a data class is all about state. So, is it related to the Flyweight design pattern at all?

To understand this pattern better, we need to jump back in time some twenty years.

Back in '94, when the original Design Patterns book was published, your regular PC had 4 MB of RAM. One of the main goals was to save that precious RAM because you could fit only so much into it.

Nowadays, some cell phones have 4 GB of RAM. Bear that fact in mind when we discuss what the Flyweight design pattern is all about.

Being conservative

...