Categorias
front-end Linguagens de programação

Hello, React! – React para iniciantes

Após esse texto você estará preparada com a base conceitual para realização de projetos utilizando ReactJS.

Os objetivos específicos são:

  • Facilitar o entendimento dos pilares do ReactJS (componentes, jsx e props)
  • Te preparar para criar aplicações em React do zero, usando um gerador de projetos e finalmente fazer o seu “Hello, world!”

O que é e quem usa ReactJS?

Já imaginou se você pudesse aprender a programar com a tecnologia que o Facebook, Instagram, WhatsApp, Twitter, Netflix, Airbnb, Notion, Trello, Tiktok e muitas outras gigantes usam? O que mudaria de possibilidades e oportunidades para sua carreira? Já parou pra refletir sobre isso?

Pois bem, react é uma biblioteca JavaScript usada para criar interfaces para pessoas usuárias.

Já quero abrir um parênteses aqui pra explicar que bibliotecas são conjuntos de funcionalidades criadas por outras pessoas desenvolvedoras que passaram por grandes problemas, criaram soluções e resolveram deixar a solução disponível em pacotes para que outras pessoas possam usar. Boazinhas, né? Eu amooo!rs

E que interfaces de usuários são aquelas telas lindas e cheias de funções que as pessoas usuárias podem interagir. No Instagram por exemplo: a tela de login, o feed onde os posts aparecem, o explorar, os stories, cada pequeno botão de curtir, compartilhar, comentar enfim.

Sim, react e á uma das tecnologias que essas empresas que eu falei e muitas outras do Brasil e do mundo usam. Eu mesma trabalho com essa tecnologia dentro da Thoughtworks. 🙂

A grande vantagem é que trabalhar com React torna a vida da pessoa desenvolvedora mais fácil, pois a gente consegue criar soluções complexas de uma maneira mais simples e em menos tempo.

Além disso tudo, é importante saber também que com React é possível criar SPA. Um acrônimo para Single Page Application que é uma única página web com super poderes para lidar com diferentes dados a partir das interações das pessoas usuárias.

Na prática, quando alguém clica num botão para abrir uma página nova, o que acontece por debaixo dos panos é a atualização de uma pequena parte de nossa única tela, em vez de atualizar a página inteira para mostrar o esperado.

Eu sei que ainda tá muito abstrato pra visualizar, mas daqui a pouquinho vai fazer mais sentido. Confia em mim e vamos que vamos!

Acesse a documentação oficialReactJS

Preparando o ambiente

Criando e entendendo meu primeiro projeto reactjs, render, estrutura de pastas, apagando arquivos padrão)

Eu sou uma pessoa supersticiosa e me contaram que toda vez que a gente está aprendendo alguma tecnologia nova, dá sorte começar com um hello world! Então vamos nessa! rs

Para essas aulas, vamos usar o editor de códido, vs code. No meu computador eu tenho também o NodeJS instalado na versão LTS e também o gerenciador de pacotes npm.

Como saber se tenho o node instalado? Abra um terminal e digite o comando abaixo:

node -v

Seu retorno positivo será um número parecido com esse, que é a versão correspondente: v14.17.0

Se seu retorno não for do modo acima, é porque você ainda não tem, acesse o link abaixo para instalar.

Node: https://nodejs.org/en/

Depois de instalar, rode o comando novamente e tenha certeza que instalou direitinho

Olá, Mundo!

Criando seu primeiro projeto React com vite

O que é e como usar vite:

- Acesse a documentação oficialVite

- Acesse um fio que fiz no twitterTwitter

- Acesse um reels que fiz no instagramInsta

- Siga o passo a passo aqui embaixo

  1. Lembra que eu falei que react é uma biblioteca e que a gente pode acessar e usar? Vamos fazer isso, no terminal rode o comando abaixo. Ele vai criar uma pasta contendo algumas outras pastas e arquivos dentro. Não se assuste! Demora um pouco até ficar pronto, rs.

npm create vite@latest nome-do-app -- --template react

Terminou e deu tudo certo, quando aparecer no terminal: Done. now run!

  1. Ainda no terminal, ele nos dá uma sugestão de entrar na pasta de nosso projeto cd nome-do-app

Baixar as dependências com npm install

Depois rodar com npm run dev

Vamos fazer isso!

  1. Ele irá abrir um navegador sozinho usando a porta localhost:3000 e é lá que você consegue ter uma prévia de como sua página está ficando.

  2. Perceba que ele rodou uma página pronta! A gente só precisou rodar alguns pequenos comandos no terminal, certo?

Vamos trocar esse conteúdo pelo nosso hello world.

Vá até src > App.jsx

  • Apague a div e tudo que está dentro dela e escreva no lugar: Olá, Mundo!
  • Salve e volte para o navegador!
  • Uhullllll, agora vamos começar com tudooo e entender como estamos escrevendo num arquivo javascript/JSX e fazendo aparecer no html. <3
  1. Entenda as pastas e arquivos

node_modules

index.html

.gitignore

package.json

package-lock.json

vite.config.js

src

app.jsx main.jsx outros arquivos que não nos interessam agora

Componentes e JSX

Em react tudo é componente! Pequenas partes onde podemos encapsular/guardar códigos e reutilizar sempre que necessário.

