Forem: Kotlinautas

Kotlin Playground para aprendizes de Kotlin

Lissa Ferreira — Thu, 24 Feb 2022 01:01:58 +0000

O quê é Kotlin Playground?

Kotlin Playground é uma plataforma criada pela Jetbrains para permitir que pessoas que estejam aprendendo Kotlin possam testar conceitos e códigos sem precisar de ter a linguagem instalada na própria máquina.

Kotlin Playground pode ser utilizado completamente via web, sem precisar instalar nada no computador, o link da plataforma é este. Inicialmente, a plataforma estará com essa aparência:

Para quê Kotlin Playground pode ser utilizado?

Kotlin Playground pode ser usado por pessoas que estão começando a aprender Kotlin, oferecendo uma interface simples, e a possibilidade de programar e testar códigos Kotlin sem nem mesmo ter a linguagem instalada no computador ou um editor de texto ou IDE.

Interface do Kotlin Playground

A interface do Kotlin Playground é bem simples, primeiramente, temos uma barra onde temos algumas opções, sendo:

Versão do Kotlin

Nessa opção podemos mudar a versão do Kotlin que vamos utilizar no nosso código. Geralmente, deixe essa opção na versão mais nova disponível.

Plataforma do Kotlin (JVM, JS, Junit, etc.)

Com essa opção, você pode escolher qual plataforma que o seu código será rodado. Caso você esteja começando a aprender Kotlin, pule essa opção por enquanto.

Argumentos do programa (--algumacoisa)

Utilizando essa opção, você irá poder escolher alguns argumentos para passar ao seu programa. Isso é útil caso o seu código utilize argumentos, como --numero ou --nome.

Copiar Link

Essa opção serve para copiar o link do seu código, e compartilhar esse link para outras pessoas, facilitando o processo de passar esse código que você criou para outra pessoa.

Compartilhar Código

Essa opção é útil para compartilhar seu código em um iframe, podendo assim colocar seu código em artigos e blogs.

Run

E também temos a opção Run podemos rodar o nosso código, onde o resultado irá aparecer abaixo do editor.

Editor

Na maior parte da tela, temos o editor do Kotlin Playground, que será o local onde iremos escrever o nosso código Kotlin. Mesmo sendo completamente via navegador, o editor tem alguns recursos para facilitar a programação, como um autocomplete para completar o nosso código enquanto estamos escrevendo.

Finalização

Nesse pequeno artigo, te mostrei o quê é o Kotlin Playground, e como usá-lo para programar Kotlin completamente pelo navegador.

Muito obrigada por ler ❤️🏳️‍⚧️ e me segue nas redes, é tudo @lissatransborda 👀

Explorando a documentação: Números em Kotlin

Lissa Ferreira — Sun, 30 Jan 2022 23:28:25 +0000

Kotlinautas

Esse conteúdo é oferecido e distribuído pela comunidade Kotlinautas, uma comunidade brasileira que busca oferecer conteúdo gratuito sobre a linguagem Kotlin em um espaço plural.

Como representar números no Kotlin?

Números em Kotlin podem ser representados de duas maneiras, essas maneiras são os tipos de números que o Kotlin suporta, sendo:

Inteiros (Byte, Short, Int e Long): números negativos e positivos sem casas decimais
Racionais (Float/Double): Número negativos e positivos com casas decimais

Quais são os tipos inteiros?

Os tipos inteiros se dividem em quatro, sendo esses quatro:

Byte: Números inteiros de -128 á 127
Short: Números inteiros de -32768 á 32767
Int: Números de -2,147,483,648 á 2,147,483,647
Long: Números de -9,223,372,036,854,775,808 á 9,223,372,036,854,775,807

Por conta desses tipos de números diferentes, devemos pensar em qual será o tamanho do número que vamos guardar, para usar um tipo apropriado para esse número.

Quais são os tipos racionais?

Os tipos racionais se dividem em Float e Double. A diferença entre Float e Double, é que o número máximo de casas decimais do float são de 7 números, enquanto que o número máximo de casas decimais do Double são de 16 números.

Usando números inteiros no Kotlin

Podemos usar números inteiros no Kotlin definindo em variáveis, por exemplo:

val exemploNúmero = 101

Como não informamos o tipo de número no exemplo acima, O Kotlin irá entender automaticamente qual é o melhor tipo para usar nesse número, que no caso, será Int. Mas caso você prefira, também é possível de informar o tipo do número, como no exemplo abaixo:

val exemploNúmero: Int = 101

Usando números racionais no Kotlin

A mesma coisa acontece com os números racionais, podendo ser definidos sem determinarmos o tipo:

val exemploNúmero = 50.5

E também determinando o tipo:

val exemploNúmero: Double = 50.5

Operações com números

Podemos fazer operações com números do Kotlin da mesma maneira que qualquer outra linguagem. Uma soma por exemplo pode ser feita dessa forma:

val soma = 10 + 30 // 40

Na variável soma, será atribuida o resultado da soma entre os números 10 e 30, logo, a variável soma terá o valor 40.

Em Kotlin, temos alguns operadores, como:

Operador	Símbolo	Exemplo
Soma	+	5 + 10
Subtração	-	5 - 10
Multiplicação	*	5 * 10
Divisão	/	5 / 10
Resto de divisão	%	5 % 10

Você pode estar se perguntando o quê é esse operador de Resto de Divisão. Esse operador faz uma divisão comum, mas ao invés de retornar o resultado da divisão, retorna o resto que ficou dessa divisão.

Esse operador é utilizado principalmente para descobrir se um número é par ou impar usando o número 2. Como por exemplo: 5 % 2, 10 % 2,etc.

Conversão de tipos numéricos

Podemos converter qualquer número para outro tipo numérico ou para outros tipos, como no exemplo abaixo:

val numeroInt = 10
val numeroFloat = numeroInt.toFloat() // 10.0

No exemplo acima, criamos uma variável chamada numeroInt valendo 10;
Após isso numeroFloat é definida com o valor de numeroInt (10), mas transformado em Float. Tendo assim um valor com casas decimais 10.0;

Também podemos converter para outros tipos que não sejam numéricos, como no exemplo abaixo:

val numeroInt = 10
val numeroString = numeroInt.toString() // "10"

No exemplo acima, criamos a numeroInt novamente, e depois criamos a numeroString tendo o valor da numeroString, mas em forma de String, não número.

Finalização

Nesse artigo, você aprendeu a como usar números, fazer operações, e conversões com esses números no Kotlin!

Muito obrigada por ler ❤️🏳️‍⚧️ e me segue nas redes, é tudo @lissatransborda 👀

Encoding, Hashing e Encryption: Qual a diferença?

Ste Suzart 🦊 ~ — Sat, 22 Jan 2022 22:34:16 +0000

Encoding, hashing e encryption são conceitos comuns aplicados e discutidos ao tentar proteger os dados. Muitos devs afirmam usar métodos e padrões de criptografia fortes, mas é necessário que uma equipe de segurança avalie se realmente é apropriado.👌

Vamos dar uma olhada nas diferenças entre o uso adequado de encoding, hashing e encryption.

Encoding

Encoding(codificar) algo é comunicá-lo de uma maneira que o receptor entenda. Existem muitos padrões de codificação, como por exemplo, Base64, UTF-8 e ASCII. Cada padrão tem uma finalidade e as aplicações que usam esses padrões de codificação esperam receber dados compatíveis com esse padrão de codificação.

Uma comparação fácil é a linguagem humana. As palavras, sintaxe e regras da linguagem são diferentes e únicas para cada cultura linguística. Um nativo de português pode não ser capaz de ler ou falar japonês, mas com o tradutor adequado, ele pode decodificar o japonês para o português e até codificar o português para o japonês usando um tradutor.

As duas linhas a seguir representam os mesmos dados:

Texto: Esta linha tem dados secretos que você realmente deve codificar.
Base64: RXN0YSBsaW5oYSB0ZW0gZGFkb3Mgc2VjcmV0b3MgcXVlIHZvY8OqIHJlYWxtZW50ZSBkZXZlIGNvZGlmaWNhci4=

Para os olhos humanos, essas duas linhas são totalmente diferentes. Para uma aplicação, elas são iguais.

Se você codificar diversas vezes os mesmos dados, o encode gerado será o mesmo valor, caso mude uma vírgula, irá mudar tudo.

A codificação de dados é normalmente usada para garantir a integridade e usabilidade dos dados e na maioria das vezes é usada quando os dados não podem ser transferidos em seu formato atual entre sistemas ou aplicações.

A codificação não é usada para proteger dados, porque é fácil de reverter.

Qualquer fornecedor que afirme usar criptografia base64 forte em sua solução é suspeito.

Exemplo de código em kotlin:

import java.util.*

fun main() {
    val mensagem = "Esta linha tem dados secretos que você realmente deve codificar."

    //codifica para base64
    val codificarString: String = Base64.getEncoder().encodeToString(mensagem.toByteArray())

    println("string codificada: $codificarString")

    //decodifica
    val decodificarBytes = Base64.getDecoder().decode(codificarString)
    val decodificarString = String(decodificarBytes)

    println("string decodificada: $decodificarString")
}

Hashing

Hashing é um método de validação de integridade. O problema que o hashing se propõe a resolver não é proteger os dados de serem lidos, mas sim validar que os dados em questão não foram alterados.

Os algoritmos de hash são funções unidirecionais que recebem uma entrada e calculam uma única saída. Os algoritmos de hash são projetados de tal forma que você não pode pegar um valor de hash e trabalhar o algoritmo de volta para obter a entrada original. Caso haja uma invasão na sua base de hash, o invasor teria que gerar muitas entradas em potencial e comparar a saída com a saída do algoritmo de hash para ver se elas estavam corretas.

Os algoritmos de hash incluem SHA1, SHA256 e SHAKE256, entre outros.

As três linhas a seguir representam os mesmos dados:

Texto: Esta linha tem dados secretos que você realmente deve criptografar.
MD5: ca37111d05a53346b2c14d749e4c4191
SHA1: f6472fbf25720494e4d02d0ec2c94aacee34d602

Hashing nunca deve ser revertido. Ele não deve ser usado para impedir que as comunicações sejam lidas por partes não autorizadas.

Um uso comum de hash é para proteger o armazenamento de senhas. Quando um usuário cria uma senha, a senha é colocada por meio de um algoritmo de hash. O hash resultante é então armazenado. Quando um usuário tenta se autenticar, a senha é criptografada novamente e comparada com o hash armazenado.

Novamente, o hash é uma verificação de integridade. Não é criptografia.

Exemplo de código em kotlin:

import java.math.BigInteger
import java.security.MessageDigest

fun main() {

    val input = "Esta linha tem dados secretos que você realmente deve criptografar."
    val md5 = input.md5()
    println("o hash do md5 é $md5")

    val sha1 = input.sha1()
    println("o hash do sha1 é $sha1")
}

fun String.md5(): String {
    val md = MessageDigest.getInstance("MD5")
    return BigInteger(1, md.digest(toByteArray())).toString(16).padStart(32, '0')
}

