Forem: Vanessa Nascimento

Qual a diferença entre require e import numa aplicação JS?

Vanessa Nascimento — Sat, 24 Feb 2024 11:26:44 +0000

O require e o import são duas formas de importar módulos em JavaScript, mas possuem diferenças em relação à sua sintaxe e principalmente ao contexto em que são utilizados.

O "require" é uma forma de importar módulos que pertence ao CJS (CommonJS), um padrão utilizado no Node.js. Ele é utilizado em versões mais antigas do JavaScript, como o ES5. A sintaxe para utilizar o require é a seguinte:

const modulo = require('nome-do-modulo');

Já o "import" é uma forma de importar módulos que pertence ao ESM (EcmaScript Modules) da versão do ECMAScript (ES6), e esse utilizado em versões mais recentes do JavaScript. A sintaxe para utilizar o import é a seguinte:

import modulo from 'nome-do-modulo';

Agora sobre o contexto que elas são utilizadas, essa é uma das principais diferenças entre o require (CJS) e o import (ESM). O require é síncrono, ou seja, ele carrega os módulos de forma sequencial, enquanto o import é assíncrono, permitindo o carregamento de módulos de forma paralela.

Outra diferença é que o import permite a utilização de recursos como o import { recurso } from 'nome-do-modulo', que possibilita importar apenas recursos específicos de um módulo. Mas, o import também permite a utilização de recursos como o import * as modulo from 'nome-do-modulo', que possibilita importar todos os recursos de um módulo em um objeto.

É importante ressaltar que o import é mais utilizado em projetos que utilizam o ECMAScript (ES6) e o Babel, enquanto o require é mais utilizado em projetos que utilizam o CommonJS, como o Node.js.

Como faço para utilizar require ou import na minha aplicação?

Numa aplicação Node.js, para utilizar o ESM, vá até o package.json da sua aplicação e insira essa propriedade na raiz do objeto:

"type": "module",

Já para o require (CJS) o Node.js considera ele como padrão. Vale que ressaltar que o CJS é definido como padrão de ferramenta de modularidade no Node.js mas nunca foi oficial da linguagem JavaScript. No entanto, a fim de conhecimento o "type": "commonjs" indica a utilização do CJS no projeto. Podemos observar na imagem a seguir os valores da propriedade type:

Bom, espero ter esclarecido essa dúvida e que te ajude a definir o melhor ao seu projeto. Até a próxima! 😊✨

Técnicas para Teste de Software e Boas Práticas

Vanessa Nascimento — Sun, 18 Feb 2024 17:53:43 +0000

O teste de software é uma etapa indispensável no desenvolvimento de sistemas, com o objetivo de garantir que o produto final funcione conforme o esperado. Ele envolve a execução do software para identificar possíveis falhas ou defeitos, como:

Erros de runtime (como crashes);
Resultados incorretos;
Operações inacessíveis para o usuário;
Respostas anormais;
Senhas não ofuscadas ao digitar;
Links quebrados.

Neste artigo, vamos explorar as principais abordagens de testes de software, incluindo técnicas específicas que garantem a qualidade e robustez do sistema.

Abordagens de Teste de Software 📚

Existem diferentes formas de classificar os testes de software, e cada uma delas é adequada para diferentes tipos de cenários. Vamos dar uma olhada nas abordagens mais utilizadas:

Teste Funcional (Caixa-Preta): Avalia a funcionalidade do software sem considerar seu código interno.
Teste Estrutural (Caixa-Branca): Analisa o código e a estrutura interna do software.
Teste Baseado em Estados: Avalia o comportamento de um sistema ao mudar de estado.
Teste de Mutação: Introduz alterações no código para verificar se os testes conseguem capturar essas mudanças.
Teste de Regressão: Garante que novas mudanças não causem problemas em funcionalidades já existentes.

Cada uma dessas abordagens foca em diferentes aspectos do software, desde as funções do sistema até a análise detalhada do código. A seguir, veremos como cada técnica funciona e como você pode aplicá-las no seu processo de desenvolvimento.

Teste Funcional (Caixa-Preta) 🎁

