DEV Community: Paulo Castro

Elixir Roadmap

Paulo Castro — Fri, 22 Apr 2022 17:20:52 +0000

Introdução

Muitas pessoas da rede social do passarinho azul (essa mesma que você imaginou) me procuraram para saber um bom roadmap de estudos em Elixir, e bem, eu não sou a maior referência da área, mas creio que posso guiar com clareza qualquer um que queira aprender sobre essa linguagem maravilhosa. Dito isso, resolvi juntar todo o conteúdo que mapeei e filtrei para o melhor aprendizado em Elixir dada a minha experiência estudando-os. Dessa forma, só apresentarei conteúdos que ESTUDEI e que me ajudaram a entender melhor a linguagem.

Parte 1 - Entendendo o básico

A primeira parte para um bom estudo, independentemente da linguagem, são as bases, entender concisamente os tipos básicos, operadores, funções, sintaxe e afins é de suma importância. Dessa forma, nada melhor do que aprender isso logo de cara pela documentação da linguagem. Nela você já terá acesso à aba GUIDES, com um guia bem entendível dos principais elementos que formam a linguagem Elixir. No entanto, caso queira algo mais tátil, visual e direto ao ponto, é possível estudar todos esses conteúdos por meio do ElixirSchool. Assim, se estudadas a sério, suas bases teóricas serão excelentes para um bom entendimento da linguagem.

E caso você goste de cursos em vídeo, é possível complementar os estudos por eles, no YouTube e na Udemy você encontra alguns canais ensinando Elixir com uma didática excelente, sendo eles:

E Sobre a prática?

Para praticar os tipos básicos e operações, aí vai uma opinião MINHA:
- Utilizar o iex: Eu sempre apoiei o começo dos estudos sobre a linguagem por meio da ferramenta iex, que já vem instalada com o Elixir, a mesma possibilita ao desenvolvedor criar funções, operações e manipular diversos elementos da linguagem sem ter que abrir uma IDE, fazendo tudo pelo terminal. Desse modo, eu incentivo imensamente o uso dela para o maior costume de testar as coisas em um ambiente seguro e prático.
- MUITOS EXERCÍCIOS: Hoje, não vejo um site mais completo para praticar Elixir que não o Exercism. Os desafios nele contidos te permitem explorar as mais diversas formas de resolução e manipulação de dados, e em contextos divertidos, sem contar a ferramenta incrível de mentoria em que o estudante pode solicitar de forma GRATUITA na plataforma, onde alguém mais experiente pode ajudar.
- Projetos simples: começar com projetos simples sempre é uma boa escolha, criar um módulo com funções que manipulam as estruturas de dados do Elixir, interagem com a criação e manipulação de arquivos, etc.

Parte 2 - Conhecendo ferramentas e libs

Após um bom estudo do básico da linguagem, creio que o próximo passo seria entender o mix, uma das principais ferramentas do Elixir, a partir dela é possível criar um conjunto de diretórios que permitem uma excelente estruturação do código, juntamente com exemplos de testes, libs e etc...

Você também pode acessar um conteúdo de ótima qualidade no ElixirSchool

Praticas com o Mix:

Aqui vão algumas sugestões para se praticar no mix:
- Aplicação de libs (credo, oban, plugcowboy, money, etc.).
- Criação de Plugs (Caso não saiba o que raios são Plugs em Elixir, recomendo o meu Post sobre).
- Testes unitários com ExUnit e uma introdução ao TDD utilizando a lib mix-testwatch.
- Primeiro CRUD com Ecto.
- Criação de um projeto de gastos financeiros (CLI ou utilizando alguma lib para ter componentes visuais)
- Criação de um projeto simulando um banco (Contas, transferencias, saques, depósitos)
- Criar um mini RPG com personagens, habilidades, etc...

Parte 3 - Conhecendo o Framework Web Phoenix

Com uma boa base das partes 1 e 2, já é possível introduzir o framework Phoenix, e você pode aprender a base diretamente na documentação do mesmo. Em contraposição à parte básica do Elixir, não se acha um bom conteúdo gratuito sobre phoenix (pelo menos eu não achei, então sinta-se à vontade para deixar nos comentátios sugesões de conteúdo para eu colocar aqui), somente alguns tutoriais no youtube. Dessa forma, fica a indicação do Elxpro acima citado como um conteúdo introdutório do phoenix, juntamente com o estudo da sua documentação.