fun String.sha1(): String {
    val md = MessageDigest.getInstance("SHA-1")
    return BigInteger(1, md.digest(toByteArray())).toString(16).padStart(32, '0')
}

Encryption

A Encryption(criptografia) torna os dados ilegíveis por qualquer pessoa, exceto aqueles que conhecem a secret key(chave secreta). O segredo pode ser uma única shared key(chave compartilhada) ou pode ser dividido em duas chaves - uma mantida privada e outra fornecida à outra parte.

Digamos que Quinn e Gary desejam se comunicar com segurança. Eles decidem usar uma shared key(chave compartilhada) de “chookity” para seu segredo. Ao criptografar uma mensagem, Quinn insere a chave de criptografia. Ao descriptografar a mensagem, Gary digita a chave para poder ler a mensagem.

Quinn e Gary, no entanto, estão preocupados com o fato da mensagem secreta ser lida por um terceiro que possa adivinhar ou obter essa chave. Eles decidem usar um sistema de duas chaves (criptografia de chave assimétrica - asymmetric key encryption) para criptografar as mensagens. Quinn quer enviar uma mensagem que somente Gary pode ler. Quinn usa uma chave (chave pública - public key) que Gary deu a ela com antecedência. Gary recebe essa mensagem criptografada e usa sua outra chave (chave privada - private key) para descriptografar e ler essa mensagem. Como apenas Gary conhece sua chave privada e nunca a compartilhou com ninguém, ninguém pode descriptografar a mensagem, exceto Gary. Gary também usa sua chave privada para enviar uma mensagem para Quinn e Quinn pode usar a chave pública que Gary deu a ela para lê-la. Esse tipo de criptografia é conhecido como signing(assinatura). Como a chave pública que Gary deu a Quinn descriptografou a mensagem, Quinn pode presumir com segurança que Gary enviou a mensagem, pois apenas Gary tem a outra chave desse par.

Algoritmos de criptografia fortes comuns incluem: AES, Blowfish e RSA.

Conclusão

Encoding, hashing e encryption podem ser usados juntos. Uma mensagem codificada em base64 para uma aplicação pode ser hash para que a integridade dessa mensagem possa ser verificada pelo receptor. A mensagem pode então ser criptografada e enviada para o destinatário que irá descriptografar e comparar o hash da mensagem com o valor de hash recebido do remetente para garantir que a mensagem não foi alterada.

Compreender a diferença entre esses conceitos pode ajudá-lo a considerar o design e a arquitetura de segurança, especialmente quando se trata de aquisição ou revisão de aplicações. Implementar acidentalmente a codificação como um método de criptografia pode ser muito perigoso para uma organização, pois isso significaria que as transmissões são dados reais que podem ser facilmente decodificados por qualquer pessoa, então tomem cuidado senhores & senhoras ✌️

Meu início no mundo Kotlin

Victor Castro — Wed, 12 Jan 2022 03:10:38 +0000

Em janeiro de 2021 comecei em um novo trabalho. Além dos desafios de adaptação que costuma ocorrer ao você iniciar em uma nova empresa, como, por exemplo, regras e cultura da organização, arquitetura e objetivo do projeto, etc.

Nesse novo trabalho tive outro desafio que foi desenvolver com uma linguagem de programação que eu nunca tinha tido contato anteriormente e essa linguagem foi o Kotlin, de início fiquei um pouco com medo de ter que mexer com algo que nem sequer tinha estudado antes. Só tinha visto alguns vídeos aleatórios no youtube sobre Kotlin, mas bem por cima mesmo, sem algo muito detalhado.

Mas depois de um tempo eu me senti mais confortável, durante esse artigo, irei explicar um pouco de como comecei a estudar Kotlin e, porque resolvi continuar investindo nele.

Kotlin além do Android

Um dos grandes desafios era que eu iria desenvolver com o Kotlin no lado do servidor, é muito comum se ouvir falar de Kotlin para programação Android, mas ela é uma linguagem multiplataforma, ao decorrer do artigo vou explicar melhor sobre isso.

Fiquei receoso em investir o meu tempo de estudos em uma linguagem que quase não via vaga para backend, via muitas para mobile, mas backend era quase zero. Lembro que chamei a @morgannadev para conversar, pois, ela era a única pessoa que eu conhecia que trabalhava com Kotlin no backend e perguntei se realmente valia a pena investir meu tempo estudando e se tinha mercado para essa tecnologia no backend.

Após conversar bastante, cheguei na decisão de que iria continuar estudando Kotlin.

Como surgiu?

Kotlin foi desenvolvida em 2011 pela Jetbrains, o seu principal objetivo ao ser criada era porque a Jetbrains queria uma linguagem de programação para resolver problemas de produtividade na criação de suas IDEs, que eram desenvolvidas com Java.

Porém, ela estava tendo problemas com certas características do Java, foi aí que Jetbrains resolveu desenvolver uma linguagem de programação, que pudesse suprir suas necessidades e melhorar o desenvolvimento de seus produtos. A versão 1.0 do Kotlin foi lançada oficialmente em 15 de fevereiro de 2016.

Onde posso usar Kotlin?

Como foi falado anteriormente, Kotlin é uma linguagem multiplataforma. Ela roda em cima da JVM (Java Virtual Machine), ou seja, você consegue executar em qualquer lugar que rode a JVM.

Hoje em dia é muito comum ver o Kotlin ligado ao desenvolvimento Mobile, o motivo disso é que em 2017 o Google anunciou que a partir daquele momento, Kotlin era uma linguagem suportada para o desenvolvimento Android e em 7 de maio de 2019 declarou como a linguagem oficial para o desenvolvimento de aplicações Android.

Mas podemos trabalhar com Kotlin no lado do servidor, desenvolvendo aplicações Web utilizando frameworks como Micronaut, Ktor, Spring etc, esse é meu foco atualmente. Também podemos criar aplicações Desktop utilizando bibliotecas de interfaces como TornadoFx ou JavaFx. Existe ainda a possibilidade de transpilar um código Kotlin para javascript, fazendo com que seja possível desenvolver aplicações web frontend. Você pode achar mais informações sobre o nessa parte da documentação.

Também é possível desenvolver aplicações para IOS utilizando o KMM(Kotlin Multiplatform Mobile) e conseguimos criar aplicações nativas para várias plataformas utilizando o Kotlin native, temos um artigo da @lissadev sobre isso.

Kotlin possui várias possibilidades para trabalhar, você pode ver melhor na documentação oficial. Mas resumindo temos os seguintes locais onde podemos criar aplicações:

Desenvolvimento Android
Desenvolvimento Backend
Desenvolvimento Desktop
Transpilação para Javascript
Desenvolvimento multiplataforma (Ios e Android)
Desenvolvimento nativo

Características do Kotlin

Logo abaixo você consegue ver um exemplo de um código escrito em Kotlin:

fun soma(valor1: Int, valor2: Int): Int {
    return valor1 + valor2
}

fun main() {
    val primeiroNumero = 10
    val segundoNumero = 5
    val resultado = soma(primeiroNumero, segundoNumero)
    println("O resultado da soma é: $resultado")
}

main()
// O resultado da soma é: 15

Esse é um código bem simples que declara uma função chamada soma esperando dois parâmetros do tipo inteiro e retorna a soma desses valores. Já na função main() definimos duas variáveis que recebe dois números inteiros, definimos uma variável chamada de resultado que recebe o retorno da função soma passando como parâmetro às duas variáveis declaradas anteriormente e por fim mostramos na tela o valor da soma, concatenado com uma string.

E no final chamamos nossa função main. Você pode executar o código acessando esse link.

Como pode ver a sintaxe do Kotlin é bem simples e amigável. Uma coisa que escutei quando tava começando, é que o Kotlin pega as coisas que são boas de várias linguagens e junta em uma só.
Durante o tempo em que estou escrevendo código em Kotlin, me lembro de várias coisas que utilizo em outras linguagens como, por exemplo javascript e Java.

Vantagens do Kotlin

Bom, mas quais são as vantagens em relação as outras linguagens? Existem diversas vantagens, mas eu resolvi destacar aqui nesse artigo as quais eu considero mais legais pra quem está iniciando saber.

Compatibilidade com Java: Como falado antes, Kotlin roda em cima da JVM, isso é possível, pois, um código escrito em Kotlin no final é compilado para um bytecode Java, ou seja, você consegue utilizar Java e Kotlin no mesmo projeto, pois, no final na hora de executar, tudo vai ser convertido para um arquivo bytecode Java. Mas qual a vantagem disso? A vantagem é que você pode fazer a transição de um projeto escrito em Java para Kotlin com pequenos passos, pois, você pode ter um projeto Java e começar a escrever novas funcionalidades em Kotlin e ir transcrevendo as classes antigas escritas em Java para Kotlin. Um recurso legal que você pode usufruir é o Java2Kotlin através de uma funcionalidade da IDE da Jetbrains. Você pode entender melhor nesse link.
Suporte a várias bibliotecas: Pela vantagem falada acima você pode utilizar todas as bibliotecas utilizadas no mundo Java em seu projeto Kotlin, basta instalar a lib no seu projeto e importar no seu arquivo, provavelmente você vai ter que mudar a forma de chamar certas funções, mas a própria IDE da Jebrains te ajuda com isso. Uma dúvida que tive no início era se eu precisava aprender Java antes de aprender Kotlin. E a resposta é NÃO, você ter uma base de pode te ajudar, mas não é um requisito para começar a estudar o Kotlin.
Linguagem multiparadigma: Uma coisa bem legal que o Kotlin te proporciona é você poder utilizar diversos paradigmas de programação em seus projetos. Pois, o Kotlin suporta o paradigma de POO(Programação Orientada a Objetos), paradigma procedural e paradigma Funcional, uma coisa que fiquei admirado quando comecei a estudar Kotlin é que eu poderia declarar uma variável recebendo uma estrutura de decisão (if e else), pois, diferente de outras linguagens no Kotlin uma estrutura de decisão é uma função.
Null safety: Algo queridinho da comunidade do Kotlin é o Null safety se você veio de linguagens como javascript, provavelmente durante o desenvolvimento de alguns sistemas você já se deparou com um 'undefined' ou no Java você, já se deparou com o erro 'NullPointerException' isso ocorre, pois, nessas linguagens você pode declarar uma variável inicialmente sem nenhum valor declarado a ela, no Kotlin isso não é possível, você deve atribuir um valor a uma variável ao declara-la. Existe formas de contornar isso utilizando o operador '?' depois do tipo da variável, por exemplo.

var nome: String? = null;

Mas observe que eu atribuo o valor null na variável. Isso não dever ser feito com frequência, pois pode trazer problemas futuros na execução do seu projeto. Mas o importante ressaltar essa funcionalidade do Kotlin é que você tem um código mais seguro. Antes eu programava com Javascript e PHP e essas linguagens não têm esse tipo de suporte, você nem mesmo precisa declarar o tipo da variável e isso de inicio me travava um pouco na hora de desenvolver, mas com o tempo você vai pegando o jeito. Você pode estudar melhor sobre esse assunto olhando na documentação do Kotlin nesse link.

