DEV Community: João Vitor Martins Araújo

Anotações da faculdade - Matemática - Teoria dos conjuntos

João Vitor Martins Araújo — Tue, 21 May 2024 17:56:40 +0000

Testando algumas linguagens de programação para expressar um conjunto.

F = {x | x² = 9}

O conjunto de valores de x, tal que x² = 9, é o conjunto {-3; 3}.

Python

A primeira coisa que lembrei foi como a expressão do conjuntos F = {x | x² = 9 era parecida com python.

Python consegue fazer comprehension de diversas estruturas como listas, dicionários e conjuntos e fica muito parecido com a notação matemática.

A sintaxe é bem simples e ocupa pouquíssimo espaço no código e eu não preciso dizer que quero um conjunto como resultado final pois o uso de chaves {} já determina isso.

set = {x for x in range(-10, 10) if x ** 2 == 9}

print(set)

{-3, 3}

Elixir

Como trabalho com Elixir foi natural usa-la em sequencia para resolver o mesmo problema. Usando a estrutura for de 3 argumentos e a sintaxe inline do for é possível ter o mesmo resultado do python de forma simples e elegante.

Elixir também é capaz de fazer comprehension em diversas estruturas como listas, mapas e conjuntos.

Não fica tão parecido com a notação matemática mas é simples de de fácil compreensão.
import java.util.HashSet;
import java.util.Set;
Nota: Eu poderia ter usado o for de 2 argumentos o resultado seria uma lista, então usei o terceiro argumento, into: MapSet.new(), para que o resultado final fosse um conjunto.

set = for x <- -10..10, x ** 2 == 9, into: MapSet.new(), do: x

IO.inspect(set)

MapSet.new([-3, 3])

Java

Java não fornece uma construção sintática para este conceito, então o que podemos fazer é usar o for tradicional com os tipos HashSet e Set para termos o nosso conjunto. Java também não usa o operador de potenciação ** como Python e Elixir então chamamos Math.pow para isso.

import java.util.HashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();

        for (int i = -10; i < 10; i++) {
            if (Math.pow(i, 2) == 9) {
                set.add(i);
            }
        }
        System.out.println(set);
    }
}

[-3, 3]

JavaScript

Essa aqui eu pedi para o ChatGPT fazer pra mim 😅.

JavaScript também não possui uma construção sintática para comprehension, então usamos o bom e velho for tradicional e o tipo Set para termos um conjunto.

Nota: Existia uma proposta para incluir list comprehension em JavaScript mas nunca chegou a ser incorporado oficialmente.

let set = new Set();

for (let i = -10; i <= 10; i++) {
  if (i ** 2 === 9) {
    set.add(i);
  }
}

console.log(set);

{ -3, 3 }

Lua

Aproveitando que mexi com Lua recentemente então nada mais justo do que incluir uma versão em Lua.

Lua não possui estruturas como listas, conjuntos e tuplas como outras linguagens, apenas tabelas, que são parecidas como os arrays e são usadas para tudo na linguagem, construção de módulos, classes, estruturas de chave-valor e etc. Então aqui um "conjunto" nada mais é que uma tabela. Usamos o for para ir inserindo os valores no nosso conjunto e no final para imprimir de maneira formatada os valores na tela.

local write = io.write
local set = {}

for x = -10, 10 do
    if x ^ 2 == 9 then
        table.insert(set, x)
    end
end

write("{")
for i, v in ipairs(set) do
    write(v)
    if i < #set then
        write(", ")
    end
end
write("}")

{-3, 3}

Estudo sobre Grafos com Elixir

João Vitor Martins Araújo — Wed, 15 Nov 2023 19:35:05 +0000

Introdução

Este estudo tem como objetivo explicar o conceito de grafos e demonstrar uma aplicação simples de grafos em Elixir. O código em Elixir define um módulo Person com uma estrutura básica de entidade e um módulo ProfessionalFinder, que contém uma função para encontrar um profissional na lista de amigos de uma pessoa.

Grafos

Em ciência da computação, um grafo é uma estrutura de dados que consiste em um conjunto finito de nós (ou vértices) e um conjunto de arestas que conectam esses nós. Um grafo pode ser usado para representar relações entre diferentes entidades.