Colocando em prática / ideias de projetos

A minha principal dica para se estudar o framework é fazendo projetos reais, tais como:
- Consumo de API's de terceiros (ViaCep, Riotgames, Github)
- Criação de usuários
- Criação e autenticação de tokens com a lib Guardian
- Desenvolvimento de alguma API que interage com algum valor monetário (Controle de gastos, Simulação de banco, etc...)

Parte extra - Mapa visual e conclusão

Abaixo temos um bom resumão do que é MUITO interessante estudar caso queira conhecer e utilizar Elixir no dia-a-dia, e lembrando, esse artigo foi escrito com base nas minhas experiências e conteúdos gratuitos de ensino que encontrei na internet, mas para o meu estudo, também utilizei livros e alguns cursos da udemy (todos pagos).

Entendendo Plugs em Elixir

Paulo Castro — Mon, 18 Apr 2022 14:28:10 +0000

Introdução

A motivação do Artigo veio através de uma dificuldade que tive estudando Plugs em Elixir, o conteúdo não exemplificava e/ou explicava muito bem o funcionamento desse tipo de componente, e após muito estudo consegui uma forma interessante para entender tudo isso, e nada melhor do que compartilhar esse estudo!

Dessa forma, artigo de hoje tem o intuito de explicar o funcionamento dos Plugs em Elixir por meio das seguintes etapas abaixo. No entanto, é de SUMA importância que você tenha conhecimento do protocolo HTTP e do ciclo de vida das requisições, pois isso não será abordado no texto abaixo:

Middlewares: Um breve resumo
1. Tipos comuns de middlewares utilizados em Elixir
Plugs em Elixir!
1. Elementos e caminhos de um Plug
Tipos de Plugs em Elixir
1. Function Plugs
2. Module Plugs
Plug Pipelines

1 - Middlewares: Um breve resumo

Middleware é um tipo de software que gerencia dados e informações de um determinado tipo de aplicação, seja ela um sistema de mensageria, autenticação, API, dentre outros. Dessa forma, o middleware atua como uma "ponte" entre os processos do software, possibilitando a criação de aplicações mais legíveis e eficientes, uma vez que o desenvolvedor entenda todos os processos de seu middleware, onde as conexões e dados do usuário final sejam tratadas de forma integral e legível pelo programa.

1.1 - Tipos comuns de middlewares utilizados em Elixir

Integração abrangente: Esse middleware possibilita conectar sistemas internos e externos da aplicação, facilitando a tratativa dos dados recebidos, temos como exemplo uma linha de autenticação por token, onde o usuário envia a primeira requisição com seus dados e em seguida ganha um "Token" para continuar navegando em outras áreas de um determinado site. Em elixir temos libs que disponibilizam plugs para isso.
API's: As nossas boas e velhas APi's também são tipos de middlewares, uma vez que as mesmas também podem ser ferramentas integradas por meio de protocolos, transmitindo e/ou tratando dados para uma aplicação e podendo conectar os produtos e serviços de um software.

2 - Plugs em Elixir!

Em Elixir, o Plug é o que possibilita diferentes frameworks se comunicarem com diferentes servidores na VM do Erlang, atuando como um Middleware. Entender os Plugs é algo vital para um bom desenvolvedor Elixir, uma vez que grande parte do ecossistema de uma aplicação e seus frameworks é feita por meio de Plugs.

Os Plugs vão interagir em todas as etapas de uma aplicação, sejam elas controllers, endpoints ou routers, e internamente, todos são plugs.

A intenção principal de um Plug é unificar o conceito de "Connection" (isso não será traduzido, pois, será tratado como elementos e parâmetros em Elixir, e é uma convenção abreviar tal parâmetro) ou "Conn". Dessa forma, o Plug difere-se de outros middlewares que utilizam desse mesmo sistema de Connections, pois internamente ele não separa a requisição da resposta.

2.1 - Elementos e caminhos de um Plug

É possível pensar em um Plug como um trecho do código que recebe uma estrutura de dados, transforma-a e retorna a mesma estrutura, porém, com algum tipo de transformação. A estrutura principal recebida pelo Plug é a "Connection", que representa tudo em uma requisição.

Desse modo, ao receber a Connection por meio da estrutura de dados %{} - "struct", a mesma será transformada progressivamente por meio do que chamamos de "Plug pipeline" até a resposta final que precisamos.