O teste funcional, também conhecido como caixa-preta, foca nas funcionalidades do software sem levar em consideração sua implementação interna. Ou seja, você testa se o software faz o que deveria fazer com base nos requisitos, sem se preocupar com o código em si.

Vamos supor que você tem uma calculadora em JavaScript que soma dois números. O teste funcional se concentraria em garantir que a função realiza a soma corretamente.

test('testa soma', () => {
   const calc = new Calculadora();
   const resultado = calc.soma(2, 3);
   expect(resultado).toBe(5);
});

Se quiser saber mais sobre teste de caixa preta, há um artigo meu mais detalhado aqui.

Teste Estrutural (Caixa Branca) 📦

O teste estrutural, ou caixa-branca, verifica se o código interno está funcionando corretamente. Aqui, o testador tem acesso ao código-fonte e testa o funcionamento interno da aplicação, verificando a lógica e a estrutura do código.

O teste estrutural para a mesma função de soma verificaria se a lógica de soma está correta ao comparar o resultado da função com a soma feita manualmente.

test('testa soma', () => {
   const calc = new Calculadora();
   const resultado = calc.soma(2, 3);
   const esperado = 2 + 3;
   expect(resultado).toBe(esperado);
});

Teste Baseado em Estados 🌟

O teste baseado em estados é útil para sistemas que possuem diferentes estados (como uma aplicação com login e logout). O objetivo é testar as transições entre esses estados.

Imagine testar se o usuário foi logado corretamente. O teste verifica se, após a execução da função de login, o estado do usuário foi alterado para "logado".

test('testa estado do login', () => {
   const user = new User();
   user.login('username', 'password');
   expect(user.isLoggedIn()).toBe(true);
});

Teste de Mutação 🧬

O teste de mutação cria versões modificadas do código original (chamados de mutantes) para verificar se os testes conseguem detectar essas mudanças. Se os testes não falharem diante do código alterado, isso indica que os testes precisam ser melhorados.

No código abaixo, o operador de soma foi trocado por subtração. Se o teste não detectar essa diferença, ele falha.

// código original
function soma(a, b) {
  return a + b;
}

// código mutante
function soma(a, b) {
  return a - b; // operador '+' foi substituído por '-'
}

test('testa mutação na função soma', () => {
   const resultadoOriginal = soma(3, 2);
   const resultadoMutante = soma(3, 2);
   expect(resultadoOriginal).not.toBe(resultadoMutante);
});

Teste de Regressão ⏮️

O teste de regressão garante que mudanças recentes no código não quebrem funcionalidades já existentes. Após implementar novas funcionalidades ou corrigir bugs, o teste de regressão verifica se o sistema antigo ainda funciona corretamente.

Aqui, testamos se a funcionalidade de soma ainda funciona após alterações no código:

test('testa soma após implementação de nova funcionalidade', () => {
   const calc = new Calculadora();
   const resultado = calc.soma(2, 3);
   expect(resultado).toBe(5);
});

Conclusão

O teste de software é uma prática essencial que garante a qualidade e confiabilidade dos sistemas. Ele envolve diversas abordagens e técnicas, como teste funcional, teste estrutural, teste de mutação, entre outros, cada um com um foco específico no comportamento ou na estrutura do software.

Adotar essas técnicas desde o início do desenvolvimento ajuda a identificar e corrigir problemas antes que eles se tornem mais complexos e caros de resolver. Lembre-se: testar bem é garantir um software de alta qualidade!

Se gostou deste artigo, curta e compartilhe para que mais pessoas possam aprender sobre as melhores práticas de teste de software! 🚀✨

Teste Funcional (Caixa-Preta) e Critérios de Teste: Guia Prático e Descomplicado

Vanessa Nascimento — Sun, 18 Feb 2024 17:29:41 +0000

No desenvolvimento de software, a qualidade do produto final é essencial. Para garantir essa qualidade, utilizamos testes eficazes. Hoje, vamos explorar um tipo específico de teste: o teste funcional, também conhecido como teste de caixa-preta (black-box).

O que é o Teste Funcional ou Caixa-Preta?

