DEV Community: Starch1

Easy setup Elixir / Erlang OTP using mise

Starch1 — Mon, 17 Feb 2025 15:22:01 +0000

First, what is mise?

Straight to the point, mise-en-place (or simply mise) is a modern dev-tool manager that simplifies managing multiple versions of programming languages and development tools.

Just like:

asdf manages versions of development tools,
direnv manages environment variables dynamically,
make automates development tasks,

mise combines version management with a seamless experience for developers.

Why should I use mise instead of ASDF (or others)?

While asdf is a well-known tool, mise offers some advantages that might make it a better fit for your workflow:

All-in-One Solution: mise provides a unified experience, reducing the need for additional plugins and manual setup.
Better Performance: It’s optimized for speed, making tool switching and environment loading faster.
Compatibility: It supports .tool-versions files (used by asdf), making migration easy.
Simplified Configuration: Unlike asdf, mise is designed with sane defaults and minimal configuration hassle.
Declarative & Reproducible Environments: Define tools per project with a single file, making onboarding and collaboration smoother.

How does mise work?

mise works by reading configuration files (like .tool-versions or .mise.toml) and ensuring that the correct versions of tools are available in your shell environment. It integrates seamlessly with popular shells like bash, zsh, and fish, making it easy to use across different systems.

Installation & First Steps

To install mise, simply run:

curl -fsSL https://mise.run/install.sh | sh #On linux OS

Or, if you are using Homebrew

brew install mise

After installation, you can add it to your shell profile:

eval "$(mise activate zsh)" #Replace `zsh` with your shell if needed

And last, activate:

mise activate

Check if everything is right:

mise doctor

Install a tool (e.g., Elixir, because Elixir is great):

mise use --global elixir@latest erlang@latest

Check the installed tools:

mise ls

And you might have something like that:

Tool    Version        Source                      Requested
elixir  1.18.2-otp-27  ~/.config/mise/config.toml  latest
erlang  27.2.2         ~/.config/mise/config.toml  latest
node    22.14.0        ~/.config/mise/config.toml  22

With mise, managing development environments becomes faster, easier, and more efficient.

DeepSeek e a Descentralização

Starch1 — Tue, 28 Jan 2025 11:45:37 +0000

O que é a DeepSeek?

Se você têm estado online ou na bolha dev, deve ter visto alguém falar sobre a nova corrida espacial(Só que dessa vez, de IAs) da geração atual, então, DeepSeek veio para desbancar qualquer oponente até então.

DeepSeek é uma IA que está revolucionando a forma como pensamos sobre o poder computacional e o processamento de dados. Diferente dos modelos tradicionais de IA, que dependem de servidores centralizados e grandes corporações, a DeepSeek opera em uma rede descentralizada. Isso significa que o poder de processamento e os dados são distribuidos entra vários nós na rede, eliminando a necessidade de controle centralizado.
Em outro artigo eu expliquei Como redes P2P funcionam, se você ainda não sabe, dá uma conferida

Como funciona essa descentralização na DeepSeek?

Para entender a descentralização da DeepSeek, vamos comparar com o modelo tradicional de IA:

Modelo Tradicional

No modelo centralizado, os dados e o processamento são controlados por um servidor principal. Por exemplo, quando você faz uma pergunta a um assistente virtual, a requisição é enviada para um servidor central, que processa a informação e retorna a resposta.

Modelo Descentralizado

Na DeepSeek, não há um servidor central. Em vez disso, a rede é composta por vários nós (peers), onde cada nó pode atuar tanto como cliente quanto como servidor. Quando você faz uma requisição, ela é processada por múltiplos nós na rede, que trabalham juntos para fornecer a resposta.

Vantagens da descentralização.

Segurança e privacidade

Como os dados são distribuídos, não há um único ponto de falha ou um repositório central que possa ser hackeado. Isso reduz significativamente os riscos de vazamentos de dados e aumenta a privacidade dos usuários.

Resistencia a falhas

Se um nó da rede falhar, outros nós continuam operando. Isso torna a DeepSeek muito mais resiliente do que sistemas centralizados, que podem falhar completamente se o servidor principal cair.

Transparência e confiança

A DeepSeek democratiza o acesso à IA, permitindo que mais pessoas e organizações participem da rede. Isso é especialmente importante para comunidades ou regiões que antes não tinham recursos para investir em tecnologia de ponta.

Acesso democratico

Inovação contínua

A natureza descentralizada da DeepSeek incentiva a colaboração e a inovação. Desenvolvedores e pesquisadores de todo o mundo podem contribuir para o ecossistema, criando soluções personalizadas e impulsionando o avanço da tecnologia.

Conclusão

A DeepSeek representa um avanço significativo no mundo da inteligência artificial, mostrando que a descentralização não é apenas uma tendência, mas uma necessidade para um futuro mais seguro, transparente e inclusivo. Com sua abordagem inovadora, a DeepSeek está abrindo caminho para uma nova era de tecnologia, onde o poder da IA está ao alcance de todos.

Como redes peer-to-peer funcionam?

Starch1 — Tue, 14 Jan 2025 19:24:25 +0000

O que é peer-to-peer?

O modelo peer-to-peer (P2P) é uma arquitetura de rede que permite a troca direta de dados entre dispositivos, eliminando a necessidade de servidores centralizados. Essa abordagem descentralizada tem sido amplamente utilizada em diversas áreas, como compartilhamento de arquivos, sistemas financeiros, e até mesmo em aplicações de comunicação.
Vale pontuar que em arquiteturas baseadas em servidores, o ciclo é: Cliente faz uma requisição > Servidor responde. E a rede precisa de um servidor principal.
Enquanto em uma conexão P2P, todos os peers trabalham como clientes e servidores e a conexão é organizada de forma descentralizada.

