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

Cover
Title page
Copyright and Credits
Dedications
Foreword
Contributors
Table of Contents
Preface
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
Index
About Packt
Other Books You May Enjoy