Imagine testar uma caixa fechada: você sabe o que entra e o que deve sair, mas não precisa se preocupar com o que acontece dentro dela. Esse é o princípio por trás do teste funcional.

No teste de caixa-preta, o objetivo é verificar se o sistema funciona conforme esperado, sem olhar para o código interno. Aqui estão alguns pontos importantes:

Foco externo: O teste funcional olha para o comportamento do software de fora, verificando se ele faz o que deveria.
Baseado em requisitos: Os testes são projetados com base nos requisitos e especificações do software.
Entrada e saída: Você fornece entradas ao sistema e verifica se as saídas estão corretas, sem precisar saber como o sistema processa essas entradas internamente.
Verificação de conformidade: O teste verifica se cada funcionalidade está de acordo com o que foi especificado.

Em resumo, no teste de caixa-preta, você não olha o código. Você se concentra nas entradas e saídas, sem se preocupar com o que acontece por dentro.

Onde os Testes Funcionais podem ser aplicados?

Essa técnica pode ser usada em vários níveis de teste, como:

Testes Unitários: Testa partes específicas do software, como funções ou métodos.
Testes de Integração: Verifica se diferentes partes do sistema funcionam bem juntas.
Testes de Sistema: Testa o sistema completo para garantir que ele funcione como um todo.
Testes de Aceitação: Garantem que o sistema atenda às expectativas do usuário final.

A seguir, vamos aplicar a técnica black-box nos códigos, usando os critérios mais populares de teste de software com JavaScript.

Como planejar os testes?

Para realizar bons testes, é necessário escolher os valores certos para testar. Isso é feito criando casos de teste, que são cenários projetados para verificar se o software está funcionando conforme o esperado.

O que é um caso de teste?

Um caso de teste é um conjunto de condições e variáveis que determinam se o software está funcionando corretamente. A ideia é perguntar: "O software está fazendo o que deveria?".

Como encontrar todas as falhas de um software?

Para garantir que o software funcione corretamente e encontrar o maior número de falhas possível, precisamos criar um conjunto de casos de teste eficaz, que deve ser:

Finito e factível;
Capaz de revelar o maior número de falhas perceptíveis;
Capaz de revelar as falhas mais críticas ou relevantes do software.

Critérios de Teste

Os critérios de teste são regras que determinam o que precisa ser verificado nos testes. Esses critérios ajudam a garantir que os testes cubram os cenários mais importantes e críticos.

1. Classe de Equivalência

As classes de equivalência dividem os dados de entrada em grupos onde o comportamento do software deve ser igual para todos os membros. Ou seja, se um teste em uma classe funcionar, espera-se que todos os testes nessa classe se comportem da mesma forma.

Por exemplo, em uma calculadora, podemos dividir as operações em classes de equivalência: soma, subtração, multiplicação e divisão. Em cada operação, esperamos que todos os valores válidos se comportem da mesma maneira.

// arquivo: tests/calculadora.test.js
const calculadora = require('../calculadora');

test('verifica se a soma de 2 + 2 é igual a 4', () => {
  expect(calculadora.soma(2, 2)).toBe(4);
});

test('verifica se a subtração de 5 - 2 é igual a 3', () => {
  expect(calculadora.subtrai(5, 2)).toBe(3);
});

test('verifica se a multiplicação de 3 * 3 é igual a 9', () => {
  expect(calculadora.multiplica(3, 3)).toBe(9);
});

test('verifica se a divisão de 10 / 2 é igual a 5', () => {
  expect(calculadora.divide(10, 2)).toBe(5);
});

2. Análise de Valor-Limite

A análise de valor-limite complementa as classes de equivalência, verificando os extremos dos intervalos de entrada. Isso é importante porque muitos erros ocorrem nos limites dos dados.

No exemplo da calculadora, podemos testar a função de divisão para garantir que:

A divisão de um número positivo por outro positivo funcione corretamente.
A divisão por zero retorne um erro, como esperado.
A divisão de números negativos e positivos funcione corretamente.

// arquivo: tests/calculadora.test.js
const calculadora = require('../calculadora');

// análise valor-limite para a operação de divisão