Existem dois tipos principais de grafos:

Grafo Direcionado (DiGraph): Em um grafo direcionado, as arestas têm uma direção, ou seja, vão de um nó para outro. Essa direção é frequentemente representada por setas.
Grafo Não Direcionado: Em um grafo não direcionado, as arestas não têm direção. A relação entre os nós é mútua.

Nós e Arestas

Nó (ou Vértice): Representa uma entidade no grafo. No código Elixir, uma estrutura Person (Pessoa) é usada para representar os nós. Cada pessoa tem um nome, uma profissão e uma lista de amigos (nós conectados).

Aresta: Representa uma relação entre nós. No contexto desse exemplo, as arestas são amizades entre pessoas.

Explicação do Código Elixir

Módulo Person

O módulo Person define uma struct que representa uma pessoa com atributos como name (nome), profession (profissão) e uma lista de friends (amigos). Essa estrutura captura as informações básicas necessárias para uma pessoa no contexto de uma rede social.

defmodule Person do
  @moduledoc """
  Person Entity
  """
  defstruct name: nil, profession: nil, friends: []
end

Módulo ProfessionalFinder

O módulo ProfessionalFinder contém uma função chamada search/2, que procura por uma pessoa com uma profissão específica na lista de amigos de uma pessoa fornecida.
A função recebe uma pessoa e uma profissão como entrada. Ela inicializa uma fila de busca com os amigos da pessoa de entrada e um conjunto para acompanhar os nós verificados. A função privada do_search/3 realiza uma pesquisa em largura (BFS) no grafo para encontrar uma pessoa com a profissão especificada.

defmodule ProfessionalFinder do
  @moduledoc """
  Find a professional on your friends list
  """

  @spec search(Person.t(), String.t()) :: {:ok, Person.t()} | {:error, :not_found}
  def search(person, profession) do
    search_queue = :queue.from_list(person.friends)
    checked = MapSet.new()

    do_search(search_queue, checked, profession)
  end

  defp do_search({[], []}, _, _), do: {:error, :not_found}

  defp do_search(search_queue, checked, profession) do
    friend = :queue.head(search_queue)

    with false <- MapSet.member?(checked, friend),
         ^profession <- friend.profession do
      {:ok, friend}
    else
      # has already checked
      true ->
        do_search(:queue.tail(search_queue), checked, profession)

      _profession ->
        search_queue
        |> :queue.tail()
        |> append_friends(friend.friends)
        |> do_search(MapSet.put(checked, friend), profession)
    end
  end

  defp append_friends(queue, []), do: queue

  defp append_friends(queue, friends) do
    Enum.reduce(friends, queue, fn friend, queue ->
      :queue.in(friend, queue)
    end)
  end
end

Exemplo de Uso

O exemplo a seguir cria uma pequena rede social de pessoas e usa o ProfessionalFinder para procurar uma pessoa com uma profissão específica na rede.

Criação de Pessoas:

Anuj, Peggy, Tom, Jonny, Claire, Alice, Bob e João representam indivíduos na rede social.

Definição de Amizades:

Amizades são definidas usando o campo friends na struct Person.

anuj = %Person{name: "Anuj", profession: "Engineer"}
peggy = %Person{name: "Peggy", profession: "Doctor"}
tom = %Person{name: "Tom", profession: "Seller"}
jonny = %Person{name: "Jonny", profession: "Carpenter"}
claire = %Person{name: "Claire", profession: "Lawyer", friends: [tom, jonny]}
alice = %Person{name: "Alice", profession: "Engineer", friends: [peggy]}
bob = %Person{name: "Bob", profession: "Manger", friends: [anuj, peggy]}
joao = %Person{name: "Joao", profession: "Farmer", friends: [alice, bob, claire]}

Execução da Busca:

O exemplo procura por uma pessoa com a profissão “Vendedor” na lista de amigos de João usando ProfessionalFinder.search(person, profession).

person = joao
profession = "Seller"
ProfessionalFinder.search(person, profession)

Saída:

A saída {:ok, %Person{name: "Tom", profession: "Vendedor", friends: []}} indica que uma pessoa chamada Tom com a profissão “Vendedor” foi encontrada.