Como Funciona o P2P?

Primeiro, vamos pontuar como uma conexão baseada em servidores trabalha.
Quando estamos acessando algum conteúdo, como uma stream na Twitch, por exemplo, o seu celular(Ou PC) trabalha como o Cliente, então você abre o app escolhe o streamer que quer assistir e o app faz uma requisição pro servidor, o servidor recebe esta requisição e responde com o conteúdo que você quer assistir no seu dispositivo.

Em uma rede P2P, cada dispositivo conectado à rede – conhecido como peer (ou par) – pode atuar tanto como cliente quanto como servidor. Isso significa que os peers podem tanto consumir quanto fornecer recursos, como dados, armazenamento e poder de processamento. Essa caracterização contrasta com o modelo tradicional cliente-servidor, em que o cliente solicita serviços de um servidor central.

Mas se nós quisermos fazer a mesma request em uma arquitetura P2P, ao invés de enviar a requisição pro servidor central, seu celular(Ou PC) vai simultaneamente enviar requisições para vários outros dispositivos (Outros peers) dentro da rede.

Então, cada peer vai responder com parte do video. Isso significa que ao invés de fazer o download do video inteiro de uma única fonte você vai receber diferentes partes de várias fontes da rede

Ao mesmo tempo que o seu dispositivo recebe partes do vídeo, ele vai começar a compartilhar estas partes com outros clientes que estiverem buscando o mesmo conteúdo.

Tipos de rede P2P

Rede estruturada

As informações são guardadas em um DHT (Distributed Hash Table), permitindo pesquisas específicas e respostas baseadas em índices. Geralmente, essas redes são mais eficientes e escaláveis para ambientes com um grande número de nós.

Redes não estruturadas

As redes P2P não estruturadas não possuem uma organização pré-definida entre os nós. Qualquer nó pode atuar como cliente ou servidor, conectando-se de maneira arbitrária. Essas redes são mais simples de configurar, mas podem enfrentar dificuldades em localizar recursos específicos em grandes redes, especialmente sob alta carga de tráfego.

Redes híbridas

Redes híbridas combinam características de redes estruturadas e não estruturadas. Elas geralmente contam com nós superpoderosos (supernós) que desempenham papéis de coordenação, como indexação de conteúdo ou gerenciamento de conexões. Essa abordagem busca aproveitar a eficiência das redes estruturadas e a simplicidade das não estruturadas, oferecendo uma solução equilibrada entre desempenho e flexibilidade.

Beleza, mas por que usar P2P, quais as vantagens?

Se eu ainda não te convenci, continua lendo.

Segurança

Como redes P2P não possuem um servidor principal(Na maioria dos casos), elas não podem ser hackeadas facilmente, mesmo se um dos peers for atacado, o impacto no sistema é minimo

Escalabilidade

Quanto mais peers interagirem com nossa rede, mais peers trabalham como servidores. Considerando isto, a capacidade de uma rede P2P é ilimitada.

Flexibilidade

Como mencionei, existem vários tipos de rede P2P, dependendo dos nossos requisitos nós podemos escolher e implementar uma estrutura que cabe melhor na nossa aplicação.

E eu acho que é isso :). Espero que eu tenho te ajudado a entender melhor sobre redes P2P. Se em algum momento eu errei, pode me corrigir, se precisar de ajuda para entender algo melhor, sinta-se livre para entrar em contato :)

Genserver e OTP

Starch1 — Fri, 20 Sep 2024 20:03:45 +0000

Elixir e seus processos

Elixir é uma linguagem de programação funcional que roda na Erlang VM, a BEAM, conhecida pela capacidade de construir sistemas distribuídos, concorrentes e bastante resilientes. Um dos conceitos em Elixir pra lidar com concorrência e estado é o GenServer.

Nesse artigo vamos destrinchar o GenServer, entender por que ele é útil e como implementá-lo.

Se você não sabe o que é Programação funcional ou Elixir, eu já escrevi um pouco sobre ambos, dá uma lida, medita um pouco e depois vem aqui.

Processos em Elixir

Antes de entrar em outros tópicos eu quero falar um pouco sobre os processos em Elixir a fim de facilitar a leitura sobre os outros tópicos.

Processos em Elixir são parecidos com threads virtuais onde a VM da linguagem é quem gerencia os processos, a BEAM cria e gerencia os processos Elixir, que são internamente mapeados para um thread do sistema operacional, mas os processos em Elixir não estão vinculados a nenhum thread do sistema operacional e são completamente gerenciados pela BEAM. Cada processo inicialmente ocupa um espaço pequeno e com isso criar um processo é muito rápido porque não requer 'intervenção' direta do sistema operacional.

isso significa que você pode criar milhares ou até mesmo milhões de processos simultaneamente sem sobrecarregar significativamente o sistema.

Genserver

Basicamente GenSever (Ou Generic Server) é um processo em Erlang/Elixir que executa em um loop infinito que pode receber, enviar mensagens e gerenciar estados.

Ele é construído em cima de vários conceitos relacionados ao primitivo de concorrência, os processos, como criação de processos, registro de processos, vinculação de processos, passagem de mensagens, envio de mensagens síncronas, gerenciamento de estado usando recursão do bloco de recebimento, etc. Algumas das principais aplicações do GenServer são a criação de processos de servidor de longa duração que gerenciam estado, respondem a solicitações de forma síncrona e assíncrona, suportam resiliência via supervisores, fornecem rastreamento, depuração, monitoramento, atualização de estado durante troca de código em execução e capacidades de relatório de erros.