Se liga aqui no Instagram. Deve existir lá no código deles um componente chamado perfil. Olha como todos são exatamente iguais. tem o nome, a imagem, a quantidade de seguidores, seguindo, publicações, a Bio. Só o conteúdo muda de uma usuária pra outra, certo?

Se alguma funcionalidade muda, então fica muito mais fácil fazer uma manutenção, você sabe exatamente onde o código vai estar. Basta ir no componente e mudar onde a lógica está encapsulada.

Vamos aprender a criar um componente react.

Existem duas formas de criar componentes: classes e funcões.

Aqui, vamos focar somente em funções, pois em 2018 o time que criou o react introduziu uma forma de resolver problemas onde antes somente componentes com classes poderiam fazer.

Eu chamo isso de React moderninho! haha Você vai curtir, mas na próxima aula!

Um componente é justamente uma função que retorna um HTML. e quando temos javascript misturado com html chamamos de jsx.

Vamos à prática: Crio um arquivo com extensão jsx ou js iniciando o nome com letra maiúscula.

Dentro do arquivo crio e exporto uma função. Que poderei importar e usar em qualquer outro componente no meu projeto.

function SayHello() {
  return(
    <h1>Hello</h1>
  )
}

export default SayHello
function Title() {
  return(
    <h1>Eu sou um título lindão</h1>
  )
}

export default Title

Props e Children

Lembra do componente de perfil que a gente tá supondo que o instagram deve ter? Como será que eles fazem pra mudar os conteúdos sempre que identificam que estamos mudando de perfil ao acessar?

Uma das soluções para fazer isso seria usando as props, ou propriedades. Vamos à prática. Temos o componente Title que para cada página esse título irá mudar. A gente não precisa criar um h1 toda vez e criar todo estilo novamente. Vamos encapsular em um componente e permitir que por props ele receba conteúdos diferentes para o mesmo componente.

function Title(props) {
  return(
    <h1>{props.text}</h1>
  )
}

export default Title

Ao usar esse componente, por exemplo no App.js ficaria dessa forma:

import Title from "caminho para o arquivo Title"

function App() {
  return(
    <div>
      <Title text="Home"/>
    </div>
  )
}

Dentro das props também existem o children e basicamnete em vez de usar dentro de atributos em tags de autofechamento usaríamos como conteúdo em componentes de fechamento e de abertura. Assim:

function Name(props) {
  return(
    <p>{props.children}</p>
  )
}

export default Name

Ao usar esse componente, por exemplo no App.js ficaria dessa forma:

import Title from "caminho para o arquivo Name"

function App() {
  return(
    <div>
      <Name>Simara Conceição</Name>
    </div>
  )
}

É isso! Espero que esse texto tenha te ajudado a dar os primeiros passos com ReactJS. Deixa suas dúvidas nos comentários! Até mais!

Categorias
backend

Serverless para iniciantes

Quando ouvi a palavra serverless pela primeira vez, levei a tradução ao pé da letra e pensei que se tratava de um projeto onde não existiria um servidor. Mas não é bem isso…

E criei esse artigo pra te contar o que entendi sobre o assunto. Dessa forma acredito que pode rolar uma troca legal entre a gente: de um lado, eu vou consolidar meus estudos iniciais da arquitetura serverless e do outro, você fica conhecendo mais um ponto de vista sobre o assunto. Então aqui vou falar sobre:

  • O que é serverless
  • Quais os benefícios de usar serverless
  • Qual a importância de devs aprenderem a criar soluções serverless
  • Como criei experiência ao estudar serverless
  • Tutorial de “Hello, world!” na arquitetura serverless

O que é serverless?

Serverless é uma arquitetura orientada a eventos e não é que não exista um servidor, na real a gente não precisa se preocupar com a configuração de um servidor, pois o provedor de nuvem que usaremos fará isso pra gente.

Além disso, na arquitetura serverless, as aplicações são iniciadas apenas quando um evento aciona a execução do código da aplicação de forma dinâmica.

Dos modelos de serverless que existem aqui embaixo estão alguns dos mais populares:

  1. BaaS – Backend as a Service, como o Firebase do Google Cloud Platform
  2. FaaS – Function as a Service como AWS Lambda e Azure function

Quais os benefícios de usar serverless?

Mas você deve estar se perguntando, quais as vantagens de começar a usar serverless, não é mesmo? Dentre uma lista extensa de benefícios que fazem as empresas decidirem por usar serverless posso destacar estes 3:

  •  A escalabilidade da aplicação é automática
  •  A configuração de deploy é super simples
  •  Só pagamos pelo que usamos

A arquitetura serverless popularizou quando as empresas entenderam que podem crescer sua infraestrutura com redução de custos e de forma automática.

Além disso, é possível usar serverless na linguagem de programação que o time já utiliza, facilitando ainda mais a adesão.

Qual a importância de devs aprenderem a criar soluções serverless?

Soluções serverless garantem facilidade no dia a dia de trabalho, para determinados projetos, onde muitas configurações já existem, como por exemplo de conteinerização, escalonamento e muitas outras.

Dessa forma, podemos nos concentrar em criar regras com qualidade, explorando o ágil e utilizando boas práticas.

Podemos também acessar diversas oportunidades ao sermos capazes de gerar crescimento para os negócios em que colaboramos com economia utilizando serverless.

