Eliminating Duplicate Code and Magic Numbers with Kotlin

Introduction and Context Setting

Welcome to our lesson on eliminating duplicated code and enhancing maintainability through method extraction and refactoring magic numbers . Writing clean and maintainable code is crucial in modern software development, and refactoring is a key practice that helps achieve these goals. This lesson focuses on identifying duplicate code segments and restructuring them to improve readability and maintainability. Throughout this course, we will be using Kotlin, a modern, concise, and expressive programming language that runs on the JVM, designed to work seamlessly with existing Java code. We'll leverage JUnit, a widely used testing framework, for test-driven development (TDD). This lesson builds upon an existing ShoppingCart example to focus on the Refactor step of the Red-Green-Refactor cycle. Let's dive into identifying and refactoring duplicated code to enhance the quality of our codebase.

What are Code Smells and How Do You Eliminate Them?

Before we delve into specific "smells," it's important to understand what "code smells" are. Code smells are indicators in the code suggesting deeper problems, such as poorly structured code or potential defects, though they aren't bugs themselves. Common examples include duplicate code, long methods, and magic numbers. These signals can hinder code readability and maintainability and may eventually lead to significant issues. Refactoring patterns provide structured techniques to address these code smells, improving the overall quality of the codebase while maintaining its behavior. By employing these patterns, we can systematically transform problematic sections into cleaner, more efficient code. In this lesson, we'll target duplications by leveraging refactoring patterns, such as method extraction and refactoring magic numbers, to enhance the clarity and adaptability of our code. We can rely on our tests to ensure that we don't break any existing functionality!

Understanding Code Duplication