test('verifica se a divisão de 10 / 2 é igual a 5', () => {
  expect(calculadora.divide(10, 2)).toBe(5);
});

test('verifica se a divisão de 10 / 0 retorna um erro', () => {
  expect(() => calculadora.divide(10, 0)).toThrow('Divisão por zero não é permitida');
});

test('verifica se a divisão de -10 / 2 é igual a -5', () => {
  expect(calculadora.divide(-10, 2)).toBe(-5);
});

test('verifica se a divisão de 10 / -2 é igual a -5', () => {
  expect(calculadora.divide(10, -2)).toBe(-5);
});

3. Análise de Causa-efeito

A análise de causa-efeito examina a relação entre entradas (causas) e saídas (efeitos). O objetivo é verificar se a entrada correta gera a saída esperada.

Causas:

Cada item no carrinho tem um preço.
O carrinho pode conter vários itens.
Pode haver itens com quantidades diferentes ou preços diferentes.

Efeito:

O total do carrinho deve ser calculado corretamente com base nos preços e quantidades dos itens.

Para demonstrar a análise de causa-efeito, vamos criar diferentes causas (como carrinhos com diferentes combinações de itens) e observar os efeitos (o total calculado corretamente).

// arquivo: tests/calculaTotal.test.js
const calculaTotal = require('../calculaTotal');

test('verifica se o total do carrinho é calculado corretamente', () => {
  const carrinho = [
    { item: 'Camiseta', preco: 50 },
    { item: 'Calça', preco: 100 },
    { item: 'Sapato', preco: 200 },
  ];

  expect(calculaTotal(carrinho)).toBe(350);
});

Conclusão: A Jornada do Teste Funcional

O teste funcional é uma ferramenta essencial para garantir que o software esteja funcionando corretamente. Ao aplicar critérios como classes de equivalência, análise de valor-limite e análise de causa-efeito, você pode encontrar falhas e garantir a qualidade do seu software.

Este artigo foi inspirado nas minhas anotações do curso de Teste de Software, em que fui aluna especial no mestrado da USP, com o professor Dr. Marcelo Eler. Espero que tenha sido útil para você e ajude na sua jornada no mundo dos testes de software. Até a próxima! ✌️✨

Artigo Software Testing: A Research Travelogue - Resumo em PT-BR

Vanessa Nascimento — Mon, 12 Feb 2024 16:12:03 +0000

Estou animada para compartilhar um resumo do artigo "Software Testing: A Research Travelogue". Quero passar o meu conhecimento que adquiri (e anotações que fiz) durante minha vida acadêmica de um jeito fácil de entender; neste caso foi para minha matéria de Teste de Software no mestrado como aluna especial em Sistemas de Informação na USP. Neste resumo, coloquei as informações mais importantes do artigo para ajudar a todos interessados em Teste de Software, seja estudante, profissional ou apenas curioso. Espero que este resumo seja útil, dando uma visão geral do progresso da pesquisa em Teste de Software e mostrando as maiores contribuições e desafios desde os anos 2000. Vamos lá! 🚀

O Teste de Software é uma estratégia amplamente estudada para avaliar e melhorar a qualidade do software. O artigo tem como objetivo apresentar as pesquisas bem-sucedidas e desafios da área desde os anos 2000, contemplando o estado da arte e possíveis direções futuras.

Em 2000, a Conferência Internacional de Engenharia de Software realizou sua primeira trilha "Futuro da Engenharia de Software", apresentando alguns roadmaps para a área. Um deles era o "Testing: A Roadmap", de autoria de Mary Jean Harrold. A partir desse conceito, surgiu este diário de bordo do Teste de Software pelos autores, prestando homenagem à cientista e orientadora de PhD deles. 👸🏻

O Teste de Software continua sendo um dos tópicos mais pesquisados na Engenharia de Software. Mary Jean Harrold afirma em sua trilha que:

"A qualidade do software se tornará o critério de sucesso dominante na indústria de software."

Foi realizada uma pesquisa com mais de 50 pesquisadores da área de Teste de Software, com as seguintes perguntas:

Quais são as contribuições mais significativas para os testes desde os anos 2000, sejam suas ou de outros pesquisadores?
Quais são os maiores desafios e oportunidades em aberto para futuras pesquisas nesta área?

