DEV Community: Eduardo Teixeira

Clojure - Símbolos globais e locais

Eduardo Teixeira — Fri, 18 Feb 2022 18:20:00 +0000

Até agora, sempre que foi necessário manter um valor em memória nós usamos o conceito de "variável", realizando a "definição de um símbolo" com o comando "def". Porém essa abordagem corresponde ao que conhecemos nas linguagens mais tradicionais como "definição de variável global".

Como é de conhecimento, as definições de "variáveis globais" podem trazer uma série de problemas as aplicações, uma vez que é quase impossível ter conhecimento de todas, com isso podemos acabar gerando problemas com a substituição de valores durante seu uso, podendo causar erros em diversos pontos da aplicação e tornando a aplicação instável e de difícil manutenção.

Dito isso, veremos como trabalhar com símbolos dentro de um escopo limitado, seguiremos os próximos exemplos dentro de nossas funções.

Escopo global

Como vimos até aqui, os símbolos de escopo global podem ser acessados de qualquer parte da aplicação, vamos ao exemplo, considerando uma aplicação hipotética de uma escola, temos duas rotinas distintas que mostram a média dos alunos em duas condições distintas:

Uma que mostra e média "padrão" acrescida de um ponto extra;
Outra que mostra a média do aluno em uma condição de "recuperação", que acresce a média dois pontos extras;
Enquanto a rotina que mostra a média "padrão" olha para um símbolo global para fazer seu cálculo sem fazer qualquer alteração a rotina que mostra a média dos alunos em condição de "recuperação" também utiliza o mesmo símbolo global, porém ela sempre altera seu valor para "dois".

O problema que teremos é o seguinte, enquanto a rotina que mostra as médias de alunos em "recuperação" não for executada a rotina de média "padrão", quando executada, apresentará um resultado correto, porém após primeira execução da rotina de "recuperação" a "padrão" começará a mostrar um resultado errado:

(def ponto-extra 1)

(defn verifica-situacao-aluno-padrao
  "Retorna a media do aluno somada a seu ponto extra"
  [nota1 nota2]
  (+ (/ (+ nota1 nota2) 2) ponto-extra)
)
(defn verifica-situacao-aluno-recuperacao
  "Retorna a media do aluno somada a seu ponto extra (em caso de recuperação)"
  [nota1 nota2]
  (def ponto-extra 2)
  (+ (/ (+ nota1 nota2) 2) ponto-extra)
)

ponto-extra
(verifica-situacao-aluno-padrao 5 5)
(verifica-situacao-aluno-recuperacao 5 5)
(verifica-situacao-aluno-padrao 5 5)

Sobre a imagem:

Na linha três definimos nosso símbolo global "ponto-extra";
Da linha cinco até a linha dezesseis definimos nossas duas funções, "padrão" e "recuperação" respectivamente;
Na linha dezenove checamos o valor do nosso símbolo global "ponto-extra", que é "1";
Na linha vinte e um consultamos a situação de um aluno com a rotina "padrão" e vemos que sua média é "6";
Na linha vinte e três consultamos a situação de um aluno com a rotina de "recuperação" e vemos que sua média é "7";
Na linha vinte e cinco consultamos a situação de um aluno com a rotina "padrão" novamente e agora vemos um resultado diferente, sua média passou a ser "7", mesmo valor que a rotina de "recuperação";
Na linha vinte e sete checamos o valor do nosso símbolo global "ponto-extra" novamente, e conforme esperado ele agora é "2";

Conforme já explicado, a função de "recuperação" altera o valor do símbolo global que é usado por outras funções, essa mudança não era esperada em outras partes da aplicação e isso gerou um problema de divergência de valores, e pior, a momentos onde o problema não ocorre (já que ele só ocorre a partir da primeira execução da rotina de "recuperação") e a rotinas que continuam a funcionar (a rotina "recuperação" sempre funciona). Acabamos de gerar um bug em nossa aplicação que não será nada fácil de simular/encontrar/corrigir.

Escopo local

Como visto anteriormente, o uso inadequado de um símbolo global gerou um bug em nossa aplicação, para resolver esse problema o desenvolvedor que criou a função de "recuperação" deveria ter usado um símbolo de escopo local na rotina, uma vez que o valor de "ponto-extra" usado ali é uma regra especifica dessa rotina.

Para trabalharmos com o escopo local utilizaremos a função "let", com ele criamos um escopo local com símbolos e funções:

O "let" deve ser usado entre parênteses;
Ele recebe um vetor de símbolos/valores;
Ele recebe uma ou mais funções;
Ele retorna o resultado da execução de sua última função;

(let [idade 40] (+ idade 1))

Na imagem acima:

Na linha um criamos nosso escopo local com o "let", nesse escopo temos o símbolo "idade" com o valor "40" dentro do vetor e temos uma função que soma a valor "1" ao nosso símbolo "idade";
Na linha dois temos o resultado da função de soma;
Na linha três tentamos usar o símbolo "idade" e recebemos um erro na sequencia dizendo que não foi possível resolver o símbolo;

Bom, agora que já sabemos como resolver o problema de escopo vamos aplicar uma correção em nossa função "recuperação", para que ela deixe de usar o símbolo global, primeiro vamos reiniciar o símbolo global para seu valor correto, em seguida vamos corrigir a função e ne sequencia executar os testes:

(def ponto-extra 1)

(defn verifica-situacao-aluno-recuperacao
  "Retorna a media do aluno somada a seu ponto extra (em caso de recuperação)"
  [nota1 nota2]
  (let [ponto-extra-recuperacao 2]
    (+ (/ (+ nota1 nota2) 2) ponto-extra-recuperacao))  
)

(verifica-situacao-aluno-padrao 5 5)
(verifica-situacao-aluno-recuperacao 5 5)
(verifica-situacao-aluno-padrao 5 5)
ponto-extra

Na imagem acima:

Na linha 1 redefinimos nosso símbolo global para seu valor correto;
Da linha três até a oito temos a refatoração de nossa função com o uso do "let";
Nas linhas dez, doze e catorze repetimos os testes, e agora os seus respectivos resultados estão corretos;

Conclusão

Nesse post entendemos e exemplificamos os problemas causados pelo uso do escopo global, vimos como trabalhar com escopo local com o "let" e refatoramos nossa função problemática para que nossa aplicação voltasse a funcionar da forma esperada.

Saiba mais

Clojure - Criando nossa primeira função

Eduardo Teixeira — Wed, 09 Feb 2022 17:26:29 +0000

Anteriormente vimos como configurar o ambiente e em seguida escrevemos nossas primeiras linhas de código para começarmos a entender como o Clojure funciona, usamos algumas funções "nativas", declaramos algumas "variáveis" e também brincamos com um vetor.

Nesse post daremos mais um passo, escreveremos nossa primeira função, passando por algumas de suas características e entendendo um pouco sobre como a criação delas funciona.

Definindo nossa primeira função

Para criar nossa primeira função precisamos ter em mente que o que deve ser feito é algo semelhante a definição de uma variável, a diferença fica por conta do uso do comando "defn" (é possível usar o "def", mas veremos isso futuramente), basicamente precisaremos:

Escrever todo o conteúdo dentro de parênteses;
Usar o comando "defn";
Definir uma lista de parâmetros, se não existirem parâmetros (nosso caso agora) essa lista deve estar vazia;
Definir o corpo da função;
Opcionalmente podemos colocar um comentário para deixar mais claro o que a função faz;

Definindo nossa função:

(defn minha-primeira-funcao
  "Exemplo de uma função"
  []
  (println "Minha primeira função!")
)

Executando nossa função:

(minha-primeira-funcao)

Na imagem acima temos:

Na linha três temos o inicio da definição de nossa função com o uso de "defn" seguido do nome que escolhemos;
Na linha quatro, entre aspas duplas, temos o comentário que explica o que a função faz;
Na linha cinco temos o vetor de parâmetros vazio;
Na linha seis temos o corpo de nossa função, que realiza a impressão no console de uma frase;
Na linha sete temos o fechamento de nossa função;
Na linha nove executamos a nossa função;
Na linha dez temos o resultado da execução e na onze o retorno;

Apenas um detalhe, a função toda foi escrita no bloco de notas, e depois copiada para o console para a execução.

Criando uma função que recebe parâmetros e devolve um valor

De acordo com nosso exemplo anterior, para criarmos uma função que receba parâmetros basta declara-los no vetor que tem essa responsabilidade, agora para retornar um valor basta construirmos uma instrução que retorne um valor.

Para nosso segundo exemplo criaremos uma função que calculará e retornará a média de um aluno com base em duas notas:

(defn calcula-media
  "Calculando a media de duas notas"
  [nota1, nota2]
  (/ (+ nota1 nota2) 2)
)

Executando nossa segunda função:

(calcula-media 7M 8M)

Na imagem acima temos:

Da linha três a linha sete temos a definição de nossa função, destaque para a linha cinco onde temos a definição de dois parâmetros (nossas duas notas) e para a linha seis, onde de fato realizamos o cálculo e por consequência o retorno da média, analisando de "dentro" para "fora" temos a soma das notas e depois a divisão por dois;
Na linha nove temos a execução da função de média, onde informamos as duas notas, a "letra M" colocada junto do valor das notas é apenas para termos um resultado mais amigável, a frente entenderemos melhor a questão de tipos de dados;
E na linha dez temos o resultado apresentado, a média calculada;