Vagas

No inicio eu falei que tinha medo de não achar uma vaga para Kotlin no backend, além de ter várias para o mobile também possuimos várias vagas para Kotlin no backend. Você pode dar uma olhada nesse repo do github sobre empresas que utilizam Kotlin no backend aqui no Brasil. Isso sem contar as vagas que temos fora do Brasil, então temos bastante vagas para você poder trabalhar.

Como estudar Kotlin?

Bom depois de ler tudo isso sobre Kotlin espero ter despertado em você um interesse em estudar Kotlin :) Mas, como eu posso fazer isso? Bom eu vou passar aqui dicas que eu recebi quando eu estava iniciando, mas isso não quer dizer que só existe essa forma, essa foi apenas a forma que eu aprendi e pode ajudar você também.

A primeira dica que eu passo é ler a documentação. A documentação do Kotlin é bem detalhada e explica muito bem, você pode acessar a documentação aqui.
A segunda coisa que me ajudou bastante no inicio e ajuda até hoje é uma parte especifica da documentação que mostra a sintaxe básica da linguagem, se você é do tipo de pessoa que gosta de aprender uma linguagem nova já colocando a mão na massa você pode iniciar lendo a parte de base syntax. Nela você consegue ver como declarar coisas básicas da linguagem, como por exemplo variáveis, funções, arrays, estruturas de decisão e repetição e etc.
Se você gosta de cursos eu separei uma lista de cursos gratuitos que você pode fazer, essa lista tá disponibilizada aqui no site da Kotlinautas.
Se você gosta de ler indico você seguir a gente da Kotlinautas aqui no dev.to nesse link você pode achar vários artigos legais sobre Kotlin no geral.
Uma da parte mais importante para aprender uma linguagem de programação nova é praticar escrevendo algoritimos, para isso você pode utilizar a parte de Kotlin By Examples na documentação do Kotlin.
E por último uma coisa que é legal você saber é sobre a forma "Kotliniana" de se escrever um código. Isso é apenas uma forma que um código escrito em Kotlin deve ser, mas você não deve ficar preso a isso no início, pois isso pode atrapalhar na sua evolução, eu apenas indico você dar uma olhada e saber que existe.
Bom e por último mas não menos importante você pode seguir no twitter o perfil da Kotlinautas da Jetbrains e o da linguagem Kotlin para saber sobre atualizações da linguagem.

Bom espero ter ajudado você nesse início com Kotlin e ter tirado algumas dúvidas sobre essa linguagem que mal conheço mas já considero Pakas. E qualquer dúvida que você tiver pode me chamar lá no Twitter kastrowalker que eu vou ter um prazer imenso em ajudar você.

Um grande abraço e até a próxima.

Frontend com KVision

Lissa Ferreira — Tue, 04 Jan 2022 02:47:18 +0000

Kotlinautas

Esse conteúdo é oferecido e distribuído pela comunidade Kotlinautas, uma comunidade brasileira que busca oferecer conteúdo gratuito sobre a linguagem Kotlin em um espaço plural.

O quê é Kotlin/JS?

Com Kotlin/JS podemos escrever um código totalmente em Kotlin, e esse código em Kotlin será transformado em Javascript. Com isso, poderemos criar uma página web, com estrutura (HTML), estilos (CSS) e interação (Javascript) unicamente com Kotlin.

Uma das vantagens do Kotlin/JS é poder usar bibliotecas multi-plataforma dentro do Kotlin/JS, aumentando as combinações entre bibliotecas que podem ser feitas.

O quê é KVision?

KVision é um framework para a plataforma Kotlin/JS. Com KVision poderemos escrever código do Kotlin/JS de maneira mais simples, criando componentes, usando Bootstrap, estilizando elementos HTML com Kotlin,etc. Uma outra funcionalidade é usar componentes React/Redux dentro do KVision.

Além disso, KVision pode se integrar facilmente com Ktor, Spring, Quarkus e outros frameworks para Kotlin.

Materiais

Será necessário ter o IntelliJ instalado na máquina, conhecimento básico sobre a linguagem Kotlin e conhecimento básico sobre frontend (HTML, CSS e Javascript).

Instalando o plugin do KVision

Agora, vamos começar a criar o projeto, primeiro, vamos ao marketplace de extensões do IntelliJ. Vá ao menu de configurações, com o atalho Ctrl+Alt+S, e ao menu Plugins:

Após isso, vá na barra de pesquisa e pesquise por kvision. Com isso, o plugin do KVision irá aparecer e você poderá instalar clicando no botão Install

Agora, caso você clique no botão New Project, terá um novo menu no canto esquerdo, sendo o menu do KVision que acabamos de instalar.

Criando um projeto com KVision

Agora vamos criar um projeto com KVision. Primeiro, observe que o menu do KVision tem alguns campos, sendo:

Project Type: Define o tipo de projeto que será criado, podendo ser um projeto Ktor, Spring, Quarkus,etc. No caso, será apenas um projeto de frontend, então deixe na opção padrão Frontend project
GroupId: Define o grupo do pacote que será criado, esse campo é totalmente livre. Você pode colocar algo como com.kvsion
ArtifactId: Define o artifact do pacote que será criado, esse campo é totalmente livre. Você pode colocar algo como kvision
Kotlin/JS compiler: Define qual será o compilador que vamos usar no projeto. Deixe como está, que é o IR.
Opitional Modules: São diversos módulos que podem ser instalados de maneira opicional, primeiramente, vamos selecionar os dois primeiros, sendo o Bootstrap based components, e o Standard Bootstrap CSS styling

Após fazer essas configurações, clique no botão Next para continuar.

Agora preencha o nome, e a localização do projeto, sendo de escolha completamente pessoal. Caso não tenha nenhuma ideia, pode nomear com algo como kvision ou kvisiondemo por exemplo.

Caso você crie o projeto e dê algum erro dizendo que a configuração da JDK do Gradle é inválida, dessa maneira (texto e imagem):

Texto

Invalid Gradle JDK configuration found. Open Gradle Settings
Use JDK from project structure

Imagem

Para resolver isso, clique no botão Open Gradle Settings, e irá aparecer o menu de configurações do Gradle

Vá á opção Gradle > Use Gradle from: e mude essa opção de 'gradle-wrapper.properties' file para 'wrapper' task in Gradle build script.

Caso a opção abaixo Gradle JVM esteja em vermlho, mude para uma versão válida. Clicando será possível de escolher uma versão da JVM específica para esse projeto.

Clique em OK para aplicaras mudanças. Com isso, as dependências do seu projeto serão carregadas no projeto.

Entendendo a estrutura de pastas do KVision

Os arquivos dentro da raiz do projeto são referentes á configuração do projeto e do KVision. Esses não iremos mexer em nada por enquanto.

Dentro da pasta src temos todos os arquivos fonte da nossa aplicação, primeiramente temos duas pastas, sendo a main que guarda o código principal da nossa organização, e a test que irá guardar os testes da nossa aplicação.

Dentro da main, temos apenas duas pastas, kotlin que irá armazenar apenas código Kotlin. Caso nosso projeto tivesse Java (que não é o caso) teriamos uma pasta Java também. A outra pasta é a web que guarda arquivos que serão usados por toda a aplicação. Agora temos apenas o arquivo index.html, que guarda um template HTML:

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>KVision Template</title>
    <script type="text/javascript" src="main.bundle.js"></script>
</head>
<body>
<div id="kvapp"></div>
</body>
</html>

A nossa aplicação está dentro de src/main/kotlin/com/kvision/kvision/App.kt, que por enquanto apresenta apenas um Hello World. Vamos ver mais sobre esse arquivo:

package com.kvision.kvision

import io.kvision.Application
import io.kvision.CoreModule
import io.kvision.BootstrapModule
import io.kvision.BootstrapCssModule
import io.kvision.html.div
import io.kvision.module
import io.kvision.panel.root
import io.kvision.startApplication

class App : Application() {
    override fun start() {
        root("kvapp") {
            div("Hello world")
            // TODO
        }
    }
}

fun main() {
    startApplication(
        ::App,
        module.hot,
        BootstrapModule,
        BootstrapCssModule,
        CoreModule
    )
}

Linha 3 á 10 importa diversos componentes, classes, elementos HTML,etc que vamos usar na nossa aplicação;
Linha 12 declara uma classe que irá representar a nossa aplicação;
Linha 13 - declara a função start, que irá guardar o código dessa página web em específica;
Linha 14 - root é uma função que cria um novo container. Esse container irá armazenar todas as tags HTML da aplicação, apenas precisamos informar um ID que é o ID do elemento que irá guardar todos esses elementos. No caso sendo kvapp;
Linha 15 - cria um elemento div que apenas está escrevendo um hello world na tela. Servindo apenas como exemplo;
Linha 21 - declara a função main da nossa aplicação, sendo essa a função principal;
Linha 22 - Inicia a aplicação com a função startApplication;
Linha 24 á 27 - São passados os módulos que baixamos para a aplicação, sendo o module.hot um módulo que nos permite mudar uma página e automaticamente a mudança ocorrer no navegador, BootstrapModule e BootstrapCssModule que são módulos relacionados á Bootstrap, e o CoreModule que é um módulo padrão do KVision;

Para iniciar a aplicação, clique na barra lateral Gradle, depois em Run Configurations, e em Run run duas vezes, para assim fazer que a aplicação seja iniciada na URL localhost:3000

Agora nossa aplicação está inciada, e na página localhost:3000 irá aparecer o Hello World do KVision.

Agora vamos fazer um exercício bem simples, vamos mudar o texto de hello world para Olá, mundo!. Isso pode ser feito mudando o conteúdo da função div:

class App : Application() {
    override fun start() {
        root("kvapp") {
            div("Olá, mundo!")
        }
    }
}

Mudamos o conteúdo de dentro de div e também removemos o comentário // TODO;

Agora, o novo conteúdo será automaticamente atualizado e mostrado na página.

Criando elementos HTML

Agora, vamos ver alguns exemplos de elementos HTML que podem ser criados usando KVision.

Primeiro, vamos modificar uma importação do nosso código. Pode ser visto na linha 7 que importamos apenas o elemento div:

import io.kvision.html.div

Vamos mudar esse import, para ao invés de importar apenas o elemento div, importar todos os elementos HTML suportados pelo KVision, e mais algumas funcionalidades relacionadas á CSS e JS. Isso pode ser feito utilizando o caractere coringa *:

import io.kvision.* // Funções, classes,etc. do KVision
import io.kvision.core.* // Funcionalidades relacionadas á CSS e JS
import io.kvision.html.* // Todas as tags HTML
import io.kvision.panel.* // Importar todos os painéis que podem ser criados (veremos mais adiante)
import io.kvision.utils.* // Unidades de medida como px (pixel)

Listas

Uma lista em HTML é uma série de dados unidos em uma forma visual de uma lista, um exemplo de lista é:

Primeiro elemento
Segundo elemento
Terceiro elemento

Isso pode ser feito em HTML com dois elementos, sendo <ul>, que é uma lista não ordenada, e <li> que é um elemento de uma lista. Logo, em HTML a lista acima seria:

<ul>
    <li>Primeiro elemento</li>
    <li>Segundo elemento</li>
    <li>Terceiro elemento</li>
</ul>

Isso pode ser feito no KVision usando a função listTag, que representa uma lista em HTML.

na função listTag, iremos precisar informar o tipo da lista, sendo ul para listas não ordenadas (só com as bolinhas por exemplo) e ol para listas ordenadas, e após isso informar a lista. Um exemplo prático disso é esse:

...

class App : Application() {
    override fun start() {
        root("kvapp") {
            listTag(ListType.UL, listOf("Primeiro elemento", "Segundo elemento", "Terceiro elemento"))
        }
    }
}

...

Informamos o tipo da lista usando o método listType.UL, caso quisessemos que essa lista fosse uma <ol>, apenas iriamos mudar para listType.OL;
Após isso, passamos uma lista de strings usando a função listOf, colocando os elementos da lista dentro;

Com isso, a lista será mostrada na página.

Caso mudemos o argumento ListType.UL para listType.OL, com o código ficará dessa maneira:

...

class App : Application() {
    override fun start() {
        root("kvapp") {
            listTag(ListType.OL, listOf("Primeiro elemento", "Segundo elemento", "Terceiro elemento"))
        }
    }
}

...

A lista ficará ordenada na página, seguindo assim a mudança feita de lista não ordenada para lista ordenada.

Links

No HTML, para criar links usamos a tag <a>, que representa uma "âncora" que cria um link para uma página. No caso da tag <a> vamos precisar informar um parametro href, que é para onde aquele link irá levar, e também um texto ou outros elementos dentro da tag <a>. Dessa maneira:

<a href="https://dev.to/kotlinautas">Ver artigos da Kotlinautas</a>

Para criar links no KVision podemos usar a função link, passando um placeholder, que é um texto que será clicável, e o link. Dessa maneira:

...

class App : Application() {
    override fun start() {
        root("kvapp") {
            link("Ver artigos da Kotlinautas", "https://dev.to/kotlinautas")
        }
    }
}

...

Agora teremos um texto clicável em nossa página, que quando é clicado levará á lista de artigos da Kotlinautas.

Quando o link é clicado, a página atual é substuida pela lista de artigos da Kotlinautas. Como posso mudar esse comportamento, e fazer que quando o link é clicado, seja criada uma nova página com a página do link?

Olhando para a assinatura da função link, podemos ver todos os argumentos que podem ser passados:

fun Container.link(
    label: String,
    url: String? = null,
    icon: String? = null,
    image: ResString? = null,
    separator: String? = null,
    labelFirst: Boolean = true,
    target: String? = null,
    className: String? = null,
    init: (Link.() -> Unit)? = null
): Link

Podemos ver que os únicos argumentos que usamos foram o label, que é o texto do link, e o url que é para onde o link está redirecionando. O argumento que precisamos adicionar para mudar o comportamento de redirecionamento desse link é no target. Isso pode ser feito passando esse target na chamada dessa função link, dessa maneira:

...

class App : Application() {
    override fun start() {
        root("kvapp") {
            link("Ver artigos da Kotlinautas", "https://dev.to/kotlinautas", target = "_blank")
        }
    }
}

...

Passamos o target diretamente, usando o target =, e passando o valor _blank que irá fazer que uma nova página seja aberta.

Conteúdo dinâmico

Podemos mudar o conteúdo de uma página dependendo de alguma interação que a pessoa usuária da página fizer. Isso pode ser feito usando a função .onEvent, que irá executar algo se algum evento específico, como um clique, o mouse passar por cima do elemento,etc. acontecer.

Vamos ver o exemplo abaixo:

...

class App : Application() {
    override fun start() {
        root("kvapp") {
            link("Link para o Twitter da Kotlinautas", "https://twitter.com/kotlinautas").onEvent {
                mouseover = {
                    self.label = "Link para o Twitter da Feministech"
                    self.url = "https://twitter.com/feminis_tech"
                }
            }
        }
    }
}

...

Temos um elemento link que leva ao twitter da Kotlinautas;
Usamos a função .onEvent, iniciando um bloco onde podemos colocar os eventos que podem ocorrer com esse link;
Colocamos um evento dentro desse bloco, sendo o mouseover, que é um evento que ocorre toda vez que o mouse passa por cima do elemento;
Dentro desse mouseover, mudamos o texto e a url do link usando a variável self que representa o elemento;

Agora, quando você passar o mouse pelo link que levava ao twitter da Kotlinautas, o link será automaticamente modificado, e irá te enviar ao twitter da Feministech no lugar.

Há outros eventos que podem ser colocados no lugar, caso queira ver todos que podem ser usados, veja nessa lista da MDN

Rich Text

Podemos inserir um texto com tags HTML como seu conteúdo no KVision. Veja no exemplo abaixo:


...
class App : Application() {
    override fun start() {
        root("kvapp") {
            p(
                "<strong>Texto em negrito</strong>"
            )
        }
    }
}
...

Quando você abrir a página, o conteúdos será um texto Texto em negrito:

Isso aconteceu pois o texto na página está sendo mostrado apenas como texto, não como tags HTML. Para fazer que um texto seja interpretado como HTML, podemos passar um argumento chamado rich como verdadeiro. Dessa maneira:


...
class App : Application() {
    override fun start() {
        root("kvapp") {
            p(
                "<strong>Texto em negrito</strong>",
                rich = true
            )
        }
    }
}
...

Agora, o texto mostrado na página será interpretado como HTML:

Criando componentes

Um componente é como se fosse uma tag HTML criada por nós mesmos. Onde podemos informar seu conteúdo, criar um estilo personalizado, misturar uma ou mais tags dentro de uma única,etc.

Primeiro, vamos criar um novo arquivo em src/main/kotlin/com/kvision/kvision chamado Cartão.kt. Esse arquivo terá algumas importações:

package com.kvision.kvision

import io.kvision.core.*
import io.kvision.html.*
import io.kvision.utils.*

Depois, vamos criar uma função chamada Cartão que será o nosso componente. A ídeía é criar um texto em negrito, com um fundo cinza. Formando como se fosse um retângulo. Primeiro, vamos criar a função:

fun Container.Cartão(texto: String? = null): Strong {

}

Essa interface Container foi usada pois todo componente (e tag HTML no KVision) precisa estar dentro dessa interface para ter alguns métodos e propriedades disponíveis;
Recebemos uma variável texto, que será o conteúdo do componente;
o retorno : Strong deixa claro que o elemento que iremos retornar será um elemento em negrito ()

Após isso, vamos criar o elemento:

fun Container.Cartão(texto: String? = null): Strong {
    val elemento = Strong(content = texto, className = "cartão")

}

Usamos o método Strong(), que irá criar por sua vez, um elemento HTML 
Passamos apenas dois argumentos, sendo um content que é o conteúdo do elemento, no caso será a variável texto. E um className que representa o nome da classe que poderá eventualmente ser usado em um arquivo CSS ou JS;
Guardamos tudo isso em uma variável chamada elemento;

Agora, vamos fazer algumas modificações no estilo desse elemento, para criar assim o estilo de um cartão:

fun Container.Cartão(texto: String? = null): Strong {
    val elemento = Strong(content = texto, className = "cartão")

    elemento.background = Background(Color("#DDD"))
    elemento.padding = 10.px
    elemento.fontSize = 30.px
}

Modificamos o estilo do elemento acessando diretamente essas propriedades, usando .background, .padding,etc. e definindo o valor dessas variáveis;
Para definir o background, usamos dois métodos, sendo o Background, que irá retornar o background, e um Color que irá retornar uma cor. Dentro do color passamos a cor em forma de hexadecimal, sendo #DDD;
Para definir valores em pixel, inserimos um número, seguido de um .px indicando a unidade. Caso quissemos usar outra unidade como vh ou vw, apenas mudariamos o final, ficando 10.vw por exemplo;

Agora vamos terminar a função adicionando esse elemento ao Cartão e retornando esse elemento:

fun Container.Cartão(texto: String? = null): Strong {
    val elemento = Strong(content = texto, className = "cartão")

    elemento.background = Background(Color("#DDD"))
    elemento.padding = 10.px
    elemento.fontSize = 30.px

    this.add(elemento)
    return elemento
}

Pronto, agora já temos o componente pronto.

Agora podemos usar o nosso componente Cartão dessa maneira:


...
class App : Application() {
    override fun start() {
        root("kvapp") {
            Cartão("Testando a criação de componentes")
        }
    }
}
...

Como você pode observar, usamos a função Cartão como qualquer elemento HTML do KVision. Com esse código, a nossa página ficará assim:

Estilizando a nossa página

Agora vamos começar a estilizar a nossa página, adicionando CSS usando o próprio KVision como meio para criar esse CSS.

Primeiro, vamos mudar a página para algo mais simples, que apenas mostra diversos textos em tamanhos diferentes e com tags diferentes:


...
class App : Application() {
    override fun start() {
        root("kvapp") {
            h1("Texto maior")
            h2("Texto menor")
            strong("texto em negrito")
            br()
            i("texto em itálico")
        }
    }
}
...

Criamos um título com h1, um subtítulo com h2, um texto em negrito com strong, quebramos a linha usando o br (Break Line), e ao final inserimos um texto em itálico com i.

Agora, vamos criar um arquivo chamado estilo.kt em src/main/kotlin/com/kvision/kvision. Esse arquivo irá armazenar os estilos que iremos aplicar.

Primeiro, vamos importar o KVision nesse arquivo:

package com.kvision.kvision

import io.kvision.core.*
import io.kvision.utils.*

Agora vamos inserir primeiro o estilo do h1. Isso pode ser feito definindo uma variável que irá armazenar esse estilo, usando uma classe Style, e dentro dessa classe iremos colocar os estilos. Isso pode ser feito da seguinte forma:

package com.kvision.kvision

import io.kvision.core.*
import io.kvision.utils.*

val estiloH1 = Style {
    color = Color("blue")
}

Usamos a classe Style, e dentro dela determinamos que a cor do texto desse estilo fosse azul, mudando a variável color, atribuindo com o retorno de uma função chamada Color, que gera uma cor baseada em um texto (código hexadecimal, nome,etc.).

Agora, vamos voltar ao arquivo App.kt e vamos adicionar esse estilo ao nosso h1. Isso pode ser feito da seguinte forma:


...
class App : Application() {
    override fun start() {
        root("kvapp") {
            h1("Texto maior") { addCssStyle(estiloH1) }
            h2("Texto menor")
            strong("texto em negrito")
            br()
            i("texto em itálico")
        }
    }
}
...

Adicionamos ao corpo dessa função h1, a função addCssStyle. Que permite a adição de estilos ao elemento apenas informando a variável que está guardando o estilo, no caso sendo a estiloH1.

