DEV Community: Kauê Fraga Rodrigues

Conhecendo o Node JS

Kauê Fraga Rodrigues — Sat, 26 Oct 2024 21:12:01 +0000

Neste final de semana eu decidi revisar um pouco sobre o JavaScript e o Node. Isso porque eu esbarrei na definição enquanto testava um projeto que apareceu no feed do meu GitHub.

Também planejo estudar alguns tópicos como o event loop e as promises mais profundamente, então uma revisão cai muito bem.

Aqui vão minhas anotações.

O que é Node.js

É um ambiente (runtime) que permite a execução de JavaScript pelo lado do servidor. Com ele é possível criar aplicações que executam fora do navegador (aplicações back end, mobile, desktop...).

Só pra relembrar, JavaScript é uma linguagem de programação interpretada e multiparadigma criada para adicionar interatividade nas páginas web, ou seja, ela foi desenvolvida com o intuito de ser usada no navegador.

Foi o Node que trouxe essa possibilidade de executar JavaScript fora do navegador.

Hoje em dia já existem outros ambientes de execução de JavaScript como Deno ou Bun, mas o Node foi o pioneiro, lançado em 2009.

A capacidade de desenvolver tanto o front end quanto o back end de uma aplicação usando apenas uma linguagem de programação é fantástica. É uma das grandes vantagens do JavaScript, embora alguns profissionais questionem a utilização no lado do servidor.

Pensando no lema "Write once, run anywhere" do Java, temos o nosso: learn once, run everywhere.

O Node é baseado no motor V8, que é o mesmo do Google Chrome, ele que lê e executa o código JavaScript no navegador. Uma característica importante é que um motor JavaScript é independente do navegador em que ele executa, essa característica foi o que permitiu a criação do Node e dos outros ambientes.

Existem outros motores de JavaScript:

SpiderMonkey, usado pelo Firefox
JavaScriptCore, utilizado pelo Safari e pelo Bun
Chakra, era usado pelo Edge, que usa o motor V8 atualmente

Eu disse anteriormente que o JavaScript é considerado uma linguagem interpretada, porém os motores possuem uma etapa de compilação just-in-time (JIT), levando-o a ser uma linguagem interpretada e compilada.

Importante ressaltar que o Node não tem acesso as APIs de manipulação do DOM, window, localStorage, etc. No lugar dessas ele tem sua biblioteca padrão que permite ter acesso ao sistema de arquivos, escutar requisições HTTP, gerar UUIDs, emitir eventos e tantas outras coisas.

// ❌
const element = document.getElementById('js-in-server')
console.log(element.textContent)

// ✅
import fs from 'fs'

fs.readFile('js-is-really-cool.md', 'utf-8', (err, content) => {
    console.log(content)
})

O Node vem equipado com o gerenciador de pacotes NPM (Node Package Manager) que serve para organizar, instalar e resolver as dependências de projetos.

NPM também é o registrador de pacotes padrão, é onde as bibliotecas e frameworks são registrados para serem utilizados posteriormente.

Só para esclarecer, existe a ferramenta de gerenciamento de pacotes NPM e o registrador desses pacotes, que também se chama NPM. Mais sobre aqui.

Alternativas à ferramenta são yarn e pnpm. O ambiente Bun também tem um gerenciador de pacotes compatível com o Node e que tem a proposta de ser o substituto mais rápido entre as opções que citei antes.

Falando do registrador, esse ano surgiu uma espécie de alternativa moderna que diz ser feita para especialmente pensando em Typescript e ESM, o JSR. Só a título de conhecimento, continuo usando e recomendo o NPM.

Resumindo, se você está começando seus estudos de JavaScript e Node, use o Node e o NPM.

Depois você decide se vai usar o yarn porque é mais bonitinho, o pnpm pois é mais rápido ou o Bun porque é o melhor (🔥).

Instalando o Node

Na instalação você pode seguir o tutorial do site mas eu recomendo usar um gerenciador de versões porque vai facilitar bastante caso você precise trocar de versão.

Acredito que esses sejam os principais:

Eu uso o asdf junto com o plugin do node. O asdf é um gerenciador de versões genérico, com ele basta adicionar o plugin da ferramenta/runtime que você quer gerenciar e pronto.

Prefiro não colocar nada aqui para que não fique desatualizado, minha dica é: use um gerenciador de versões. Abra a documentação dos que citei e leia.

Novas funcionalidades

Não são novas novas, mas são legais e não existem desde o começo. Perdão pelo bait...

Tem um arquivo .env e quer carregar os valores? Carregamento de variáveis de ambiente.

// Digamos que você tenha a váriavel SECRET_KEY=jsmelhorquejava

// $ node env.js
console.log(process.env.SECRET_KEY) // undefined

// $ node --env-file=.env env.js
console.log(process.env.SECRET_KEY) // jsmelhorquejava

Quer escrever testes sem ter que adicionar dependências como Jest, Mocha ou Vitest? O executor de testes nativo foi introduzido de forma estável na versão 20.x .

import assert from 'assert'
import { it, describe } from 'test'

describe('user entity', () => {
    it('should create user instance', () => {
        // ...
    })
})

Quer executar TypeScript? Usa Bun! Brincadeiras à parte, é possível executar código .ts usando Node, ainda experimental.

# Usando o Node V22.6.0 pra cima
node --experimental-strip-types tsisawesome.ts

Por enquanto é isso, pretendo ir atualizando essa revisão pra cobrir mais alguns tópicos que vou revisar, além do que é event loop e sua importância.

Um fato divertido é que eu desenvolvi meu primeiro servidor HTTP usando Node e foi com ele que descobri que gostava de desenvolvimento back end, um caminho sem volta.

Obrigado por ler!

Open source, learn in public e minha experiência