30 deles responderam à pesquisa com comentários onde as seguintes palavras foram as 5 mais citadas:

Empírico
Prático
Regressão
Ferramentas
Simbólico

As pesquisas dos contribuintes foram identificadas e classificadas como contribuições de pesquisa e contribuição prática, sendo que a última foi impulsionada mais pelo esforço industrial do que pelas atividades de pesquisa.

Contribuições de Pesquisa

Existem 9 contribuições principais, que podem ser classificadas em 4 categorias principais:

1. Geração de entrada de teste automatizado

As técnicas automatizadas de geração de entrada de teste tentam gerar um conjunto de valores de entrada para um programa ou componente de programa, geralmente com o objetivo de atingir alguma meta de cobertura ou alcançar um estado particular (como a falha de uma asserção).

Execução Simbólica: Executa um programa usando entradas simbólicas em vez de concretas. Em qualquer ponto da computação, o estado do programa consiste em um estado simbólico expresso em função das entradas, e as condições nas entradas que fazem com que a execução chegue a esse ponto são tipicamente expressas como um conjunto de restrições em forma conjuntiva chamada condição de caminho (PC).
Baseado em Busca: Empresas como Microsoft e IBM usam técnicas de SBST. Essa técnica visa problemas de otimização, como encontrar o menor conjunto de casos de teste que cobrem todas as ramificações de um programa, tudo baseado em técnicas de otimização baseadas em meta-heurísticas.
Testes Aleatórios: Nos RTs, pesquisas vão além da geração de entrada aleatória simples, investigando abordagens mais sofisticadas e, até certo ponto, baseadas em princípios que possam melhorar a eficácia dessa técnica tradicional. Uma abordagem de RT é o teste aleatório adaptativo, que é uma classe de técnicas de teste projetadas para melhorar a eficácia de detecção de falhas do teste aleatório.

2. Estratégias de teste

Estas incluem testes combinatórios, testes baseados em modelos e mineração e aprendizado a partir dos dados de campo. Entre eles, temos:

Testes Combinatórios: Na prática, testar todas as configurações de um sistema, que pode ter um número enorme de configurações diferentes, é, na maioria das vezes, impossível devido ao tamanho do espaço de configuração. Os testadores devem, portanto, encontrar maneiras de amostrar esses espaços e realizar testes eficazes ao mesmo tempo que contêm o custo envolvido. O teste de interação combinatória (CIT) oferece estratégias para fazer isso.
Teste Baseado em Modelo: O teste baseado em modelo (MBT) envolve a derivação de conjuntos de testes a partir de uma ampla variedade de modelos de sistemas de software.
Mineração e Aprendizagem com Dados de Campo: Atualmente, é cada vez mais comum coletar um amplo espectro de informações dinâmicas do software após ele ter sido implantado, enquanto ele é executado nas plataformas do usuário, e usar esse campo (ou telemetria) para apoiar as atividades de teste e melhorar sua eficácia.

3. Teste de regressão

Para realizar testes de regressão, os engenheiros geralmente começam reutilizando T, mas reutilizar todo T (a abordagem de reteste-tudo) pode ser excessivamente caro. Técnicas de seleção de teste de regressão (RTS) são muito incentivadas na pesquisa para diminuir o custo de execução de suítes de teste de regressão.

4. Estudos empíricos e suporte para eles

As técnicas de teste são tipicamente heurísticas e seu desempenho pode diferir amplamente em diferentes cargas de trabalho e cenários de teste. Para entender e avaliar essas técnicas, métodos empíricos são, portanto, essenciais. A disponibilidade crescente de objetos de experimentação tem contribuído para este progresso.

Contribuições Práticas

Duas grandes contribuições nesse contexto são a definição de novos frameworks para execução de testes, que melhoram e difundem drasticamente a arte do teste de software (como por exemplo o JUnit), e a ampla adoção de práticas inovadoras que promovem ciclos mais curtos no processo de teste, como a integração contínua (CI). Este conceito está ligado ao teste automatizado de frameworks de execução, em que um conjunto de testes de regressão deve ser executado automaticamente no código para ajudar a garantir que a base de código permaneça estável.