Agora a nossa página está com o h1 estilizado com a cor azul, dessa maneira:

Podemos agora seguir o mesmo padrão e estilizar cada elemento que criamos. Tente criar estilos para o h2, strong e i sem ajuda primeiramente.

Caso tenha ficado com algum problema, ou não teve idéias de como estililzar esses elementos, você pode seguir o exemplo abaixo de como ficaria o arquivo estilo.kt ao final:

package com.kvision.kvision

import io.kvision.core.*
import io.kvision.utils.*

val estiloH1 = Style {
    color = Color("blue")
}

val estiloH2 = Style {
    background = Background(Color("#DDD"))
}

val estiloStrong = Style {
    color = Color("green")
}

val estiloI = Style {
    padding = 40.px
}

No estiloH2 usamos a função background para gerar um background para o elemento. Esse background no caso é um Color, que representa uma cor. Essa cor sendo #DDD que é um cinza bem claro.
No estiloStrong deixamos a cor do texto verde. O método foi o mesmo que usamos para o estiloH1;
No estiloI, temos apenas um padding de 40 pixels, usando o método de colocar um número, um . e a unidade de medida;

Agora apenas precisamos aplicar esses estilos na página. Podemos fazer isso da mesma forma que fizemos com o h1:

class App : Application() {
    override fun start() {
        root("kvapp") {
            h1("Texto maior") { addCssStyle(estiloH1) }
            h2("Texto menor") { addCssStyle(estiloH2) }
            strong("texto em negrito") { addCssStyle(estiloStrong) }
            br()
            i("texto em itálico") { addCssStyle(estiloI) }
        }
    }
}

Pronto, agora nossa página terá vários elementos com vários estilos diferentes:

Botões

Para criar um botão no KVision, podemos usar a função button e informar qual será o texto do botão, como no exemplo abaixo:


...
class App : Application() {
    override fun start() {
        root("kvapp") {
            button("Botão feito com KVision")
        }
    }
}
...

Com esse exemplo acima, o código gerado será:

Podemos criar um botão com um estilo diferente, como um botão primário, segundário, botão de perigo,etc. Podemos mudar esse estilo passando um argumento style ao botão. Dessa maneira:


...
class App : Application() {
    override fun start() {
        root("kvapp") {
            button("Salvar alterações", style = ButtonStyle.DANGER)
        }
    }
}
...

Informando o style sendo ButtonStyle.DANGER vamos criar um botão que representa uma ação perigosa, que deve ser tomada com cuidado,etc. Ficando dessa maneira na tela:

Podemos também inserir uma ação que será feita quando esse botão for clicado. Isso pode ser feito adicionando um bloco onClick para a função button. Dessa maneira:


...
class App : Application() {
    override fun start() {
        root("kvapp") {
            button("Salvar alterações", style = ButtonStyle.DANGER) {
                onClick {
                    println("Alterações salvas")
                }
            }
        }
    }
}
...

Dentro do onClick, apenas mostramos no console que a alteração foi salva (apenas para ilustrar a funcionalidade). Isso pode ser feito usando a função println que nesse contexto, irá mostrar algo no console do navegador.

Há diversos estilos de botões que podem ser usados no KVision, sendo a lista completa sendo:

PRIMARY
SECONDARY
SUCCESS
INFO
WARNING
DANGER
LINK
LIGHT
DARK
OUTLINEPRIMARY
OUTLINESECONDARY
OUTLINESUCCESS
OUTLINEINFO
OUTLINEWARNING
OUTLINEDANGER
OUTLINELIGHT
OUTLINEDARK

Tente mudar o estilo do botão que criamos se baseando na lista acima como exercício.

Containers de Layout

Agora vamos usar um recurso chamado Containers de Layout (Layout Containers), que são tags do KVision que criam div's com um comportamento diferente, como por exemplo uma div onde os elementos dentro dela podem ser modificados em seu tamanho. Ou uma div onde cada elemento representa uma aba,etc.

Vamos ver por exemplo o splitPanel. Essa função irá criar um painel que o tamanho das áreas de dentro desse painel podem ser reajustadas pelo usuário. Esse painel pode ser criado da seguinte forma:


...
class App : Application() {
    override fun start() {
        root("kvapp") {
            splitPanel {
                div("Primeira área")
                div("Segunda área")
            }
        }
    }
}
...

Usamos o splitPanel como se fosse uma tag do KVision;
Dentro dela, inserimos duas div's apenas para demonstrar o funcionamento, contendo apenas um texto;

Com o código acima, a nossa página ficará assim:

Essa barra vertical pode mudar o tamanho de cada seção desses elementos, criando mais interação com a pessoa usuária.

Podemos também criar um Tab Panel que é um layout em abas, mostrando um elemento filho por vez. Pode ser criado dessa maneira:


...
class App : Application() {
    override fun start() {
        root("kvapp") {
            tabPanel {
                tab("Primeira aba") {
                    div("Conteúdo da primeira aba")
                }
                tab("Segunda aba") {
                    div("Conteúdo da segunda aba")
                }
                tab("Terceira aba") {
                    div("Conteúdo da terceira aba")
                }
            }
        }
    }
}
...

A função usada para criar o painel é a tabPanel, onde iremos colocar os elementos do painel dentro;
Cada aba do painel é criada usando a função tab, que representa a aba;

Com esse código, o resultado será:

Há outros painéis que podem ser usados no KVision, mas esses dois são ótimos exemplos.

Finalização

Nesse artigo vimos algumas funcionalidades interessantes do KVision, e como criamos HTML, CSS e Javascript com Kotlin. Tente criar um site simples usando KVision, como um portifólio ou algo do tipo.

Muito obrigada por ler ❤️🏳️‍⚧️ e me segue nas redes, é tudo @lissatransborda 👀

Usando Ktor com Docker

Lissa Ferreira — Tue, 28 Dec 2021 04:58:02 +0000

Kotlinautas

Esse conteúdo é oferecido e distribuído pela comunidade Kotlinautas, uma comunidade brasileira que busca oferecer conteúdo gratuito sobre a linguagem Kotlin em um espaço plural.

Materiais

Será necessário ter o Docker instalado na máquina e alguma aplicação para praticar. Tanto pode ser alguma aplicação sua, quanto alguma que você encontrar. Caso não tenha idéia de qual aplicação usar para praticar, sugiro usar a KTasks, uma aplicação criada pela Lissa Ferreira e pelo KastroWalker em um workshop para a Codecon 2021.

O quê é Docker?

Docker É um software que permite criar imagens de outros softwares, como aplicações Ktor. Facilitando o processo de criação de Containers, agrupando todas as dependências e instruções para rodar um software. Com isso, podemos colocar nossas aplicações Ktor nesses conteiners, facilitando por exemplo o deploy dessa aplicações na nuvem por exemplo.

O quê é o Dockerfile?

Dockerfile é o arquivo do Docker onde está as instruções para criar esse container Docker, por isso vamos criar esse arquivo neste artigo.

Shadow

Precisamos antes, adicionar o Shadow á aplicação que estamos trabalhando. Sobre o Shadow, a Kotlinautas tem um arquivo exclusivo para esse tema, chamado Usando Shadow em um projeto Kotlin.

Toda vez que você criar ou atualizar um container (com a aplicação já pronta), é necessário usar o Shadow para compactar toda a aplicação dentro de um único JAR, com a task do Gradle shadowjar.

Criando o Dockerfile

Para criar esse Dockerfile vamos na pasta da nossa aplicação, e vamos criar um arquivo chamado Dockerfile.

Nesse arquivo, vamos usar o Alpine com o sistema operacional do container. É um sistema bem leve e muito utilizado para criar containers. Dessa maneira:

FROM alpine:3.14

Após isso vamos instalar o openjdk no container:

FROM alpine:3.14
RUN apk update && apk add openjdk11

Agora precisamos criar um diretório chamado microservices dentro do container, para iniciar o container dentro desse diretório.

FROM alpine:3.14
RUN apk update && apk add openjdk11
RUN mkdir /aplicacao/
WORKDIR /aplicacao/

Agora vamos copiar o JAR gerado pelo Shadow nesse novo diretório. O nome desse JAR depende da sua aplicação, logo, mude esse nome no exemplo abaixo:

FROM alpine:3.14
RUN apk update && apk add openjdk11
RUN mkdir /aplicacao/
WORKDIR /aplicacao/
COPY build/libs/[ARQUIVO JAR DA APLICAÇÃO] .

Após isso, use o comando CMD para rodar o arquivo JAR da aplicação:

FROM alpine:3.14
RUN apk update && apk add openjdk11
RUN mkdir /aplicacao/
WORKDIR /aplicacao/
COPY build/libs/[ARQUIVO JAR DA APLICAÇÃO] .
CMD ["java", "-jar", "[ARQUIVO JAR DA APLICAÇÃO]"]

Gerando o container

Para gerar o container da aplicação, podemos usar o comando docker build, esse comando irá executar nosso Dockerfile, gerando a imagem da aplicação.

Logo, na pasta da nossa aplicação (que também está o Dockerfile), execute o comando:

docker build -t minha-aplicacao .

Com isso, o output desse comando será algo parecido com:

Sending build context to Docker daemon  86.17MB
Step 1/6 : FROM alpine:3.14
 ---> 14119a10abf4
Step 2/6 : RUN apk update && apk add openjdk11
 ---> Using cache
 ---> 1de39c8424ab
Step 3/6 : RUN mkdir /aplicacao/
 ---> Using cache
 ---> bfdd62868475
Step 4/6 : WORKDIR /aplicacao/
 ---> Using cache
 ---> e6805f21228f
Step 5/6 : COPY build/libs/com.microservices.user-microservices-0.0.1-all.jar .
 ---> Using cache
 ---> 4ed056dbe9f6
Step 6/6 : CMD ["java", "-jar", "com.microservices.user-microservices-0.0.1-all.jar"]
 ---> Using cache
 ---> 89ec77f86456
Successfully built 89ec77f86456
Successfully tagged minha-aplicacao:latest

Executando a aplicação no Docker

Para executar o container que você criou no Docker, use o comando docker run, caso a sua aplicação exteja expondo alguma porta, use a opção -p para definir a porta, dessa maneira:

docker run minha-aplicacao -p 4500:4500

A porta do exemplo deve ser mudada para a porta que você definiu na sua aplicação.

Publicando a sua aplicação no DockerHub (Opicional)

Caso você queria, você pode publicar essa sua imagem em uma plataforma chamada DockerHub, com isso a sua imagem ficará pública (ou privada), e poderá ser usada em oquestradores de containers como Kubernetes, Nomad,etc.

Para fazer isso, primeiramente crie uma conta nessa plataforma, e execute o comando docker login para logar na plataforma.

Após isso, faça uma build da sua imagem, mas com o nome da imagem da seguinte maneira:

[SEU USUÁRIO DOCKERHUB]/[NOME DA IMAGEM]

como por exemplo:

lissaferreira/user-microservice

Após isso, use o comando docker push para publicar sua imagem, da seguinte maneira:

docker push [SEU USUÁRIO DOCKERHUB]/[NOME DA IMAGEM]

como por exemplo:

docker push lissaferreira/user-microservice

Pronto! Com isso sua imagem estará publicada no DockerHub.

Finalização

Neste artigo você aprendeu a criar a build da sua aplicação Ktor, para assim, poder fornecer a sua aplicação em forma de containers.

Muito obrigada por ler ❤️🏳️‍⚧️ e me segue nas redes, é tudo @lissatransborda 👀

Como usar Elvis Operator

Lissa Ferreira — Mon, 20 Dec 2021 04:40:29 +0000

Kotlinautas

Esse conteúdo é oferecido e distribuído pela comunidade Kotlinautas, uma comunidade brasileira que busca oferecer conteúdo gratuito sobre a linguagem Kotlin em um espaço plural.

O quê é Null Safety?

Kotlin é uma linguagem que utiliza vários recursos de outras linguagens, e também melhoramentos, principalmente em relação ao Java.

Muitas pessoas que já programaram Java, tiveram problemas bem chatos envolvendo NullPointerExeception, que é um erro que ocorre quando tentamos usar uma propriedade de uma classe que tem seu valor como null.

A linguagem Kotlin tenta ao máximo evitar esse tipo de problema. Adicionando garantias que o seu código DEVE ser seguro á erros envolvendo instâncias de classes, variáveis, propriedades,etc. que podem ser nulas.

Para poder utilizar uma propriedade que pode ser nula, é necessário ou fazer o tratamento caso essa variável seja um erro, ou usando !! para dizer ao Kotlin que você tem certeza que não terá nenhum erro relacionado. Como no exemplo abaixo:



val nome = usuario!!.nome

No exemplo acima, usuario pode ser uma variável nula, e por conta disso foi usado o símbolo !!, deixando claro ao Kotlinque temos certeza que essa variável não é null. Caso seja null, um erro vai ser lançado.

Podemos também como foi citado acima, tratar esse erro, buscando evitar o problema de termos um erro indesejado na nossa aplicação. E esse tratamento pode ser feito usando Elvis Operator

O quê é Elvis Operator?

Elvis Operator (?:) é um operador que podemos usar junto da propriedade ou variável que pode ter null como seu valor. da seguinte maneira:



repositorioPostagem.encontrar(10) ?:

Usamos um exemplo comum, um sistema onde precisamos pegar uma postagem (ou qualquer outro item que está guardado dentro do banco de dados), e caso essa postagem com esse ID 10 não seja encontrada, iremos usar o tratamento no Elvis Operator (que por enquanto não existe)
Elvis Operator tem esse formato de ?: por conta que parece com o cabelo do Elvis Presley.

A expressão á direita do Elvis Operator representa o quê vamos fazer caso essa propriedade ou variável seja nula. Podemos por exemplo, retornar a função:



fun pegarTituloDaPostagem(id: Int): String {
  return repositorioPostagem.encontrar(id).titulo ?: return "postagem não encontrada"
}

Temos uma função que irá retornar o título de uma postagem. Caso a postagem não seja encontrada, a postagem será null, com isso o Elvis Operator irá fazer que a string postagem não encontrada seja retornada, pois não há nenhuma postagem relacionada com esse ID.

Esse exemplo é simples, mas há situações em que é realmente necessário usar um Elvis Operator para garantir que o seu código não vai dar nenhum erro inesperado, pois como o próprio nome diz, não tem como planejar quando um erro inesperado irá acontecer.

Finalização

Neste artigo você aprendeu como utilizar o Elvis Operator para tornar seu código mais legível e com melhor tratamento de erros. Evitando erros inesperados, deixando sua aplicação mais resiliente.

Muito obrigada por ler ❤️🏳️‍⚧️ e me segue nas redes, é tudo @lissatransborda 👀

HTTP4K como cliente HTTP

Lissa Ferreira — Sun, 28 Nov 2021 22:47:31 +0000

Kotlinautas

Esse conteúdo é oferecido e distribuído pela comunidade Kotlinautas, uma comunidade brasileira que busca oferecer conteúdo gratuito sobre a linguagem Kotlin em um espaço plural.

HTTP4K

HTTP4K é uma biblioteca feita em Kotlin para receber e fazer requisições HTTP. A principal vantagem do HTTP4K para criar servidores e clientes HTTP é que com poucas linhas conseguimos ter o básico de uma aplicação pronta.

Materiais

Será necessário ter o IntelliJ instalado na máquina e um conhecimento básico sobre a linguagem Kotlin.

Criando o projeto

Abra seu IntelliJ no menu inicial e clique em New Project:

Depois, selecione a opção Kotlin DSL build script, selecione também a opção Kotlin/JVM, e opicionalmente remova a primeira opção Java. Essa opção não vai mudar em nada, pois ela dá suporte do Gradle á linguagem Java, mas apenas iremos usar Kotlin.

Após isso, clique em Next e escreva o nome do projeto e a localização na sua máquina. Essas duas opção são completamente pessoais, caso não tenha nenhuma ideia, coloque algo como http4k apenas como identificação.

Agora, com o projeto aberto, vá ao aquivo build.gradle.kts e vamos adicionar as dependências do HTTP4K, com a seção dependencies ficando assim:

dependencies {
    implementation(platform("org.http4k:http4k-bom:4.14.1.0"))
    implementation("org.http4k:http4k-core")
}

Agora, clique no elefante no canto superior direito para carregar as alterações no Gradle.

Após isso, poderemos começar a programar. Você pode criar um arquivo em src/main/kotlin/ chamado main.kt para ser o arquivo principal da aplicação.

Mas com qualquer nome de arquivo, como você irá usar as corotinas, sempre se lembre de importar a biblioteca de corotinas no começo do arquivo:

import org.http4k.client.JavaHttpClient
import org.http4k.core.HttpHandler
import org.http4k.core.Method
import org.http4k.core.Request

Criando um cliente HTTP

Para enviar uma requisição HTTP, e mostrar o resultado dessa requisição na tela, temos o código de exemplo abaixo:

fun main() {
    val requisição = Request(Method.GET, "https://xkcd.com/info.0.json")
    val cliente: HttpHandler = JavaHttpClient()
    val respostaRequisição = cliente(requisição)

    println(respostaRequisição)
}

Usamos uma classe Request para criar um objeto que represente a requisição. Nesse objeto, passamos o método e a URL dessa requisição;
Criamos uma variável cliente que recebe um cliente nativo do HTTP4K, que é o JavaHttpClient;
Executamos a requisição com cliente(requisição), guardando todos os dados da resposta dessa requisição na variável respostaRequisição;
Mostramos o resultado dessa requisição na última linha com println;

Executando esse código, teremos todos os dados sobre a resposta dessa requisição na tela:

HTTP/1.1 200
accept-ranges: bytes
age: 0
cache-control: max-age=300
connection: keep-alive
content-length: 382
content-type: application/json
date: Wed, 06 Oct 2021 02:26:36 GMT
etag: "615bc0f5-17e"
expires: Wed, 06 Oct 2021 00:56:13 GMT
last-modified: Tue, 05 Oct 2021 03:05:25 GMT
server: nginx
vary: Accept-Encoding
via: 1.1 varnish
x-cache: HIT
x-cache-hits: 1
x-served-by: cache-gig17025-GIG
x-timer: S1633487196.752074,VS0,VE392

{"month": "10", "num": 2524, "link": "", "year": "2021", "news": "", "safe_title": "Comet Visitor", "transcript": "", "alt": "It's a myth that the Great Wall of China is the only human-made structure visible from space--there are LOTS of structures for us to feel self-conscious about!", "img": "https://imgs.xkcd.com/comics/comet_visitor.png", "title": "Comet Visitor", "day": "4"}

Podemos acessar algumas informações usando as propriedades contidas dentro da variável respostaRequisição, caso você queira pegar o status da requsição, pode ser usada a opção respostaRequisição.status:

fun main() {
    val requisição = Request(Method.GET, "https://xkcd.com/info.0.json")
    val cliente: HttpHandler = JavaHttpClient()
    val respostaRequisição = cliente(requisição)

    println(respostaRequisição.status)
}

O resultado desse código será o status da resposta da requisição:

A mesma coisa pode ser feita para outras propriedades, como o corpo da resposta (respostaRequisição.body), os cabeçalhos da resposta (respostaRequisição.headers),etc.

Finalização

Esse é o básico sobre corotinas no Kotlin. Há muito mais detalhes e conteúdos que podem ser abordados, mas para um artigo introdutório isso já é suficiente.

Muito obrigada por ler ❤️🏳️‍⚧️ e me segue nas redes, é tudo @lissatransborda 👀

5 dicas e um bônus para deixar seu código Kotlin melhor

Lissa Ferreira — Sun, 21 Nov 2021 21:41:41 +0000

Kotlinautas

Esse conteúdo é oferecido e distribuído pela comunidade Kotlinautas, uma comunidade brasileira que busca oferecer conteúdo gratuito sobre a linguagem Kotlin em um espaço plural.

Créditos

Esse artigo foi baseado principalmente nesses slides do Anton Arhipov.

O quê é Kotlin Ideomático?

Kotlin Ideomático é uma maneira de escrever Kotlin tentando seguir os melhores padrões e funcionalidades da linguagem. Buscando tornar o código mais legível e menor.

Há uma página oficial da documentação do Kotlin apenas para listar diversas formas ideomáticas de fazer coisas. Caso saiba um pouco de inglês, é interessante ler esse documento. Neste artigo vamos abordar apenas algumas formas ideomáticas de se usar Kotlin, mas nessa página há uma quantidade bem maior.

Criando funções sem classes

Muitas pessoas que migram do Java para o Kotlin, continuam com o costume de criar uma classe toda vez que precisarem criar uma ou mais funções, mas isso não é necessário no Kotlin, pois podemos criar funções sem precisar de uma classe associada, dessa maneira:

fun main(){
  olaMundo()
}

fun olaMundo(){
  println("Olá Mundo!")
}

Criamos uma função olaMundo, que mostra o texto Olá Mundo! na tela;
Chamamos essa função dentro da main;

Extensões

Sabe aquelas funções .toInt, .equals,etc. que podemos usar em tipos do Kotlin? Podemos adicionar novas funções completamente feitas por nós á esses tipos, usando as extensões.

Vamos supor que você quer criar uma função chamada ÉNumero que irá checar se uma string é um número ou não. Essa função seria executada da seguinte forma:

"isso não é um número".ÉNumero
"10".ÉNumero

Isso pode ser feito criando a função ÉNumero dessa maneira:

fun String.ÉNumero() = all { it.isDigit() }

Passamos o tipo, no caso String, seguido de um . e o nome da função, que no caso é ÉNumero;
A função all irá testar se todos os caracteres do texto conseguem passar de uma certa condição, que no caso é se esse caractere é um dígito usando a função isDigit;

Após isso, podemos utilizar essa função em qualquer lugar do nosso código:

fun main(){
    println("10".ÉNumero())
    println("abracadabra".ÉNumero())
}

