Kotlin
A concise multiplatform language developed by JetBrains
Como iniciar a adoção do Kotlin para desenvolvedores em Java
Postagem convidada de Urs Peter, Engenheiro de Software Sênior e Instrutor de Kotlin certificado pela JetBrains. Para leitores que preferirem uma maneira mais estruturada de adquirir conhecimentos sobre Kotlin, Urs também dirige o Programa de Qualificação em Kotlin da Xebia Academy.
Esta postagem abre a série O guia definitivo para a adoção bem-sucedida do Kotlin em um ambiente dominado pelo Java, que acompanha o processo de adoção do Kotlin por equipes reais, desde a curiosidade de um só desenvolvedor até uma transformação geral da empresa.
“Você não aperta simplesmente um botão e ‘muda para o Kotlin’.
Você elimina os riscos, faz medições, celebra as vitórias
e só então dobra a aposta.“
Adotar o Kotlin em um ambiente com o uso estabelecido do Java não é uma mera decisão técnica — é uma jornada que requer planejamento cuidadoso, pensamento estratégico e o mais importante: ganhar os corações e mentes dos seus colegas.
Depois de treinar mais de 1.000 desenvolvedores e ajudar inúmeras organizações a fazerem uma transição bem-sucedida para o Kotlin, pude ver o que funciona e o que não funciona. Este guia ajudará você a percorrer receitas bem-sucedidas que coletei ao longo do tempo para adotar o Kotlin, desde as suas primeiras experiências sem compromisso até uma transformação da organização em larga escala.
Esta é a jornada que esta série percorrerá com você:
- Tudo sempre começa com uma faísca iniciada por você!
- O estágio da brincadeira: começando pequeno — com testes
- O estágio de avaliação: o Kotlin como mais que uma brincadeira
- Pregando a palavra: ganhe os corações e mentes dos seus colegas desenvolvedores
- Convencendo a administração: criação do caso de negócios a favor do Kotlin
- Fatores de sucesso para a adoção do Kotlin em larga escala
- Usar ou não o Kotlin: que tipo de empresa você quer ser?
Tudo sempre começa com uma faísca iniciada por você!
Por que se dar ao trabalho de mudar para o Kotlin? Por que não ficar com o Java e ir em frente?
A resposta depende de inúmeros fatores. Embora os dados mostrem vantagens claras do Kotlin em várias áreas, a decisão não é puramente técnica. A subjetividade (“gosto da minha linguagem porque sim”) e o ceticismo em relação a algo novo, o que geralmente é uma coisa boa, desempenham um papel importante.
Porém, a evolução das linguagens de programação mostra que nossas preferências e necessidades mudam com o tempo. Crucialmente, cada nova geração de linguagens incorpora novos paradigmas — segurança (nula), sintaxe concisa e leve, funções tratadas como cidadãs de primeira classe, uma rica biblioteca-padrão, simultaneidade assíncrona, suporte a várias plataformas, adequação à IA gerativa, etc. — que dão vantagens decisivas aos desenvolvedores e às organizações.
Sem essa evolução natural, ainda estaríamos programando tudo em COBOL ou em outra linguagem arcaica, sem podermos atender às demandas de hoje. Portanto, a evolução não é opcional; ela faz parte da história do nosso setor.
Porém, para essa evolução se enraizar em uma empresa, é preciso mais que mérito técnico. É preciso que haja facilitadores — pessoas dispostas a explorar, defender e mostrar na prática o valor desses novos paradigmas. Na minha experiência, tipicamente, há três tipos de engenheiros que catalisam a adoção do Kotlin:
- Engenheiros de Java pragmáticos, com foco na produtividade: desenvolvedores experientes que consideram o Java uma ferramenta, não uma religião. Estão sempre procurando maneiras melhores de fazer o trabalho mais rapidamente.
- Entusiastas de linguagens modernas com uma mentalidade voltada para a qualidade: engenheiros que dão prioridade a um código legível, conciso e fácil de manter. Costumam ser os mesmos que, em outros tempos, teriam mudado para o Scala.
- Desenvolvedores juniores, que fazem uma pergunta simples, mas poderosa: “Por que eu deveria usar Java, se posso usar Kotlin?” Para eles, sem a bagagem de anos de experiência com Java, o Kotlin costuma ser uma solução óbvia.
A qual grupo você pertence?
Esses pioneiros iniciam o primeiro estágio. Mas como começar? Continue lendo… ;-)
O estágio da brincadeira: começando pequeno — com testes
Você ouviu falar sobre o Kotlin e quer experimentá-lo, sem compromisso imediato.
A primeira coisa de que você precisa é uma ferramenta de desenvolvimento na qual você possa plantar as suas primeiras sementes do Kotlin. Algumas opções são:
- https://play.kotlinlang.org/ é um grande playground on-line. Basta digitar e executar código em Kotlin, não só na JVM, mas também em várias outras plataformas (JS, WASM, etc.).
- Os notebooks de Kotlin são um recurso poderoso do IntelliJ IDEA, que permite que você facilmente importe dependências, execute código e até trabalhe com dados, trace gráficos, etc. Veja este exemplo, que mostra como é fácil fazer uma chamada REST com o RestClient do Spring:
- O IntelliJ IDEA tem suporte de primeira ao Kotlin. Isso não é nenhuma surpresa, pois é a JetBrains que desenvolve o Kotlin e grande parte do IntelliJ IDEA é escrita nessa linguagem. Então, é muito fácil começar a usar o Kotlin no IntelliJ IDEA — até no seu projeto já existente em Java:
E é só isso!
- E ainda há mais! Recentemente, a JetBrains lançou o Kotlin Language Server, que leva uma experiência de desenvolvimento em Kotlin, com todos os recursos, para outros IDEs além do IntelliJ IDEA, como o VS Code. Dê uma olhada: https://github.com/Kotlin/kotlin-lsp
Agora você pode programar em Kotlin no seu ambiente favorito de desenvolvimento. Como avaliar a linguagem em um contexto do mundo real, com o mínimo de impacto e o máximo de insights? Usando a suíte de testes de um projeto já existente em Java!
Esta é uma abordagem segura e realista da experimentação com o Kotlin e oferece várias vantagens:
- Baixo risco: os testes não afetam o código de produção.
- Oportunidade de aprendizado: você pode explorar os recursos da linguagem em um contexto familiar.
- Introdução gradual: os membros da equipe podem ir se acostumando sem pressão com a sintaxe do Kotlin.
Dicas
- Experimente Kotest + MockK para sentir imediatamente a expressividade das DSLs (linguagens específicas de domínios) do Kotlin, como as asserções cheias de recursos [
shouldHaveSize(...), infix (value shouldBe 1), etc.]. - Use as concisas e poderosas Kotlin Collections, em vez de Java Streams.
- Brinque com vários recursos da linguagem, como os tipos “nullable”, desestruturação, imutabilidade (
val,data classes), construtos de expressões (when,try-catch,if else) e vários outros.
O que você obtém com isso:
Java
@Test
void shouldGetAverageRating() {
when(productRepository.findAll()).thenReturn(products);
Map ratings = productService.averageRatings();
assertAll(
() -> assertThat(ratings).hasSize(4),
() -> assertEquals(ratings, products
.stream()
.collect(Collectors.groupingBy(
Product::getName,
Collectors.flatMapping(
p -> p.getRatings()
.stream()
.mapToDouble(Integer::doubleValue)
.boxed(),
Collectors.averagingDouble(Double::doubleValue)
)))
)
);
verify(productRepository).findAll();
}
Kotlin
@Test
fun `should get average rating`() { //descriptive tests using ``
every { productRepository.findAll() } returns products
val ratings = productService.averageRatings()
assertSoftly(ratings) { //powerful testing DSLs (Kotest)
shouldHaveSize(4)
this shouldBe productRepository.findAll()
.groupBy { it.name } //concise collections
.mapValues { (_, products) -> //destructuring
products.flatMap { it.ratings }.average() }
}
verify { productRepository.findAll() }
}
Em seguida nesta série
Geralmente, a adoção do Kotlin começa com uma pessoa explorando a linguagem e alguns testes mostrando sua utilidade. Naturalmente, esses primeiros momentos de descoberta levam a algo maior: avaliar o Kotlin em um projeto real.
A próxima postagem desta série descreve esse estágio e explica como testar o Kotlin em ambientes de produção.
Artigo original em inglês por:
Subscribe to Kotlin Blog updates