Observe que Tom não é uma conexão direta de João. Tom é amigo de Claire que é amiga de João, ou seja, Tom é uma conexão de segundo grau de João.

A pesquisa utilizando grafos busca primeiro os amigos mais próximos de João, se não encontrar nenhum vendedor nessa lista então a busca se expandirá para os amigos dos amigos de João.

Dependendo do seu objetivo, talvez queira estabelecer um limite para não acabar encontrando um completo desconhecido.

Conclusão

Grafos são uma estrutura de dados versátil que pode ser aplicada em diversos cenários. Por exemplo:

Redes Sociais: Modelagem de amizades e conexões entre usuários baseados em grau de conexão ou proximidade geográfica.
Sistemas de Recomendação: Análise de padrões de comportamento de usuários para recomendar produtos ou conteúdo.
Logística e Roteamento: Otimização de rotas em redes de transporte, como GPS e logística de entrega.

Elixir: Usando Tesla.Middleware.Telemetry

João Vitor Martins Araújo — Wed, 02 Nov 2022 13:56:42 +0000

A biblioteca Tesla, usada para trabalhar com requisições HTTP em Elixir, possui um middleware de telemetria que podemos usar para obter algumas informações sobre as requisições que estão sendo executadas.

No caso de uso que irei demonstrar estarei coletando algumas informações da requisição para posteriormente salvar em um banco de dados como se fosse um log.

Para começar vamos criar um projeto Phoenix que irei carinhosamente chamar de Frog.

mix phx.new frog

Primeiro adicionamos o tesla em nossas dependências, no arquivo mix.exs

defp deps do
    [
     ...,
      {:tesla, "~> 1.4"}
    ]
end

Em seguida precisamos criar um cliente HTTP qualquer, para podermos ter algo com o que trabalhar. Então vamos consultar uma API de CEP chamada: Viacep

A base do nosso cliente fica assim:

defmodule Frog.Client do
  use Tesla
  @url "http://viacep.com.br/ws/01001000/json/"

  plug Tesla.Middleware.JSON

  def get, do: get!(@url).body
end

Então, para começar, vamos adicionar o middleware de telemetria junto aos middlewares que estamos usando em nosso cliente.

defmodule Frog.Client do
  use Tesla
  @url "http://viacep.com.br/ws/01001000/json/"

  plug Tesla.Middleware.JSON
  plug Tesla.Middleware.Telemetry

  def get, do: get!(@url).body
end

A partir daí o middleware já estará trabalhando.

O que ele faz é emitir eventos. Quando a requisição for feita, ele emitirá um evento de start e quando terminar, um evento de stop.
Cada evento é composto de três partes, vamos ver a composição do evento de stop:

Evento, formado por uma lista de átomos.

[:tesla, :request, :stop]

Medição, contem a duração da requisição em nanosegundos.

%{duration: native_time}

Metadados, todas as informações que vem na resposta do tesla.

%{env: Tesla.Env.t()}

Agora só precisamos capturar esses eventos quando forem emitidos. Para isso iremos utilizar um recurso pro próprio Erlang, o módulo :telemetry.

Vamos criar um módulo para poder trabalhar isso, e criaremos uma função para iniciar o nosso handler.

defmodule Frog.HandleTelemetry do

  def setup do
    :telemetry.attach(
      "my-tesla-telemetry", # Nome do evento, pode ser qualquer nome.
      [:tesla, :request, :stop], # Evento que queremos capturar
      &__MODULE__.handle_event/4, # Função que irá tratar os dados.
      nil # Trata-se de configurações, mas podemos ignorar.
    )
  end
end

O :telemetry.attach/4 fica escutando os eventos lançados e captura os que definirmos. Essa função recebe 4 argumentos:

Um nome para o nosso evento
O evento que queremos capturar
Uma função para tratarmos os dados
E configurações adicionais, que segundo a documentação, podemos ignorar com segurança.

Agora vamos criar a nossa função para tratar os dados que estão vindo.

defmodule Frog.HandleTelemetry do

  def setup do
    :telemetry.attach(
      "my-tesla-telemetry",
      [:tesla, :request, :stop],
      &__MODULE__.handle_event/4,
      nil
    )
  end

  def handle_event(_event, %{duration: duration}, %{env: metadata}, nil) do
   %{
      duration: duration,
      status: metadata.status,
      method: metadata.method,
      url: metadata.url
    }
  end
