Apresentamos o Kotlin Notebook

Já está disponível a primeira versão experimental do plug-in Kotlin Notebook para o IntelliJ IDEA! Esta postagem oferece um insight sobre a funcionalidade e os casos de uso do plug-in, mas antes de entrarmos nisso, gostaríamos de deixar o plug-in falar por si mesmo:

O que é o plug-in Kotlin Notebook?

Um notebook é uma ferramenta interativa que permite a você combinar código, visualizações e texto em um único documento. Em notebooks, você pode escrever e executar trechos de código (células), visualizar os resultados e documentar o seu processo mental, tudo em um só lugar.

Notebooks já são amplamente usados com confiança para prototipagem rápida, estatísticas e ciência de dados. O plug-in Kotlin Notebook leva o poder do desenvolvimento interativo ao IntelliJ IDEA, suplementando todo o poder do suporte à linguagem Kotlin nesse IDE com os recursos versáteis de visualização dos navegadores.

Vamos mergulhar nos detalhes técnicos para vermos o que este plug-in pode fazer e como ele funciona.

Instalação

Para obter o plug-in, basta instalá-lo a partir do Marketplace na aba Settings | Plugins do IntelliJ IDEA Ultimate. Você precisa estar usando pelo menos a versão 2023.1.2 do IntelliJ IDEA. Talvez você até consiga instalar o plug-in em versões anteriores, mas ele ficará instável.

Durante o processo de instalação, você verá uma sugestão para instalar o plug-in do Python e você deve aceitá-la. Não se preocupe, isso não instalará o Python na sua estação de trabalho. O Kotlin Notebook apenas tem algumas dependências de componentes da interface de usuário que estão localizados no plug-in do Python. Planejamos remover essas dependências em breve.

Observe que no momento, o plug-in Kotlin Notebook só funciona no IntelliJ IDEA Ultimate.

Familiarizando-se com o Kotlin Notebook

Depois de instalar o plug-in, você estará pronto para criar o seu primeiro notebook. Essencialmente, um notebook é apenas um arquivo em um drive. Portanto, ele pode ser criado em qualquer lugar da visualização Project através da ação New | Kotlin Notebook.

Será criado um arquivo com a extensão .ipynb. Se você já conhecer os notebooks do Jupyter, esta extensão deve lhe ser familiar. Internamente, os notebooks do Kotlin seguem a mesma estrutura, formato e protocolo, o que significa que esses arquivos podem ser visualizados no GitHub ou em notebooks do Jupyter ou JupyterLab com o kernel do Kotlin instalado.

Depois de criado, o notebook conterá apenas a primeira célula, vazia. Células são os principais blocos sobre os quais os notebooks são construídos e podem conter código ou texto. Para executar uma célula de código, você pode simplesmente selecioná-la e depois clicar no botão Run, ou usar o atalho Shift + Enter. O código será executado e qualquer saída ou erros serão exibidos abaixo da célula.

Você também pode escrever texto em Markdown nas células, o que dará suporte a opções de formatação como cabeçalhos, listas, links, LaTeX e imagens. Para processar uma célula em Markdown e visualizar o texto formatado, basta executá-la da mesma maneira que você executaria uma célula de código.

Notebooks oferecem um fluxo de trabalho tanto interativo quanto iterativo. Você pode executar células em qualquer ordem, modificar o código ou texto, declarar e redeclarar variáveis e reexecutar as células para ver os resultados atualizados. Isso torna fácil experimentar, prototipar e documentar o seu trabalho.

Para experimentar em primeira mão as vantagens de se usar notebooks na explicação e documentação de código, recomendamos que você baixe e explore este notebook. Ele demonstra todos os aspectos dos notebooks do Kotlin discutidos nesta postagem, permitindo que você una a teoria e a prática.

Notebook de exemplo

A melhor maneira de se familiarizar com notebooks é através de um notebook! 😉

Saídas

Um recurso-chave que faz os notebooks se destacarem é a variedade de tipos de saída que eles suportam:

Texto: Este é o tipo mais simples de saída e inclui declarações impressas, valores de variáveis ou qualquer saída do seu código que seja baseada em texto. Se o resultado de uma célula não se enquadrar em nenhuma das categorias abaixo, ele será impresso como texto, através do método toString().
HTML: os notebooks do Jupyter podem exibir HTML diretamente, permitindo formatação de texto, o uso de tabelas e até embutir Web sites.
Imagens: Imagens estáticas podem ser exibidas em formatos como PNG, JPEG e SVG. Resultados do tipo BufferedImage também são suportados. Todas essas imagens podem vir de arquivos, gráficos gerados ou qualquer outro tipo de mídia visual.
Texto formatado: Células em Markdown geram saída em HTML formatado, com suporte a listas, estilos de fonte, blocos de código e muito mais.
LaTeX: Fórmulas e equações matemáticas podem ser mostradas lindamente usando o LaTeX, um sistema de composição de textos amplamente usado no meio acadêmico.
Erros e traceback: Quando o código contém erros, os notebooks mostram uma mensagem de erro e um traceback, oferecendo insights para a depuração.