Tenta uma coisa? Pesquisa no LinkedIn a quantidade de vagas disponíveis para quem tem esse conhecimento. Eu pesquisei aqui com o termo AWS Lambda e encontrei quase 400 vagas para o Brasil. Bastante, não?

Criando experiência enquanto estudo

Meu primeiro projeto serverless usando AWS Lambda do zero ao deploy

Minha primeira experiência com serverless foi realizando um projeto guiado, no curso Ignite da Rocketseat, no módulo de backend com Node.js nas aulas da maravilhosa Dani Leão.

A gente fez uma aplicação que cria e valida um certificado de conclusão de curso gerando uma versão pdf. Se liga no resultado abaixo!

A request de criação do certificado:

O pdf gerado:

Para isso utilizamos as tecnologias abaixo:

  • Typescript
  • Framework serverless
  • AWS Lambda
  • DynamoDb
  • S3
  • puppeteer
  • handlebars

Algumas lições aprendidas:

  • Como criar uma lambda
  • Tipagem da aws-lambda
  • Criei minha conta aws e configurei as credenciais na minha máquina
  • Como usar o dynamoDb offline
  • Como rodar o projeto serverless offline
  • Como fazer deploy da solução
  • O uso de algumas libs pra transformar data e pra gerar pdf
  • Como usar S3
  • Como consultar o log na aws
  • O principal aprendizado foi entender o arquivo serverless.ts e que ele pode ser no formato yml também
  • Como criar e rodar um projeto com o framework serverless usando o esbuild

O código completo você pode conferir aqui no meu repositório: https://github.com/simaraconceicao/serverless

Tutorial: “Hello, Serverless!”

Agora que você já sabe os motivos pelos quais deveria aprender a criar projetos usando a arquitetura serverless, chegou a hora de colocar a mão no código e vamos dar um hello world com serverless. 

Aqui a gente vai fazer um tutorial rodando localmente, ou seja não faremos deploy na AWS.

Requisitos: É preciso ter instalado o “node”: “>=14.15.0”.

Passo 1:  Instalar o framework serverless 

Um boilerplate para gerar projetos aws lambda. Você pode ler mais detalhes aqui na documentação: https://www.serverless.com/

Comando:

npm install -g serverless

Verifique se instalou corretamente usando o comando:

serverless --version

Deverá retornar as versões instaladas.

Passo 2: Criar o projeto usando o template aws-nodejs-typescript

Comando:

serverless create --template aws-nodejs-typescript --path nome-do-projeto

Passo 3: Entrar no projeto, instalar as dependências e abrir no vscode

Comandos: 

cd nome-do-projeto
npm i
code .

Passo 4: Excluir arquivos default (pasta de libs e pasta hello)

Antes de excluir estava assim:

 

Após excluir os arquivos default, sua estrutura de pastas vai ficar assim:

Passo 5: Hello, Serverless!

Criar um arquivo dentro da pasta functions e nomear de hello.ts 

Código:

import { APIGatewayProxyHandler } from 'aws-lambda'

export const handler: APIGatewayProxyHandler = async (event) => {
 return {
  statusCode: 200,
body: JSON.stringify({
message: 'Hello, Serverless!'
})
}
}

Passo 6: entender estruturas de pastas, principalmente arquivo serverless.ts

├── src

│   ├── functions               # Lambda configuration and source code folder

│      ├── hello.ts

│  

├── package.json

├── serverless.ts               # Serverless service file

├── tsconfig.json               # Typescript compiler configuration

├── tsconfig.paths.json         # Typescript paths

└── webpack.config.js           # Webpack configuration

Passo 7: Dentro do arquivo serverless.ts mudar importação do arquivo hello

Importar a funcao via path, excluir importação que vem por default dos arquivos e pastas que excluímos.

Código:

// import the function via paths
functions: {  
hello: {
 handler: "src/functions/hello.handler",
events: [
{
http: {
path: "hello",
method: "get",
cors: true
}
}
]
}
}


Passo 8: Incluir plugin serverless offline

Comando:

npm i serverless-offline -D

Inserir config de plugin no arquivo serverless.ts 

Código:

plugins: ['serverless-offline'],

Observação

Como o arquivo serverless.ts estava antes por default:

Como o arquivo serverless.ts ficou após todas as alterações:

Passo 9: rodar projeto localmente

Comando:

serverless offline

 

Passo 10: acessar o link que aparece no terminal que é a request get

Resultado:

Conclusão

Espero que esse artigo te ajude a dar os primeiros passos com AWS Lambda. Se você tentou fazer o hello world e precisa de ajuda, pode consultar esse meu repo aqui: https://github.com/simaraconceicao/hello-serverless.

Caso queira trocar ideia sobre esse ou outro conteúdo, vou adorar te receber na comunidade do telegram quero ser dev: https://t.me/queroserdev

Até o próximo post!

Categorias
front-end Linguagens de programação

Um guia prático de testes unitários para pessoas desenvolvedoras iniciantes no front-end usando ReactJS

Como pessoas iniciantes na programação, uma das ferramentas que pode nos dar confiança em quase toda linha de código que a gente escreve são os testes unitários.

Além disso, o mercado espera que advoguemos pela qualidade do nosso trabalho. Por isso, em entrevistas de emprego costumam perguntar: “Você tem alguma familiaridade com testes unitários?”

E pra você que está estudando ReactJS, esse artigo vai te ajudar a responder essa pergunta com um “SIM”bem grandão. 🙂 Vamos nessa?