"Code Duplication" is a code smell that occurs when similar or identical code segments are repeated across a codebase, leading to maintenance difficulties and bugs. Consider constant values spread throughout a codebase without clear labeling. This mirroring phenomenon complicates updates or adjustments, requiring changes in multiple places, and increases the risk of errors. Adhering to the DRY (Don't Repeat Yourself) principle ensures each piece of knowledge has a single, unambiguous representation within the system. This leads to better maintainability and understandability, reducing troubleshooting and debugging efforts. Remember, refactoring to eliminate code duplication fits into our TDD workflow, ensuring minimal disturbance to existing functionalities.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Kotlin

class ShoppingCart {
    private val items = mutableListOf<CartItem>()

    fun addItem(name: String, price: Double, quantity: Int) {
        items.add(CartItem(name, price, quantity))
    }

    fun calculateTotal(): Double {
        var total = 0.0

        for (item in items) {
            var itemTotal = item.price * item.quantity

            if (item.quantity >= 5) {
                itemTotal *= 0.9 // 10% discount
            }

            total += itemTotal
        }

        return total
    }

    fun calculateTotalWithStudentDiscount(): Double {
        var total = 0.0

        for (item in items) {
            var itemTotal = item.price * item.quantity

            if (item.quantity >= 5) {
                itemTotal *= 0.9 // 10% discount
            }

            total += itemTotal
        }

        // Apply student discount
        return total * 0.85 // 15% student discount
    }
}

data class CartItem(val name: String, val price: Double, val quantity: Int)

class ShoppingCart {
    private val items = mutableListOf<CartItem>()

    fun addItem(name: String, price: Double, quantity: Int) {
        items.add(CartItem(name, price, quantity))
    }

    fun calculateTotal(): Double {
        var total = 0.0

        for (item in items) {
            var itemTotal = item.price * item.quantity

            if (item.quantity >= 5) {
                itemTotal *= 0.9 // 10% discount
            }

            total += itemTotal
        }

        return total
    }

    fun calculateTotalWithStudentDiscount(): Double {
        var total = 0.0

        for (item in items) {
            var itemTotal = item.price * item.quantity

            if (item.quantity >= 5) {
                itemTotal *= 0.9 // 10% discount
            }

            total += itemTotal
        }

        // Apply student discount
        return total * 0.85 // 15% student discount
    }
}

data class CartItem(val name: String, val price: Double, val quantity: Int)

Kotlin

class ShoppingCart {
    private val items = mutableListOf<CartItem>()

    fun addItem(name: String, price: Double, quantity: Int) {
        items.add(CartItem(name, price, quantity))
    }

    private fun calculateSubtotal(): Double {
        var total = 0.0

        for (item in items) {
            var itemTotal = item.price * item.quantity

            if (item.quantity >= 5) {
                itemTotal *= 0.9 // 10% discount
            }

            total += itemTotal
        }

        return total
    }

    fun calculateTotal(): Double {
        return calculateSubtotal()
    }

    fun calculateTotalWithStudentDiscount(): Double {
        val subtotal = calculateSubtotal()

        // Apply student discount
        return subtotal * 0.85 // 15% student discount
    }
}

class ShoppingCart {
    private val items = mutableListOf<CartItem>()

    fun addItem(name: String, price: Double, quantity: Int) {
        items.add(CartItem(name, price, quantity))
    }

    private fun calculateSubtotal(): Double {
        var total = 0.0

        for (item in items) {
            var itemTotal = item.price * item.quantity

            if (item.quantity >= 5) {
                itemTotal *= 0.9 // 10% discount
            }

            total += itemTotal
        }

        return total
    }

    fun calculateTotal(): Double {
        return calculateSubtotal()
    }

    fun calculateTotalWithStudentDiscount(): Double {
        val subtotal = calculateSubtotal()

        // Apply student discount
        return subtotal * 0.85 // 15% student discount
    }
}

Kotlin

fun calculateItemCost(item: CartItem): Double {
    var itemTotal = item.price * item.quantity

    if (item.quantity >= 5) {
        itemTotal *= 0.9
    }

    return itemTotal
}

fun calculateItemCost(item: CartItem): Double {
    var itemTotal = item.price * item.quantity

    if (item.quantity >= 5) {
        itemTotal *= 0.9
    }

    return itemTotal
}

Kotlin

class ShoppingCart {
    companion object {
        private const val BULK_DISCOUNT_THRESHOLD = 5
        private const val BULK_DISCOUNT_RATE = 0.9 // 10% discount
    }

    fun calculateItemCost(item: CartItem): Double {
        var itemTotal = item.price * item.quantity

        if (item.quantity >= BULK_DISCOUNT_THRESHOLD) {
            itemTotal *= BULK_DISCOUNT_RATE
        }

        return itemTotal
    }
}

class ShoppingCart {
    companion object {
        private const val BULK_DISCOUNT_THRESHOLD = 5
        private const val BULK_DISCOUNT_RATE = 0.9 // 10% discount
    }

    fun calculateItemCost(item: CartItem): Double {
        var itemTotal = item.price * item.quantity

        if (item.quantity >= BULK_DISCOUNT_THRESHOLD) {
            itemTotal *= BULK_DISCOUNT_RATE
        }

        return itemTotal
    }
}

Kotlin

class ShoppingCart {
    private val items = mutableListOf<CartItem>()

    fun addItem(name: String, price: Double, quantity: Int) {
        items.add(CartItem(name, price, quantity))
    }

    fun calculateTotal(): Double {
        var total = 0.0

        for (item in items) {
            var itemTotal = item.price * item.quantity

            if (item.quantity >= 5) {
                itemTotal *= 0.9 // 10% discount
            }

            total += itemTotal
        }

        return total
    }

    fun calculateTotalWithStudentDiscount(): Double {
        var total = 0.0

        for (item in items) {
            var itemTotal = item.price * item.quantity

            if (item.quantity >= 5) {
                itemTotal *= 0.9 // 10% discount
            }

            total += itemTotal
        }

        // Apply student discount
        return total * 0.85 // 15% student discount
    }
}

data class CartItem(val name: String, val price: Double, val quantity: Int)

Kotlin

class ShoppingCart {
    private val items = mutableListOf<CartItem>()

    fun addItem(name: String, price: Double, quantity: Int) {
        items.add(CartItem(name, price, quantity))
    }

    private fun calculateSubtotal(): Double {
        var total = 0.0

        for (item in items) {
            var itemTotal = item.price * item.quantity

            if (item.quantity >= 5) {
                itemTotal *= 0.9 // 10% discount
            }

            total += itemTotal
        }

        return total
    }

    fun calculateTotal(): Double {
        return calculateSubtotal()
    }

    fun calculateTotalWithStudentDiscount(): Double {
        val subtotal = calculateSubtotal()

        // Apply student discount
        return subtotal * 0.85 // 15% student discount
    }
}

Kotlin

fun calculateItemCost(item: CartItem): Double {
    var itemTotal = item.price * item.quantity

    if (item.quantity >= 5) {
        itemTotal *= 0.9
    }

    return itemTotal
}

Kotlin

class ShoppingCart {
    companion object {
        private const val BULK_DISCOUNT_THRESHOLD = 5
        private const val BULK_DISCOUNT_RATE = 0.9 // 10% discount
    }

    fun calculateItemCost(item: CartItem): Double {
        var itemTotal = item.price * item.quantity

        if (item.quantity >= BULK_DISCOUNT_THRESHOLD) {
            itemTotal *= BULK_DISCOUNT_RATE
        }

        return itemTotal
    }
}