Poucos meses após o lançamento da versão Beta, a JetBrains anunciou a primeira versão estável do Kotlin, a nova linguagem com base na JVM compatível com o Android. Como o fabricante indica, a linguagem tem como objetivo ser uma "boa ferramenta", ideia que tem impulsionado as decisões de design no sentido de pragmatismo e interoperabilidade. A linguagem promete resolver vários dos problemas que só podem ser resolvidos no Java através de bibliotecas e ferramentas externas, enquanto fornece um caminho para uma transição gradual e suave.
Concebido inicialmente em 2010, a JetBrains decidiu criar o Kotlin de forma que pudesse melhorar a produtividade enquanto desenvolvia os próprios produtos (o Kotlin é atualmente usado em produtos como o IntelliJ IDE). Considerando que vários outros usuários terão os mesmos problemas, a JetBrains decidiu abrir o código fonte do Kotlin e encorajar a comunidade a participar e contribuir. Devido ao fato de que o Kotlin é compatível com o Java 1.6, provavelmente se tornará popular entre os desenvolvedores Android, fornecendo acesso à um conjunto de funcionalidades disponíveis em outras versões e linguagens. Prova desta popularidade é o fato de que as novas ferramentas para o desenvolvimento em Android, como o JRebel para o Android, inclui suporte ao Kotlin.
Embora a vantagem do Kotlin sobre o Java, na área do desenvolvimento Android, possa ser menos significante uma vez que o Android finalize a transição para o OpenJDK, existem outras áreas que os desenvolvedores podem se beneficiar. Algumas destas áreas são:
- Métodos get/set: escrever código para acessar atributos no Java é realizado através da geração de código pela IDE, manipulação de bytecode como o Project Lombok, ou simplesmente tornando os atributos públicos (que vai contra os princípios de encapsulamento). No Kotlin, a criação de uma data class fornece por padrão getters e setters para todos os atributos.
- toString, hashCode, equals: o Java fornece implementação padrão para todos estes três métodos, mas raramente são úteis, obrigando os desenvolvedores a sobrescrever o padrão. Em vários casos, a necessidade de implementação necessária é bastante simples, de modo a ser fornecidas por bibliotecas com o Apache Commons Lang ou Google Guava. Os data classes do Kotlin fornecem uma implementação padrão para os atributos com base nessa classe, parecido com o que a maioria dos desenvolvedores precisam, não os forçando a sobrescrever métodos. Além disso, o operador '==' não compara referências no Kotlin, funciona como o método equals.
- Construção parcial de objetos: em várias ocasiões, o objeto precisa ser construído de uma maneira que somente alguns dos parâmetros são fornecidos, enquanto o resto mantém um valor padrão. Isto é normalmente feito através de padrão builder, o que cria a necessidade de criar uma classe construtora, juntamente com a classe de destino. O Kotlin resolve isso com named arguments.
- Verificações de null: Evitar nulos é uma dor de cabeça comum para desenvolvedores Java, tipicamente resolvido através da inspeção realizada por IDE (detecção de valores que sempre serão nulos), asserções por classes (Objects.requireNotNull()), validações implícitas através de anotações como @NotNull ou @NonNull, o Optional do Google ou no Java 8 o Optional. No Kotlin o conceito de nulo foi movido para a linguagem em si, o que significa que as variáveis são conscientes de sua própria nulidade em tempo de compilação:
val x: String? = "Hi" // Declarando um x como uma String nula
x.length // Não compila, x pode ser nulo, a verificação de nulo deve acontecer primeiro
if (x != null) {
x.length // Compila, o Kotlin entende que o x não é nulo aqui
}
val y: String = null // Não compila, y não foi declarado como podendo ser nulo
- Construção de String: no Java, é possível criar uma String usando o operador de concatenação ("a " + variável + " b"), o método String.format() para melhor leitura (String.format("a %s b", variável)), ou um StringBuilder/StringBuffer se o desempenho for uma preocupação StringBuilder().append("a ").append(variáve;).append(" b").build()). O Kotlin suporta interpolação de String parecido com Ruby e outras linguagens, ou seja, os desenvolvedores podem simplesmente digitar "a ${variável} b".
- Lambdas em ambientes pré-Java 8: os Lambdas somente foram introduzidos na última versão do Java e, embora versões mais antigas não sejam mais suportadas, ainda continuam sendo amplamente usadas. Para usar os lambdas em versões anteriores, é necessário usar ferramentas como o Retrolambda. O Kotlin fornece suporte ao lambda, uma vez que ele suporta o Java 6, faz com que esse recurso esteja disponível em ambientes mais velhos.
Existem vários outros problemas do dia a dia que são facilmente resolvidos com o Kotlin. Entretanto, além dos vários benefícios, adotar uma nova linguagem traz consigo riscos e desafios. Por um lado, adotar o Kotlin em um projeto existente pode precisar de código Java e Kotlin coexistindo por um período significante. A JetBrains tenta resolver isto tornando a interoperabilidade tão transparente quanto possível, e fornecendo um tradutor Java-Kotlin.
Por outro lado, é necessário suporte a longo prazo para que os usuários invistam em uma nova ferramenta. A JetBrains indicou comprometimento ao Kotlin através da atribuição de uma quantidade significativa de recursos (mais de 20 desenvolvedores em tempo integral) e prometendo um processo de padronização através de contribuições da comunidade. A JetBrains também está comprometida e fazer com que cada nova versão do Kotlin mantenha a compatibilidade. Estes princípios lembram a governança do Java em si, que é uma plataforma de referência open source (OpenJDK), o processo de padronização é liderado pela comunidade (a JCP), e o compromisso em manter novas versões compatíveis com as mais antigas.
É necessário observar se o Kotlin continuará entre a crescente população de linguagens da JVM (mais de 50 e aumentando). No momento, existem 2 milhões de linhas de código do Kotlin no GitHub (excluindo os projetos da JetBrains) e aproximadamente 800 questões no StackOverflow.