O Zen do Java e a Developer Experience (DX)

Muitas vezes nós desenvolvedores ouvimos falar sobre UX (User Experience), e nos preocupamos em desenvolver sistema amigáveis e intuitivos para os usuários, uma vez que sistemas devem ser desenvolvidos para resolver problemas, e não criá-los. Contudo, em muitas ocasiões pensamos pouco sobre a qualidade do nosso ambiente de desenvolvimento, assim como a facilidade ou dificuldade de codificar com uma determinada linguagem, framework ou arquitetura de projeto.

Contudo, todos estes pontos são realmente muito importantes, pois sem um bom ambiente de desenvolvimento, se torna muito mais difícil criar bons sistemas para o usuário final, ou ao menos mais estressante e custoso. É justamente devido a esta necessidade de otimizar o desenvolvimento de software que são adotados diversos padrões, metodologias, e linguagens de sintaxe mais simplificada, como no caso do Python.

Esse tema brevemente abordado tem nome: Developer Experience (DX). E este é tão importante quanto seu parente famoso, o UX (ou ao menos deveria ser).

O Zen do Python

Falando sobre Python e DX, não é de se estranhar que esta linguagem tenha estado tão em evidência nas últimas décadas. O Python tem uma sintaxe extremamente simples, sem ponto e vírgula, sem abre-fecha chaves, e com nomenclaturas que via de regra são extremamente descritivas e curtas, como um print() ou input(). De fato, apesar dos seus pesares (como a velocidade de execução em sistemas mais robustos), o Python tem uma curva de codificação muito menor que a maioria das linguagens, impondo menos custo mental para executar comandos repetitivos e bastante usuais.

Muito destas características presentes no Python são pensadas como design da linguagem, e fazem parte de um conceito que engloba até mesmo a forma como se codifica, visando um script organizado, legível, compreensível e até mesmo bonito. Isso é o que se chama de estilo de código Pythonico.

Muitos dos preceitos que norteiam a estrutura base da linguagem, tal como a concepção de códigos Pythonicos, estão presentes em uma série de princípios findamentais do Python, conhecidos como o Zen do Python. Estes são tão importantes que estão mesmo presentes no interpretador do Python através do comando import this.

A DX do Java

Com uma boa familiaridade com JavaScript (TypeScript) e Python, resolvi me aventurar no Java, e devo admitir que essa é uma linguagem bem mais agradável e simples do que eu imaginava. Sempre vi memes acerca da verbosidade do Java, e imaginava que os códigos nesta linguagem seriam quase ilegíveis. Contudo, tenho me impressionado, e posso até dizer que gostei de fazer meus primeiros projetos básicos no Java. Contudo, não posso tirar o mérito de algumas das criticas feitas ao longo da interwebs.

Acontece que por mais que o Java não seja assustador, existem algumas coisas que deveriam ser triviais, mas que o Java acaba transformando em uma redação do ENEM. Por exemplo, para exibir uma mensagem para o usuário nós precisamos estar executando o System.out.println(), enquanto no Python nós temos o simples e conciso print().

Mais assustador ainda é tentar pegar algum dado do usuário através do terminal. Se no Python nós temos o input(), aqui no Java nos temos que percorrer um épico homérico: primeiro importe o módulo Scanner com import java.util.Scanner, depois instancie a classe através do Scanner scan = new Scanner(system.in), e só então você vai poder realizar o comando scan.next().

Acontece que o Java não é nem deve ser o mesmo que o Python. Ambas as linguagens possuem abordagens diferentes para problemas semelhantes, ou mesmo aplicações em áreas completamente distintas. Inclusive, existem pessoas que consideram a verbosidade do Java positiva, pois esta tornaria as intenções do código mais explicitas. Isso sem contar que existem IDEs especificas para o Java que já possuem ótimos sistemas de auto complete, simplificando bastante a codificação na linguagem.

Contudo, acredito que a performance do desenvolvedor é importante, e a verbosidade de comandos simples e rotineiros (como o input e output de dados) implica diretamente em dificuldade de manutenção devido a códigos mais poluídos, tal como em uma codificação mais lenta. Enquanto o Python resolveu parte destes problemas, eu sinto que o textão necessário para executar um simples comando de input no Java não está de fato ajudando ninguém, e por isso eu tomei essa minha dor como um motivo para criar um projeto pessoal simples em Java segundo a seguinte premissa: E se desse pra trazer um pouco da experiência de desenvolvimento do Python para o Java?

O Zen do Java?