Erlang tem um modulo chamado :gen_server que define um numero de funções que devem ser implementadas pelo módulo "generic server". Se você estiver familiarizado com outras linguagens de programação, :gen_server é como uma interface, em Erlang, um módulo define quais funções devem ser implementadas por outros módulos, e isso é chamado de behavior ou comportamento.

Em Elixir temos o módulo GenServer que diferente do módulo:gen_server do Erlang, o GenServer é um módulo que você implementa através da macro use

defmodule SomeGenericModule do
    use GenServer
end

Basicamente quando você usa use GenServer, o Elixir trás por padrão várias implementações do módulo :gen_server, isso permite que você implementa apenas as funções necessárias no seu módulo, enquanto pode deixar o restante das funções retornar os padrões do GenServer

Algumas das características mais importantes do GenServer são:

Comunicação síncrona e assíncrona:

Processos podem se comunicar através de mensagens síncronas, enviando uma mensagem e esperando a resposta, ou assíncrona enviando mensagens, independente de ter um retorno ou não.

Supervisão e tolerância a erros:

Processos GenServer são frequentemente usados com árvores de supervisores, permitindo que eles possam ser supervisionados e reiniciados quando necessário.

Tratamento de mensagens:

Os processos recebem mensagens de forma assíncrona e as tratam usando correspondência de padrões no conteúdo da mensagem. O comportamento do servidor pode ser definido com base na mensagem recebida.

OTP

A sigla significa 'Open Telecom Platform', mas hoje em dia OTP não é mais algo exclusivo da Telecom. OTP é basicamente uma coleção de bibliotecas padrões de projeto e diretrizes de arquitetura para o desenvolvimento de sistemas em Erlang e Elixir. OTP oferece uma abordagem estruturada para construir sistemas distribuídos e concorrentes, incorporando conceitos como processos leves (também conhecidos como "processos Erlang")

Modelo de ator

Em Elixir, cada ator é um processo isolado(Nesse ponto você já deve ter notado que em Elixir tudo é função / processo) e independente que executa sua lógica de forma concorrente em relação a outros atores. Essa abordagem é altamente escalável, já que permite que centenas, milhares ou até mesmo milhões de atores coexistam e cooperem em um sistema, sem a necessidade de preocupação com a sincronização manual de threads ou locks.

Cada ator possui um identificador único, o PID (identificador de processo), que permite enviar mensagens para ele de forma direta. As mensagens são enfileiradas em uma 'mailbox' associada a cada ator, garantindo que as mensagens sejam processadas de forma sequencial e na ordem em que foram recebidas. Isso promove uma comunicação assíncrona entre os atores, evitando bloqueios desnecessários e melhorando a eficiência do sistema.

Além disso, o modelo de ator em Elixir é construído sobre o conceito de imutabilidade e isolamento de estado. Cada ator possui seu próprio estado interno, que só pode ser modificado através do processamento de mensagens. Isso simplifica a construção de sistemas concorrentes, reduzindo a necessidade de compartilhamento de estado e eliminando condições de corrida e problemas de concorrência.

Vamos brincar um pouco.

defmodule GenericActor1 do
  use GenServer

  def start_link do
    GenServer.start_link(__MODULE__, :ok, name: __MODULE__)
  end
  
  def init(state) do
  
    {:ok, pid} = GenServer.start_link(GenericActor2, self(), name: GenericActor2)
    schedule_message(pid)
    {:ok, state}

  end

  def handle_info(:send_ok, state) do
  
    io_pid = inspect(self())
    IO.puts("Actor 1 received from #{io_pid}")
    schedule_message(self())
    {:noreply, state}

  end

  defp schedule_message(pid) do
    Process.send_after(pid, :send_ok, 2000)
  end
end

defmodule GenericActor2 do
  use GenServer
  
  def start_link(pid) do
    GenServer.start_link(__MODULE__, pid, name: __MODULE__)
  end

  def init(pid) do
  
    schedule_message(pid)
    {:ok, nil}
  end

  def handle_info(:send_ok, state) do

    io_pid = inspect(self())
    IO.puts("Actor 2 received from #{io_pid}")
    schedule_message(self())
    {:noreply, state}
  end

  defp schedule_message(pid) do
    Process.send_after(pid, :send_ok, 2000)
  end
end

No código acima eu criei dois atores que dentro de um intervalo de tempo enviam :ok e só respondem um ao outro após receber o :ok

"Tá, mas como eu vejo isso acontecendo?"

Inicia o iex interativo com iex -S mix
Depois inicie um dos atores com iex> GenericActor1.start_link
E veja a mágica acontecendo.