Conclusão

Nesse post escrevemos nossas duas primeiras funções e entendemos como passar parâmetros e devolver um resultado.

Saiba mais

Clojure - Funções, vetores e def

Eduardo Teixeira — Mon, 07 Feb 2022 12:28:47 +0000

Nessa postagem escreveremos nossas primeiras linhas de código com o Clojure, aqui tentaremos trazer alguns conceitos para mais perto de quem já programa com os paradigmas mais tradicionais (orientação a objetos por exemplo), de modo que fique mais simples entender as intenções e começarmos a correlacionar alguns pontos, mesmo que alguns deles não sejam necessariamente a mesma coisa.

Funções

Como já é de conhecimento, funções são pequenas partes de um programa que executam um trabalho e devolvem um resultado, e para que esse trabalho seja realizado muitas vezes é necessário informar argumentos ou informações para que algo seja feito.

Em Clojure toda invocação de uma função ocorre dentro de parênteses, logo podemos interpretar o conteúdo que esta dentro dos parênteses da seguinte forma:

O primeiro valor é a função a ser executada;
O segundo valor é o primeiro argumento que a função receberá;
Vamos agora ao nosso primeiro exemplo, iremos chamar uma função que escreve no console, passando como "argumento" o famoso "Olá Mundo!":

(println "Olá Mundo!")

Vamos falar sobre a imagem agora, linha por linha:

Na primeira linha estamos iniciando o Clojure com o comando "clj";
Na segunda linha nos é apresentada a versão atual (1.10.3);
Na terceira linha começamos a escrever nosso primeiro código, chamando a função "println";
Na quarta linha temos o resultado da execução interna da função "println", que é a escrita no console da frase que informamos como "argumento";
Na quinta linha temos o retorno da função "println", como ela não retorna nada recebemos nulo (nil);
Na sexta e última linha temos o controle a disposição novamente para informar os próximos comandos;

Ainda sobre funções vale destacar que os operadores matemáticos também são considerados como funções, logo se quisermos somar dois números, por exemplo, precisaríamos iniciar a expressão com o operador de soma, seguido dos "argumentos" (números) que desejamos somar:

(+ 1 2)

Iniciar a a expressão com um número, utilizando um padrão de operação comum nas linguagens de programação mais tradicionais resultaria em erro, uma vez que o Clojure tentaria interpretar um número como uma função:

(1 + 2)

Na imagem acima vemos os dois exemplos, o primeiro com o resultado correto, onde a soma é o primeiro parâmetro e o segundo com o resultado incorreto, onde o Clojure nos diz que o número informado não é uma função.

def

Quando estamos programando é trivial mantermos determinados valores (independente do tipo) armazenados em memória, para podermos acessá-los durante a execução de uma aplicação ou função e comumente realizamos isso por meio de "variáveis", sendo justamente esse o conceito que utilizaremos agora para tentar entender o "def".

Com o "def" criamos (ou definimos) símbolos que nos permitem salvar e recuperar determinados valores, funcionando de forma semelhante a uma variável, sua sintaxe é simples, e funciona como uma função, onde temos a função propriamente dita, o símbolo a ser criado/atualizado e o valor que pretendemos associar ao símbolo:

(def total-de-alunos 25)

Para poder ver o valor armazenado em nosso símbolo podemos usar o "println" ou podemos ver seu conteúdo simplesmente digitando o nome do símbolo (fora de parentes é claro):

(println total-de-alunos)

total-de-alunos

Na imagem acima vemos o seguinte:

Na linha três a definição do símbolo "total-de-alunos" com o valor "25";
Na linha quatro o retorno que nos indica o espaço onde nosso símbolo esta gravado (user);
Na linha cinco executamos a função "println" para ver o conteúdo;
Na linha oito verificamos o valor do símbolo diretamente, sem o uso de uma função;
Nas linhas seis e nove podemos ver o valor armazenado no símbolo;

Para alterar o valor de um símbolo basta utilizarmos o "def" novamente, informando o identificador e o novo valor, esse novo valor pode ser um número fixo (como vimos anteriormente) ou pode ser a execução de uma outra função:

(def total-de-alunos 30)

(def total-de-alunos (+ total-de-alunos 5))

Podemos observar na imagem acima:

Na linha um definimos um novo valor para o símbolo;
Na linha três pedimos para ver o novo valor e na linha quatro o vemos (30);
Na linha cinco alteramos o valor novamente, fazendo com que o novo valor seja o valor já existente "30" somado a "5";
Na linha sete pedimos para ver o novo valor e na linha oito o vemos (35);

