Gain insights into Kotlin language essentials and delve into design patterns and best practices. Discover functional programming techniques to enhance code reuse, robustness, and build reliable, scalable projects.

Packt MBE - Kotlin Design Patterns and Best Practices.png

Kotlin_optimized.tar.gz

Kotlin

Kotlin_Co

Kotlin_SPA

Cats_Hostel

Cats_Shelter(1..5)

Cats_Shelter(6-7-8)

Design patterns enable developers to speed up the development process by providing proven development paradigms. Reusing design patterns helps prevent complex issues that can cause major problems. Moreover, it improves your codebase, promotes code reuse, and makes an architecture more robust.

In this course, you will start with a gentle introduction of the Kotlin language. You will explore design patterns that are part of the best practices that help developers use Kotlin efficiently. Design patterns appeared in the era of object-oriented languages such as C++ and Java. You will learn the language features that Kotlin provides, which allow developers to program in a functional style and implement the design patterns.

After taking this course, you’ll be able to take your knowledge of Kotlin, design patterns, and associated best practices to the software industry and apply it to build reliable, scalable, and maintainable projects.

Kotlin Design Patterns and Best Practices

The two most essential concurrent data structures are _channels_ and _flows_. However, before we can discuss them, we need to look at another data structure: **sequences**. While this data structure is not concurrent itself, it will provide us with a bridge into the concurrent world.

## Sequences

Higher-order functions on collections existed in many functional programming languages for a long time. But for Java developers, the higher-order functions for collections first appeared in Java 8 with the introduction of the Stream API.



Despite providing developers with valuable functions such as `map()` and `filter()`, there were two major drawbacks to the Stream API. First, in order to use these functions, we had to migrate to Java 8. And second,
our collection had to be converted to something called a stream, which had all of the functions defined on it. If we want to return a collection again after mapping and filtering our stream, we can collect it back.

Explore different data structures in Kotlin and how sequences are the solution to avoid clashing.

Getting Started with Kotlin

Working with Creational Patterns

Understanding Structural Patterns

Getting Familiar with Behavioral Patterns

Introducing Functional Programming

Threads and Coroutines

Controlling the Data Flow

Designing for Concurrency

Idioms and Anti-Patterns

Concurrent Microservices with Ktor

Reactive Microservices with Vert.x

Conclusion

Exploring Concurrent Data Structures

Sequences