Loading...

Lesson 1

Managing a Potluck Dinner System in Kotlin: Ensuring Backward Compatibility and Introducing Advanced Features

Introduction

Welcome to today's lesson! We're exploring how to introduce complex features while maintaining backward compatibility in software systems. Our journey will take us through a Potluck Dinner organization system where participants and their dishes are tracked for each round. Get ready to dive into Kotlin programming, unveiling strategies and crafting solutions. Let's embark on this exciting adventure!

Starter Task Review

Our Potluck Dinner organization system currently lets us add and remove participants and manage their dishes for each round. Here are the essential functions:

fun addParticipant(memberId: String): Boolean: Adds a participant if they don't already exist. Returns true if successful, or false if the participant is already in the system.
fun removeParticipant(memberId: String): Boolean: Removes a participant and their dish if they exist. Returns true if successful, false otherwise.
fun addDish(memberId: String, dishName: String): Boolean: Allows a participant to add a dish. Returns true if added successfully, false if the participant is invalid or has already added a dish.

Let's implement these methods using Kotlin, following the initial state of our system:

Kotlin
1class Potluck {
2    private val participants = mutableSetOf<String>()
3    private val dishes = mutableMapOf<String, String>()
4
5    fun addParticipant(memberId: String): Boolean {
6        return if (participants.contains(memberId)) {
7            false
8        } else {
9            participants.add(memberId)
10            true
11        }
12    }
13
14    fun removeParticipant(memberId: String): Boolean {
15        return if (!participants.contains(memberId)) {
16            false
17        } else {
18            participants.remove(memberId)
19            dishes.remove(memberId)
20            true
21        }
22    }
23
24    fun addDish(memberId: String, dishName: String): Boolean {
25        return if (!participants.contains(memberId) || dishes.containsKey(memberId)) {
26            false
27        } else {
28            dishes[memberId] = dishName
29            true
30        }
31    }
32}

With this setup, we use Kotlin's mutableSetOf for unique participant IDs and mutableMapOf to associate dishes with participant IDs. Now, let's extend our system with advanced features.

Introducing Advanced Functionalities

Currently, our Potluck Dinner organization system is simple yet effective. To enhance its capabilities, we're introducing a "Dish of the Day" feature. This allows participants to vote for a dish, with the most voted dish earning the title "Dish of the Day."

The new functionalities introduce these methods:

fun vote(memberId: String, voteId: String): Boolean: Allows a participant to cast a vote. Each participant can vote only once per round. Returns false if the participant or vote action is invalid.
fun dishOfTheDay(): String?: Calculates and returns the "Dish of the Day." In cases of ties, the earliest joining participant's dish is prioritized. Returns null if no votes exist.

Building Advanced Features. Step 1: Constructor Change

To accommodate these features, we'll modify our class:

Kotlin
1class Potluck {
2    private val participants = mutableMapOf<String, Long>()
3    private val dishes = mutableMapOf<String, String>()
4    private val votes = mutableMapOf<String, String>()
5}

Kotlin's mutableMapOf efficiently suits our need to track participant IDs with their join time.

Step 2: Implementing the 'vote' Method

Kotlin
1fun vote(memberId: String, voteId: String): Boolean {
2    return if (participants.containsKey(memberId) && !votes.containsKey(memberId)) {
3        votes[memberId] = voteId
4        true
5    } else {
6        false
7    }
8}

The vote function confirms the existence of memberId and checks whether a vote has been cast. If valid, it stores the vote; otherwise, it returns false.

Step 3: Implementing the 'dishOfTheDay' Method

Kotlin
1fun dishOfTheDay(): String? {
2    if (votes.isEmpty()) return null
3
4    val voteCount = votes.values.groupingBy { it }.eachCount()
5    val maxVotes = voteCount.values.maxOrNull() ?: 0
6
7    val maxVoteDishes = voteCount.filter { it.value == maxVotes }.keys
8    val earliestJoinTime = participants.filterKeys { it in maxVoteDishes }
9        .minByOrNull { it.value }?.key ?: return null
10
11    return "Participant: '$earliestJoinTime', Dish: '${dishes[earliestJoinTime]}'"
12}

Here, Kotlin's grouping and filtering methods elegantly compute vote counts and resolve ties while maintaining readability and leveraging Kotlin's safety features.

Step 4: Updating Previous Methods for Compatibility and Integration

The addParticipant function requires modification to integrate join times, maintaining our system's functionality:

Kotlin
1fun addParticipant(memberId: String): Boolean {
2    return if (participants.containsKey(memberId)) {
3        false
4    } else {
5        participants[memberId] = System.currentTimeMillis()
6        true
7    }
8}

Updating it ensures join times are tracked for our new features.

Step 5: Adjustments in 'removeParticipant' and 'addDish'

Ensure the removeParticipant function is comprehensive to maintain data integrity:

Kotlin
1fun removeParticipant(memberId: String): Boolean {
2    return if (!participants.containsKey(memberId)) {
3        false
4    } else {
5        participants.remove(memberId)
6        dishes.remove(memberId)
7        votes.remove(memberId)
8        true
9    }
10}

Maintaining correctness across interactions remains pivotal, so addDish functions are similarly concise:

Kotlin
1fun addDish(memberId: String, dishName: String): Boolean {
2    return if (!participants.containsKey(memberId) || dishes.containsKey(memberId)) {
3        false
4    } else {
5        dishes[memberId] = dishName
6        true
7    }
8}

Final Implementation

Here is your final Potluck implementation in Kotlin:

Kotlin
1class Potluck {
2    private val participants = mutableMapOf<String, Long>()
3    private val dishes = mutableMapOf<String, String>()
4    private val votes = mutableMapOf<String, String>()
5
6    fun addParticipant(memberId: String): Boolean {
7        return if (participants.containsKey(memberId)) {
8            false
9        } else {
10            participants[memberId] = System.currentTimeMillis()
11            true
12        }
13    }
14
15    fun removeParticipant(memberId: String): Boolean {
16        return if (!participants.containsKey(memberId)) {
17            false
18        } else {
19            participants.remove(memberId)
20            dishes.remove(memberId)
21            votes.remove(memberId)
22            true
23        }
24    }
25
26    fun addDish(memberId: String, dishName: String): Boolean {
27        return if (!participants.containsKey(memberId) || dishes.containsKey(memberId)) {
28            false
29        } else {
30            dishes[memberId] = dishName
31            true
32        }
33    }
34
35    fun vote(memberId: String, voteId: String): Boolean {
36        return if (participants.containsKey(memberId) && !votes.containsKey(memberId)) {
37            votes[memberId] = voteId
38            true
39        } else {
40            false
41        }
42    }
43
44    fun dishOfTheDay(): String? {
45        if (votes.isEmpty()) return null
46
47        val voteCount = votes.values.groupingBy { it }.eachCount()
48        val maxVotes = voteCount.values.maxOrNull() ?: 0
49
50        val maxVoteDishes = voteCount.filter { it.value == maxVotes }.keys
51        val earliestJoinTime = participants.filterKeys { it in maxVoteDishes }
52            .minByOrNull { it.value }?.key ?: return null
53
54        return "Participant: '$earliestJoinTime', Dish: '${dishes[earliestJoinTime]}'"
55    }
56}

Lesson Summary

Congratulations on integrating complex functionalities within Kotlin while ensuring backward compatibility! This showcases how Kotlin's concise syntax and modern features can efficiently solve real-world engineering problems. Continue to hone these skills, and explore more Kotlin adventures ahead! Happy coding!

Enjoy this lesson? Now it's time to practice with Cosmo!

Practice is how you turn knowledge into actual skills.