Essa Connection que utilizaremos sempre é chamada de %Plug.Conn{}, uma struct onde armazenaremos as informações da nossa requisição, você pode consultar a documentação da mesma aqui.

3 - Tipos de Plugs em Elixir

Em seu nível mais simples, os Plugs dividem-se em duas formas: Function Plugs e Module Plugs.

3.1 - Function Plugs

Para atuar como um Plug, uma função precisa de duas coisas:

Aceitar uma Connection struct ( %Plug.Conn{} ).
Retornar uma Connection struct

Toda função que receber e retornar tais parâmetros pode ser chamada Function plug.

Temos como exemplo:

def connection_example(conn, _opts) do
  conn
end

Explicando o código:

Elementos:

conn: struct %Plug.Conn{}.
_opts: abreviação para "options", como não será utilizada e, por convenção em elixir, é colocado um underscore ( _ ) para ignorar os valores.

Comportamento:

Receberá a connection e as options (que não utilizaremos).

3.2 - Module Plugs

É considerado Module Plug tudo aquilo que implementa as duas funções: init/1 e call/2:

defmodule PlugExample do
  def init(opts) do
    opts
  end

  def call(conn, opts) do
    conn
  end
end

Explicando o código:

Elementos:

função init/1
função call/2

Comportamento:

init receberá um parâmetro (options) e retornará o parâmetro recebido.
call receberá dois parâmetros: a connection e as options de init/1, agilizando muito o processo de execução do programa.
- Curiosidade: init/1 é executada enquanto o programa é compilado, enquanto call/2 acontece enquanto o programa está sendo executado.

Um exemplo

Para não deixar esse artigo gigante, você pode consultar um exemplo funcional de um MODULE PLUG no meu github

Plug pipelines

Os Plugs começam a tomar sentido quando começamos a utilizar pipelines, que nada mais é do que um jeito de aninhar os Plugs, cada um fazendo uma pequena tarefa, transformando os dados e mandando-os para o próximo Plug de forma sequencial.

Tal coisa é muito utilizada no Phoenix, o framework para aplicações Web do Elixir, de modo que temos a seguinte pipeline como padrão:

pipeline :browser do
  plug :accepts, ["html"]
  plug :fetch_session
  plug :fetch_flash
  plug :protect_from_forgery
  plug :put_secure_browser_headers
end

Dessa forma, cada requisição terá como retorno uma Connection modificada, que será passada para outros plugs até chegarmos a uma resposta final.

Conclusão

Com esse artigo, é possível entender o que é um middleware, Plugs em Elixir, Tipos de Plugs e Plug pipelines, não será possível, nessa ocasião, a construção de um Plug em Phoenix. No entanto, farei um artigo futuramente detalhando passo-a-passo a criação de um Plug desde o mix phx.new até o término do código.

No mais, espero que eu tenha conseguido clarear um pouco a ideia dos Plugs, e qualquer dúvida e/ou correções é possível me contatar no twitter!

[PT-BR] - RSPEC & RUBY - DO GO HORSE AO TDD

Paulo Castro — Sat, 15 Jan 2022 20:09:52 +0000

Prólogo

O que você irá ler abaixo são apenas alguns dos vários motivos para se usar testes, especialmente desenvolver guiado por testes.

Como um desenvolvedor iniciante, sempre questionei internamente os porquês dos testes, mesmo com todos ao meu redor dizendo sua importância e valor, nunca havia posto em prática as técnicas necessárias para executar bons testes e/ou desenvolver algo totalmente guiado por eles, antes a vida era bem simples, era só montar no cavalo e escrever tudo às cegas, sem planejamento, sem pensar, o belo e não ideal eXtreme Go Horse. No entanto, com isso me vi perdendo produtividade, testar tudo de um código "na unha" se tornou cansativo demais, brechas e bugs apareciam com facilidade, foi nesse momento em que me dei conta, com a seguinte frase passando pela minha cabeça: "Se eu tivesse os testes escritos, tudo seria mais tranquilo". Dessa forma, com esse pensamento, tomei vergonha na cara e entrei a fundo naquilo que chamam de Test Driven Development, ou melhor, TDD.

Sobre o TDD:

Test Driven Development, ou comumente conhecido como TDD, é uma técnica de desenvolvimento em que o desenvolvedor primeiro pensa nas funções e/ou comportamentos do seu código, escreve os testes para só posteriormente escrever as linhas de código propriamente ditas. Sua importância se dá pela previsibilidade das funções definidas pelo teste, em que você arquiteta todo o código sabendo exatamente o que deve(ria) ser retornado. Desse modo, o TDD é formado pelos seguintes passos:

(RED) Escrever um teste que falhe: Ao escrever o teste, ele obviamente irá falhar a priori, pois você não tem código nenhum para fazer o que o teste espera que seja feito.
(GREEN) Fazer o código funcionar: Ao escrever o código, o desenvolvedor deve fazer o possível para que o teste seja aceito, não importando como.
(REFACTOR) Eliminar a redundância: Após garantir o funcionamento do código, o desenvolvedor deverá aplicar ao máximo as boas práticas da linguagem, buscando sempre o equilíbrio entre legibilidade e qualidade.

Conhecendo o RSpec:

Não vou entrar a fundo na instalação e afins pois esse não é o foco da postagem, mas aqui e aqui você encontrará tudo o que é preciso para entender e utilizar o RSpec com Ruby e Rails.

O RSpec é uma ferramenta (gem) de testes para códigos na linguagem Ruby, sendo uma das mais famosas e geralmente acompanhado de outras gems que amplificam sua utilidade, tais como: Capybara, Cocumber e Factorybot (antigo FactoryGirl).

Sua sintaxe simples e muito semelhante com a lingua inglesa auxília no entendimento e escrita de testes, geralmente com suas descrições feitas na terceira pessoa.

RSpec.describe ArticlesController do
  describe '#index' do
    it 'returns a success response' do
      get '/articles'
      expect(response).to have_http_status(:ok)
    end

    it 'returns articles in a proper order' do
      older_article = 
        create(:article, created_at: 1.hour.ago)
      recent_article = create(:article)
      get '/articles'
      ids = json_data.map { |item| item[:id].to_i }
      expect(ids).to(
        eq([recent_article.id, older_article.id])
      )
    end
  end
end

Entendendo o código:

.describe: Utiliza-se describe para descrever as classes, módulos ou métodos em que irão ser feitos os testes. Nesse caso o que está sendo descrito acima é a classe ArticlesController. e a chamada index da rota /articles.
it: Utiliza-se it para descrever o que será testado (descrito na terceira pessoa). Nesse caso 'Returns a success response' implica na requisição de get '/articles' retornar uma resposta "Sucesso", ou melhor, o status HTTP 200 (OK).

O próximo passo, sob o viés do TDD, você deverá rodar o comando rspec no seu terminal para iniciar o teste, que obviamente falhará, na maioria dos casos, a falha do teste te dará um norte sobre o que deve ser feito.

Após isso, será iniciada a linha de pensamento para o código ser aceito pelo teste, nesse caso:

Exemplo do teste feito em uma API.

Deverá existir um Model e um Controller para articles, juntamente com um Serializer (JSON API gem) para definir os atributos e organizá-los e um método index para renderizar o arquivo em formato .json.

  #./app/models/article.rb

  class Article < ApplicationRecord
    validates :title, presence: true
    validates :content, presence: true
    validates :slug, presence: true, uniqueness: true

    scope :recent, -> { order(created_at: :desc) }
  end

  # ./app/controllers/articles_controller.rb

  class ArticlesController < ApplicationController
    def index
      articles = Article.recent
      render json: serializer.new(articles), status: :ok
    end

    def serializer
      ArticleSerializer
    end
  end

  # ./serializers/article_serializer.rb

  class ArticleSerializer
    include JSONAPI::Serializer
    attributes :title, :content, :slug
  end

O código deverá ter uma rota definida para o controller articles juntamente com o método index.

# ./config/routes.rb
Rails.application.routes.draw do
 resources :articles, only: %i[index]
end

Fazendo isso e rodando novamente rspec é esperado que o teste passe.

Conclusão

Seguindo dois dos três passos do TDD, consegue-se chegar a um código que terá sempre testes que podem indicar seu funcionamento digitando um simples comando no terminal, o que por sua vez é muito útil caso o desenvolvedor queira seguir o terceiro passo do TDD e refatorar, melhorar e adicionar novas funcionalidades para sua aplicação / API.

Sob essa ótica, o aumento da produtividade e qualidade de código será apenas questão de tempo, conforme o desenvolvedor aprende mais de suas ferramentas de teste, suas nuances e novas técnicas.