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

Sequential, parallel, concurrent, asynchronous


Responsive, resilient, elastic, message-driven


What are the fundamental principles of reactive programming, according to _The Reactive Manifesto_?

What are the fundamental principles of reactive programming, according to The Reactive Manifesto?

It returns a new collection with elements that don't match the criteria.


It modifies the existing collection and removes elements that don't match the criteria.


 It returns a new collection with elements that match the criteria.


It modifies the existing collection and adds elements that match the criteria.


Which of the following statements is true about filtering elements using the `filter()` function in Kotlin?


Which of the following statements is true about filtering elements using the <code>filter()</code> function in Kotlin?

What is the output of the code snippet? 

```
 fun main() {
    val list = listOf(1, 2, 3, 4, 5)
    val result = list.reduce { 
        acc, i -> acc * i 
     }
    println(result)
}
```




What is the output of the code snippet?
<pre><code> fun main() {
 val list = listOf(1, 2, 3, 4, 5)
 val result = list.reduce { 
 acc, i -&gt; acc * i 
 }
 println(result)
}
</code></pre>

```
val doubledList = myList.map { it * 2 }
```

```
val doubledList = myList.map { it + it }
```


```
val doubledList = myList.map { it / 2 }
```


```
val doubledList = myList.map { it * it }
```


Which of the following pieces of code using the `map()` function will correctly double all the elements in the list?


Which of the following pieces of code using the <code>map()</code> function will correctly double all the elements in the list?

What is the output of the following code?
```
fun main() {
    val l = (1..10).toList()

    l.filter { it % 2 == 0 }
        .also { println(it) }
        .map { it * it }
}
```

What is the output of the following code?
<pre><code>fun main() {
 val l = (1..10).toList()

 l.filter { it % 2 == 0 }
 .also { println(it) }
 .map { it * it }
}
</code></pre>

Practice your learning outcomes and test your understanding of the material presented in this chapter by taking this quiz.

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

Quiz on Controlling the Data Flow