Conociendo Kotlin: null-safety y puntos fuertes

Índice

1. ¿Qué es Kotlin?
2. Puntos fuertes de Kotlin
3. Declaración de variables
4. Conciso y expresivo
5. Null safety 
6. Conclusiones

1. ¿Qué es Kotlin?

Cómo desarrolladora Kotlin (que viene del mundo de Java), hoy intentaré “convencerte” a dar una posibilidad a estudiar Kotlin.

Empezamos por las bases, ¿qué es eso? 

Kotlin es un lenguaje de programación bastante nuevo y conciso que se ejecuta sobre la máquina virtual de Java (JVM). Lo interesante es que es interoperable con Java, lo que significa que puedes usar ambos lenguajes en el mismo proyecto sin problemas. Entonces no, no tienes que cambiar todo tu código para empezar a usarlo, ¡puedes implementarlo desde ahora mismo!
Las principales razones para considerar Kotlin son su seguridad, eficiencia y facilidad de uso.
Además, Kotlin fue creado por JetBrains en 2016, la misma empresa detrás de IntelliJ, por lo cual cuenta con una muy buena comunidad.

2. Puntos fuertes de Kotlin

• Conciso: Kotlin reduce la cantidad de código boilerplate, lo que significa que puedes hacer más con menos líneas de código.
• Seguro: Kotlin tiene un sistema de null safety que previene los NullPointerException (lo cual es un GRAN alivio para quienes trabajamos con Java)
• Interoperable: Al ser interoperable con Java, puedes usar bibliotecas y frameworks Java en los proyectos de Kotlin.
• Expresivo: pensado para ser claro, tiene funciones lambda, coroutines y programación orientada a objetos muy intuitiva.
• Multiplataforma: Aunque originalmente fue creado para el desarrollo en Android, ahora también se usa en backend y en iOS.
  

3. Declaración de variables

Empezamos con las bases para que puedas escribir tus primeras líneas en Kotlin (puedes usar su “patio de juegos”/playground aquí para probarlo sin descargar nada): ¡declara tu primera variable!

En Kotlin, existen dos formas principales de declarar variables:

VAR: define una variable mutable. Esto significa que su valor puede cambiar después de ser asignado. Es similar a las variables regulares en muchos lenguajes como Java o C.

Vamos a ver unos michi-ejemplos con la asignación del nombre a un gato.

var catName = "Oreo"

catName = "Zelda"  //Ok, compila y corre bien, la ver se puede modificar

*pues si una protectora tuviera un sistema informático de gestión de gatitos con kotlin, probablemente debería declarar con var los nombres de los michis ya que muchos adoptantes cambian el nombre al nuevo peque de la familia*

VAL: define una variable inmutable. Una vez asignado un valor, no se puede cambiar. Similar a las constantes en otros lenguajes.
val catName = «Oreo»

catName = «Zelda»  // Error, no se puede cambiar el valor de una val

*y este caso se daría si yo tuviera un sistema de gestión de gatitos con kotlin. Teniendo 3 no sería ni tan descabellada la idea jeje. Debería declarar con val los nombres de mis michis, ya que no quiero que puedan cambiar de nombre. Aunque cada pocos días le pongo un apodo nuevo… probablemente la clase que representa mis michis sería algo así:*

<em>class michiDeElena { 
 val nombreDelMicrochip: String 
 var apodoCariñosoDeLaSemana: String 
} </em>

La decisión de cómo declarar una variable tiene un impacto importante en la inmutabilidad del código, que es un tema muy importante en Kotlin para mejorar la seguridad y evitar errores comunes como la modificación no deseada del estado.

4. Conciso y expresivo

En Kotlin puedes hacer más con menos código, reduciendo la cantidad de líneas necesarias para expresar una lógica. Esto se logra con características del lenguaje que simplifican las tareas comunes.
El código es fácil de leer y entender, y esto mejora la mantenibilidad.

Eliminación del código boilerplate: Kotlin elimina la necesidad de escribir código redundante. Por ejemplo, la declaración de getters y setters en una clase es automática:

// En Java:

<em>public class Cat { 
 private String name; 
 public Cat(String name) { this.name = name; } 
 public String getName() { return name; } 
 public void setName(String name) { this.name = name; } 
} </em>

// En Kotlin:

<em>class Cat (val name: String)</em>

Inferencia de tipos: Kotlin infiere automáticamente los tipos, lo que significa que no necesitas especificar el tipo de una variable a menos que sea necesario.

val name =  «Oreo»  // El tipo String es inferido automáticamente

Data classes: Kotlin introduce las data classes que, de manera rápida, ofrecen una estructura clara para almacenar datos sin necesidad de escribir métodos como toString(), equals(), o hashCode().

<em>data class Cat (val name: String, val age: Int)</em>

5. Null safety

Vamos a uno de los puntos más interesantes de Kotlin: su lucha contra los NullPointers.

Repaso para los afortunados que no saben que es un NullPointerException: En muchos lenguajes de programación, como Java, las variables pueden ser nulas por defecto, lo que puede causar errores en tiempo de ejecución si no se manejan correctamente. Un NullPointerException ocurre cuando intentas acceder a un objeto que no ha sido inicializado (es decir, es null).

Una de las mayores ventajas de Kotlin sobre Java es su sistema de null safety (ojo, parte de la responsabilidad sigue siendo nuestra). 

Kotlin adopta un enfoque diferente. De manera predeterminada, las variables en Kotlin no pueden ser nulas. Para que una variable pueda ser nula, debes declararlo explícitamente agregando un ? al tipo de la variable.

var stringValue: String? = null //Ok, con ? indicamos que el tipo puede ser o string o null

var stringValue: String = null //error a tiempo de compilación, String no acepta nulos

Existen varios operadores para trabajar de manera segura con valores nulos:

• Operador de llamada segura (?.): Permite acceder a las propiedades de un objeto sólo si no es nulo.

val longitud = nombre?.length //El resultado será int (si la val está inicializada) o null si no lo está. La longitud es de tipo Int?.

• Operador Elvis (?:): Permite asignar un valor por defecto si el valor es nulo.
  val longitud = nombre?.length ?: 0 //El resultado será la length si la val está inicializada o 0 (el valor por defecto) si no lo está.  Longitud es de tipo Int.

• Operador de aserción no nula (!!): Si estás absolutamente seguro de que un valor no es nulo, puedes decir al compilador que el valor va a estar sí o sí usando “!!”. Es una mala práctica en la mayoría de los casos. Piensalo bien antes de usarlo.
  val longitud = nombre!!.length //El resultado será int (si la val está inicializada) o java.lang.NullPointerException si no lo está.  Longitud es de tipo Int.

6. Conclusiones

En este artículo he dado solo una pequeña introducción a algunos puntos fuertes que, en mi opinión, tiene kotlin.

Espero haberte motivado a leer un poco más sobre el tema y a reflexionar sobre si este lenguaje puede ser bueno para tu caso.