Referências

Orso, Alessandro, and Gregg Rothermel. "Software testing: a research travelogue _(2000–2014)." _Future of Software Engineering Proceedings. 2014. 117-132. Link do artigo.

O que são os containers? Uma introdução ao Docker

Vanessa Nascimento — Mon, 12 Feb 2024 15:11:48 +0000

📦 O que é container?

Containers são como a mais nova moda no mundo da tecnologia, uma evolução da virtualização que permite rodar várias versões de um sistema operacional, cada uma na sua caixinha, no mesmo host. A popularidade chegou com o Docker em 2013, que trouxe uma interface amigável e uma plataforma para compartilhar containers prontos para uso. Nascidos no universo Linux, os containers são baseados em tecnologias como namespaces, cgroups e chroot. O que são elas?

Os namespaces garantem que cada container tenha sua visão particular do sistema operacional, como se fosse um adolescente em seu quarto. Isso inclui seu próprio espaço de nomes de processo, rede e sistema de arquivos montado. 🏘️
Os cgroups, ou grupos de controle, são como a mamãe Linux controlando o uso de recursos (como CPU, memória, disco I/O, rede, etc.) de um conjunto de processos, garantindo que ninguém passe dos limites. 🧐
O chroot é como se fosse um truque de mágica que muda o diretório raiz percebido por um processo, fazendo com que o processo e seus descendentes vejam um pedaço do sistema de arquivos como se fosse todo o sistema de arquivos, tipo um tour guiado com acesso VIP.🚪

Confuso? 🫠 Vamos à um exemplo então:
Agora imagine que você está numa festa 🥳, nela há um buffet de mini pizzas individuais para cada convidado. Cada mini pizza é como um "container", com sua própria "visão" da pizza (seus próprios ingredientes), isolada das outras, tipo os namespaces. Além disso, é preciso garantir que cada pizza tenha uma quantidade equilibrada de ingredientes, tipo os cgroups, que controlam o uso de recursos de cada container. Por último, cada mini pizza está em sua própria bandeja de papel, o que impede que os ingredientes de uma pizza entrem em contato com os de outra. Isso é parecido com o chroot, que dá um nível extra de isolamento. 🍕😋

Então, a computação em container permite que você rode várias versões isoladas do sistema operacional no mesmo host, cada uma com seus próprios recursos e isolada das demais, assim como você pode preparar várias mini pizzas, com suas especificidades, numa única festa. Ao contrário das máquinas virtuais (VMs), que emulam um ambiente completo, incluindo um sistema operacional convidado, os containers compartilham o kernel do sistema operacional hospedeiro, o que os torna mais leves e eficientes em termos de recursos. Essa abordagem oferece um equilíbrio entre isolamento e eficiência, sendo ideal para ambientes de desenvolvimento e implantação de aplicativos modernos.

✨ PS.: Um mantra para sempre te acompanhar quando te perguntarem qual a diferença entre máquina virtual (VM) e container (Docker), tenha em mente que:

Na máquina virtual você emula um novo sistema operacional dentro do sistema operacional do host. Já no container você emula somente as aplicações e suas dependências.

O que é o Docker?

Docker é uma plataforma de código aberto que foi lançada em 2013 por uma empresa chamada dotCloud, que depois se tornou Docker Inc. 👩‍💻 O Docker foi construído com base na tecnologia de containerização do Linux, que já existia há um bom tempo, mas que ainda não tinha uma interface amigável nem uma maneira padronizada de distribuir e rodar containers.

O Docker chegou e transformou a tecnologia de containers em algo mais amigável e acessível. Ele se tornou um verdadeiro mágico da tecnologia, empacotando software em pequenas unidades chamadas containers. Esses containers, como vimos, são essas pequenas caixinhas que incluem tudo o que o software precisa para funcionar: código, tempo de execução, ferramentas do sistema, bibliotecas e configurações. É como se cada container fosse uma pequena casa, com tudo o que você precisa para viver com conforto e autonomia. 🏡

Todo mundo tem um passado...