iex(1)> GenericActor1.start_link
{:ok, #PID<0.152.0>}
Actor 1 received from #PID<0.152.0>
Actor 2 received from #PID<0.153.0>
Actor 1 received from #PID<0.152.0>
Actor 2 received from #PID<0.153.0>
Actor 1 received from #PID<0.152.0>
Actor 2 received from #PID<0.153.0>
Actor 1 received from #PID<0.152.0>
Actor 2 received from #PID<0.153.0>
Actor 1 received from #PID<0.152.0>
Actor 2 received from #PID<0.153.0>

É um exemplo super básico, mas tendo processos independentes dessa forma torna as possibilidades infinitas.

O que é Blochchain e como a tecnologia funciona?

Starch1 — Sat, 22 Jun 2024 16:35:24 +0000

Como Blockchain Funciona?

Blockchain é uma tecnologia que trabalha como um sistema de registro distribuído e descentralizado. A tecnologia fundamentalmente cria um registro digital de transações compartilhado por uma rede de computadores. Cada transação é agrupada em blocos, que são conectados ao bloco anterior, formando uma cadeia contínua de blocos, daí o nome "blockchain". Essa estrutura permite a manutenção de um histórico imutável de transações, proporcionando transparência e confiança sem a necessidade de intervenção de autoridades superiores(Como bancos).

Descentralização

Uma das grande vantagens do blockchain é a descentralização. Ao contrário dos sistemas tradicionais que dependem de uma entidade central para validar transações, o blockchain permite que múltiplos participantes na rede verifiquem e registrem transações. Isso melhora a segurança e a transparência, já que não há um único ponto de falha que possa comprometer toda a rede. A descentralização também promove a democratização do controle, onde todos os participantes têm acesso igual à informação e ao poder de validação.

Redes Peer-to-Peer (P2P)

Blockchain funciona em redes peer-to-peer (P2P), onde cada nó possui uma cópia completa do registro digital. Isso elimina a necessidade de uma autoridade central e permite que transações sejam conduzidas diretamente entre os participantes da rede. As redes P2P são fundamentais para a descentralização e a resistência do blockchain, pois distribuem o poder computacional e os dados entre todos os participantes, tornando a rede mais robusta e menos suscetível a ataques.

Proof of Work

O Proof of Work é um mecanismo usado por algumas blockchains, como o Bitcoin, para validar e processar transações. Neste processo, os nós da rede competem pra resolver problemas matemáticos complexos. O primeiro nó a resolver o problema é recompensado com criptomoedas e adiciona um novo bloco à blockchain. Esse método intensivo em recursos computacionais garante a segurança da rede. Contudo, ele também é criticado por seu alto consumo de energia e por contribuir para a centralização da mineração em áreas com eletricidade barata.

Proof of Stake

Em resposta às limitações do Proof of Work, algumas blockchains adotaram o Proof of Stake como mecanismo de consenso. No Proof of Stake, os validadores são escolhidos com base na quantidade de criptomoeda que possuem e estão dispostos a "apostar" como garantia de seu compromisso com a rede. Esse método é mais eficiente em termos energéticos e reduz o risco de centralização, já que não depende de poder computacional para validar transações.

Funções de Criptografia Hash

As funções de criptografia hash atual na segurança de redes blockchain. Elas transformam dados de tamanho variável em uma sequência de comprimento fixo, conhecida como hash. Isso garante que cada bloco na blockchain seja único e identificável, proporcionando integridade e segurança aos dados. Exemplo de algoritmo hash bastante usado SHA-256. Os hashes são fundamentais para a estrutura de dados do blockchain, garantindo que qualquer alteração em um bloco seja facilmente detectável.

SHA-256 Hash

SHA-256 é um algoritmo de hash criptográfico essencial em várias blockchains, incluindo o Bitcoin. Ele gera hashes de 256 bits e é vital para garantir a segurança e a integridade da blockchain. Qualquer modificação nos dados de um bloco resulta em um hash completamente diferente, facilitando a detecção de fraudes ou alterações não autorizadas. O uso do SHA-256 contribui para a robustez do sistema, tornando as transações seguras contra tentativas de falsificação e corrupção.

Smart Contracts

Smart contracts, são programas que executam automaticamente os termos de um contrato quando certas condições são atendidas. Eles são armazenados e executados no blockchain, o que garante transparência e imutabilidade. Os smart contracts tem potencial para revolucionar várias indústrias ao automatizar processos que tradicionalmente requerem intermediários, reduzindo custos e aumentando a eficiência.

Casos de Uso

Além das criptomoedas, o blockchain possui uma ampla gama de aplicações potenciais. Exemplos incluem registros médicos eletrônicos que garantem privacidade e acessibilidade, cadeias de suprimentos transparentes que rastreiam produtos desde a origem até o consumidor final, e sistemas de votação eletrônica seguros que aumentam a confiança pública. A capacidade do blockchain de oferecer segurança sem intermediários tem o potencial de transformar vários segmentos. No setor financeiro, contratos inteligentes podem automatizar processos como empréstimos e seguros, enquanto em governos, podem garantir a integridade dos processos eleitorais e da administração pública.

Embarcando no Elixir, Mix e Ecto.

Starch1 — Mon, 08 Apr 2024 08:53:03 +0000

Escrevo este artigo supondo que você, leitor tem noções básicas de programação. Pretendo manter a leitura simples , mas se sua primeira linguagem de programação for Elixir, talvez fique confuso.

Elixir

Elixir é uma linguagem de programação funcional que roda em cima da máquina virtual do ERlang a BEAM.
Elixir é mundialmente usado principalmente em outros países e grandes produtos como Brex, Discord, Pinterest e vários outros, mas é um orgulho nacional.

O diferencial do Elixir é que seu código é executado em processos isolados, esse isolamento permite que o retorno de cada processo possa ser coletado de forma independente, utilizando da melhor forma os recursos da maquina.

Tipos de dados em Elixir

Em Elixir existem tipos de dados que são utilizados para representar diferentes tipos de informações, como:

int Inteiros que podem ser positivos ou negativos
float Pontos flutuantes que representam números decimais.
string Que representam uma sequencia de caracteres escritos entre aspas duplas
boolean Representa valores verdadeiros ou falsos / true false
atom Que são constantes onde o próprio valor é equivalente ao próprio nome, por exemplo :true, :heyThere, :barco

Sintaxe e Módulos

Vamos começar um Hello World pra dar boa sorte.

defmodule helloModule do
    def hello do
    IO.puts("Hello World") #Output => Hello World
    end
end

Aqui já é possível notar algumas 'peculiaridades do Elixir' que são os módulos.
Módulos no Elixir são unidades de organização de código e são usados pra agrupar funcionalidades relacionadas. Módulos também podem conter valores, constantes e até outros módulos.
Você também pode criar uma função sem encapsular com um módulo, mas em Elixir é uma prática recomendada encapsular funções em módulos para organizar e estruturar seu código de forma mais clara e modular.
Módulos em Elixir também são átomos

iex> is_atom(helloModule) #Output => true

Como citei, em Elixir é possível criar módulos dentro de módulos, mas por convenção, é recomendado criar apenas um módulo por arquivo. (A não ser que situação peça o contrário)

Além disso também temos duas extensões principais dentro do Elixir, sendo .ex e .exs.
os arquivos .ex são usados para código compilado que faz parte do aplicativo ou biblioteca, enquanto os arquivos .exs são usados para scripts Elixir executados diretamente pelo interpretador, principalmente para tarefas de automação, experimentação e prototipagem.

Supervisão e Supervisores

Os conceitos de supervisão e supervisores vem do sistema ERlang. Em Elixir os supervisores são responsáveis pelo monitoramento do ciclo de vida de um processo filho e reinicialização dos mesmos quando necessário.
O supervisor garante que, se o processo falhar, ele seja reiniciado de acordo com a estratégia definida. Isso ajuda a criar sistemas tolerantes a falhas.

Existe alguns tipos de supervisores:

Supervisor Simples: Tipo mais básico, supervisiona processos e os reinicia se falharem.
Supervisor Dinâmico: Com este é possível adicionar e remover processos filhos dinamicamente durante a execução do sistema.
Supervisor de Tarefa: Este supervisor supervisiona tarefas assíncronas, como operações de E/S .(Entrada e Saída)
Supervisor de Grupo: Permite agrupar processos filhos para gerenciar em conjunto.

Exemplo de um supervisor:

defmodule GenericSupervisor do
    use Supervisor
    def start_link do
        Supervisor.start_link(__MODULE, [])
    end
    def init([]) do
    children = [
        worker(GenericWorker), []]
        Supervisor.init(children, strategy: :one_for_one)
    end
end

Nesse exemplo o GenericSupervisor supervisiona um único processo que, se falhar, será reiniciado, de acordo com a estratégia :one_for_one

Mix

Mix é uma para ajudar no desenvolvimento de aplicações Elixir. Ela é responsável por criar, compilar e gerenciar projetos, bem como tarefas de automação e teste.

Com Mix, você pode facilmente iniciar um novo projeto Elixir usando o comando mix new projeto. Isso criará uma estrutura de diretórios padrão para o seu projeto, com arquivos de configuração, testes e o esqueleto básico do código.

├── README.md
├── lib
│   └── projeto.ex
├── mix.exs
└── test
    ├── projeto_test.exs
    └── test_helper.exs

Estrutura de um projeto Mix

lib É neste diretório onde fica o código fonte do seu projeto e os arquivos .ex aqui dentro serão compilados.

mix.exs Este é o arquivo de configuração principal do seu projeto. É aqui onde você define metadados do projeto, dependências, tarefas personalizadas e outras configurações.

test Neste diretório ficam os arquivos de testes do seu projeto. Os arquivos de teste são escritos usando o ExUnit e têm a extensão .exs

Além disso, Mix é usado para compilar e executar seu código. Por exemplo, você pode usar mix compile para compilar seu projeto e mix run para executá-lo.

Mix também suporta a criação de tarefas personalizadas, que podem ser usadas para automatizar tarefas comuns de desenvolvimento, como a execução de testes ou a geração de documentação.

Ecto

Ecto é uma biblioteca de persistência de dados para o Elixir, projetada para trabalhar com bancos de dados relacionais. Ela fornece uma maneira limpa e elegante de interagir com o banco de dados, usando uma abordagem baseada em modelos e consultas.

(Persistência de dados é o conceito de armazenar informações de forma duradoura, de modo que elas possam ser recuperadas e utilizadas posteriormente, mesmo após o encerramento da aplicação que as gerou )

Com Ecto, você pode definir modelos para representar suas tabelas de banco de dados e usar esses modelos para criar, atualizar, excluir e consultar registros no banco de dados.

Além disso, Ecto fornece um mecanismo de migração que permite gerenciar o esquema do banco de dados ao longo do tempo. Com migrações, você pode criar e modificar tabelas, índices e restrições de chave estrangeira de forma controlada e reversível.

Ecto também suporta consultas usando a linguagem de consulta Ecto.Query. Com Ecto.Query, você pode construir consultas SQL de forma programática, tornando mais fácil e seguro gerar consultas dinâmicas com base em variáveis de entrada.

Ecto também oferece suporte a transações, permitindo que você execute várias operações de banco de dados como uma única unidade atômica. Isso garante que todas as operações sejam bem-sucedidas ou que nenhuma delas seja aplicada, mantendo a consistência dos dados.

Se você se interessou por Elixir, considere checar a incrível documentação.
https://elixir-lang.org/docs.html
E o tutorial em PT-BR, claro
https://elixirschool.com/pt

Processos, paralelismo e concorrência

Starch1 — Sat, 30 Mar 2024 22:11:42 +0000

Atualmente a demanda por sistemas eficientes e escaláveis é cada vez mais alta, com isto, paradigmas como processamento paralelo e concorrente ganharam muito mais visibilidade como pilares fundamentais. A grande ideia por trás destes paradigmas é otimizar a utilização de recursos computacionais, maximizando a eficiência dos sistemas. Hoje eu vou falar um pouco sobre conceitos, diferenças e aplicações de processamento paralelo e concorrente.

Processos e Threads

O que é um processo?

Processo é uma entidade ativa dentro de um sistema operacional que executa uma tarefa especifica. Veja os processos como instancias de um programa em execução.

Cada processo é isolado dos outros o que significa que eles não podem interagir com outros processos, acessando memoria ou espaço uns dos outros, mas podem conversar entre si através de pipes, sockets ou sinais.

O que é uma thread?

Threads ou linhas de execução? São unidades de execução em um software, elas são sequencias de instruções que podem ser executadas por um processador. Em sistemas que suportam o multi threading, cada thread representa um fluxo de controle separado dentro de um processo que aguarda por

As threads podem ser usadas pra realizar tarefas simultâneas em um software, aproveitando os recursos do processador e melhorando a capacidade de resposta do sistema. Por exemplo, em um software de processamento de texto, uma thread pode ser ser responsável por lidar com a entrada do usuário enquanto outra está formatando texto em segundo plano.

Por que usar threads?

Threads simplificam o uso de multi-tarefas em projetos com várias entidades independentes.
Threads tem vantagens em sistemas com múltiplos processadores.
Threads ajudam na performance em 'segundo plano' e processos assíncronos ## Processamento paralelo.

Basicamente o processamento paralelo é a execução simultânea de várias tarefas. (É isso, já pode ir pro próximo sub tópico. Brincadeira)
A ideia é dividir as tarefas em partes menores pra poderem ser executadas de forma independente, a abordagem visa explorar o potencial dos sistemas que comumente possuem limites de processamento.

Por exemplo processamento paralelo é comumente usado para renderização de gráficos e animações e processamentos de dados em grandes conjuntos, onde é necessário que os dados sejam divididos em partes menores para então serem processados simultaneamente por vários nós de computação em um cluster

Aplicações e tendências

Balanceamento de carga

Balanceamento de carga é uma técnica onde a ideia é distribuir as tarefas entre os recursos de processamento, como CPUs e GPUs. O objetivo é evitar sobrecargas em alguns recursos enquanto outros estão ociosos para maximizar a eficiência do sistema.

Processamento concorrente

O processamento concorrente refere-se à execução coordenada de múltiplas tarefas, permitindo que diferentes partes de um sistema avancem simultaneamente. Ao contrário do paralelismo, que se concentra na execução efetiva de múltiplas tarefas ao mesmo tempo, a concorrência trata mais da estruturação e organização das tarefas.

Já o processamento concorrente é comumente usado em servidores web e sistemas de bancos de dados, onde é necessário que acessar e modificar dados, garantindo que várias partes do sistema possam operar de forma independente e eficiente

Diferenças e Complementaridade

Embora o processamento paralelo e concorrente tenham abordagens distintas, eles frequentemente se complementam na implementação de sistemas modernos. Enquanto o processamento paralelo busca otimizar a utilização de recursos computacionais, permitindo a execução simultânea de tarefas intensivas, o processamento concorrente lida com a estruturação e coordenação de múltiplas atividades, garantindo a eficiência e a responsividade dos sistemas.

Conclusão

Embora o processamento paralelo e concorrente tenham abordagens diferentes, eles se complementam na implementação de sistemas modernos. Enquanto o processamento paralelo busca otimizar a utilização de tarefas intensivas, o processamento concorrente lida com a estruturação e coordenação de múltiplas atividades, garantindo a eficiência e a responsividade dos sistemas.

Iniciando na Programação funcional.

Starch1 — Wed, 21 Feb 2024 17:27:13 +0000

O que é programação funcional

Contextualizando, Programação funcional é um paradigma de programação, ou seja uma forma de abordar a resolução de problemas no mundo da tecnologia, diferente de outros paradigmas como POO. Como o nome sugere, Programação funcional trata programação como funções matemáticas, visando evitar a criação de estados e dados mutáveis, promovendo a ideia de stateless e immutable.

Conceitos

Stateless e Immutable

Immutable

Significa que depois que um dado é criado ele nunca deverá ser alterado. Com isto evitamos retornos inesperados.

Stateless

Trata das funções que devem se comportar sem estado, isso significa que ela deve retornar algo como se fosse sua primeira chamada, tudo que rodou antes da função não deve ter nenhuma influência no seu retorno.

Regras / convenções

Funções devem ser independentes.
Sempre ter pelo menos um argumento: Isso ajuda a evitar dependências de estados globais.
Funções sempre devem retornar algo.
Dados, informações ou até outras funções: Isso promove a transparência e clareza nas operações. Não existem loops
Loops devem ser criados através de recursividade: Isso favorece a imutabilidade e a clareza do código. Funções devem ser puras
Não depender de nenhum dado externo: Isso garante que uma função produza o mesmo resultado para as mesmas entradas, facilitando o teste e a compreensão do código

Funções impuras

Funções impuras nem sempre retornam o valor esperado, isso acontece quando a função tem variáveis mutáveis, permitindo a mudança de estado. Que é o que por construção não acontece na programação funcional.
Um exemplo de função impura:

def remove_last_from_list(input):
    input.pop()
names = ['Lucas', 'Tsugami', 'Rafa']
print(names) #Output: ['Lucas', 'Tsugami']
remove_last_from_list(names)
print(names) #Output: ['Lucas']

Diferenças de Imperativo e POO

Imperativo

No paradigma imperativo, a ideia está na execução de instruções que modificam o estado do programa ao longo da sua execução, com variáveis mutáveis por exemplo. A estrutura do código é baseado em procedimentos e funções, com ênfase em "como" as operações são realizadas, detalhando passos específicos a serem seguidos.

Programação orientada a Objetos(POO)

No POO a abordagem é centrada a objetos que encapsulam dados e comportamentos relacionados. Esses objetos interagem entre si, proporcionando uma organização modular do código.

Exemplos

Aqui vou usar Python para mostrar um exemplo de como é este paradigma na pratica. Vou usar um exemplo no paradigma Imperativo e um Funcional, visto que o POO pode ser 'aproveitado' e utilizado na programação funcional.

##Imperativo
number_list = [1,2,3,4,5,6]
sum_pairs = 0
for num in number_list:
    if num %2 ==0:
        square = num **2
        sum_square += square
print(sum_square) #Output:56

Note que é necessário usar de um loop for para percorrer a lista de números e conseguir o resultado. Ou seja, a cada iteração é gerado um novo estado.

##Funcinoal
number_list = [1,2,3,4,5,6]
sum_pairs = sum(map(lambda x: x**2, filter(lambda x: x % 2==0, number_list)))
print(sum_pairs) #Output: 56

Neste exemplo funcional utilizamos expressões map, lambda e filter para criar uma lista de números pares e em seguida a função sum para conseguir a soma total. Este exemplo é mais conciso e expressa uma operação de forma funcional, evitando estados mutáveis.

Vantagens da programação funcional

Suporte a debug e testes

A Programação Funcional proporciona um suporte melhor a debug e testes devido à imutabilidade e à pureza das funções. Isso facilita a identificação e correção de erros, tornando o desenvolvimento mais robusto.

Performance de código

A abordagem funcional contribui para a melhoria da performance do código em situações em que a imutabilidade e a ausência de efeitos colaterais são críticas. Isso é particularmente útil em sistemas que exigem alta confiabilidade e escalabilidade.

Expressividade e concisão

A programação funcional permite a expressão concisa de lógicas complexas, tornando o código mais legível e fácil de entender. Essa característica é valorizada em projetos que demandam manutenção a longo prazo e colaboração entre desenvolvedores.

Linguagens de programação funcionais.

Elixir

O maior diferencial do Elixir é o polimorfismo, permitindo a criação de funções com diferentes implementações para tipos distintos de dados.

Haskell

Haskell é uma linguagem funcional pura que se destaca pela forte tipagem, inferência de tipos e imutabilidade. Sua sintaxe concisa e expressiva é favorecida em ambientes acadêmicos e aplicações matemáticas.

Scala

Scala é uma linguagem híbrida, incorporando conceitos funcionais e orientados a objetos. Oferece flexibilidade na transição de códigos imperativos para funcionais, sendo amplamente utilizada em ambientes corporativos.

Como criar .Xauthority manualmente.

Starch1 — Tue, 30 Jan 2024 13:37:06 +0000

Se o arquivo .Xauthority não existe no seu diretorio home, você deve ver o seguinte erro

xauth
xauth:  file /root/.Xauthority does not exist
Using authority file /root/.Xauthority

Criando o .Xauthority

touch ~/.Xauthority

# Gera um magic cookie aleatorio de 128 bit hex
xauth add ${HOST}:0 . $(xxd -l 16 -p /dev/urandom)

Depois verifique o arquivo.

xauth list

Desenvolvendo um login com NodeJS, MongoDB, Express e Passport.

Starch1 — Tue, 23 Jan 2024 17:06:27 +0000

Introdução

Este artigo explora a utilização do Express.js, um framework que simplifica a estruturação de aplicações web por meio de middleware e rotas. Além disso, aborda o MongoDB, um banco de dados NoSQL popular que oferece uma abordagem distinta para o armazenamento de dado

Express.js é um framework que simplifica a organização de funcionalidades em aplicações, facilitando o uso de middleware e a definição de rotas.

MongoDB é um banco de dados NoSQL popular. Ao contrário dos bancos relacionais, como tabelas, o MongoDB oferece uma abordagem diferente para armazenar dados, utilizando o formato chamado BSON.

Passport.jsé um middleware de autenticação flexível para NodeJS. Ele pode ser facilmente integrado em qualquer aplicação web baseada em Express, tornando a implementação de autenticação mais simples e personalizável.

Passos para criar o projeto e instalar os modulos:

Vamos iniciar um novo projeto usando

npm init

Instale os modulos usando o comando

npm i express ejs mongoose body-parser express-session
npm i passport passport-local 
npm i passport-local-mongoose

Crie duas pastas dentro do diretorio do projeto usando o comando

mkdir model
mkdir views

Crie um arquivo app.js
Dentro da pasta model, crie um arquivo User.js o que vai ter os nossos Schemas
Dentro da pasta views crie os seguintes arquivos

home.ejs
login.ejs
secret.ejs
register.ejs

EJS é uma linguagem de modelo que permite incorporar codigo JS diretamente em um arquivo de modelo.

Estrutura do projeto deve se parecer com algo assim

Dependencias no package.json

"dependencies": {
    "body-parser": "^1.20.2",
    "ejs": "^3.1.9",
    "express": "^4.18.2",
    "express-session": "^1.17.3",
    "mongoose": "^8.1.0",
    "passport": "^0.7.0",
    "passport-local": "^1.0.0",
    "passport-local-mongoose": "^8.0.0"
  }

No User.js vamos definir um schema que recebe dois campos usernamee password, o passportLocalMongooseadiciona os metodos e campos adicionais ao schema pra facilitar a autenticação local.

//Arquivo User.js
const { default: mongoose } = require('mongoose')
const mangoose = require('mongoose')
const Schema = mongoose.Schema 

const passportLocalMongoose = require('passport-local-mongoose')

const User = new Schema({
    username: {
        type: String
    },
    password: {
        type: String
    }
})

User.plugin(passportLocalMongoose)

module.exports = mongoose.model('User', User)

No arquivo app.js vamos começar definindo as libs do projeto

//Arquivo app.js

const express = require("express"),
    mongoose = require("mongoose"),
    passport = require("passport"),
    bodyParser = require("body-parser"),
    LocalStrategy = require("passport-local"),
    passportLocalMongoose = 
        require("passport-local-mongoose")
const User = require("./model/User")
let app = express()

Vamos criar uma conexão com o MongoDB

mongoose.connect("mongodb://localhost/27017")

Vamos configurar o express para usar a engine de visualização do EJS, configurar o middleware para processar os dados do formulário e a autenticação com Passport.js


app.set('view engine', 'ejs')
app.use(bodyParser.urlencoded({ extended: true}))
app.use(require("express-session")({
    secret: "xxx",
    resave: false,
    saveUninitialized: false
}))

app.use(passport.initialize())
app.use(passport.session())

passport.use(new LocalStrategy(User.authenticate()))
passport.serializeUser(User.serializeUser())
passport.deserializeUser(User.deserializeUser())

Agora vamos configurar as rotas GET com express.

app.get('/', (req,res)=>{
    res.render('home')
})


app.get('/secret', isLoggedIn, (req,res)=>{
    res.render('register')
})

app.get('/register', (req,res)=>{
    res.render('register')
})


app.get('/login', (req,res) =>{
  res.render('login')
})

Vamos definir a rota que vai tratar as solicitações post para o endpoint /register, que cria um novo usuario com base no dados fornecidos no formulario do register.ejs.

app.post('/register', async (req,res)=>{
    const user = await User.create({
        username: req.body.username,
        password: req.body.password,
    })
    return res.status(200).json(user)
})

Agora definir a rota de login que lida com autenticação dos usuarios e logout que, bom, faz log out

app.post('/login', passport.authenticate('local', {
  sucessRedirect: '/secret',
  failureRedirect: 'login',
 // failureFlash: true,
}))

app.get("/logout", (req, res)=> {
    req.logout((err)=> {
        if (err) { return next(err) }
        res.redirect('/')
      })
})

Vamos criar uma função que age como middleware que vai garantir que só usuários autenticados tenham acesso a rotas privadas da aplicação.

function isLoggedIn(req,res,next){
    if(req.isAuthenticated()) return next()
    res.redirect('/login')
}

Por fim vamos definir a porta para acessar-mos e fazer os testes localmente e por o servidor online.

const port = 3000 
app.listen(port, ()=>{
    console.log('🔥')
})

Pra tudo acima funcionar você precisa ter o um servidor mongoose rodando. Caso não tenha eu escrevi um artigo sobre como preparar o ambiente Preparando ambiente de trabalho MongoDB

Você pode iniciar o servidor com o comando

mongod

Depois navegue até a pasta onde está o app.js e digite no terminal

node app.js

Abra o navegador e digite na barra o endereço:

http://localhost:3000/

Conclusão

Integrando essas tecnologias, você ganha não apenas eficiência no desenvolvimento, mas também uma base sólida para construir aplicações escaláveis e seguras. O uso intuitivo de middleware, a flexibilidade do MongoDB e a robustez da autenticação com Passport.js proporcionam uma experiência de desenvolvimento acessível, mesmo para aqueles que estão começando.

Preparando ambiente de trabalho para usar MongoDB

Starch1 — Tue, 23 Jan 2024 17:01:34 +0000

Guia rápido de como preparar o ambiente de trabalho para começar a usar MongoDB

Instalando no Windows

Vá em Download MongoDB e faça o download do MongoDB Community Server.

Aqui você pode escolher a versão e pacotes de acordo com seus requisitos.

Quando o download estiver completo abra o arquivo MSI e clique em 'next' até concluir a instalação. Se você for um iniciante, não precisará fazer configurações especificas.
Agora vá até o diretório que o MongoDB está instalado e copie o caminho

Agora crie uma variável de sistema para assegurar que não vamos ter problemas de caminho no futuro.

Editar variaveis do Sistema>>Variaveis do Ambiente>>Path>>New>> Cole o caminho que você copiou.

A variável PATH é uma configuração do sistema operacional que lista os diretórios nos quais o sistema deve procurar por executáveis quando você digita um comando no prompt de comando ou em um script.

Depois de configurar o ambiente de variaveis, vamos rodar o servidor MongoDB. Abra o prompt de comando e digito o comando:

mongod

Você verá um erro de i.e. C:/data/db/not found.

Agora, abra a unidade C e crie uma pasta chamada "data" dentro desta pasta crie outra pasta chamada "db". Depois de criar essas pastas. Abra novamente o prompt de comando e execute o seguinte comando:

mongod

Agora o servidor mongo vai estar rodando :)