end

A nossa função handle_event deve esperar receber 4 argumentos:

O evento, que podemos ignorar nesse caso.
A duração da requisição
O dados da requisição
As configurações que passamos em :telemetry.attach/4, e que podemos ignorar.

Observação sobre o retorno da função:
Nesse caso eu contruí um mapa com as informações relevantes para mim, e a ideia aqui é passar isso para outro módulo que fará a inserção desses dados num banco. Você pode usar o IO.inspect/1 para ir analisando tudo que está recebendo, e o que será importante para montar o retorno da função conforme a sua necessidade.

Um ponto importante aqui é que se a lógica desse handle_event quebrar o :telemetry.attach/4 para de funcionar e você perderá os dados. Para evitar, isso podemos usar o rescue para tratar possíveis exceções. Junto a isso estarei usando o módulo Logger para ter uma visualização do erro. Vou aproveitar e adicionar também uma função privada para capturar a data nos headers da requisição.

defmodule Frog.HandleTelemetry do
  require Logger

  def setup do
    :telemetry.attach(
      "my-tesla-telemetry",
      [:tesla, :request, :stop],
      &__MODULE__.handle_event/4,
      nil
    )
  end

  def handle_event(_event, %{duration: duration}, %{env: metadata}, nil) do
    %{
      date: get_date(metadata.headers),
      duration: duration,
      status: metadata.status,
      method: metadata.method,
      url: metadata.url
    }
  rescue
    error -> Logger.error("[#{__MODULE__}] Error: #{inspect(error)}")
  end

  defp get_date([{"date", date} | _]), do: date
  defp get_date([_ | tail]), do: get_date(tail)
  defp get_date(_), do: nil
end

Para finalizar, precisamos chamar a nossa função setup dentro do start da aplicação.

defmodule Frog.Application do
  ...
  def start(_type, _args) do
    children = [
      ...
    ]

    Frog.HandleTelemetry.setup()

    ...
  end
 ...
end

Com isso, a partir do momento que a sua aplicação iniciar, o handler estará esperando os eventos e os capturando quando ocorrerem. Agora você pode usar essas informações da forma que achar mais apropriado.

Obs:

Os nomes das funções "setup" e "handle_event" são opcionais, mas verá que na própria documentação também é usado o nome "handle_event", então estou seguindo essa convenção.
Outra maneira de fazer isso seria capturando essas informações diretamente no módulo do cliente. Mas isso criaria um acoplamento desnecessário. E estaria indo contra o princípio da responsabilidade única, pois o seu cliente estaria fazendo muitas coisas em um só lugar.
A função :telemetry.attach_many/4 recebe uma lista de eventos e irá capturar todos os eventos definidos da lista. Assim você poderá capturar os eventos de start e stop caso queira.
Muitas outras bibliotecas Elixir tem suporte a telemetria, como Ecto, Oban, Absinthe e o próprio Phoenix.

Links para as Documentações:

Obrigado por ler até aqui. 😁

Configurar Token de acesso do GitHub

João Vitor Martins Araújo — Wed, 15 Jun 2022 14:42:19 +0000

No seu perfil do GiHub clique em configurações

Na parte inferior da barra lateral você vai encontrar a opção de desenvolvedor

Cligue em Personal access token e depois em Generate new token

Escolha as permissões do token conforme a sua necessidade

Você pode personalizar a data de expiração do token. O padrão é 30 dias.

Apos concluir essa etapa role a página até embaixo e clique em generate token

❗ Lembre-se de salvar o token em um arquivo ou anote em algum lugar, pois não será possível visualizar o token novamente. ❗

Configurar usuario e senha global no github

João Vitor Martins Araújo — Wed, 15 Jun 2022 13:21:07 +0000

Configure o nome de usuário e o email de acordo com a sua conta do GitHub.

git config --global user.name "fname lname" 
git config --global user.email "example@gmail.com"

A senha deve ser o seu token de acesso gerado no GitHub: https://dev.to/jvmartyns/configurar-token-de-acesso-do-github-5eep

git config --global user.password "github_access_token"

Para ver as configurações existentes use o comando

git config --list --show-origin