O que são testes unitários?

Testes unitários são testes realizados de forma isolada para garantir qualidade para pequenas partes do seu código, como as funções, as classes e por aí vai.

3 benefícios de realizar testes unitários

  1. Encontrar e corrigir bugs, otimizando o tempo da pessoa QA
  2. Aumentar a confiabilidade da sua aplicação
  3. Servir como documentação

Vamos aprender como fazer os testes unitários dos componentes numa aplicação bem simples em reactjs?

Ferramentas

Em vez de usar Jest, vamos usar o vitest como ambiente para rodar nossos testes. Esta é uma alternativa para projetos criados com vite. Se você ainda não conhece o vitest, se liga no que sua própria documentação diz sobre ele:

Vitest é uma estrutura de teste de unidade extremamente rápida, desenvolvida pela Vite.

Já para criação do testes a gente vai automatizar a forma como a pessoa usuária poderia interagir com a nossa tela. Pra isso vamos usar o testing library react que segundo a documentação é:

Uma família completa de pacotes para criar testes utilizando boas praticas centradas no comportamento da pessoa usuária.

Entendendo um teste unitário

Bloco de teste

  • Renderizar o componente que queremos testar
  • Encontrar os elementos que queremos interagir
  • Interagir com esses elementos
  • Afirmar o resultado esperado

describe, test e expect

  • describe serve para criarmos um conjunto de testes
  • test serve para criar um caso de teste
  • expect serve para descrever o que esperamos com resultado ideal para aquele teste

screen, render, userEvent, queryBy…/findBy…, toBeInTheDocument/toHaveTextContent

  • screen é o que nos permite visualizar a tela e a partir daí encontrar os nós do DOM
  • render é o metodo que renderiza nosso componente no ambiente de testes
  • userEvent simula alguns eventos e interações da pessoa usuária
  • queryBy…/findBy… são as queries, alguns dos muitos metódos que nos ajudam a encontrar, buscar, trazer um ou mais elementos da tela
  • toBeInTheDocument/toHaveTextContent são os matchers, alguns dos muitos metodos que nos ajudam a comparar o resultado esperado com o resultado recebido. Eles nos ajudam também com o log de mensagens de erro.

Vamos para o tutorial

Configurando ambiente

Vamos usar o vite para criar nosso projeto que vem um contador por padrão, não esqueça de escolher react as duas vezes que aparecem para escolher a linguagem:

npm create vite@latest aprendendo-testes

Vamos entrar no projeto:

cd aprendendo-testes

Vamos baixar as dependências importante para o projeto reactjs funcionar:

npm install

Agora vamos configurar nosso projeto para receber e rodar testes unitários com vitest e testing library react:

Passo 1: Instalar as dependências como dependências de desenvolvimento

npm install vitest -D
npm install @vitest/ui @testing-library/jest-dom @testing-library/react @testing-library/react-hooks @testing-library/user-event jsdom -D --force

Passo 2: Inserir os scripts no package.json

 "test": "vitest",
 "test:ui": "vitest --ui"

Passo 3: Inserir a propriedade test no vite.config

test: {
 globals: true,
 setupFiles: 'src/setupTests.js',
}

Passo 4: Criar o setupTests.js

import '@testing-library/jest-dom'
export { default as userEvent } from '@testing-library/user-event'

Agora vamos criar nossos testes:

Passo 5: Criar arquivo de testes

App.test.jsx

Passo 6: Incluir a config do jsdom no arquivo de cada teste

/**
* @vitest-environment jsdom
*/

Passo 7: Importar tudo que é necessário para realizar os testes

 import { describe, test } from 'vitest'
 import { render, screen, waitFor } from '@testing-library/react'
 import userEvent from '@testing-library/user-event'
 import App  from './App'

Passo 8: Agora vamos escrever nosso primeiro teste que cobre os caos de renderizar corretamente o h1 e testa se o contador funciona:

 describe('App', () => {
  test('should return the correct text', () => {
    render(<App />)

    expect(screen.getByText('Vite + React')).toBeInTheDocument() 
  })

  test('should return 1 when the user click one time at button', () => {
    render(<App />)

    const buttonElement = screen.getByRole('button')
    expect(screen.queryByText('count is 0')).toBeInTheDocument() 

    userEvent.click(buttonElement)

    waitFor(() => expect(screen.queryByText('count is 1')).toBeInTheDocument() ) 
  })
})

Passo 9: Agora vamos rodar nossos testes:

npm run test

ou

npm run test:ui

Prontinho! Esse aqui é o resultado esperado:

Espero que esse guia tenha te ajudado. Me conta nos comentários se tentou fazer.

Continue seus estudos e avance:

Até a próxima!🚀👩🏾‍💻

Categorias
backend

Desafio 6 CRUDs MongoDB em 2 semanas

Fiz 6 projetos de CRUD MongoDB, ao longo de 10 dias, com o objetivo de consolidar o meu aprendizado. E compartilho aqui a evolução e as lições aprendidas.

Apresentação

Prazer, Simara Conceição! Eu sou desenvolvedora grad na ThoughtWorks, professora na {reprograma} e criadora do Podcast Quero Ser Dev.

Gif Yeah

Iniciei minha migração para área de tecnologia em 2019, você pode conhecer essa história completa ouvindo o quero ser dev.