Vetores

Quando começamos a aprender uma nova linguagem de programação umas das primeiras estruturas que aprendemos para armazenar uma série de elementos é o vetor, em Clojure não é diferente, a exemplo do que vimos anteriormente, iremos usar o "def" para definir um símbolo ficando por conta do valor atribuído a definição desse vetor, em nosso caso iremos atribuir uma série de nomes entre colchetes:

(def alunos ["Maria", "Flávia", "Teresa"])

Perceba que no comando acima utilizamos "virgulas" para separar os elementos, mas o que conta mesmo para essa separação são os espaços, a virgula esta ali apenas como uma boa prática que nos permite identificar melhor os itens (inclusive as virgulas são consideradas como espaços no Clojure).

Para ver os itens de nosso vetor podemos usar tanto as formas já vistas até aqui, com o "println" ou digitando o nome do símbolo diretamente, o que resulta na apresentação de todos os valores ou podemos acessá-los por meio de suas posições, nesse último caso o vetor acaba funcionando como uma função que recebe como parâmetro a posição desejada:

(println alunos)

alunos

(alunos 2)

Quando trabalhamos com vetor temos a disposição a função "count" para contar o total de elementos:

(count alunos)

Agora se nossa intenção for adicionar um novo item ao vetor devemos usar a função "conj", aqui é muito importante entendermos que essa função não altera o vetor original, o que ela faz é retornar um novo vetor que possui os valores anteriores e também o novo, isso devido a imutabilidade do Clojure:

(conj alunos "Eduardo")

Mas qual a vantagem da imutabilidade então? Bom ela nos garante que nossa informação (no caso os valores de nosso vetor) não serão alterados sem o nosso conhecimento ao utilizarmos outras funções, desse modo temos uma confiabilidade maior sobre a informação uma vez que ela só será alterada se realmente desejarmos, ou seja, não corremos o risco de termos os dados alterados por uma função que se quer conhecemos a implementação.

Na imagem acima temos:

Na linha sete usamos a função "conj" para adicionar um elemento ao vetor;
Na linha oito a função "conj" nos retorna o novo vetor contendo a alteração que realizamos;
Na linha nove e dez podemos perceber que o vetor original "alunos" não foi alterado;

Certo, como já é possível imaginar, se nossa intenção for alterar o vetor original precisaremos então redefinir o valor do nosso símbolo "vetor", sendo que seu novo valor será o resultado da execução da função "conj":

(def alunos (conj alunos "Eduardo"))

Como podemos ver na imagem acima agora o vetor original "alunos" possui o novo valor.

Conclusão

Nessa postagem sentimos o gostinho inicial do Clojure, escrevemos nosso primeiro "Olá Mundo!", definimos nossa primeira "variável" e criamos nosso primeiro vetor. Também nos deparamos com a imutabilidade, entendendo como ela funciona e uma de suas principais vantagens.

Saiba mais

Clojure - Preparando o ambiente

Eduardo Teixeira — Thu, 03 Feb 2022 18:56:19 +0000

Antes de mais nada precisamos preparar nosso ambiente para podermos começar a brincar, no link oficial temos os processos de instalação de acordo com os SOs suportados, nessa postagem iremos falar sobre as instalações no Linux e no Windows.

Windows

Para a instalação no Windows podemos usar o instalador ou fazer o processo via linha de comando com o PowerShell, esse último seguindo as seguintes instruções (conforme indicado aqui):

Se certificar que o PowerShell esta na versão 5 ou posterior, para tal basta abrir o mesmo (pressione "Windows + X", escolha "Executar" e digite o comando "Powershell"), e em seguida digitar o comando "get-host":

Também devem estar instalados o ".NET Core SDK 2.1+ or .NET Framework 4.5+ (ou mais recente)". Além disso precisaremos do Java 8+ e a variável de ambiente JAVA_HOME configurada;
Se tudo estiver certo basta executar o comando para o download "iwr -useb download.clojure.org/install/win-install-1.10.3.1058.ps1 | iex":

Como podemos ver acima, após o download nos é apresentada uma lista de possíveis locais para a instalação, no nosso caso escolheremos a opção "2":

Se tudo correu bem até aqui temos nossa configuração inicial pronta;

Linux

Em nosso caso estamos usando a distribuição Ubuntu 18.4;
Precisamos garantir que as seguintes dependências estão instaladas: bash, curl, rlwrap e o Java (em nosso caso precisamos instalar apenas o Java, e para tal utilizamos esse artigo);
Se estiver tudo OK basta baixar um script pronto (com o curl), depois executar ele:

Conclusão

Concluímos a instalação base do Clojure tanto no Windows como no Linux, nas próximas postagens começaremos nossa caminhada!