Funções de escopo

Funções de escopo são funções axuliares que executam um código com o contexto de um objeto. Isso significa que essas funções criam um escopo temporário, onde poderemos usar todas as propriedades de um objeto sem precisar informar esse projeto. Caso tenha tido alguma confusão, vamos ver na prática.

Vamos supor que temos uma classe Estrela, com as propriedades nome, diâmetro, dessa maneira:

data class Estrela(
    var nome: String = "",
    var diâmetro: Int = 0,
    var numeroDePlanetas: Int = 0,
)

Podemos criar uma variável que guarde uma instância, e mudar as propriedades dessa variável. Dessa maneira:

val sol = Estrela()
sol.nome = "sol"
sol.diâmetro = 1392700
sol.numeroDePlanetas = 8

Esse código irá funcionar, mas não está sendo ideomático, pois estamos repetindo a variável sol diversas vezes. Podemos escrever esse código de uma maneira mais bonita como no exemplo abaixo:

    val sol = Estrela().apply {
        nome = "sol"
        diâmetro = 1392700
        numeroDePlanetas = 8
    }

Usamos a função apply do Kotlin, que irá receber um objeto (no caso uma instância de Estrela) e irá fazer alterações com esse objeto em seu contexto. No caso, definindo valores de propriedades.

Dessa maneira, nosso código estará mais consiso, legível, e ideomático.

Há outras funções de escopo, essas outras funções podem ser vistas Nessa página da documentação do Kotlin

Argumentos Padrão e Argumentos Nomeados

Vamos supor que temos a seguinte função:

fun saudações(nome: String, momento: String){
    println("Olá $nome! $momento")
}

Essa função está recebendo um nome, como Pedro ou Maria, e momento recebe uma saudação do dia, como boa tarde ou boa noite.

Mas vamos pensar: Na maior parte das vezes, damos bom dia para as pessoas, e menos vezes damos boa tarde ou boa noite.

Logo, podemos mudar a função e fazer que esse momento tenha um valor padrão usando um = depois de seu tipo.

fun saudações(nome: String, momento: String = "Bom Dia!"){
    println("Olá $nome! $momento")
}

E além, e se essa pessoa não quiser passar seu nome? Podemos deixar Pessoa Anônima como valor padrão, da mesma forma que dizemos com momento. Dessa maneira:

fun saudações(nome: String = "Pessoa Anônima", momento: String = "Bom Dia!"){
    println("Olá $nome! $momento")
}

Com isso, podemos chamar essa função saudações de algumas formas:

fun main(){
    saudações()
    saudações("Maria")
    saudações("Pedro", "Boa Noite!")
}

Resultado:

Olá Pessoa Anônima! Bom Dia!
Olá Maria! Bom Dia!
Olá Pedro! Boa Noite!

E se eu quiser deixar o argumento nome padrão, e mudar só a mensagem?

Isso pode ser feito nomeando o argumento momento na chamada, dessa maneira:

fun main(){
    saudações(momento = "Boa Tarde!")
}

Resultado:

Olá Pessoa Anônima! Boa Tarde!

Funções de única expressão

Vamos supor que temos uma função testarTemperatura que recebe uma temperatura em String e diz se é possível tomar uma bebida nessa temperatura ou não:

fun testarTemperatura(temperatura: String): String{
    when(temperatura){
        "quente" -> return "Quente demais para beber"
        "frio" ->  return "Temperatura boa para beber"
        else -> return "Preciso deixar um pouco na geladeira"
    }
}

Essa função tem apenas uma única expressão, um único comando em seu corpo. logo, podemos simplificar essa função, removendo seu corpo e seu retorno e adicionando um = seguido pela expressão.

Dessa maneira, nossa função ficará assim:

fun testarTemperatura(temperatura: String) = when(temperatura){
        "quente" -> "Quente demais para beber"
        "frio" ->  "Temperatura boa para beber"
        else -> "Preciso deixar um pouco na geladeira"
}

Dessa maneira, nossa função ficará bem menor, consisa e legível, essas são as funções de única expressão, a mesma coisa que fizemos com o when pode ser feita com if, try,etc.

Operador Elvis

Vamos supor que temos uma classe Cachorro, essa toda instância de Cachorro tem um nome, raça (que pode ser null caso esse cachorro seja vira-lata) e uma propriedade educado. Dessa maneira:

class Cachorro(
    val nome: String,
    val raça: String?,
    val educado: Boolean,
)

Junto com essa classe, temos uma função apresentarCachorro que irá receber uma instância dessa classe Cachorro, e caso esse cachorro seja de raça, e a sua raça não seja null, o seu nome e raça serão mostrados na tela jutn ocom uma mensagem. Normalmente, fariamos dessa maneira:

fun apresentarCachorro(cachorro: Cachorro){
    if (cachorro.raça == null){
        return
    }

    val raça = cachorro.raça
    val nome = cachorro.nome

    if (cachorro.educado){
        println("Au Au Au, meu nome é $nome e sou da raça $raça, Au Au Au")
    }
}

Esse código pode ser melhorado. Podemos remover o primeiro if que testa se a raça do cachorro é null ou não. Podemos colocar esse teste direto na definição da variável raça, dessa maneira:

fun apresentarCachorro(cachorro: Cachorro){
    val raça = cachorro.raça ?: return
    val nome = cachorro.nome

    if (cachorro.educado){
        println("Au Au Au, meu nome é $nome e sou da raça $raça, Au Au Au")
    }
}

No código acima, usamos o operador Elvis (?:), onde se o valor da esquerda for null, o código da direita será executado. No caso, é o return que irá fechar a função sem nenhum conteúdo no retorno.

Finalização

Nesse artigo, você aprendeu 6 dicas de como deixar o seu código Kotlin mais ideomático, consiso e legível. Busque aplicar os conceitos mostrados nesse artigo (e em outros sobre Kotlin Ideomático que podem existir) em seus projetos, pois assim seu código ficará bem melhor.

Muito obrigada por ler ❤️🏳️‍⚧️ e me segue nas redes, é tudo @lissatransborda 👀

Criando variáveis no Kotlin - Explorando a documentação

Morganna — Mon, 15 Nov 2021 02:21:59 +0000

Pensando em formas diferentes de aproximar a comunidade da documentação do Kotlin, darei início a uma série de postagens para traduzir o conteúdo dessa documentação. Fiquem a vontade para compartilhar seus feedbacks e complementar o conteúdo.

De qualquer forma, ainda que você já esteja trabalhando com kotlin, aconselho a consultar a documentação sempre que puder. Muitas das vezes, existem recursos da linguagem que facilitam nosso dia a dia, mas por costume de outras linguagens de programação com as quais já trabalhamos, temos a tendência de estruturar o código da forma como conhecemos até então.

Vamos dar os primeiros passos?

Se ainda não conhece a documentação, você pode consultar o conteúdo por aqui. Ela está em inglês e não existe, até o momento, uma tradução oficial para outras línguas, como o português.

Dentro do tópico Basic Syntax, que seria a Sintaxe Básica, estão os primeiros tópicos da linguagem. Vamos iniciar aqui pelas variáveis.

Variáveis

Variáveis são utilizadas para guardar valores durante a execução do nosso código. Esses valores podem ser apenas de leitura, ou seja, não podemos alterá-lo durante a execução do programa. Mas também podem ser mutáveis, ou seja, podem mudar de valor durante o processamento e de acordo com a necessidade.

No Kotlin, as variáveis de leitura, as chamadas read-only em inglês, são definidas no código quando utilizamos a palavra-chave val.

Para variáveis que podem ter seu valor alterado durante a execução de um programa, utilizamos a palavra-chave var para sua criação no código.

Para facilitar, você pode associar a origem das palavras-chaves:

val: value;
var: variable.

Vejamos os exemplos a seguir.

Variáveis somente leitura

Uma variável pode ter seu tipo declarado e receber uma atribuição durante a sua criação:

No trecho de código abaixo, estamos criando uma variável apenas de leitura chamada "a". Seu tipo é Int, ou seja, ela recebe valores que são números inteiros. E foi declarada com o valor 1.

Uma variável pode ter seu tipo não declarado e receber uma atribuição durante a sua criação:

Quando atribuímos um valor diretamente a uma variável, o Kotlin entende qual será o seu tipo. No caso abaixo, o tipo é Int, pois recebeu o valor 1, que é um número inteiro.

Uma variável pode ter seu tipo declarado e não receber uma atribuição durante a sua criação:

No caso abaixo, a variável foi criada e, só durante a execução do programa, ela receberá um valor. Não necessariamente precisa ter uma atribuição diretamente em sua criação.

Uma variável de leitura não poderá ter seu valor alterado:

No caso abaixo, se você executar o código, verá que retornará um erro dizendo Val cannot be reassigned, ou seja, a variável declarada como somente leitura não poderá ter um novo valor atribuído.

Variáveis mutáveis

Uma variável pode ter seu tipo declarado e receber uma atribuição durante a sua criação:

No trecho de código abaixo, estamos criando uma variável mutável chamada "a". Seu tipo é Int, ou seja, ela recebe valores que são números inteiros. E foi inicializada com o valor 1. Posteriormente, teve seu valor alterado para 2, pois é var.

Uma variável pode ter seu tipo não declarado e receber uma atribuição durante a sua criação:

Quando atribuímos um valor diretamente a uma variável, o Kotlin entende qual será o seu tipo. No caso abaixo, o tipo é Int, pois recebeu o valor 1, que é um número inteiro. E, por ser var, teve seu valor alterado para 2 sem problemas.

Uma variável pode ter seu tipo declarado e não receber uma atribuição durante a sua criação:

No caso abaixo, a variável foi criada e, só durante a execução do programa, ela receberá um valor. Não necessariamente precisa ter uma atribuição diretamente em sua criação.

Mundo real

Precisamos avaliar e entender um contexto para tomar uma decisão entre deixar uma variável como mutável ou como somente leitura. Tudo depende da necessidade e dos requisitos que estamos atendendo, além de pontos de controle e de segurança que podem ser importantes em nosso código.
Normalmente, uma variável é criada como val, impedindo alterações diretas de seu valor. E, se houver necessidade, alteramos para var durante o desenvolvimento de um projeto.
Contudo, além disso, também avaliamos a necessidade de uma variável ser:

uma constante;
local, que atenda apenas a um escopo;
global, que esteja disponível a todo o projeto;
uma propriedade, controlando de acordo com o modificador de acesso.

Pontos extremamente importantes e que abordaremos no próximo artigo.

Caso tenha algo a acrescentar, sugestões ou queira tirar alguma dúvida, fique a vontade para enviar nos comentários. Até a próxima!

Criando testes unitários com Kotest

Lissa Ferreira — Mon, 08 Nov 2021 03:58:54 +0000

Kotlinautas

Esse conteúdo é oferecido e distribuído pela comunidade Kotlinautas, uma comunidade brasileira que busca oferecer conteúdo gratuito sobre a linguagem Kotlin em um espaço plural.