Motivação para criar esse desafio

Fui convidada para ensinar na Reprograma para mais de 40 mulheres iniciantes em backend como criar um CRUD MongoDB usando o mongoose.

E toda vez que estou me preparando para uma aula eu fico imersa no conteúdo pensando em construir a melhor experiência possível para minhas queridas alunas.

Eu embarquei nesse desafio, pois acredito que não há nada que a gente saiba tão pouco que não possa compartilhar.

Quando conheci MongoDB

Eu tenho uma história engraçada sobre como me apaixonei pelo MongoDB, rs.

Em 2020, antes de entrar na TW eu apliquei pra lá em uma vaga de dev full stack. Lembro que a entrevista foi em inglês e com uma colaboradora baseada em NYC e uma das primeiras perguntas foi: você já usou nossa ferramenta?

E eu bem garota, faceira, ousada, iniciante mais que tudo respondi que não havia ainda tido a oportunidade de usar, mas que era uma entusiasta.

Fui reprovada, óbvio, rs. A verdade é que eu tinha ficado feliz demais só de ter sido considerada para vaga, ao ser convocada para essa primeira entrevista.

Saí de lá decidida a usar o MongoDB em meus projetinhos de estudo e ganhar mais maturidade em padrão de projeto e melhores práticas de desenvolvimento.

Afinal de contas, eu queria carreira em uma empresa global, que tivesse um programa explicito de diversidade e de desenvolvimento para as pessoas colaboradoras.

Fico feliz de ter alcançado tudo isso aqui na empresa que estou atualmente, a gente só consegue conectar os pontos olhando pra trás, já dizia Jobs. <3

O que é um CRUD?

Pra quem tá chegando agora, CRUD é um acrônimo para Create, Read, Update e Delete(criação, consulta, atualização e remoção de dados). São as 4 operações principais em um banco de dados.

Resumo de cada CRUD que criei :

  1. Primeiro: Cadastro de inscritos no canal
  2. Segundo: Cadastro de episódios de podcast
  3. Terceiro: Cadastro de filmes
  4. Quarto: Cadastro de livros
  5. Quinto: Cadastro de séries
  6. Sexto: Cadastro de estudios e títulos

As informações de ferramentas utilizadas, requisitos, arquitetura e também os códigos, você encontra aqui nesse repositório: https://github.com/simaraconceicao/node-mongo-mongoose

 Lições aprendidas

 Procurando direitinho tem muito conteúdo incrível no youtube

A ideia original desses projetinhos foram retiradas desse tutorial do canal Web Dev Simplified. Obrigada Kyle! haha

Build A REST API With Node.js, Express, & MongoDB – Quick

Já a parte de relacionamento, eu me inspirei nesse vídeo aqui da Rocketseat. Valeuu, Diego! rs

API NodeJS + Express + Mongo – CRUD e relacionamentos com MongoDB

Eu fiz o projeto 1 acompanhando o tutorial do Kyle e a partir do projeto 2 fui implementando e modificando conforme meu repertório ia deixando, rs.

Para ter embasamento teórico assisti aulas de de data driven, aulas de conceitos, mapa mental sobre tipos de bancos de dados. Aqui está um comparativo entre SQL e NoSQL:

NoSQL

Surgiu no final dos anos 90 e como uma alternativa de natureza não relacional.

Possuem alta escalabilidade e desempenho.

Alguns tipos de bancos de dados não relacional: armazenamento de chave-valor, armazenamento column family, orientado a grafos e orientado a documentos.

SQL

RDBMS ou Sistema de Gerenciamento de Banco de Dados Relacional, armazenam dados em um formato estruturado, usando linhas, colunas e tabelas.

Structured Query Language, ou Linguagem de Consulta Estruturada ou SQL, é a linguagem de pesquisa declarativa padrão para banco de dados relacional.

Geralmente demanda distribuição vertical de servidores, o que gera mais custo, pois quanto mais dados, mais memória e mais disco um servidor precisa.

Aqui está um comparativo dos termos MongoDb e SQL:

| MongoDB | SQL |
| — | — |
| `database` | database|
| `collection` | table|
| `document` | row|
| `field` | column|
| `lookup` | table joins|

Referência: https://docs.mongodb.com/manual/reference/sql-comparison/

Repetição é importante demais

A cada dia, ficava mais fluído entender a responsabilidade de cada arquivo, a lógica de cada função do CRUD, percebia os comportamentos e conseguia lidar melhor com os erros também.

Mas Simara, faz sentido criar basicamente o mesmo projeto 6 vezes? Faz muito sentido! De tanto repetir, eu comecei a não precisar consultar o tutorial ou algum projeto meu anterior.

O último então fluiu que só. Consegui desenhar toda a estratégia de como compartilhar o conhecimento com as meninas, comparando com o que elas já viram antes conectando pontos para o entendimento fluir melhor.

Começando com o MongoDb

Os dados são armazenados no formato que se parece muito com JSON, o que é uma grande facilidade para quem já programa com Javascript.

Podemos usar o Mongo pelo serviço de nuvem(cloud) ou localmente fazendo o download para nossa máquina (eu usei essa opção) e ainda é possível integrar as 2 formas.