Kauê Fraga Rodrigues — Mon, 21 Oct 2024 02:33:54 +0000

Tudo certo? Quero começar a semana fomentando as iniciativas de projetos públicos e trazer um pouco da minha experiência construindo projetos open source.

Vamos começar colocando os pingos nos is.

O que é open source

Open source significa "código aberto" e é uma corrente no mundo da tecnologia que busca a construção transparente e colaborativa de software. É possível ver o código fonte de um projeto open source, entendê-lo, sugerir alterações ou fazê-las por conta própria, entre outras possibilidades.

Alguns projetos open source:

O conhecido kernel Linux
O sistema de versionamento de código mais utilizado, git
Zen browser, um recente navegador baseado no Firefox
A rede social Bluesky
O emulador de terminal que uso, WezTerm

E a lista segue. Quantas aplicações e ferramentas que você usa são open source?

O GitHub é uma plataforma de hospedagem de software (código e afins) que é bastante usada pela comunidade open source porque

Usa Git
Tem ótimas ferramentas
Tem várias funcionalidades que facilitam o trabalho colaborativo

Outro ponto importante, um projeto open source deve ter uma licença que restrinja o acesso e as modificações do código para proteger os criadores, contribuidores e até mesmo os usuários.

O que é learn in public e build in public

Learn in public, aprenda em público ou aprendizado público é a prática de compartilhar a sua jornada de aprendizado. É ir na sua rede social favorita e postar isso

Estou aprendendo x! O conceito y é bem simples mas o z me pegou, alguém pode me ajudar?

Não tenha vergonha! Você vai ter diferentes respostas, como:

"Que legal! Também estou aprendendo x, porém não entendi o conceito y ainda..."
"Isso é fácil demais, como você não compreende?"
"O artigo w me ajudou a entender z, dá uma olhada."

O importante é você saber extrair o melhor disso.

Caso alguém se identifique e diga que não sabe algum tópico que você compreende (um pouco pelo menos), tente explicar da melhor forma que conseguir. Ensinar é uma das melhores formas de reforçar o conhecimento.

Se a pessoa te oferece ajuda ou mentoria, aproveite, agradeça e pergunte.

Se alguém for rude ou insensível, pergunte qual foi o erro ou simplesmente ignore/bloqueie.

Não tenha medo de errar. Se você errar, vão te corrigir e você vai aprender também.

Vale ressaltar que você não tem só sua rede social pra ser público. Mantenha um blog, comece uma newsletter, poste vídeos no YouTube, faça live na Twitch...

Build in public ou construa em público é uma especialização do aprendizado público, nele você expõe as dificuldades, erros e aprendizados que você teve na construção de um projeto pessoal ou profissional.

É uma maneira orgânica e funcional de converter leads, atrair investidores e criar marca. Um bom exemplo disso é a alertpix do Daniel e do Christopher que cresceu bastante por conta das publicações no Twitter/X, Instagram e TikTok.

Pra mim, dois benefícios absurdos de todo esse processo de compartilhar, ensinar, construir, errar e ser ensinado (além do aprendizado) são:

Documentação do teu processo. Você cria um histórico, uma trajetória visível que pode ser acompanhada ou revivida no futuro.
Visibilidade. As pessoas se identificam, querem acompanhar seu progresso e você pode acabar virando referência em determinado assunto.

A visibilidade não é o objetivo, você não deve esperar likes, mas é verdade que ela também aumenta sua "sorte". Inclusive, uma vez li no blog do GitHub um artigo muito bom sobre como publicar o seu trabalho aumenta sua "sorte", "Publishing your work increases your luck", um trecho a seguir:

For every snarky comment, there are 10x as many people admiring your work.

Como o criador do movimento descreveu em "Learn In Public", o aprendizado público é o jeito mais rápido de aprender.

Por que praticar o learn in public (tl;dr)

Acelera seu aprendizado
Ajuda a criar conexões, o famoso networking
Contribui para o aprendizado alheio
Novas oportunidades como consequência da visibilidade

Como praticar

Construindo um projeto open source (e divulgando ele)
Postando um vídeo no YouTube explicando um conceito
Postando um vídeo ensinando como criar um projeto usando uma tecnologia específica
Mantendo um blog e escrevendo sobre a construção dos seus projetos, seu dia a dia, suas filosofias sobre software
Criando um canal na Twitch e fazendo stream construindo software e explicando (live coding)
Postando vídeos curtos no YouTube ou TikTok dando dicas rápidas

A verdade é que existem muitas maneiras de praticar o learn in public, se você está aprendendo e tornando seu aprendizado público em alguma plataforma/rede social, você está praticando o learn in public.

Existem várias soluções de blogging como Substack, Medium, Hashnode, WordPress, etc.

Também existem diversos fóruns onde você pode publicar seus escritos, tipo o TabNews, dev.to e o Reddit.

Não esqueça das redes sociais: Twitter/X, Bluesky, Instagram, TikTok, YouTube, Twitch, LinkedIn...

Unindo learn in public e open source

Não tem segredo, começar um projeto open source por si só já é praticar o learn in public, a questão é maximizar o alcance dos seus projetos por meio das redes sociais que você usa.

Quando iniciei meus estudos de desenvolvimento web optei por estudar sozinho, sem falar publicamente sobre, isso em meados de 2021.

Eu fiquei quase 3 anos na "caverna" e em 2024, quando decidi criar minha conta no Twitter e interagir diretamente com a comunidade dev, minha carreira começou.

O "boom" da minha integração com a bolha dev foi durante a segunda edição da Rinha de Backend, uma competição de soluções back end. Nesse evento compartilhei o desenvolvimento da minha solução, meu aprendizado da linguagem Go e participei de várias discussões sobre o desafio.

Desde de então postei sobre meus projetos pessoais, estudos e códigos.