Antes do Docker, já existiam algumas tecnologias que também trabalhavam com a ideia de isolar processos. Vamos falar um pouco sobre elas. Temos algumas como a LXC (Linux Containers), a Jails, a Solaris Zones e a VPS (Virtual Private Server).

A LXC, ou Linux Containers, é uma tecnologia que permite a criação e execução de múltiplas instâncias isoladas do Linux no mesmo host. É como se cada instância fosse um apartamento em um grande prédio, cada um com suas próprias características e configurações. 🏢

Jails é uma tecnologia introduzida pelo sistema operacional FreeBSD. Ela permite a execução de várias instâncias isoladas do FreeBSD no mesmo host, como se fossem várias casas geminadas compartilhando o mesmo terreno. 🏘️

Solaris Zones, também conhecido como Solaris Containers, é uma tecnologia do sistema operacional Solaris. Ela permite a execução de múltiplas instâncias isoladas do Solaris no mesmo host, como se fossem várias cabanas em uma ilha. 🛖🏝️

Já a VPS (Virtual Private Server) é uma tecnologia que permite a execução de múltiplas instâncias isoladas de um sistema operacional em um único servidor físico. É como se fossem várias lojas em um shopping, cada uma com seu próprio espaço. 🏬

O Docker, por sua vez, pegou essas tecnologias existentes e deu um passo adiante. Ele introduziu uma camada de abstração e automação que torna o processo de criação, implantação e execução de aplicações em containers muito mais simples e eficiente. Além disso, o Docker introduziu um formato padronizado para a distribuição de aplicações em containers, facilitando o compartilhamento e a colaboração, como se fosse uma rede social de containers.

Bom, espero que tenha gostado do artigo e que esclareça suas dúvidas dos princípios de Docker e o porquê é tão popular (e exigido para vagas em tech). 😄

Um curso que me ajudou muito a entender, criar este artigo e usar o Docker nos meus projetos foi o Docker Essentials da LinuxTips. É gratuito e qualidade de primeira! 🥇

Como instalar o Node.js no meu computador?

Vanessa Nascimento — Thu, 08 Feb 2024 20:31:57 +0000

Arregace as mangas 🥭 e vamos começar. O primeiro passo é acessar https://nodejs.org/en. Para Windows e Mac, o processo é o mesmo. Para distribuições Linux, o processo muda um pouco, mas explicarei isso mais adiante. 🏃🏽‍♀️

Instalando o Node.js no Windows ou MacOS

Uma dúvida comum é sobre as duas opções, LTS e Current. Basicamente, LTS significa Long-Term Support, ou Suporte de Longo Prazo, que é uma versão mais segura e estável do Node. A opção Current é a versão mais recente, com recursos mais recentes, mas que pode ainda conter alguns bugs. Eu sempre recomendo baixar a versão mais estável, a LTS.

Ao abrir o Node.js Setup, o programa de instalação, prossiga e clique em 'Next' com força e depois ‘Install’. Nessas etapas ele instalará o Node.js, adicionará a documentação e o gerenciador de pacotes do Node, o npm, ao Path do seu sistema operacional. Dessa forma, você poderá acessar o Node pela linha de comando. O npm é muito útil aqui para baixar as bibliotecas do Node, por isso vamos instalar ele. E se esta parte não está totalmente clara, os próximos artigos irão esclarecer para você.

Abra o Prompt de Comando/Terminal do seu computador, digite node -v e se aparecer na linha debaixo a versão, significa que tudo deu certo! O Node.js está instalado com sucesso no seu computador. 💃🏾

Instalando o Node.js para distribuições Linux

Acesse https://nodejs.org/en/download e vá até o final da página e clique na opção 'Installing Node.js via package manager’ como mostra a imagem.

Ao acessar esta página, você encontrará diversos tutoriais para vários sistemas operacionais, incluindo distribuições Linux. Ao clicar neles, será apresentado um tutorial específico para instalação.

Siga o tutorial adequado para o seu sistema operacional. Acesse o Terminal ou a Linha de Comando do seu computador e, assim como no Windows e MacOS, digite node -v. Se a versão aparecer, significa que o Node está instalado com sucesso na sua máquina! 🕺🏼

