Explorando o Kotlin 2.0: O que há de novo e interessante?

Apresentamos o Kotlin 2.0, a atualização mais recente na história de uma das linguagens de programação mais populares para desenvolvimento de software. A cada lançamento, ele expande os limites do desenvolvimento contemporâneo e oferece aos programadores uma fusão de segurança, expressividade e concisão.

Neste artigo, exploramos os recursos e melhorias de ponta do Kotlin 2.0, que tem o potencial de transformar completamente a maneira como os desenvolvedores criam aplicativos. Vamos explorar as novidades e os aspectos interessantes da versão mais recente, desde conceitos avançados de sintaxe até o robusto suporte a ferramentas.

Índice

• O que há de novo no Kotlin 2.0?
1. Suporte IDE
2. Integração multiplataforma perfeita
3. Novo Modo K2
4. Velocidade de compilação aprimorada
5. Suporte a plugins de compilador
6. Kotlin/JVM
7. Kotlin/Nativo
8. Kotlin/Wasm
9. Kotlin/JS
10. Melhorias no Gradle
11. Biblioteca padrão
• Conclusão

O que há de novo no Kotlin 2.0?

Um novo modo de compilador K2, melhor suporte multiplataforma, compilação mais rápida e diversas alterações para Kotlin/JVM, Kotlin/Native, Kotlin/Wasm e Kotlin/JS são apenas algumas das novidades interessantes da versão mais recente. Para acelerar ainda mais o processo de desenvolvimento, a integração com o sistema de compilação Gradle foi otimizada e a biblioteca padrão recebeu melhorias substanciais.

Suporte IDE

Os plugins que suportam Kotlin 2.0.0 estão incluídos nas versões mais recentes do Android Studio e do IntelliJ IDEA. Não é necessário atualizar o plugin no seu IDE. Basta modificar seus scripts de compilação para incorporar o Kotlin 2.0.0.

Integração multiplataforma perfeita

O suporte aprimorado para projetos multiplataforma é um dos seus recursos mais notáveis. Com esta versão, compartilhar código entre plataformas ficou mais simples do que nunca, reduzindo a duplicação e garantindo consistência em todos os aplicativos. Independentemente do seu objetivo de desenvolvimento — JVM, Native, JavaScript ou a recém-lançada plataforma WebAssembly (Wasm) — o Kotlin 2.0 oferece as ferramentas e bibliotecas necessárias para facilitar o desenvolvimento multiplataforma eficaz.

Novo Modo K2

Uma das principais funcionalidades do Kotlin 2.0 é o novo modo de compilador K2, que proporciona um processo de compilação mais confiável e eficiente. Ele busca aprimorar a velocidade geral do compilador, oferecendo tempos de compilação mais rápidos e diagnósticos de erros mais precisos. Ao reduzir o tempo de espera para a conclusão das compilações e simplificar o processo de identificação e correção de problemas, esse modo visa melhorar a experiência do Kotlin para desenvolvedores Java.

Os avanços vão além da velocidade de compilação. O modo K2 do IntelliJ IDEA, atualmente em versão alfa, está produzindo resultados promissores. Na base de código do IntelliJ IDEA Ultimate, ele oferece uma coloração de código cerca de 1,8 vezes mais rápida e uma conclusão de código 1,5 vezes mais veloz, e sua comunidade continua determinada a aprimorá-lo ainda mais. No futuro, espera-se que o Kotlin se torne mais estável, oferecendo conclusão e coloração de código mais rápidas.

Velocidade de compilação aprimorada

O Kotlin 2.0 possibilita ganhos significativos de desempenho na compilação, permitindo que os desenvolvedores trabalhem de forma mais produtiva e iterem rapidamente. Os tempos de compilação são reduzidos e o processo de desenvolvimento torna-se mais eficaz com a adição do novo compilador K2 e outras melhorias de eficiência, especialmente para projetos maiores.

Suporte a plugins de compilador

Com o suporte ampliado para plugins de compilador, os desenvolvedores agora podem criar plugins personalizados para expandir os recursos do compilador. Isso possibilita maior flexibilidade e a capacidade de personalizar o processo de compilação para atender a requisitos específicos de cada projeto.

Os seguintes plugins do compilador Kotlin são atualmente suportados pelo compilador K2:

• totalmente aberto
• AtômicoFU
• jvm-abi-gen
• js-objetos-simples
• capitão
• Lombok
• sem argumento
• Parcelizar
• SAM com receptor
• serialização
• Afirmação de poder

Além disso, o compilador Kotlin K2 oferece suporte a:

• O plugin de compilação Jetpack Compose 2.0.0 foi movido para o repositório Kotlin.
• O plugin Kotlin Symbol Processing (KSP) desde o KSP2.

Kotlin/JVM

Esta versão traz as seguintes alterações:

