Design Patterns are a popular approach to solving problems in software. Design patterns are an organized way to solve problems in the real world, they can almost be likened to algorithms, their main difference being that design patterns usually scale to different scenarios as they are more reusable than algorithms. Reactive programming is a design pattern that is based on functional programming in which code logic is modeled as a set of operations within a data stream.

Principles of Reactive Programming

According to The Reactive Manifesto, all reactive programs should conform to the following principles:

• Message-driven - Programs should wait for messages as opposed to events to react to them, conversely they should be lying dormant.

• Responsive - If available, your program should respond promptly.

• Resilient - Your program should stand the test of time. In the event of failure, it should remain responsive.

• Elastic - The program should be able to scale efficiently when input size varies. Allocation of more resources when needed is always a good way to achieve this.

Reactive Kotlin Features

Since Kotlin is a functional programming language, there are numerous language features available from the standard library that follow reactive patterns. These include but are not limited to; sequences, channels, flows, etc.

For us to understand the benefits that reactive programming offers, we will review two data structures available in Kotlin; List, and Sequence. Both these data structures can be used as linear collections, however, they have different implementations.

We will only discuss the Sequence data structure in this article, if you have never worked with Kotlin Lists before, you can have a sneak peek here.

Sequences

Unlike regular collections, a Sequence is a data structure that does not contain elements, alternatively, they emit elements while iterating. They may be confused as Kotlin Iterable's but they are distinct in that they implement an approach of multi-staged collection processing. Sequences use a lazy loading strategy to emit data while Iterable's with multiple steps use the eager approach.

Sequences were inspired by Java's Stream API while also providing an intuitive Java 6 backward compatibility which is not supported by Streams that are limited to Java 8. Sequences also offer scalability to different target platforms beyond the JVM. They are also available in Kotlin/Native, Kotlin/JS, and Kotlin/Wasm. Sequences can either have a limited number of items they can emit or an infinite if so desired.

There are three main approaches to creating sequences in Kotlin:

1. generateSequence() function -

   val infinite: Sequence<Long> = generateSequence(0L) { it + 2 } // generate infinite sequence of even numbers

2. asSequence() function can transform any collection into a Sequence. (1..10).asSequence()

3. sequence builder is used to provide advanced logic such as building a Fibonacci sequence.

    val fibonacci = sequence {
        var i = 0
        var j = 1
        yield(i) // show first element of sequence
        yield(j) // show second element of sequence
        while(true){
            yield(i + j) // show consecutive sums
            val tmp = i
            i = j
            j += tmp
        }
    }
   

Performance Benchmark

While performance benchmarks are an intuitive way of comparing the benefits and cons of different tools, they are usually subjective and they should be taken with a grain of salt.

We will compare the absolute time taken to retrieve the square root of the first 10 numbers in a collection of 10 million numbers.

fun sequenceBenchmark(){
    val records = (1..10_000_000).toList() // number of records

    println(" listSquareRoots \n")

    val timeListRoots = measureTimeMillis {
        records.map {
            sqrt(it.toDouble())
        }.take(10).forEach {
            print("$it ")
        }
    }

    println("\n =================================== \n")
    println(" sequenceSquareRoots \n")

    val timeSequenceRoots = measureTimeMillis {
        records.asSequence().map {
            sqrt(it.toDouble())
        }.take(10).forEach {
            print("$it ")
        }
    }

    println("\n =================================== ")
    println("Results:=> list($timeListRoots ms), sequence($timeSequenceRoots ms)")
}

Upon running this benchmark 5 times, we found the following results:

From the above table, you can see that a sequence is at least 32 times faster than a list on average. Even comparing the worst-case scenario of a sequence and the best-case scenario for the list it is still at least 20 times faster. All this is made possible by the reactive principles offered by sequences.

It is important to remember that these are absolute times that have been measured and the results are controlled by other factors outside of time complexity; these include CPU, RAM, and even disk writing rates.

Conclusion

Try applying some reactive concepts to your code to realize the benefits it offers to how well your system can scale as your application grows. As a Kotlin developer concurrency is mainly implemented using reactive principles using structures like Channels and Flows that are found in the standard library as part of Kotlin coroutines. Android's Jetpack Compose toolkit also uses a whole host of reactive principles to manage the state and rendering of the UI.