Qualquer dúvida, manda aqui nos comentários. 💕 Agora que estamos com o Node.js instalado, vamos baixar um bom editor de código e finalmente dar nossos primeiros passos. 🌈

O que é o Node.js?

Vanessa Nascimento — Thu, 08 Feb 2024 19:24:08 +0000

Antes de entender o Node.js, precisamos saber o que é JavaScript. Essa linguagem de programação faz uma página web ser dinâmica e interativa. Cada navegador tem um interpretador para processar o JavaScript. O Node.js nada mais é que um interpretador JavaScript, que permite que o JavaScript seja usado fora do navegador. 😉

Então, o Node.js é uma plataforma que deixa o JavaScript rodar no servidor. Ele usa o motor V8 do Google Chrome para interpretar o JavaScript, que é bem rápido e eficiente. Com o JavaScript funcionando além dos navegadores, ele pode ser usado para construir aplicações web, assim como PHP, C# ou Ruby; permite criar aplicativos para computador, aplicativos de comando, embarcados e aplicativos para celular. Isso só é possível por causa do Node.js, que expandiu o uso do JavaScript. 🤯

Por que usar o Node.js?

Existem várias razões maravilhosas para usar o Node.js. Primeiramente, o Node.js torna possível programar tanto o lado do cliente quanto o do servidor usando apenas JavaScript. Isso pode aumentar a produtividade, pois os desenvolvedores não precisam mudar de linguagem ao mover-se entre o front-end e o back-end. Como sempre fui front-end em toda minha carreira, particularmente foi ótimo para mim ter essa transição mais leve do front para o back-end.

Além disso, o Node.js é conhecido por sua alta performance. Como mencionado anteriormente, ele usa o motor V8 do Google Chrome, que é extremamente rápido, está entre uma das tecnologias mais velozes. O Node.js consegue receber 10 vezes mais requisições por segundo, do que a linguagem PHP com as configurações básicas, um máximo né?! O Node.js também é assíncrono e orientado a eventos, o que significa que pode lidar com muitas conexões simultâneas sem perder velocidade.

Finalmente, o Node.js tem uma comunidade de desenvolvedores ativa e vibrante. 🥳 Isso significa que há muitos recursos disponíveis para ajudar a aprender e resolver problemas, incluindo uma grande quantidade de bibliotecas de software livre disponíveis através do gerenciador de pacotes npm (Node Package Manager).

Resumindo, temos como vantagem:

☁️ Muito leve;
⚡️ Muito rápido;
🌟 Usa JavaScript;
🌎 Tem um dos maiores ecossistemas do mundo;
👩🏻‍💻 Está sendo utilizado fortemente no mercado.

Agora que você já sabe o porquê desta tecnologia estar na boca do povo, vamos dar os primeiros passos? No próximo artigo vou te ensinar a instalar o Node no Ubuntu, Mac e Windows. GO! 🚀

Ps.: Ah, se você teve interesse em saber sobre qual linguagem é mais rápida em nível de desempenho, recomendo este artigo aqui: Benchmarks Game

Guia do Node.js, do começo ao fim

Vanessa Nascimento — Thu, 08 Feb 2024 18:48:32 +0000

Olá, sejam muito bem-vindes ao Guia de formação Node.js, do começo ao fim. Meu objetivo aqui é facilitar a sua jornada com Node.js, essa plataforma incrível que talvez ainda seja um pouco misteriosa para você. ✨👩🏻‍💻

Node.js é uma plataforma de desenvolvimento de software open-source que faz maravilhas permitindo que os desenvolvedores criem aplicações de rede eficientes e escaláveis. Mas vamos deixar a conversa mais técnica para o próximo artigo, onde vamos mergulhar fundo no que é o Node.js. Neste guia, vamos caminhar juntos, desde conceitos básicos até os tópicos mais avançados. Espero que você goste deste roteiro e que ele seja um grande aliado na sua jornada para se tornar uma pessoa desenvolvedora Node.js de mão cheia.

Vejo você nos próximos artigos! Até daqui a pouco! 😊