Além disso, o Mongo possui seu driver com suas próprias queries(comandos para interação com o banco que se assemelham muito com javascript com orientação a objeto), podemos também usar uma interface gráfica(usei o MongoDb Compass) e ainda podemos usar um ODM, ferramenta que mapeia entre nosso objeto e a db(usei o mongoose).

Teste, teste e teste

Eu não criei uma estratégia de testes, mas fiz testes manuais com Insomnia e tratei os possíveis erros para retornar status e mensagens coerentes.

Não usei o driver do MongoDB, usei a interface gráfica MongoCompass para verificar se meus dados estavam salvando direitinho.

Mongoose faz um meio de campo lindão entre nosso projeto e o MongoDb

Sabe quando a gente inventa de editar uma foto no photoshop, mesmo sabendo que existem filtros prontos que fazem um ótimo trabalho? Então usar o mongoose é apelar para templates prontos, lindos e rápidos.

– Mas muita atenção, pois a comunicação dele com o MongoDB é feita de forma assíncrona.
– Passando nossa string de conexão e informações default é possível fazer a Criação da conexão com a db e também tratar os erros.
– Mas o melhor de todos os pontos, é que ele cria nosso model, informando exatamente como nossos documentos e collections serão. <3

 Separar as responsabilidades faz sentido demais

A partir do terceiro projeto fui percebendo o quanto os arquivos de server e de routes estava ficando densos e estranhos com tantas informações, dessa forma modularizei melhor e separei a minha lógica. Você pode perceber a diferença do primeiro para o último.

Compartilhar conhecimento/vivência é disparada a melhor maneira para aprender de forma eficiente

Repito: não há nada que a gente saiba tão pouco que não possa compartilhar.

Estou em constante aprendizado, nessa minha rotina de transição, mas eu só tenho segurança pra dizer que entendi algo de verdade depois que eu compartilho esse conhecimento.

Além disso, compartilhar é uma troca linda e eu sempre aprendo muito com essas vivências. <3

Próximos passos

Quero me aventurar com infra e fazer o deploy de algum desses CRUDs, permitindo de forma pública as integrações e também penso em implementar uma estratégia de testes automatizados.

É isso, pessu! Me enviem feedbacks sobre esse artigo e sobre essa minha forma de estudar.Vou amar trocar ideias com vocês. Até a próxima!

Categorias
Linguagens de programação

Prazer, backend!

Há quase 2 anos, eu dava meus primeiros passos na programação.

Naquela época, eu não fazia ideia do quanto esse mundo de tecnologia é gigante e com tantas possibilidades.

Eu não fazia ideia que dar instruções para a máquina deve ser algo puramente humano e demanda muito poder de comunicação, afinal de contas linhas de códigos devem ser mais lidas do que escritas.

Eu não fazia ideia do quanto eu precisaria ser resiliente, é difícil demais lidar com tantos erros e mudar a forma de pensar todos os dias.

Mas você ganha muito mais confiança quando entende que agilidade não tem nada a ver com velocidade, você ganha muito mais confiança quando entende que tudo é sobre construir uma jornada e que você precisa ser gentil consigo mesma.

Eu fiquei mais confiante, quando comecei a respeitar meu modo de funcionar: pensar devagar, viajar na maionese, explorar novos caminhos, entender os conceitos, planejar, testar, compartilhar minhas descobertas e ter a sensibilidade de criar soluções elegantes.

E por falar nisso, vem conferir esse episódio do podcast quero ser <dev>, convidei minha mana Analu Sampaio e abordamos vários conceitos sobre backend.

E pra complementar seus estudos, juntei aqui embaixo alguns dos conceitos que conversamos no podcast. Aproveite!

Node.js

É um interpretador Javascript que não depende do navegador.

Ele é formado pelo V8, motor interpretador de Javascript criado pelo Google, e pela libuv, uma biblioteca que deu características de linguagem backend para o node.

Node.js revolucionou a forma de programar em Javascript, pois a linguagem evoluiu de uma forma de dar vida aos elementos no navegador para uma linguagem capaz de rodar sistemas em computadores/servidores.

Leia mais: Primeiros passos em Node.js

HTTP

É o protocolo de transferência de hipertexto.

O principal protocolo de comunicação entre computadores utilizados na internet.

Ele cria as regras para enviar e receber informações na internet.

Ele é responsável pelo o que acontece por debaixo dos panos quando usamos a internet.

Verbos ou métodos

Para além de GET e POST, temos também no nosso leque de principais métodos o PUT, DELETE e PATCH.

É simples de entender:

  • GET: para consultas de recursos
  • POST: para criação de recursos
  • DELETE: para remoção de recursos
  • PUT e PATCH: para atualização de recursos

Os verbos PUT e PATCH servem para atualização de um recurso.

Mas quando escolher um ou outro? Não fique confusa! O PUTserve para atualização do recurso inteiro enquanto o PATCH é uma atualização de um ou mais campos daquele recurso.

Verbo PUT:

  • Geralmente usado com parâmetro
  • Deve passar todos os dados do recurso preenchidos, independente de quais dados você de fato editou.

Por exemplo, digamos que seu model músicas possui os atributos nome e artista – e você editou apenas o nome. A documentação indica que você deve passar ambos os atributos preenchidos para o serviço (mesmo só tendo editado o nome).

Para resolver isso de forma elegante a adote por convenção, um quinto verbo HTTP: PATCH.