Geração de funções lambda usando invokedynamic

A versão mais recente introduz um novo método padrão para a geração de funções lambda do invokedynamic. Comparada à geração convencional de classes anônimas, essa modificação reduz o tamanho dos binários das aplicações.

As lambdas são geradas como classes anônimas desde o seu lançamento inicial. No entanto, a partir do Kotlin 1.5.0, a opção de compilador `-Xlambdas=indy` tornou possível invocar a geração dinâmica. O método padrão para criação de lambdas agora é `invokedynamic`. Ao usar essa técnica, os aplicativos podem aproveitar os aprimoramentos de velocidade atuais e futuros da JVM, além de gerar binários mais leves e alinhar o Kotlin às otimizações da JVM.

Atualmente, apresenta três desvantagens em relação à compilação lambda padrão:

• Quando compilada em invokedynamic, uma expressão lambda não pode ser serializada.
• As expressões lambda criadas por invokedynamic não são suportadas pela API experimental reflect().
• Uma representação de string menos legível é produzida quando .toString() é chamado em uma expressão lambda desse tipo:

 fun main() { println({}) // With Kotlin 1.9.24 and reflection, returns // () -> kotlin.Unit // With Kotlin 2.0.0, returns // FileKt$$Lambda$13/0x00007f88a0004608@506e1b77 }

Você tem duas opções se quiser continuar criando funções lambda da mesma forma que antes:

• Use @JvmSerializableLambda para anotar lambdas.
• Para a técnica histórica de gerar todas as expressões lambda em um módulo, use a opção do compilador -Xlambdas=class.

A biblioteca kotlinx-metadata-jvm agora está na versão estável.

A biblioteca kotlinx-metadata-jvm agora está estável na atualização mais recente. Você pode encontrá-la como kotlin-metadata-jvm, pois agora utiliza seu próprio pacote e coordenadas.

A biblioteca kotlinx-metadata-jvm foi publicada anteriormente sob uma versão e método de publicação diferentes. Mantendo as mesmas garantias de compatibilidade com versões anteriores, as alterações do kotlin-metadata-jvm agora serão produzidas e lançadas como parte do ciclo de lançamento do Kotlin.

A biblioteca kotlin-metadata-jvm fornece uma API para ler e editar os metadados de arquivos binários produzidos pelo compilador Kotlin/JVM.

Kotlin/Nativo

A versão 2.0 do Kotlin/Native traz melhorias significativas, como ferramentas aprimoradas, melhor interoperabilidade com C e Objective-C e desempenho otimizado. Esses avanços facilitam o desenvolvimento de aplicações nativas de alto desempenho em diversas plataformas, incluindo sistemas embarcados e iOS.

Esta versão traz as seguintes alterações:

• Monitoramento do desempenho do GC com indicadores :

Uma melhoria significativa é possível graças aos indicadores, que permitem aos desenvolvedores monitorar o desempenho da coleta de lixo (GC) com mais eficiência. Essa funcionalidade ajuda a otimizar o uso de recursos, oferecendo informações valiosas sobre o gerenciamento de memória.

• Resolvendo conflitos com métodos Objective-C

Nesta versão, o Kotlin resolve conflitos com métodos Objective-C, facilitando a interoperabilidade entre bases de código Kotlin e Objective-C. Agora que a funcionalidade pode ser facilmente integrada a aplicações com componentes Objective-C preexistentes, os desenvolvedores podem melhorar a compatibilidade entre plataformas e agilizar o processo de desenvolvimento.

• Alterado o nível de registro de logs para argumentos do compilador em Kotlin/Native.

A versão X do Kotlin/Native traz melhorias no registro de parâmetros do compilador, oferecendo aos usuários mais controle e transparência sobre o processo de compilação. Os desenvolvedores podem personalizar sua experiência de depuração para atender aos requisitos do projeto, modificando os níveis de registro, o que aumenta a produtividade e as habilidades de solução de problemas.

• Dependências de biblioteca padrão e plataforma explicitamente adicionadas ao Kotlin/Native.

Agora que o Kotlin/Native foi atualizado, as dependências da biblioteca padrão e da plataforma estão explicitamente incluídas, garantindo cobertura completa de todas as partes necessárias para o desenvolvimento de aplicativos nativos. Essa atualização facilita o gerenciamento de dependências e a integração do Kotlin/Native em diversos contextos de projeto.

• Erro de tarefas no cache de configuração do Gradle

A versão X do Kotlin corrige problemas de tarefas que surgem durante o cache de configuração do Gradle, proporcionando maior estabilidade e confiabilidade ao processo de compilação. Ao trabalhar com projetos Kotlin no Gradle, os desenvolvedores podem desfrutar de compilações mais produtivas e maior eficiência, graças à correção desses problemas.

Kotlin/Wasm

A versão 2.0.0 do Kotlin/Wasm (WebAssembly) introduz diversos novos recursos e melhorias com o objetivo de aprimorar a interoperabilidade e a velocidade do JavaScript. Com esta versão, os desenvolvedores que buscam criar aplicações web de alto desempenho encontrarão no Kotlin/Wasm uma ferramenta ainda mais poderosa. Veja as novidades:

Builds de produção otimizados por padrão usando Binaryen

O Binaryen agora é usado por padrão pelo Kotlin/Wasm para compilações de produção otimizadas. Sem exigir configurações adicionais, o Binaryen otimiza o código WebAssembly (Wasm) para tornar seus aplicativos mais rápidos e eficientes.

Suporte para exportação nomeada

Agora você pode utilizar exportações nomeadas em seus módulos Wasm na versão mais recente. Isso facilita o gerenciamento e a integração de módulos Kotlin/Wasm em seus projetos JavaScript, permitindo exportações mais claras e legíveis.

Suporte para tipos primitivos não assinados em funções com @JsExport

O suporte para tipos primitivos sem sinal em funções marcadas com @JsExport foi estendido pelo Kotlin/Wasm. Essa funcionalidade garante melhor compatibilidade com JavaScript, permitindo que os programadores usem tipos primitivos sem sinal. Trabalhe com números inteiros e outros tipos primitivos com facilidade em projetos multilíngues.

Geração de arquivos de declaração TypeScript em Kotlin/Wasm

A capacidade de criar arquivos de declaração TypeScript (.d.ts) diretamente do seu código Kotlin/Wasm é um dos recursos mais notáveis desta ferramenta. Ao oferecer segurança de tipos e recursos de autocompletar em editores compatíveis com TypeScript, isso possibilita uma melhor integração com projetos TypeScript.

Quaisquer funções de nível superior designadas com @JsExport são reunidas pelo compilador Kotlin/Wasm, que então cria automaticamente definições TypeScript no arquivo adts.

Adicione a função generateTypeScriptDefinitions() ao bloco wasmJs {} do seu arquivo build.gradle (.kts) para gerar definições TypeScript:

 kotlin { wasmJs { binaries.executable() browser { } generateTypeScriptDefinitions() } }

Suporte para armazenamento em cache de exceções JavaScript

Agora que o Kotlin/Wasm consegue capturar exceções em JavaScript, seus módulos podem lidar com erros de forma mais robusta. Essa melhoria garante que erros provenientes do código JavaScript possam ser tratados e respondidos adequadamente por seus aplicativos.

Nova proposta de tratamento de exceções com suporte no âmbito da opção

O suporte para uma nova proposta de tratamento de exceções está incluído na versão mais recente e pode ser ativado por meio de uma opção dedicada. Esse recurso aprimora o tratamento de exceções do WebAssembly, oferecendo um método mais padronizado e eficaz para lidar com erros.

Função withWasm() dividida em variantes JS e WASI

Agora você tem maior flexibilidade e controle sobre seus módulos graças à separação da função `withWasm()` em versões JS e WASI. Devido a essa divisão, os desenvolvedores podem selecionar o contexto que melhor se adapta aos seus aplicativos, independentemente de estarem sendo executados em um contexto de Interface de Sistema WebAssembly (WASI) ou em um ambiente JavaScript.

Kotlin/JS

Esta versão oferece suporte a mais recursos do padrão ES2015 e adiciona compilação JS moderna ao Kotlin, entre outras modificações.

Novo alvo de compilação

Estamos adicionando o ES2015 como um novo alvo de compilação para Kotlin/JS na versão 2.0. Este é um novo método que permite habilitar todos os recursos do ES2015 que o Kotlin suporta simultaneamente.

Esta é a forma como você pode configurá-lo no seu arquivo build.gradle (.kts):

 kotlin { js { compilerOptions { target.set("es2015") } } }

Suspender funções como geradores ES2015

Com esta versão, os geradores ES2015 usados para compilar funções de suspensão agora possuem suporte experimental.

O tamanho final do pacote do seu projeto deverá aumentar se geradores forem usados em vez de máquinas de estado. Por exemplo, ao utilizar os geradores do ES2015, a equipe da JetBrains conseguiu reduzir o tamanho do pacote do seu projeto Space em 20%.

• Passando argumentos para a função principal
• Compilação por arquivo para projetos Kotlin/JS
• Interoperabilidade de coleta aprimorada

Suporte para createInstance()

Você pode usar a função createInstance() do alvo Kotlin/JS a partir do Kotlin 2.0.0. Anteriormente, ela era limitada à JVM.

Para obter a referência em tempo de execução de uma classe Kotlin, use a função de interface KClass que gera uma nova instância da classe fornecida.

Suporte para o gerenciador de pacotes npm

Anteriormente, a única maneira de baixar e instalar dependências do npm era através do plugin Multiplatform Gradle, usando o Yarn como gerenciador de pacotes. Você pode migrar para o npm como seu gerenciador de pacotes a partir do Kotlin 2.0.0. Ao usar o npm como gerenciador de pacotes, você elimina mais uma ferramenta da sua lista de configurações.

O gerenciador de pacotes padrão ainda é o Yarn, por questões de compatibilidade com versões anteriores. No seu arquivo gradle.properties, defina a seguinte propriedade para utilizar o npm como gerenciador de pacotes:

 kotlin.js.yarn = false

Alterações nas tarefas de compilação

Os mesmos diretórios foram previamente definidos como alvos das tarefas de compilação do webpack e do distributeResources. Além disso, o diretório `dist` foi especificado como diretório de saída pela tarefa de distribuição. Isso resultou em saídas sobrepostas e um aviso de compilação.

A partir do Kotlin 2.0.0, aplicamos as seguintes modificações:

• A pasta de destino para a operação do webpack foi alterada.
• A tarefa distributeResources foi eliminada.
• A pasta dist é o destino da tarefa de distribuição, que agora tem o tipo de cópia.

Descontinuação de artefatos JAR legados do Kotlin/JS

A partir da versão 2.0, a distribuição não inclui mais arquivos Kotlin/JS legados com a extensão .jar. Esses arquivos legados são supérfluos para o compilador IR que usa o formato klib e eram utilizados no antigo compilador Kotlin/JS, que já não existe mais.

Melhorias no Gradle

O Gradle 6.8.3 até o 8.5 é totalmente compatível com o Kotlin 2.0. Até a versão mais recente, você ainda pode usar versões do Gradle, mas, nesse caso, esteja ciente de que alguns recursos novos do Gradle podem não funcionar ou que você pode receber avisos de obsolescência.

As seguintes melhorias estão incluídas nesta versão:

• Nova DSL do Gradle para opções de compilador em projetos multiplataforma
• Novo plugin do Gradle para o compilador Compose
• Aumentando as versões mínimas suportadas.
• Novo atributo para distinguir bibliotecas publicadas na JVM e no Android.
• Melhoria no tratamento de dependências do Gradle para CInteropProcess em Kotlin/Native
• Alterações de visibilidade no Gradle
• Novo diretório para dados Kotlin em projetos Gradle
• O compilador Kotlin/Native é baixado quando necessário.
• Descontinuação das formas antigas de definir opções de compilador.
• Aumentada a versão mínima compatível com AGP.
• Nova propriedade do Gradle para experimentar a versão mais recente da linguagem.
• Novo formato de saída JSON para relatórios de compilação.
• As configurações do kapt herdam processadores de anotações das superconfigurações.
• O plugin Kotlin Gradle não utiliza mais convenções Gradle obsoletas.

Biblioteca padrão

Com esta versão, a biblioteca padrão torna-se ainda mais estável e mais funcionalidades tornam-se universais em todas as plataformas:

• Substituição estável da função genérica do valor da classe enum
• Interface estável com fechamento automático
• Propriedade protegida comum AbstractMutableList.modCount
• Função protegida comum AbstractMutableList.removeRange
• String comum.toCharArray(destino)

Conclusão

O lançamento do Kotlin 2.0 serve como prova do desenvolvimento contínuo da linguagem e da dedicação em fornecer aos desenvolvedores ferramentas e recursos de última geração. Com melhorias para JVM, Native, JavaScript e WebAssembly, entre outras plataformas, o Kotlin 2.0.0 cria novas oportunidades para criatividade e desenvolvimento multiplataforma. Com a adição do modo de compilador K2 e aprimoramentos no suporte a middleware, velocidade de compilação e integração com Gradle, este lançamento marca um importante ponto de virada para o projeto. Ao adotar a versão mais recente, os programadores embarcam em uma jornada infinitamente gratificante, impulsionada pela engenhosidade, produtividade e pelas possibilidades ilimitadas inerentes ao desenvolvimento de software contemporâneo.

Por fim, gostaríamos de mencionar que esta plataforma traz uma série de melhorias e recursos que a tornam uma ferramenta indispensável para o desenvolvimento de software moderno. Como uma empresa líder em contratação de desenvolvedores de aplicativos Kotlin na Índia , estamos entusiasmados com as possibilidades que esta atualização abre, especialmente para agências de desenvolvimento de aplicativos Kotlin e Android . Para desenvolvedores Java que buscam uma transição tranquila, esta versão oferece ferramentas robustas e integração, tornando-a uma excelente escolha para o seu próximo projeto. Seja para criar soluções empresariais complexas ou aplicativos móveis inovadores, adotar esta versão mais recente permitirá que você entregue aplicativos de alta qualidade, eficientes e escaláveis.