Dependências do notebook

Também é importante considerar quais dependências o seu notebook terá. Obviamente, a biblioteca-padrão pode ser usada desde a instalação, mas ela costuma não bastar. Há várias opções disponíveis para você:

Você pode usar as dependências do seu projeto, garantindo que o notebook tenha acesso às mesmas classes.
É possível usar classes e outras entidades do próprio projeto dentro do notebook. Porém, nesses casos, será verificado se houve alterações no projeto e, se necessário, este será recompilado antes da execução de cada célula.

Você pode carregar qualquer biblioteca do repositório Maven, especificando suas coordenadas através de um trecho de sintaxe ao estilo do Gradle em qualquer célula.

USE {
  repositories {
  maven {
    url = "https://my.secret.repo/maven/"
    credentials {
      username = USER
      password = TOKEN
    } 
  }
  dependencies {
    val ktorVersion = "2.0.3"
    implementation("my.secret:artifact:1.0-beta")
    implementation("io.ktor:ktor-client-core-jvm:$ktorVersion")
    implementation("io.ktor:ktor-client-apache-jvm:$ktorVersion")
  }
}

Ou você pode usar a versão mais curta, através da anotação DependsOn:

@file:DependsOn(“io.ktor:ktor-client-core-jvm:$ktorVersion“)

Lembrar-se das coordenadas do Maven e localizá-las pode ser uma tarefa trabalhosa. Para simplificar esse processo, introduzimos um método mais inteligente e conveniente de carregar bibliotecas populares. Basta usar o comando mágico %use, seguido do nome de uma ou mais bibliotecas.

Ao ser executado, o comando %use não apenas baixa as dependências de bibliotecas, como também adiciona importações-padrão ao notebook. Além disso, ele registra os renderizadores dos tipos da biblioteca e inclui várias outras funções, discutidas na próxima seção.

Integração de bibliotecas

Os notebooks do Kotlin oferecem uma grande variedade de opções de integração de bibliotecas.

Para os usuários aproveitarem essas integrações, é simples; basta adicionar uma única linha de código:

%use libraryName

Para os autores de bibliotecas, este mesmo comando serve como trampolim, permitindo que eles:

Baixem arquivos binários de bibliotecas de qualquer repositório Maven.
Incluam importações iniciais.
Executem código durante a inicialização.
Executem código antes e depois de cada execução de célula.
Pré-processem o código de cada célula.
Acionem um callback na criação de variáveis de certos tipos.
Criem renderizadores personalizados para uma variedade de tipos definidos na biblioteca.
E muito mais.

Tomados em conjunto, estes recursos oferecem possibilidades quase infinitas para criar uma experiência interativa de usuário. Considerando os tipos estáticos e AOT do Kotlin, a capacidade de geração automática de código em tempo real oferece um nível a mais de flexibilidade e expansibilidade.

Uma documentação abrangente pode ser acessada aqui. Encorajamos todos os autores de bibliotecas a compartilharem suas integrações no registro comum, para que elas fiquem disponíveis a todos os usuários do Kotlin Notebook. Em especial, estamos empolgados de vermos que algumas bibliotecas (como WebTau, Roboquant, Kaliningraph e outras) já estão se beneficiando desta abordagem.

Compartilhamento

É comum querer compartilhar os seus notebooks com outras pessoas, tanto dentro quanto fora da sua equipe. Como os notebooks do Kotlin seguem o formato universal do Jupyter, eles podem ser facilmente distribuídos através de qualquer visualizador de notebooks na Web. Em especial, o GitHub tem a capacidade de exibi-los nativamente.

Além disso, a JetBrains tem a plataforma Datalore, que tem suporte transparente aos notebooks do Kotlin. O Datalore oferece mais que apenas recursos de compartilhamento; ele também permite que você execute e edite notebooks e inclui recursos avançados, como relatórios interativos, além da opção de agendar a execução de notebooks, para ainda mais conveniência e flexibilidade.

Em resumo

A primeira versão experimental do plug-in Kotlin Notebook está pronta para você testá-la no seu projeto no IntelliJ IDEA Ultimate!

Aqui está um notebook de exemplo que você pode baixar e, através dele, aprender na prática os conceitos básicos dos notebooks do Kotlin:

Explorar notebook de exemplo

Se você for um autor de bibliotecas, considere adicionar uma integração com notebooks do Kotlin.

Se você encontrar quaisquer problemas ou bugs, informe-nos criando um ticket no rastreador de issues do projeto. Também teremos prazer em ouvir o seu feedback no canal #notebook do Slack do Kotlin.

Tenha um bom Kotlin Notebook!

Artigo original em inglês por: