Clean Code en Kotlin: principios y ejemplos para código limpio

Clean Code en Kotlin: principios y ejemplos para código limpio

El código limpio no es solo un término de moda, sino una habilidad fundamental para un desarrollador profesional. Cuando escribes en Kotlin, un lenguaje moderno y expresivo, los principios de Clean Code se vuelven aún más relevantes. El código que es fácil de leer, modificar y mantener ahorra horas de depuración y facilita la vida de todo el equipo. En este artículo, analizaremos los principios clave de Clean Code en Kotlin con ejemplos concretos que te ayudarán a escribir código elegante y confiable.

1. Nomenclatura: habla el lenguaje del dominio

La nomenclatura correcta es la base del código limpio. Los nombres de variables, funciones y clases deben responder inmediatamente a las preguntas "¿qué es esto?" y "¿para qué sirve?". Evita las abreviaturas de una sola letra y los nombres abstractos como data o temp.

Ejemplo incorrecto:

val d = mutableListOf<String>()fun prc(u: User) {    d.add(u.name)    if (u.age > 18) println(u.name)}

Ejemplo correcto:

val registeredUserNames = mutableListOf<String>()

fun printAdultUserName(user: User) {    registeredUserNames.add(user.name)    if (user.isAdult()) {        println(user.name)    }}

En el ejemplo correcto, queda claro de inmediato qué hace la función y qué datos se almacenan en la lista. Usa sustantivos para las clases (UserRepository), verbos para las funciones (processOrder) y predicados booleanos (isActive, hasPermission).

2. Funciones: pequeñas, de una sola tarea y sin efectos secundarios

Una de las ideas principales de Clean Code es que una función debe hacer solo una cosa. Si una función supera las 15-20 líneas, probablemente deba dividirse. Kotlin, con sus funciones de extensión y lambdas, es perfecto para esto.

Ejemplo: dividiendo una función compleja

Supongamos que tenemos una función para procesar un pedido:

fun processOrder(order: Order) {    // Validación    if (order.items.isEmpty()) throw IllegalArgumentException("Order must have items")    if (order.totalPrice < 0.0) throw IllegalArgumentException("Invalid price")        // Cálculo del descuento    var finalPrice = order.totalPrice    if (order.user.isPremium) {        finalPrice *= 0.9    }        // Envío de notificación    emailService.send(order.user.email, "Your order is confirmed")    smsService.send(order.user.phone, "Order #${order.id} confirmed")}

Refactorización según los principios de Clean Code:

fun processOrder(order: Order) {    validateOrder(order)    val finalPrice = calculateFinalPrice(order)    sendOrderConfirmation(order, finalPrice)}

private fun validateOrder(order: Order) {    require(order.items.isNotEmpty()) { "Order must have items" }    require(order.totalPrice >= 0.0) { "Invalid price" }}

private fun calculateFinalPrice(order: Order): Double {    return if (order.user.isPremium) order.totalPrice * 0.9 else order.totalPrice}

private fun sendOrderConfirmation(order: Order, finalPrice: Double) {    val message = "Order #${order.id} confirmed. Total: $finalPrice"    notificationService.notifyUser(order.user, message)}

Ahora cada función se encarga de una sola tarea, son fáciles de probar y reutilizar.

3. Null Safety: aprovecha las capacidades de Kotlin

Una de las principales características de Kotlin es la seguridad contra nulos (null safety). Clean Code en Kotlin implica eliminar por completo el uso de null siempre que sea posible. Evita el uso de !! (not-null assertion) — casi siempre es una señal de mal diseño.

Ejemplo incorrecto:

fun getUserName(userId: String): String {    val user = userRepository.findById(userId)!!    return user.name!!}

Ejemplo correcto:

fun getUserName(userId: String): String? {    val user = userRepository.findById(userId) ?: return null    return user.name}