Lesson 5
Backward Compatibility in Practice with Kotlin
Backward Compatibility: Practice

Welcome back! Today, we'll master what we learned about backward compatibility in practice. Prepare to apply all the knowledge to practical tasks, but first, let's look at two examples and analyze them.

Task 1: Enhancing a Complex Data Processing Function with Function Overloading

Let's say that initially, we have a complex data processing class designed to operate on a list of maps, applying a transformation that converts all string values within the maps to uppercase. Here's the initial version:

Kotlin
1class DataProcessor {
2    fun processData(items: List<Map<String, Any>>) {
3        val processedItems = items.map { item ->
4            item.mapValues { entry ->
5                if (entry.value is String) {
6                    (entry.value as String).uppercase()
7                } else {
8                    entry.value
9                }
10            }
11        }
12        processedItems.take(3).forEach { println("Processed Item: $it") }
13    }
14}

We intend to expand this functionality, adding capabilities to filter the items based on a condition and to allow for custom transformations. The aim is to retain backward compatibility while introducing these enhancements. Here's the updated approach using function overloading:

Kotlin
1class DataProcessor {
2    fun processData(items: List<Map<String, Any>>) {
3        processData(items, { true }, null)
4    }
5
6    fun processData(items: List<Map<String, Any>>, transform: ((Map<String, Any>) -> Map<String, Any>)?) {
7        processData(items, { true }, transform)
8    }
9
10    fun processData(items: List<Map<String, Any>>, condition: (Map<String, Any>) -> Boolean, transform: ((Map<String, Any>) -> Map<String, Any>)?) {
11        val processedItems = items.filter(condition).map { item ->
12            transform?.invoke(item) ?: item.mapValues { entry ->
13                if (entry.value is String) {
14                    (entry.value as String).uppercase()
15                } else {
16                    entry.value
17                }
18            }
19        }
20        processedItems.take(3).forEach { println("Processed Item: $it") }
21    }
22}
23
24// Usage examples:
25fun main() {
26    val data = listOf(
27        mutableMapOf("name" to "apple", "quantity" to 10),
28        mutableMapOf("name" to "orange", "quantity" to 5)
29    )
30
31    val processor = DataProcessor()
32
33    // Default behavior - convert string values to uppercase
34    processor.processData(data)
35
36    // Custom filter - select items with a quantity greater than 5
37    processor.processData(data, { it["quantity"] as Int > 5 }, null)
38
39    // Custom transformation - convert names to uppercase and multiply the quantity by 2
40    processor.processData(data) { item ->
41        item.mapValues { entry ->
42            if (entry.key == "name") {
43                (entry.value as String).uppercase()
44            } else {
45                (entry.value as Int) * 2
46            }
47        }
48    }
49}

In this evolved version, we've introduced function overloading with additional parameters: (Map<String, Any>) -> Boolean to filter the input list based on a given condition, and ((Map<String, Any>) -> Map<String, Any>)? for custom transformations of the filtered items. The default behavior processes all items, converting string values to uppercase, which ensures that the original functionality's behavior is maintained for existing code paths.

Notice, that in the usage examples of the processData function, we utilize Kotlin's trailing lambda feature. This feature allows us to pass a lambda expression outside of the parentheses when it is the last parameter. For instance, in the custom transformation example:

Kotlin
1processor.processData(data) { item ->
2    item.mapValues { entry ->
3        if (entry.key == "name") {
4            (entry.value as String).uppercase()
5        } else {
6            (entry.value as Int) * 2
7        }
8    }
9}

Here, the lambda expression { item -> ... } is passed as the last argument to the processData function, demonstrating the trailing lambda syntax.

Task 2: Using the Adapter Design Pattern for Backward Compatibility

Imagine now that we are building a music player, and recently, the market demands have grown. Now, users expect support not just for MP3 and WAV but also for FLAC files within our music player system. This development poses a unique challenge: How do we extend our music player's capabilities to embrace this new format without altering its established interface?

Let's say that we currently have a MusicPlayer class that can only play MP3 files:

Kotlin
1class MusicPlayer {
2    fun play(file: String) {
3        if (file.endsWith(".mp3")) {
4            println("Playing $file as mp3.")
5        } else {
6            println("File format not supported.")
7        }
8    }
9}

Let's approach this challenge by introducing a composite adapter, a design that encapsulates multiple adapters or strategies to extend functionality in a modular and maintainable manner.

Kotlin
1class MusicPlayerAdapter(private val player: MusicPlayer) {
2    private val formatAdapters: Map<String, () -> Unit> = mapOf(
3        "wav" to ::convertAndPlayWav,
4        "flac" to ::convertAndPlayFlac
5    )
6
7    private lateinit var file: String
8
9    fun play(file: String) {
10        this.file = file
11        val fileExtension = file.substringAfterLast(".").lowercase()
12        formatAdapters[fileExtension]?.invoke() ?: player.play(file)
13    }
14
15    private fun convertAndPlayWav() {
16        // Simulate conversion
17        val convertedFile = file.replace(".wav", ".mp3")
18        println("Converting $file to $convertedFile and playing as mp3...")
19        player.play(convertedFile)
20    }
21
22    private fun convertAndPlayFlac() {
23        // Simulate conversion
24        val convertedFile = file.replace(".flac", ".mp3")
25        println("Converting $file to $convertedFile and playing as mp3...")
26        player.play(convertedFile)
27    }
28}
29
30// Upgraded music player with enhanced functionality through the composite adapter
31fun main() {
32    val legacyPlayer = MusicPlayer()
33    val enhancedPlayer = MusicPlayerAdapter(legacyPlayer)
34    enhancedPlayer.play("song.mp3")  // Supported directly
35    enhancedPlayer.play("song.wav")  // Supported through adaptation
36    enhancedPlayer.play("song.flac")  // Newly supported through additional adaptation
37}

This sophisticated adaptation strategy ensures that we can extend the MusicPlayer to include support for additional file formats without disturbing its original code. The MusicPlayerAdapter acts as a unified interface to the legacy MusicPlayer, capable of handling various formats by determining the appropriate conversion strategy based on the file type.

Lesson Summary

Great job! You've delved into backward compatibility while learning how to utilize function overloading and the Adapter Design Pattern. Get ready for some hands-on practice to consolidate these concepts! Remember, practice makes perfect. Happy Coding!

Enjoy this lesson? Now it's time to practice with Cosmo!
Practice is how you turn knowledge into actual skills.