Verbo PATCH:

  • Use para editar o recurso sem a necessidade de enviar todos as chaves e valores do seu model
  • Envia de fato o que foi alterado
  • Além também de dizer qual o ID como parâmetro, para que o serviço saiba o que vai ser alterado.

API

Interface entre aplicativos e programação.

Se uma interface de um sistema é criado para o usuário final, a API é desenvolvida para que um sistema possa usar as funcionalidades de outro sistema.

Interface ideal para que um sistema se comunique com outro sistema.

REST e RESTful

Rest é uma abstração(forma de usar as regras) do protocolo HTTP para simplificar a construção de um web service, ou seja quem cria uma API com as restrições e regras do modelo Rest está criando na verdade API Restful.

O grande objetivo desse modelo é fazer com que os recursos estejam disponíveis através de URLs.

Algumas das regras:

  • Adotar convenção de URLs
  • Basear em recursos
  • Usar os verbos HTTP para indicar ações
  • Ser stateless, ou seja, toda requisição é autossuficiente/independente

MVC

É o padrão de arquitetura (Model-View-Controller). Separei aqui embaixo como você pode organizar suas pastas e recursos, usando esse padrão de arquitetura de software para projetos com Node.js.

Server.js

Aqui no server que você vai chamar o app para escutar a porta e disponibilizar toda a aplicação a partir do localhost

App.js

Aqui no app que você vai usar a rota raiz

📂Routes

Aqui nas rotas você vai usar os verbos para executar os controllers

📂Controller

Aqui no controller você vai acessar os dados do seu model a partir das requisições e enviar respostas

📂Model

Por enquanto estamos apenas guardando nosso JSON aqui, mas no futuro será o lugar onde você irá modelar os esquemas de dados para o banco. Não fique ansiosa! Acredite no processo, ele funciona!

📂View

Aqui você não precisa fazer nada, mas é onde a dev front-end cria as telas bonitonas para usar os dados que você trata e disponibiliza.

Conclusão

Talvez você esteja se sentindo meio confusa com tantos conceitos e modelos. Talvez esse conteúdo não seja só sobre mim e o início da minha jornada.

E se esse for o caso: respire, não desista, autoconhecimento é a chave. Resgate a potência que você é. Os erros na tela e os “nãos” não dizem nada sobre você!

Aprender a aprender pode ser muito doloroso, mas eu te garanto uma coisa: é libertador! 🚀

Categorias
Linguagens de programação

Primeiros passos em Node.js

Mergulhei no mundo de back-end com Node.js e estou completamente apaixonada. Poder programar em javascript sem depender do navegador para interpretar é TUDOOO de bom.

Agora, nem o céu é o limite para as aplicações que vou criar, rs. Mas vamos ao que interessa! Vou compartilhar com vocês como foram meus primeiros passos em Node.js!

O que é Node.js?

É um interpretador Javascript que não depende do navegador. Ele é formado pelo V8, motor interpretador de Javascript criado pelo Google, e pela libuv, uma biblioteca que deu características de linguagem back-end para o node.

Node.js revolucionou a forma de programar em Javascript, pois a linguagem evoluiu de uma forma de dar vida aos elementos no navegador para uma linguagem capaz de criar programas desktop, games e até inteligência artificial ou robótica.

3 Vantagens para usar Node.js

Existem muitas vantagens de escolher o Node.js para solucionar problemas reais de negócios reais ao desenvolver aplicações. Eu separei 3 delas pra contar pra vocês. Confira:

  1. Esse é o principal motivo pelo qual eu escolhi mergulhar nesse mundo. Programar em node.js é programar em Javascript, a linguagem que eu tenho proficiência. Uma linguagem com curva baixa de aprendizagem e uma comunidade gigantesca;
  2. Node.js utiliza muito pouco a memória RAM e aproveita melhor a CPU, isso significa que dá pra entregar performance com um custo baixo de servidor ;
  3. Tem uma vasta biblioteca de pacotes, módulos e plug-ins (npm) para node.js

Ambiente de desenvolvimento em Node.js

Nessa parte do artigo, preparei tópicos da preparação do ambiente de desenvolvimento.

Meu conselho é que você faça as pazes com a tela preta para usar e abusar do terminal ou prompt de comando, pois nós vamos usar muito. Vamos lá!

Instalando o Node.js

Acesse nodejs.org e identifique a versão compatível com seu sistema operacional.

Escolha a versão LTS, pois ela é uma versão livre de bugs e é estável. Já a versão current é a versão vida louca, pra quem é entusiasta do node e quer ficar testando novas features com instabilidades.

O processo de instalação no windows é muito fácil. Faça o download e instalação. Abra o terminal ou prompt de comando e verifique se tudo deu certo na instalação, digitando o comando:

npm  -v

Ele irá retornar a versão que foi instalada.

Instalando o readline

Um pacote maravilhoso para pegar inputs no terminal, ou seja pegar entradas de dados no sistema. Se você veio de programação front-end isso equivale a pegar o value do input de um usuário num formulário.

Dentro da pasta de seu projetinho instale o pacote digitando o comando:

npm install readline-sync

Instalando o code Runner

Para rodar um programa no terminal temos que utilizar  o comando:

node nomeDoArquivo.js

Você pode automatizar esse processo instalando o plug-in Code Runner no vscode.

Instalando o express

Outro pacote que podemos instalar para facilitar a nossa vida é o express, um framework minimalista do node.js.