Teste Unitário

Teste unitário é um tipo de teste onde cada componente do software pode ser testado separadamente. Com isso, cada parte do sistema será isolada, dando a garantia que está funcionando como o esperado.

Kotest

Kotest é uma biblioteca em Kotlin para a criação de testes unitários. Kotest pode ser usado com diferentes estilos de teste, permitindo uma grandle flexibilidade.

Materiais

Será necessário ter o IntelliJ instalado na máquina e um conhecimento básico sobre a linguagem Kotlin.

O quê vamos criar?

Vamos criar uma classe Calculadora, que terá quatro funções, sendo Soma, Subtração, Multiplicação e Divisão. Cada uma dessas funções representa uma operação matemática.

Iremos criar um teste unitário para essa classe, testando cada operação separadamente usando a Kotest.

Criando o projeto

Abra seu IntelliJ no menu inicial e clique em New Project:

Agora, com o projeto aberto, vá ao aquivo build.gradle.kts e adicione a dependência testImplementation("io.kotlintest:kotlintest-runner-junit5:3.1.7"), com a seção dependencies ficando assim:

dependencies {
    implementation(kotlin("stdlib"))
    testImplementation("io.kotlintest:kotlintest-runner-junit5:3.1.7")
}

Também adicione uma modificação ás Tasks do Gradle:

tasks.withType<Test> {
    useJUnitPlatform()
}

Ao final, nosso arquivo build.gradle.kts ficará assim:

plugins {
    java
    kotlin("jvm") version "1.5.30"
}

group = "org.example"
version = "1.0-SNAPSHOT"

repositories {
    mavenCentral()
}

dependencies {
    implementation(kotlin("stdlib"))
    testImplementation("io.kotlintest:kotlintest-runner-junit5:3.1.7")
}

tasks.withType<Test> {
    useJUnitPlatform()
}

Agora, clique no elefante no canto superior direito para carregar as alterações no Gradle.

Após isso, poderemos começar a programar. Você pode criar um arquivo em src/main/kotlin/ chamado main.kt para ser o arquivo principal da aplicação.

Criando a classe `Calculadora`

Vamos criar um arquivo em src/main/kotlin/Calculadora.kt que irá armazenar uma classe Calculadora com alguns métodos que representam operações matemáticas:

class Calculadora {
    fun soma(x: Int, y: Int): Int {
        return x + y
    }

    fun subtração(x: Int, y: Int): Int {
        return x - y
    }

    fun multiplicação(x: Int, y: Int): Int {
        return x * y
    }

    fun divisão(x: Int, y: Int): Int {
        return x / y
    }
}

Criando testes

Agora vamos criar uma pasta chamado src/main/tests/ e um arquivo calculadora.kt dentro dessa pasta.

Essa pasta irá guardar todos os testes unitários do nosso projeto, e será usada pela Kotest para ver quais são os testes disponíveis.

Primeiro, vamos importar a kotest ao nosso arquivo:

import io.kotlintest.shouldBe
import io.kotlintest.specs.StringSpec

Após isso, vamos criar uma variável chamada calculadora que irá armazenar uma instância da nossa classe Calculadora:

val calculadora = Calculadora()

Vamos criar uma classe chamada TestarCalculadora, que irá armazenar os testes unitários da classe Calculadora:

class TestarCalculadora: StringSpec({

})

Nesse estilo StringSpec poderemos inserir um teste usando um texto que irá definir esse teste, aumentando a semântica.

Vamos adicionar o primeiro teste que será sobre a função soma, primeiro, vamos colocar o texto do teste:

class TestarCalculadora: StringSpec({
    "Testar soma da calculadora" {

    }
})

Podemos abrir um bloco para esse teste usando o texto que define o teste, seguido por {}

Após isso, podemos inserir os testes dessa maneira:

class TestarCalculadora: StringSpec({
    "Testar soma da calculadora" {
        calculadora.soma(10, 20).shouldBe(30)
        calculadora.soma(20, 20).shouldBe(40)
        calculadora.soma(50, 40).shouldBe(90)
    }
})

Usamos a função soma, passando os números, e após isso podemos usar a função shouldBe, que recebe um argumento, e obriga o resultado de uma função ser esse argumento recebido.
Por exemplo, passamos á função soma os valores 10 e 20. Que irão resultar em 30. Após isso, usamos a função shouldBe para garantir que esse valor será 30.

Após isso, podemos repetir o mesmo processo para as outras operações, sempre criando um novo teste:

class TestarCalculadora: StringSpec({
    "Testar soma da calculadora" {
        calculadora.soma(10, 20).shouldBe(30)
        calculadora.soma(20, 20).shouldBe(40)
        calculadora.soma(50, 40).shouldBe(90)
    }

    "Testar substração da calculadora" {
        calculadora.subtração(10, 20).shouldBe(-10)
        calculadora.subtração(20, 20).shouldBe(0)
        calculadora.subtração(30, 10).shouldBe(20)
    }

    "Testar multiplicação da calculadora" {
        calculadora.multiplicação(2, 5).shouldBe(10)
        calculadora.multiplicação(5, 5).shouldBe(25)
        calculadora.multiplicação(10, 7).shouldBe(70)
    }

    "Testar divisão da calculadora" {
        calculadora.divisão(10, 2).shouldBe(5)
        calculadora.divisão(30, 3).shouldBe(10)
        calculadora.divisão(60, 5).shouldBe(12)
    }
})

Agora você pode clicar no menu do Gradle ao lado da tela, clique em Run Configurations e em kotest [test] para rodar os testes.

Com isso todos os testes irão passar e a classe Calculadora estará testada.

Agora tente modificar algum teste intencionalmente para modificar o resultado e rode os teste novamente. Com isso, os testes resultarão em um erro, mostrando que a classe Calculadora está sendo implementada de maneira incorreta segundo essa nova versão dos testes.

Finalização

Neste artigo você aplicou testes unitários com Kotest á uma calculadora. Busque aprender mais maneira de criar testes e diferentes estilos de testes para tornar esse conhecimento mais flexível.

Muito obrigada por ler ❤️🏳️‍⚧️ e me segue nas redes, é tudo @lissatransborda 👀

Transformando JARs em binário com GraalVM

Lissa Ferreira — Mon, 01 Nov 2021 00:39:52 +0000

Kotlinautas

Esse conteúdo é oferecido e distribuído pela comunidade Kotlinautas, uma comunidade brasileira que busca oferecer conteúdo gratuito sobre a linguagem Kotlin em um espaço plural.

O quê é um binário?

Binário é um executável do sistema. um binário pode ser executado diretamente pelo sistema, pois é composto totalmente por linguagem de máquina.

As vantagens de um binário é a velocidade de execução, que é geralmente BEM rápida, além de não precisarmos de uma linguagem instalada para rodar esse programa, pois o próprio sistema irá cuidar de rodar esse executável.

GraalVM

GraalVM é uma máquina virtual da Oracle para aumentar a velocidade de aplicações. Uma das funções da GraalVM é a Native Images, que é uma maneira de unir código de qualquer linguagem da JVM (Java, Kotlin, Clojure, etc.) em um único arquivo totalmente em código de máquina. Eliminando a necessidade de utilizar uma JVM para rodar um projeto.

Esse processo de transformação de código JVM para binários só deve ser feito para utilizar esse binário em produção. Pois esse processo é demorado e gasta muito processamento e memória, logo, em ambiente de desenvolvimento é mais fácil utilizar o processo normal da JVM para rodar seu código.

Instalação da GraalVM

Há alguns documentos oficiais de instalação da GraalVM para algumas plataformas, sendo:

Instalação da Native Image

A Native Image pode ser instalada usando a GraalVM Updater, que é uma ferramenta utilizada para instalar utilitários da GraalVM. Essa instalação pode ser feita com o comando:

gu install native-image

Hello World

Agora vamos criar um Hello World em Kotlin para gerar o JAR desse Hello World para transformar em binário com Native Image.

Isso pode ser feito com qualquer editor, não há necessidade de utilizar o IntelliJ, mas caso prefira, crie um projeto no IntelliJ para isso.

Arquivo main.kt:

fun main(){
  println("Olá Mundo!")
  }

Agora precisamos tranformar esse arquivo em um JAR. Para fazer isso, podemos usar o comando kotlinc que é o compilador do Kotlin. Vá até o caminho que esse arquivo está, e vamos fazer essa compilação com o comando abaixo:

kotlinc main.kt -include-runtime -d main.jar

Agora temos o nosso JAR no arquivo main.jar. Caso você queira executar esse JAR, isso pode ser feito com o comando java -jar main.kt, que terá Olá Mundo! como resultado:

Olá Mundo!

Agora precisamos transformar esse JAR em binário, podemos fazer isso com o comando native-image. Dessa maneira:

native-image --static -jar main.jar

Com isso o processamento irá começar. A GraalVM ao longo do processamento irá mostrar alguns dados sobre o processo:

$ native-image --static -jar main.jar

Build on Server(pid: 5484, port: 35163)
[main:5484]    classlist:     441.34 ms
[main:5484]        (cap):   1,017.18 ms
[main:5484]        setup:   1,581.26 ms
[main:5484]   (typeflow):   2,216.25 ms
[main:5484]    (objects):     516.04 ms
[main:5484]   (features):      86.21 ms
[main:5484]     analysis:   2,876.19 ms
[main:5484]     universe:     131.56 ms
[main:5484]      (parse):     610.96 ms
[main:5484]     (inline):     518.10 ms
[main:5484]    (compile):   2,818.48 ms
[main:5484]      compile:   4,187.55 ms
[main:5484]        image:     354.83 ms
[main:5484]        write:     164.75 ms
[main:5484]      [total]:   9,769.44 ms

Após o término desse processamento teremos um binário main com todo o código atual. Esse binário terá cerca de 12MB de tamanho.

Para executar esse binário, no Windows podemos usar o comando main no diretório que esse binário está, e em Linux/MacOS podemos usar ./main.

Velocidade

Podemos comparar o tempo de execução do JAR e do binário, caso você esteja em sistemas Linux/MacOS existe o comando time para medir o tempo de execução de um comando, comparando os dois métodos teremos o resultado abaixo:

$ time java -jar main.jar
Olá Mundo!
java -jar main.jar  0,12s user 0,02s system 64% cpu 0,114 total

$ time ./main
Olá Mundo!
./main  0,00s user 0,00s system 74% cpu 0,002 total

Podemos ver que a principal diferença entre os dois é a diferença de tempo que cada um executou. Enquanto java -jar main.jar demorou 0.12 segundos para rodar, ./main levou 0 segundos para rodar, de maneira quase instantânea. Claro, para programas pequenos a diferença pequena, mas para programas maiores como uma aplicação web essa diferença irá ficar bem maior.

Finalização

Neste artigo você aprendeu como utilizar a GraalVM para gerar binários de projetos JVM especialmente Kotlin, e executar esse binário final.

Muito obrigada por ler ❤️🏳️‍⚧️ e me segue nas redes, é tudo @lissatransborda 👀