Rodando Mongo shell

Agora vamos conectar nosso servidor (mongod) ao shell mongo. Então, mantenha aquela janela do mongod e abra uma nova janela de prompt de comando e escreva mongo. Agora, nosso shell mongo se conectará com sucesso ao mongod.

Agora você está pronto pra escrever queries no mongo shell

Preparando o ambiente de trabalho e utilizando APIs google.

Starch1 — Fri, 19 Jan 2024 21:53:42 +0000

Guia rápido de como começar ativar e começar a usar as APIs google.

Acesso o console de desenvolvedor

Abra o navegador e acesse Console do Google
Se ainda não tiver um projeto, clique em 'criar projeto'

Ativando a API

-No painel de controle clique em 'Ativar APIs e Serviços'
-Na biblioteca encontre a API que você quer utilizar
-Escolha a API e clique em 'Ativar'

Criando credenciais

-No painel de controle clique em 'Criar Credenciais'
-Selecione o tipo de credencial que faça sentido de acordo com o projeto .Por exemplo, se estiver desenvolvendo uma aplicação da web, escolha "ID do Cliente OAuth"
-Configure as informações necessárias, como URLs.
-Clique em 'Criar' e faça o download das credenciais geradas. Nota que este arquivo é muito importante e você deve guardar com cuidado.

Papeis e permissões

-No console, acesse a seção 'IAM'
-Adicione os membros da sua equipe atribua papeis apropriados

Integrando credenciais a aplicação

-Use as credenciais baixadas de acordo com o que a documentação da API pede
-Mantenha as credenciais em segredo. Recomendo usar dotenv ou algo do tipo.