Foi a partir desta premissa que eu pensei em criar um projeto em Java pensando a princípio na simplificação de dois comandos básicos de toda linguagem: input e output de dados. A minha ideia foi trazer a simplicidade e versatilidade do Python para o Java, e por isso pensei em chamar o projeto de Zen.java.

Este módulo Zen.java consiste em nada mais que uma classe cujos métodos realizam a abstração de todos os comandos verbosos da linguagem para exibir e receber dados. Assim, neste momento a linguagem conta principalmente com os métodos estáticos input(), print() e printf().

Para exemplificar seu impacto sobre um programa básico em Java, podemos ver um comparativo entre o antes e o depois em um mesmo código fonte. Aqui temos um programa que lê o nome de um aluno e após isso recebe uma quantidade indefinida de notas, parando a execução ao receber o Enter como input, sendo este o momento no qual serão exibidas duas mensagens para o usuário, a primeira sobre sua média e a segunda sobre o status (aprovado ou reprovado).

Apesar de ser um sistema extremamente simples, ainda é um pouco confuso de entender só de bater o olho, né? A estrutura do Java exige alguns excessos como para exibir uma mensagem, receber um input, arredondar um decimal para outros gruas de precisão ou formatar strings.

Então que tal dar uma animada nas coisas? Veja a seguinte versão do mesmo código, que conta apenas com a adição da classe Zen, como alguns métodos como o input(), toDouble(), print() e printf():

Aqui nós não só demos muito mais legibilidade para o código final, como também conseguimos mesmo encurtar o código em cerca de 28% do seu tamanho original, saindo das 32 linhas para as 23. Na minha visão é um ganho bastante bem vindo, ainda mais levando em consideração que os métodos usados abstraem rotinas extremamente repetitivas, e que podemos incrementar novos Zen métodos para simplificar ainda mais a codificação no longo prazo.

Se você ficou curioso acerca do funcionamento dos métodos desenvolvidos até então dentro da classe Zen do Java, vou explicar bem por cima o que cada um dos métodos usados faz:

toDouble()

Aqui nós temos um método que transforma um valor do tipo String em um valor do tipo double. Este é um dos métodos mais simples, pois simplesmente recebe um parâmetro do tipo String, aplicando o Double.parseDouble() sobre este e retornando o resultado final. Ainda, dentro da classe Zen também há um método toInt() com a mesma lógica, só que para transformar String em números inteiros.

round()

Este método recebe dois parâmetros, sendo o primeiro um número do tipo double e o segundo um valor inteiro, que será o grau de precisão. Assim, ele retorna o mesmo valor passado no primeiro parâmetro, mas arredondado de acordo com o grau de precisão informado. Ou seja, ao passar round(3.14159, 2) nós receberemos 3.14 como retorno, pois estaremos pedindo um valor decimal com duas casas apenas.

input()

Esse é o maior motivo para a criação do projeto, pois através do método input() não é necessário realizar toda aquela configuração do Scanner. Uma outra vantagem é que ele por design passa a aceitar uma mensagem que será direcionada para o usuário dentro do terminal, não sendo necessário realizar um System.out.println() toda vez que for ser pedido um valor de input.

print()

Aqui nós temos outro método bastante interessante, pois teoricamente este simplesmente executa o comando System.out.println(). Porém, eu também adicionei a possibilidade de inserir diversos parâmetros que serão concatenados com um espaço em branco os separando, sendo algo não suportado nativamente pelo System.out.println().

printf()

Por fim, o printf() usa um método chamado fstr(), que também vem da classe Zen. Este método tem como propósito receber uma string e outros parâmetros que devem ser inseridos em quaisquer pontos desta. Desta forma, ele retorna a mesma String, mas com os valores inseridos nas suas respectivas posições, sinalizadas pelo marcador {}. Assim, poderíamos por exemplo chamar o fstr(“Olá {}, hoje é dia {} e estão fazendo {}ºC”, nome, data, temperatura).

É importante ressaltar que a ideia central deste artigo foi de apresentar um debate acerca da DX usando um comparativo entre as abordagens do Python e do Java, e não depreciar quaisquer linguagens de programação.

Por fim, lembram-se que o projeto Zen.java foi mais um desafio pessoal que um pacote para ser usado em projetos reais, então seus códigos e conceitos não devem ser aplicados em produção, uma vez que existem uma série de tratamentos que deveriam ser realizados tendo em vista evitar erros e perdas de performance.

Pra quem se interessou pelo projeto e quer saber os códigos por detrás da classe deste projeto, segue seu código fonte no Replit: Zen do Java.