Principales errores de los desarrolladores principiantes de Kotlin: de la A a la Z

Introducción: ¿Por qué incluso los desarrolladores inteligentes tropiezan con Kotlin?

Kotlin es un lenguaje elegante y potente que ha conquistado los corazones de millones de desarrolladores. Pero su concisión y flexibilidad esconden trampas, especialmente para los principiantes que vienen de Java u otros lenguajes. Muchos piensan que como Kotlin es «más comprensible» que Java, habrá menos errores. En la práctica ocurre lo contrario: la falta de comprensión de la filosofía del lenguaje provoca bugs difíciles de detectar.

En este artículo analizaremos los principales errores de los desarrolladores principiantes de Kotlin, desde la simple ignorancia de null safety hasta el uso incorrecto de las corrutinas. Cada error se ilustrará con un ejemplo de código y un consejo práctico sobre cómo evitarlo.

1. Null Safety: cuándo «?» salva y cuándo no

1.1. Ignorar los tipos nullable

El error más común es usar !! (not-null assertion) donde se podrían usar llamadas seguras. Los principiantes suelen escribir:

fun printLength(str: String?) {\n    println(str!!.length) // Lanzará NPE si str == null\n}

El enfoque correcto es usar ?.let o el operador Elvis ?::

fun printLength(str: String?) {\n    str?.let { println(it.length) } ?: println("Cadena null")\n}

1.2. Olvidar el Smart Cast

Kotlin convierte tipos automáticamente después de una comprobación de null, pero los principiantes no lo notan:

fun process(value: Any?) {\n    if (value is String) {\n        // value ya es String, ¡no necesita casteo!\n        println(value.length) // Funciona sin (value as String).length\n    }\n}

Consejo: Confíen en el compilador. Usen !! solo si están 100% seguros de que el valor no es null y están preparados para un fallo si se equivocan.

2. Sealed Class y When: trampas de la exhaustividad

2.1. Usar la rama else con sealed class

Las sealed class están diseñadas para que el compilador verifique si se han manejado todas las variantes. Pero los principiantes suelen añadir else, matando toda la magia:

sealed class Result {\n    data class Success(val data: String) : Result()\n    data class Error(val message: String) : Result()\n}\n\nfun handleResult(result: Result) {\n    when (result) {\n        is Result.Success -> println(result.data)\n        is Result.Error -> println(result.message)\n        else -> {} // ¡Error! Si se añade una nueva subclase, el compilador no avisará\n    }\n}

Lo correcto es no usar else:

fun handleResult(result: Result) {\n    when (result) {\n        is Result.Success -> println(result.data)\n        is Result.Error -> println(result.message)\n    } // El compilador dará error si no se cubren todas las ramas\n}

2.2. Confundir sealed class con enum

Los principiantes suelen elegir enum donde se necesita sealed class. Recuerden: enum es para un conjunto finito de constantes, sealed class es para una jerarquía con diferentes datos en cada subclase.

3. Scope Functions: apply, let, run, with, also — cómo no confundirse

3.1. Mezclar el contexto: this vs it

La confusión más común es cuando un principiante usa apply (contexto — this) para operaciones donde se necesita let (contexto — it):

data class User(var name: String, var age: Int)\n\nfun initUser(): User {\n    return User("Anónimo", 0).apply {\n        // this — es User\n        name = "Iván"\n        age = 25\n    }\n}\n\nfun printUserInfo(user: User?) {\n    user?.let { \n        // it — es user\n        println("Nombre: ${it.name}, Edad: ${it.age}")\n    }\n}

3.2. Cadenas de scope functions sin sentido

A los principiantes les gusta escribir cadenas como:

list?.let { it.filter { it > 5 }.also { println(it) } }

                
                

                    

                        Blogs                    
                    

                                                    
                                

                                    

                                        
                                    
                                    
CI/CD para Java: GitHub Actions desde la configuración hasta el despliegue
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
C++ para aprendizaje automático: capacidades reales y limitaciones prácticas
                                
                            
                                            
                

                
                

                    

                        Book Recommendations                    
                    

                                                    
                                

                                    

                                        
                                    
                                    
GraphQL en Java: Creación de APIs modernas
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Entrevista de Java: 200 preguntas y respuestas
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Diseño de APIs web evolutivas con ASP.NET
                                
                            
                                                    
                                

                                    

                                        
                                    
                                    
Fundamentos de programación para iOS 13 con Swift
                                
                            
                                            
                
            
    

  
Leer también
  

                
                  
                 launch/join vs async/await en Kotlin: ¿qué elegir en 2025?
      
                
                  
                 Kotlin para backend vs frontend: ¿qué elegir para el desarrollador en 2025?
      
                
                  
                 Trabajo con JSON en Java: análisis y serialización de datos
      
                
                  
                 Errores comunes en Python y cómo solucionarlos: Guía completa para principiantes
      
                
                  
                 C++ en 2025: resumen de las nuevas funciones y cambios