Depois disso fui contratado para fazer uma modificação em um blog sobre computarias e recebi um convite valioso para trabalhar em um projeto confidencial.

Eu concordo que as oportunidades vieram ao acaso, mas acredito que ser mais público influenciou minha "sorte". Sou grato a isso, ao learn in public, as pessoas que me impulsionaram e as pessoas que interagi e agregaram de alguma forma.

Sobre os projetos que eu construí publicamente, gostaria de ressaltar

Os repositórios aprendendo alguma tecnologia, onde eu documentei vários tópicos que aprendi sobre as tecnologias
Esquilo Aniquilador - minha solução da segunda edição da Rinha de Backend
ruke - uma ferramenta para executar comandos configurados em um projeto, inspirada no GNU Make e just
themis - analisador de perfil do Bluesky, conta 7 contribuidores atualmente

Enfatizei esses porque foram os que eu mais divulguei e tive um feedback bacana. Eu normalmente crio meus projetos públicos e com licença MIT, porém esses escolhidos se sobressaem.

Obrigado por ter lido! Espero que tenha te ajudado de alguma maneira.

Onde me encontrar:

LinkedIn: kauefraga
GitHub: kauefraga
Bluesky: kauefraga.dev
Twitter/X: rkauefraga
Dev.to: kauefraga
TabNews: kauefraga

Referências:

Desbravando o poder do markdown

Kauê Fraga Rodrigues — Mon, 12 Aug 2024 20:56:35 +0000

Salve, salve! Vamos aprofundar nossos conhecimentos em markdown.

Este é o quarto capítulo de uma série sobre markdown, caso queira ler os capítulos anteriores

Sem mais delongas, bora pro markdown!

Lista de tarefas

Você deve conhecer as listas ordenadas e não-ordenadas, correto?

fulano
ciclano
beltrano

item
item
item

E se eu te dissesse que é possível fazer uma lista com marcações?

- [x] tarefa x
- [ ] tarefa y
- [ ] tarefa z

[x] tarefa x
[ ] tarefa y
[ ] tarefa z

Tabelas

Com linhas e colunas, uma tabela pode melhor a visualização e facilitar a busca de informações.

| Coluna 1 | Coluna 2 | Coluna 3 |
|----------|----------|----------|
| Item 1   | Item 1   | Item 1   |

Resultado:

Coluna 1	Coluna 2	Coluna 3
Item 1	Item 1	Item 1

Você pode escolher como os textos ficam alinhados e usar os estilos de texto dentro da tabela também.

Coloque : no início do divisor e as células vão ficar alinhadas à esquerda. No final, alinhadas à direita. E se você colocar : no início e no fim do divisor o texto vai ficar centralizado.

Um exemplo:

| Nome completo  |         Idade |
|:--------------:|--------------:|
|  João `Silva`  | <kbd>27</kbd> |
| Ana *Carvalho* |            20 |
| Beatriz Souza  |        **35** |

Nome completo	Idade
João `Silva`	27
Ana Carvalho	20
Beatriz Souza	35

A tag kbd serve pra mostrar entradas do teclado, veja mais na documentação da mdn sobre kbd.

Sobre tabelas é isso, bem simples, não?

A formatação das tabelas no markdown pode dificultar bastante a leitura, então tente sempre manter as tabelas bem formatadas.

Uma dica pra quem usa o Visual Studio Code: instale a extensão Markdown Table Prettifier.

Vídeos

Colocar uma demonstração visual de um conceito ou projeto pode ser poderoso, mas nem todos os processadores de markdown tem uma sintaxe pronta pra isso.

A forma mais simples e totalmente compatível é usando HTML puro.

<div align="center">
  <video width="320" height="240" controls>
    <source src="video.mp4" type="video/mp4" />
  </video>
  <p>esta é a legenda do vídeo (caption)</p>
</div>

sim, não tem um vídeo -_-

A div para centralizar e o parágrafo (p) não são necessários, você pode remover caso queira. Recomendo que dê uma olhada na documentação da tag video.

Não testei mas quero compartilhar que de acordo com uma postagem no blog do GitHub é possível apenas colocar um link que termine com a extensão mp4 ou mov e o GitHub cuida da renderização para você.

Outra forma de expor uma demonstração é usando um gif, que foi o que eu fiz no projeto Ruke (porque eu não conhecia a tag video). Você converte o vídeo para o formato gif usando uma plataforma ou ferramenta e usa a sintaxe de imagem.

![texto alternativo](demonstracao.gif)

Tenha em mente que gifs têm a qualidade reduzida e ausência de áudio.

Notas de rodapé (footnotes)

Sabe aquelas referências da Wikipédia[^1], então...

Nunca utilizei mas pode fazer sentido no seu documento ou em documentos grandes.

Aqui está meu texto falando e do nada pneumoultramicroscopicossilicovulcanoconiótico[^pneu].

[^pneu]: doença pulmonar causada ao inalar partículas finas de sílica provenientes de atividades vulcânicas.

Identificação de títulos (heading IDs)

Mesmo invisível é muito útil. Serve para você mudar a âncora daquele título/subtítulo e isso é útil quando você tem um título grande ou com emojis.

Qual link você prefere:

github.com/kauefraga/anubis#um-titulo-realmente-muito-grande-lorem-ipsum-blablabla
github.com/kauefraga/anubis#titulo-lorem

Imagino que a segunda opção, afinal, o título vai estar escrito no texto e não precisa necessariamente estar na url.

# Um título realmente muito grande lorem ipsum blablabla {#titulo-lorem}

### Um subtítulo não muito grande mas grande {#subtitulo}

O resultado do texto é o mesmo mas a âncora não, estará encurtada.

Superscript e subscript

Aquele texto em cima ou embaixo, tipo em expoentes ou quantidade de moléculas.

Também vai depender do seu processador markdown, mas a solução em HTML é a seguinte:

x<sup>2</sup> e H<sub>2</sub>O

Este texto <sup>é muito</sup> <sub>legal</sub>

x² e H2O

Este texto ^{é muito} legal

Diagramas mermaid

Em plataformas que usem Mermaid é possível usar markdown para fazer diagramas (e vários tipos deles). O GitHub e o GitLab, por exemplo, suportam esses diagramas.

Existem diversos tipos de diagramas e está tudo bem documentado. Infelizmente, o dev.to não suporta os diagramas mermaid então vou ficar devendo o código mas fique com essas duas imagens.

É isso! Te agradeço por acompanhar até aqui, espero que tenha gostado e aprendido algo novo ao longo do caminho.

Com este capítulo, eu finalizo essa série de markdown. É claro que na medida necessária irei atualizando esses 4 textos.

Personalizando o README do seu perfil do GitHub

Kauê Fraga Rodrigues — Mon, 13 May 2024 16:45:32 +0000

Opa, tranquilo? Bora deixar o README do teu GitHub bonitão!

Antes de começar realmente, se você não sabe o que é README nem markdown eu recomendo fortemente que veja os outros artigos dessa série.

O README do GitHub é o cartão de visita do seu perfil. Antes de personalizar ele, você precisa criar ele.

Criando README

Crie um repositório com o mesmo nome do seu perfil. Como meu nome de usuário é "kauefraga" o nome do repositório seria "kauefraga" também.

Para facilitar seu trabalho já inclua o arquivo README no seu repositório.

Feito isso você está pronto para customizar o seu README.

Eu recomendo que você coloque as seguintes informações:

O que você gosta de fazer
Planos para o ano atual
Projetos
As tecnologias (tech stack) e ferramentas que você usa
Contato

Vale ressaltar que o README deve ficar com a sua cara, com o que você gostar e achar que deve ter. Reflita sua extravagância, seu minimalismo, suas cores favoritas, tudo que te represente.

Para editar pelo próprio GitHub clique no lápis para editar, veja a seguir.

A partir de agora é contigo, totalmente pessoal. Vou deixar vários materiais e inspirações de estilos e layouts.

Uma coisa que eu gostaria de ressaltar, eu gosto de ter um README bonitinho e algumas pessoas (recrutadores, outros desenvolvedores, etc.) olham sim, porém não leve tão a sério. Faça porque você quer falar um pouco sobre quem você é e expor informações técnicas suas.

GitHub Readme Stats

Com esses cards você pode mostrar informações relevantes do seu perfil do GitHub e personalizar as cores.

Veja o repositório ou vá direto para a seção dos cards.

Skill Icons

Quer expor as tecnologias que você usa, está estudando ou querendo estudar? Tá na mão!

Veja o site ou vá direto na documentação.

Se você não viu ainda, na seção sobre mim do blog eu uso os skill icons.

Markdown Badges

Veja o repositório markdown badges e o badges for readme.md profile.

Snake Game

Você deve conhecer o jogo da cobrinha, certo? Imagina uma cobrinha comendo suas contribuições no seu gráfico de contribuições.

Veja o repositório e um tutorial de como adicionar no seu perfil.

Wakatime

Quer exibir métricas do seu tempo em x projeto ou usando y linguagem de programação? Comece a usar o wakatime e veja esse artigo também, "Exibindo no Github métricas de tempo gasto em linguagens usando Wakatime".

Inspirações

Não tem nada melhor que ter opções para se inspirar, né? Aqui vão alguns READMEs que eu considero legais. Clique na imagem para ir até o README.

Começando com o meu 😂

Sem frufru? Olha esse do Filipe

Simples mas nem tanto? O Lucas amassou aqui

Nessa mesma ideia, a Tifany arrasou também

Continuando...

Recomendações

Estarei aberto para dúvidas ou sugestões por aqui ou pelo Twitter/X.

Muito obrigado por ter lido até aqui ❤.

Personalizando o README do seu projeto

Kauê Fraga Rodrigues — Sun, 24 Mar 2024 11:29:57 +0000

Opa, tudo tranquilo?

Continuando a série sobre READMEs, agora vamos falar da personalização 🤩

Vamos usar markdown para customizar o README do seu projeto com seções, frases, ícones/insígnias, etc. Se você não tem ideia do que é markdown e README, recomendo ler o primeiro artigo desta série, Introdução ao markdown e aos READMES.

Estruturando o README

Pense no modo que você quer expor as informações do seu projeto. Defina uma hierarquia e use vários identificadores (seções, negrito, código...).

Depois de fazer alguns projetos e espiar um bocado de projetos alheios, eu normalmente estruturo meu projeto da seguinte forma:

Título ou nome do projeto
Descrição
Funcionalidades
Como instalar/rodar/usar
Licença

É isso! Simples, não?

Você pode adicionar mais informações, mas eu acredito que essas sejam essenciais.

Se você não sabe o que adicionar, pense em quais informações são importantes para o projeto. Eu tenho algumas sugestões:

documente as tecnologias e a escolha delas
descreva a arquitetura, os padrões de projetos e o porquê dessas decisões
dedique uma seção a sua API (interna ou não)
liste as variáveis de ambiente necessárias para executar o projeto
exemplifique a utilização do projeto (código ou imagem/vídeo)
explique os passos necessários para contribuir
mencione os contribuidores
diga se tem testes e como roda-los

Estilizando essas informações com markdown

Fique atento, em algumas partes eu vou adicionar só a opção discutida (incremental mesmo) e em outras eu vou reescrever boa parte do código já mostrado porque alguma coisinha ali foi alterada.

Especifique o título

Dica: tente criar um nome explicativo e memorável para o seu projeto, por mais difícil que isso seja 😅

# Título do projeto

Centralizado:

<h1 align='center'>Nome do projeto</h1>

Não é possível centralizar com markdown, por isso usamos HTML.

Adicione insígnias legais ao seu projeto

Veja no site shields.io. Segue as que eu mais uso:

Linguagem mais utilizada
Último commit
Palavras/frase estática
Licença
Downloads (GitHub releases, crates.io, npm...)
Versão mais recente

# Título do projeto

![Linguagem mais utilizada](https://img.shields.io/github/languages/top/:nomedeusuario/:nomedorepositorio)
![Último commit](https://img.shields.io/github/last-commit/:nomedeusuario/:nomedorepositorio)
![README bem legal](https://img.shields.io/badge/readme-bem_legal-8A2BE2)

Centralizado:

<div align='center'>
    <h1>Nome do projeto</h1>
    <img src='https://img.shields.io/github/languages/top/:nomedeusuario/:nomedorepositorio' alt='Linguagem mais utilizada' />
    <img src='https://img.shields.io/github/last-commit/:nomedeusuario/:nomedorepositorio' alt='Último commit' />
    <img src='https://img.shields.io/badge/readme-bem_legal-8A2BE2' alt='README bem legal' />
</div>

Lembre-se de trocar as informações :nomedeusuario e :nomedorepositorio.

Coloque uma descrição

# Título do projeto

![Linguagem mais utilizada](https://img.shields.io/github/languages/top/:nomedeusuario/:nomedorepositorio)
![Último commit](https://img.shields.io/github/last-commit/:nomedeusuario/:nomedorepositorio)
![README bem legal](https://img.shields.io/badge/readme-bem_legal-8A2BE2)

Esta é a descrição do meu projeto super legal.

Descrição como citação:

> Esta é a descrição do meu projeto super legal.

Centralizado:

<div align='center'>
    <h1>Nome do projeto</h1>
    <p>Esta é a descrição do meu projeto super legal.</p>
    <img src='https://img.shields.io/github/languages/top/:nomedeusuario/:nomedorepositorio' alt='Linguagem mais utilizada' />
    <img src='https://img.shields.io/github/last-commit/:nomedeusuario/:nomedorepositorio' alt='Último commit' />
    <img src='https://img.shields.io/badge/readme-bem_legal-8A2BE2' alt='README bem legal' />
</div>

Diga quais são as funcionalidades

As funcionalidades podem ser capacidades, rotas ou o que seu projeto fizer.

### Funcionalidades

- Este projeto é capaz de automatizar um processo muito chato
- Este projeto é muito performático
- Este projeto é amigável e intuitivo

## Features

- [x] Este projeto é capaz de receber requisições e responder
- [x] Este projeto é capaz de lidar com requisições simultaneamente, graças ao controle de concorrência implementado
- [ ] Este projeto pode teletransportar uma pessoa para qualquer lugar do planeta a qualquer momento

Perceba a alteração das palavras (funcionalidades e features), nível da seção (h3 e h2) e lista (não-marcada e marcada). Faça como quiser.

Como instalar e rodar

Aqui você precisa descrever o processo de instalação e execução/utilização do seu projeto.

## Como instalar e rodar

1. Clone o repositório
2. Instale as dependências
3. Execute o comando x

<----->bash
git clone https://github.com/usuario/repositorio.git
cd repositorio

npm i
go mod download
cargo build

npm run start
go run cmd/main.go
cargo run src/main.rs
<----->

Obs.: uma observação muito interessante.

Substitua esses <-----> por crases triplas (bloco de código).

Instrua contribuidores

Uma seção dedicada a como contribuir pode ser muito útil. Detalhe o processo de contribuição.

## Contribuindo

Sinta-se livre para contribuir, criar uma issue para reportar um bug, sugerir um alteração na API, uma melhoria ou uma feature. Fique à vontade.

### Como contribuir

1. Faça um fork desse repositório
2. Clone seu fork na sua máquina
3. Faça alterações, commit e dê push
4. Abra um pull request (escreva uma mensagem descritiva sobre o que você alterou)

Mencionar os seus contribuidores e declarar sua gratidão é bacana também. Coloque o ícone dos seus contribuidores.

### Contribuidores

Meus agradecimentos a essas pessoas incríveis:

[![notshwuy GitHub profile picture](https://github.com/notshwuy.png?size=50)](https://github.com/notshwuy)
[![FelipeMCassiano GitHub profile picture](https://github.com/FelipeMCassiano.png?size=50)](https://github.com/FelipeMCassiano)

Exponha a licença

## Licença

Este projeto está sob a licença y - Veja a [LICENÇA](https://github.com/usuario/repositorio/blob/main/LICENSE) para mais informações.

Resultado final

Veja como ficou o README copiando e colando direto daqui:

Basicamente é isso. Lembra que o README é um "cartão de visitas" para o seu projeto? O que você quer mostrar aos seus visitantes? Você deve montar seu README pensando nas informações que são relevantes para o seu projeto. A partir disso, escreva e refine ao longo do tempo.

Fun fact: dependendo do lugar que você pretende colocar seu README (GitHub, GitLab, Bitbucket...) pode existir um superset do markdown como diz o Markdown Guide em extended syntax, que adiciona marcações e melhora o comportamento de algumas existentes.

Se você usa o Visual Studio Code para escrever seus READMEs, eu tenho extensões para recomendar:

Também selecionei alguns dos meus melhores READMEs para você ter uma ideia de como eu faço:

Obrigado por ler 💜

Introdução ao markdown e aos READMEs

Kauê Fraga Rodrigues — Mon, 18 Mar 2024 01:09:33 +0000

Olá, tudo certo?

Hoje vou falar sobre o que é um README, o que é markdown, como escrever um README básico e por que você deveria aprender a sintaxe markdown e escrever READMEs. Bora?

O que é um README

Começando pelo começo, você provavelmente já viu projetos de outros desenvolvedores ou instalou um projeto, uma solução ou um jogo de origem duvidosa e se deparou com aquele arquivo README, README.txt ou README.md. Caso nunca tenha visto, tudo bem.

A tradução de read me é "leia me" e, resumidamente, um README é um arquivo que fica junto de um projeto e serve como um cartão de visita para o mesmo, contendo informações sobre o projeto como: objetivo, capacidade, instalação, documentação em geral, licença, etc.

Deu pra perceber a importância dos READMEs?

Um README geralmente é escrito em markdown, uma linguagem de marcação assim como o HTML. Dito isso, a forma mais comum desse arquivo é essa: README.md.

O que é markdown

Markdown é uma linguagem de marcação simplificada e de fácil uso. O primeiro processador de markdown foi o próprio Markdown feito pelo John Gruber com a linguagem de programação Perl. Ele tinha o objetivo de ser uma ferramenta de conversão de markdown para HTML.

Atualmente existem vários processadores Markdown e variações (ou supersets) da sintaxe, permitindo novas marcações e diferentes saídas. Por exemplo, de markdown para PDF.

Veja um resumo ou cheatsheet da sintaxe markdown:

# Isto é um título ou um h1 em HTML
## Isto é um subtítulo ou um h2 em HTML
### Você já entendeu... vai até o h6 ou ######

Isto é um parágrafo e a palavra **negrito** está em negrito, enquanto a palavra *itálico* está em itálico. ~~riscado~~ e [link](https://example.com).

- eu sou um item em uma lista desordenada
- eu sou outro item na lista desordenada
- eu sou mais um item

> Uma citação blablablablablabla

1. eu sou o primeiro item de uma lista ordenada
2. eu sou o segundo item
3. eu sou o terceiro!

![este é o texto alternativo de uma imagem](https://example.com/imagem.png)

--- 

Estou abaixo do divisor horizontal.

E o resultado:

Isto é um subtítulo ou um h2 em HTML

Você já entendeu... vai até o h6 ou

Isto é um parágrafo e a palavra negrito está em negrito, enquanto a palavra itálico está em itálico. ~~riscado~~ e link.

eu sou um item em uma lista desordenada
eu sou outro item na lista desordenada
eu sou mais um item

Uma citação blablablablablabla

eu sou o primeiro item de uma lista ordenada
eu sou o segundo item
eu sou o terceiro!

Estou abaixo do divisor horizontal.

Uma ótima referência para você se aprofundar é o Markdown Guide.

Por que aprender markdown e escrever READMEs

Markdown é uma linguagem de marcação que tem uma sintaxe simples, pode ser convertida para HTML e, com isso, ela pode ser usada para escrever textos formatados. Por ser fácil de ler e escrever, o markdown tem uma alta adoção na comunidade de desenvolvimento de software.

Saber markdown facilita muito sua vida ao oferecer uma sintaxe simples e ser convertido em HTML, além de ser quase uma convenção (se não for) no quesito escrita técnica.

Resumo (tl;dr)

Markdown é uma sintaxe simples que pode ser convertida para HTML e, com isso, ela pode ser usada para escrever textos formatados. Por ser fácil de ler e escrever, o markdown tem uma alta adoção na comunidade de desenvolvimento de software.

O README é como um cartão de visitas e serve para expor os detalhes mais relevantes de um projeto. Pode ser qualquer tipo de arquivo mas normalmente é escrito usando markdown, então um README geralmente tem a extensão .md para demonstrar isso.

Para conhecer a sintaxe, veja essa cheatsheet: Markdown Cheat Sheet.

Fun fact: esse texto foi escrito inteiramente em markdown e faz parte de uma série sobre READMEs :)

Obrigado por ler ❤

Eco: minha implementação em Rust do programa echo

Kauê Fraga Rodrigues — Sat, 24 Feb 2024 13:21:12 +0000

Hey, folks! Hoje quero falar sobre o meu mini-projeto, chamado "eco".

Minha implementação em Rust do programa echo.

O programa echo basicamente pega argumentos (entrada) e imprime eles na tela do seu console (stdout). O eco, atualmente, faz isso também. Escolhi esse nome porque eu sempre li o programa echo como /ɛko/. Como eu disse, o echo pega a entrada e devolve a mesma coisa, similar a uma reverberação, um eco.

A iniciativa do projeto surgiu quando pesquisei por projetos para fazer em Rust, quero praticar!

A implementação inicial (v0.1.0) foi bem simples, como esperado. Veja o código do commit 516992e:

use std::env;

fn main() {
    let mut args: Vec<String> = env::args().collect();

    /*
     * Read the `remove` docstring.
     * This `remove(0)` is the worst case,
     * all the arguments are going to be
     * shifted to the left, everytime.
     */
    args.remove(0);

    let mut output = String::new();

    for arg in args {
        output.push_str(&format!("{arg} "));
    }

    println!("{}", output.trim());
}

Pega os argumentos passados;
Remove o primeiro argumento, pois ele é o caminho do executável;
Inicializa uma string dinâmica, chamada output;
Itera sobre os argumentos adicionando cada argumento com o formato "argumento-tal " (argumento + espaço) ao final da string output;
Imprime a string output.

Agora na versão 0.1.2, o código está assim:

use std::collections::VecDeque;
use std::env;
use std::process::exit;

fn main() {
    let mut args: VecDeque<String> = env::args().collect();

    args.pop_front();

    let is_help_needed = (args.len() == 1 && args[0] == "-h")
        || (args.len() == 1 && args[0] == "--help");
    if is_help_needed {
        println!("Example: eco-rs Bom dia!");
        exit(0);
    }

    let mut output = String::new();

    for arg in args {
        output.push_str(&format!("{arg} "));
    }

    println!("{}", output.trim());
}

Alterações:

Na linha args.remove(0) havia possibilidade de otimização e mesmo sem conhecer VecDeque, que deve ser um vetor bidirecional (entrada e saída por ambos os lados), a fiz. Essa estrutura de dados possibilita a saída de um elemento do início sem precisar mover os elementos posteriores para trás, o que é vantajoso aqui.
Adicionei um menu de ajuda, que tá bem vazio por sinal.

A distribuição está sendo feito pelo crates.io em eco-rs. Infelizmente a crate "eco" já existia. O legal é que ao executar o comando cargo install eco-rs o Cargo pega a crate e compila na arquitetura do seu computador. Com isso, eu não preciso compilar para todas as arquiteturas disponíveis e manter as releases no GitHub também (deveria, quem não gosta de só baixar o executável e pronto?).

Conclusão

tl;dr: o projeto eco é, atualmente, apenas uma implementação em Rust do programa echo que pega os argumentos de entrada, junta eles em uma string e imprime a string final na saída do terminal.

Pretendo fazer mais umas funcionalidades como colorir palavras específicas e criar uma sintaxe de marcação para estilizar também.

Se quiser acompanhar o projeto, veja o repositório eco.

Você pode me achar no:

GitHub: kauefraga
TabNews: kauefraga
DevTo: kauefraga
Twitter/X: rkauefraga

Obrigado por ler! ❤

Funcionalidades do Rust

Kauê Fraga Rodrigues — Mon, 19 Feb 2024 23:32:07 +0000

Olá! Se você quer saber um pouco mais sobre as principais funcionalidades do Rust, então acho que posso ajudar. Bora 👊

A linguagem de programação Rust tem várias features peculiares e legais! Uma coleção de técnicas que deram certo em outras linguagens e paradigmas.

Features abordadas:

Zero-cost abstractions
Data Ownership ou Ownership
Algebraic Type System ou Algebraic Data Types
Polymorphism
Async/await
Meta programming
Cargo

Zero-cost abstractions

"What you don't use, you don't pay for. What you do use, you couldn't hand code any better"

Direto do C++.

As abstrações (pattern matching, iterators, generics, collections...) de recursos-base (for loops, if/else, raw pointers...) da linguagem não devem consumir nenhum recurso além daqueles já consumidos. Zero custo!

Ownership

Baseado no RAII (Resource Acquisition Is Initialization) design pattern do C++. Esse padrão de projeto diz: recursos como memória alocada, file handles e database connections devem estar presos a um tempo de vida. Quando um objeto é criado, os recursos são adquiridos e quando o objeto é destruído, os recursos são liberados. Simples. Esse padrão é tão útil porque liberar os recursos é algo facilmente esquecido, você pode ter escrito bastante código antes de precisar liberar e esqueceu, resultando em memory leaks.

Tão útil que... Rust integrou ele diretamente na linguagem e assim surgiu o Ownership. Para não precisar lembrar usar esse padrão, o próprio compilador vai te forçar a seguir um conjunto de regras chamado de "ownership e borrowing rules", caso essas regras não sejam seguidas, você verá erros na tela em tempo de compilação (compile time).

Ownership Rules

Cada valor em Rust tem uma variável que é sua dona, ou seja, cada valor tem um dono.
Só pode existir um dono de uma vez.
Quando um dono sai de escopo, o valor é largado ou dropped.

Essas regras são combinadas com as chamadas borrowing rules.

Borrowing Rules

Em um momento qualquer, você pode ter uma referência mutável ou infinitas referências imutáveis.
Referências DEVEM sempre ser válidas. SEM NULL/NIL NESSA PO@#$!!

Algebraic Type System

Algebraic data types ou ADTs permitem a criação de tipos compostos usando sum types e product types. Geralmente implementado em linguagens funcionais, como Haskell.

Um product type é um tipo composto de dois ou mais tipos. Pense em um tipo usuário que tem nome e idade, outros dois tipos, dentro dele. Classes (OO) são um exemplo de product type. Basicamente, toda linguagem que tem um sistema de tipos, tem product types.

Um sum type é um tipo que pode ser representado por uma lista finita de opções válidas (como um enum).

Polymorphism

Direto do paradigma de orientação a objetos (OOP), polimorfismo é a capacidade que um objeto ou uma função têm de assumir múltiplas formas ou se comportar diferente dependendo do contexto em que é usada. O polimorfismo geralmente é implementado a partir da herança (inheritance). Já no Rust, o polimorfismo é implementado com traits e generics.

Traits definem um conjunto de funções/métodos que um tipo pode implementar, parecido com interfaces em outras linguagens. Lembre-se, tipos podem implementar múltiplos traits e traits podem ter implementações por padrão (default).

Generics te permitem escrever código abstrato em relação ao tipo, que te leva a código reutilizável e eficiente. Você pode dizer que um tipo necessário para uma função, não é algo específico, mas algo que implemente funções específicas.

O sistema de traits (trait system) em Rust tem sua raiz nas type classes do Haskell. Rust implementa o trait system juntamente do ownership/borrowing e lifetimes, que são um dos motivos da garantia de memory-safety. Alguns benefícios em relação a herança:

Flexibilidade e composição
Não-invasivo e extensível
Evita o problema de classes bases frágeis (fragile base class problem)
Static dispatch by default e performance

Async/await

Rust roubou a sintaxe async/await para programação assíncrona da linguagem de programação JavaScript. O paradigma assíncrono permite que tarefas sejam executadas independentemente e concorrentemente sem bloquear a execução do programa principal. O JavaScript usa Promises para representar o resultado de uma operação assíncrona e para utilizar esse resultado é necessário usar os métodos .then(), .catch() e .finally(). O problema é que esses métodos podem levar a um código aninhado e complexo. A sintaxe async/await no JavaScript permite que código assíncrono seja escrito da forma como código síncrono é escrito, sem usar then, catch e finally. No final é só um syntactic sugar para trabalhar com as Promises.

O Rust adotou a programação assíncrona de maneira parecida. Notação async antes de fn e .await? a cada chamada assíncrona. O ponto de interrogação serve para propagar erros. Como em JavaScript, async/await em Rust é um syntactic sugar para trabalhar com Futures (similar a Promises). Algumas diferenças do Rust para o JavaScript:

O async/await em Rust segue o princípio de abstração sem custo (zero-cost abstraction).
Em Rust, Futures foram moldados para serem preguiçosos (lazy), ou seja, eles não começam até que sejam explicitamente chamados e "esperados" (awaited). Com isso, Futures podem ser agendados, compostos e combinados com outros Futures sem esforço desnecessário. No JavaScript, quando uma Promise é criada a operação assíncrono já começa em seguida, mesmo se a Promise não tiver sido "esperada" (awaited) ainda.
JavaScript é single-threaded e tem uma implementação que cria a ilusão do paralelismo. Rust tem paralelismo de verdade, podendo executar operações concorrentes em paralelo usando múltiplas threads.

Meta programming

O Rust tem uma feature muito poderosa, os macros. Para entender os macros, vamos falar de meta programação.

Meta programação é uma técnica que permite um programa a manipular ou gerar código durante a compilação (compile time) ou execução (runtime). Macros são um recurso do Rust que permite o desenvolvedor a definir uma sintaxe customizada e fazer geração de código ou transformação de código. Eles permitem a meta programação com uma forma de escrever código que gera ou altera outro código durante a compilação (compile time).

Cargo

Inspirado no NPM (node package manager) do NodeJS, o Cargo é a ferramenta oficial de building e gerenciamento de pacotes do Rust. Com simples comandos no terminal é possível instalar as dependências de um projeto, compilar o projeto, testar o projeto, etc. O crates.io é onde ficam as caixas/crates, os pacotes do ecossistema Cargo. O package.json em JavaScript é o cargo.toml em Rust.

Obrigado por ler! ❤

Fontes:

Introdução ao Rust

Kauê Fraga Rodrigues — Sun, 18 Feb 2024 15:08:24 +0000

Olá! Se você quer aprender ou está estudando a linguagem de programação Rust assim como eu, acho que aqui consegui sintetizar bem a linguagem nesse texto introdutório. Bora lá!!

Rust é uma linguagem de programação eficiente e segura.

Na seção "Por que Rust?" do site Rust Lang eles dizem: Rust é rápido e tem consumo de memória eficiente; Rust é confiável porque tem um rico sistema de tipos, além do modelo "ownership" que garante memory-safety e thread-safety; Programar em Rust é produtivo pois tem uma ótima documentação, boas mensagens de erro do compilador e fantásticas ferramentas (como compilador, gerenciador de pacotes, formatador...). No mesmo site, a linguagem é recomendada para fazer CLIs (interfaces de linha de comando), WebAssembly, Networking e Embedded programming (embarcados).

Não se limitando a esses campos, Rust é visto no desenvolvimento de sistemas operacionais, jogos, APIs, Web, Crypto e a lista continua aumentando. Tem um futuro brilhante.

As principais ferramentas do Rust são: Rustup e Cargo.

Rustup serve para gerenciar o Rust (versão, plataforma...)
Cargo serve para gerenciar seu projeto em Rust, desde a criação até o build.

Sobre o gerenciador de pacotes:

Cada pacote no Rust tem diversas features que podem ser desabilitadas ou não, reduzindo o tempo de compilação e o tamanho do executável final.

Os pacotes são instalados e publicados com a ferramenta Cargo e são distribuídos pelo crates.io (assim como o npmjs.com). Além disso, a documentação dos pacotes é centralizada em docs.rs/nome-no-pacote.

Para aprender Rust:

De acordo com esse vídeo (Rust is not a faster horse), Rust não é um substituto para C, você está procurando Zig. Rust não é um substituto para C++, você está procurando Go. "Rust não é um cavalo mais rápido, é um foguete!".

É isso! Pretendo postar mais conteúdo sobre Rust. Inclusive, quem viu minha primeira postagem (Aprendendo Rust) sabe que eu já tenho alguns textos escritos, vou adapta-los e publicá-los, ao final espero ter uma espécie de guia introdutório da linguagem de programação Rust.

Obrigado por ler! ❤

Se quiserem, escrevi também sobre algumas funcionalidades do Rust em outra postagem.

Aprendendo Rust

Kauê Fraga Rodrigues — Sun, 18 Feb 2024 00:49:06 +0000

Olá! 👋

Assisti uma live do Navarro sobre a Rinha de Backend em que ele usa a linguagem de programação Rust. Ao assisti-lo codando e explicando (não vou mentir, ele tem uma ótima didática) fiquei fascinado pela linguagem. Eu já tive contato com ela ao fazer o curso de Rust da Alura, mas confesso que não dei continuidade.

Dessa vez, cativado, pretendo ir adiante com a linguagem e fazer dela, parte das minhas ferramentas. Com o meu espírito entusiasta, acabei me empolgando nos estudos hoje e escrevi três textos introdutórios para mim, sobre Rust, algumas de suas funcionalidades e seu carro-chefe, Ownership. Para quem quiser ver (e quem sabe corrigir):

Partindo disso, gostaria de saber quais tópicos vocês recomendam para entender Rust e ser um Rustáceo de verdade 🤣

Brincadeiras à parte, pretendo me aprofundar no Ownership/Borrowing e seguir meus estudos pela documentação principal e pelo Rust by examples.

Quais funcionalidades, projetos, conceitos da linguagem Rust vocês recomendam para entender a linguagem Rust e se tornar minimamente proficiente?