Ele já vem com centenas de módulos que podem ser uma mão na roda para o desenvolvimento de sua aplicação.

Faça a instalação também localmente na pasta de seu projetinho:

npm install express --save

Meus programinhas

Agora, vamos codarrr, rs! Criei 4 programinhas simples que serviram para relembrar conceitos básicos de javascript e preparar meu ambiente de desenvolvimento em node, além de aplicar também técnicas de debug.

Calculadora de média 5 notas

A calculadora de média determina se uma aluna foi aprovada, reprovada ou vai para a recuperação. Usei variavéis, operadores matemáticos e lógicos e condicionais.

Para retornar notas com casas decimais usei o parseFloat() e para exibir um resultado personalizado fiz uma concatenação de strings:

const readline = require('readline-sync')

const nomeAluno = readline.question('Nome de aluno ')

const primeiraNota = parseFloat(readline.question('Nota 1 '))
const segundaNota = parseFloat(readline.question('Nota 2 '))
const terceiraNota = parseFloat(readline.question('Nota 3 '))
const quartaNota = parseFloat(readline.question('Nota 4 '))
const quintaNota = parseFloat(readline.question('Nota 5 '))


const media = (primeiraNota + segundaNota + terceiraNota 
+ quartaNota + quintaNota)/5
console.log(media)

if(media >= 7){
console.log(nomeAluno + " está aprovado(a)")
}else if (media < 5){
console.log(nomeAluno + " está reprovado(a)")
}else if (media >= 5 && media < 7){
console.log(nomeAluno + " foi pra recuperação")
}

Conversor de temperatura

Aprendizagem por repetição, fiz essa segunda calculadora para utilizar novamente alguns dos conceitos da primeira calculadora. A temperatura do input é em Celsius e chama uma função
que converte para Fahrenheit. F = 9*C/5 + 32:

const read = require('readline-sync')

let temperatura = read.question("Qual a temperatura ")

function converterTemperatura(num){
    console.log((num -32) * 5/9)
}
converterTemperatura(temperatura)

Calculadora simples modular

Mais uma vez usei o readline para pegar os inputs. Para chamar nos arquivos, você precisa criar uma variável que recebe require e como parâmento ‘readline-sync’.

Já para fazer o terminal solicitar os dados, você precisa usar a propriedade .question e como parâmento passar uma string.

Usei também o Code Runner para facilitar minha vida e rodar o código usando ctrl + alt + n

A ideia era criar uma calculadora que me permitesse usar as 4 principais operações matemáticas: soma, subtração, multiplicação e divisão. Separei cada operação por módulos. 🙂

Usei o switch case que é um tipo de condicional. E quando a condição é correspondida, o programa executa as instruções associadas.

Cada módulo é uma função que executa as operações recebendo 2 parâmetros.

Módulo soma:

var soma = function(a,b){
    return a+b
}

console.log(soma(parseInt(read.question("a ")),parseInt(read.question("b "))))
module.exports = soma

Módulo subtração:

var sub = function(a,b){
    return a-b
}

console.log(sub(parseInt(read.question("a ")),parseInt(read.question("b "))))
module.exports = sub

Módulo multiplicação:

var multi = function(a,b){
    return a*b
}

console.log(multi(parseInt(read.question("a ")),parseInt(read.question("b "))))
module.exports = multi

Módulo divisão:

var div = function(a,b){
    return a/b
}

console.log(div(parseInt(read.question("a ")),parseInt(read.question("b "))))
module.exports = div

Calculadora:

const read = require('readline-sync')

const operacao = read.question("O que deseja fazer? somar/subtrair/multiplicar/dividir ")


switch (operacao) {
    case 'somar':
        var funcSoma = require('./soma')
    break
    case 'subtrair':
        var funcSub = require('./sub')
    break
    case 'multiplicar':
        var funcMulti = require('./multi')
    break
    case 'dividir':
        var funcDiv = require('./div')
    break
    default:
        console.log(`Escolha uma opção válida.`)
}

Meu primeiro servidor usando express

A ideia era criar um servidor, criar rotas e enviar dados para o client-side. Importei o express, criei a instancia, criei a aplicação mensagem para o lado do cliente.

Criei rotas e rotas dinâmicas utilizando os parâmetros para receber dados de requisição. E por fim, criei o servidor e enviei aplicação para o servidor. Confira abaixo! Comentei cada linha:

//importando express
const express = require("express")

//criando a instância 
const app = express()

//criando aplicação para enviar 
//mensagem para o lado do cliente
app.get("/", function(req, res){
res.send("Hello, World!")
})

//criando rotas
app.get("/sobre", function(req, res){
res.send("Quem sou eu?")
})
app.get("/blog", function(req, res){
res.send("Bem-vindo ao meu Blog!")
})

//criando rotas dinâmicas utilizando parâmentros 
//e receber dados de requisição
app.get("/contato/:tel/:email/:linkedin", function(req, res){
res.send(req.params)
})

//criando servidor e enviando aplicação para o servidor
app.listen(8081, function(){console.log("Servidor rodando na porta 8081!")})

Conclusão

Essas foram os 4 primeiros programinhas que criei em node.js, os próximos passos irão me levar até a construção de uma aplicação web, utilizando express, MongoDb e Deploy no Heroku. Fiquem de olho aqui!<3