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

## Event Loop design pattern
The goal of the **Event Loop** design pattern is to continuously check for new events in a queue, and each time a new event comes in, to quickly dispatch it to someone who knows how to handle it. This way, a single thread or a very limited number of threads can handle a huge number of events.

In the case of web frameworks such as Vert.x, events may be requests to our server.

To understand the concept of the Event Loop better, let's go back to our server code in the `App.kt` file and attempt to implement an endpoint for deleting a cat:

```
val db = Db.connect(vertx)
router.delete("/:id").handler { ctx ->
    val id = ctx.request().getParam("id").toInt()
    db.preparedQuery("DELETE FROM cats WHERE ID = $1")
        .execute(Tuple.of(id)).await()
    ctx.end()
}
```
This code is very similar to what we've written in our tests in the previous section. We read the URL parameter from the request using the `getParam()` function, then we pass this ID to the prepared query. This time, though, we can't use the `runBlocking()` adapter function, because it will block the Event Loop.

## Using coroutines in Vert.x

Vert.x uses a limited number of threads, as many as twice the number of your CPU cores, to run all its code efficiently. However, this means that we cannot execute any blocking operations on those threads because it will negatively impact the performance of our application.

To solve this issue, we can use a coroutine builder we're already familiar with---`launch()`. Let's see how this works:

```
router.delete("/:id").handler { ctx ->
    launch {
       val id = ctx.request().getParam("id").toInt()
       db.preparedQuery("DELETE FROM cats WHERE ID = $1")
          .execute(Tuple.of(id)).await()
       ctx.end()
    }
}
```

Since our verticle extends `CoroutineVerticle`, we have access to all the regular coroutine builders that will run on the Event Loop.

Now, all we need to do is mark our routing functions with the `suspend` keyword:
```
private suspend fun router(): Router {
     ...
}
private suspend fun catsRouter(): Router {
    ...
}
```

Now, let's add another test for updating a cat:

```
@Test
fun `put updates a cat by ID`() {
    runBlocking {
        val catId = catRow.getInteger(0)
        val requestBody = json {
           obj("name" to "Meatloaf", "age" to 4)
        }
        client.put("/cats/${catId}")
             .sendBuffer(Buffer.buffer(requestBody.toString()))
             .await()

        val result = db.preparedQuery("SELECT * FROM cats
            WHERE id = $1")
            .execute(Tuple.of(catId)).await()

        assertEquals("Meatloaf", result.first().getString("name"))
        assertEquals(4, result.first().getInteger("age"))
    }
}
```

This test is very similar to the deletion test, with the only major difference being that we use `sendBuffer()` and not the `send()` method, so we can send a JSON body to our put endpoint.


We create the JSON similarly to what we saw when we implemented the `/status` endpoint earlier in this project.

## Implementing endpoints for deleting and updating a cat

Now, let's implement the `put` endpoint for the test to pass:

```
router.put("/:id").handler { ctx ->
      launch {
          val id = ctx.request().getParam("id").toInt()
          val body = ctx.bodyAsJson
          db.preparedQuery("UPDATE cats SET name = $1, age = $2 WHERE ID = $3")
             .execute(
                 Tuple.of(
                     body.getString("name"),
                     body.getInteger("age"),
                     id
                 )
             ).await()
          ctx.end()
      }
}
```

Here, the main difference from the previous endpoint we've implemented is that this time, we need to parse our request `body`. We can do that by using the `bodyAsJson` property. Then, we can use the `getString` and `getInteger` methods, which are available in JSON, to get the new values for `name` and `age`.



Learn how to handle a huge number of events using the Event Loop design pattern.

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

Understanding Event Loop

Event Loop design pattern