DEV Community: Ramon Borges

Não deveria ser tão simples inserir um bug na sua aplicação e eu te conto o porquê

Ramon Borges — Tue, 09 Jul 2024 22:33:58 +0000

Quem nunca ouviu aquela história (fictícia ou não) do dev júnior que apagou a base de dados em produção? Ou quantos de nós ao implementar aquela nova melhoria, sem perceber inseriu um bug dentro da aplicação? Normalmente, a nossa primeira atitude é culpar ou a pessoa (quando ela comete o erro) ou a nós mesmos (quando nós cometemos o erro).

Inserir bug em um sistema ou mesmo apagar os dados de produção não deveriam ser tarefas tão simples de realizar (você deve concordar comigo, não é mesmo?). Mas porque isso acontece?

Pessoas e Processos

Acredito que a resposta para esta pergunta inicia no entendimento de que a maioria desses erros é primeiramente uma falha de processo e não de pessoas. Observar as falhas a partir desse ponto de vista nos ajuda muito a encontrar a verdadeira causa do erro e evitá-las (ou pelo menos reduzí-las) no futuro.

No livro “A Startup Enxuta”, Eric Ries apresenta uma declaração bem interessante:

Se nosso processo de produção é tão frágil que você pode quebrá-lo logo no primeiro dia de trabalho, que vergonha por tornar isso tão fácil.

Em outras palavras, não deveria ser tão simples inserir um bug na minha aplicação!

Não chore o leite derramado, escreva testes!

Ok Ramon, eu entendi que não pode ser tão fácil. Porém, será que existe um meio pelo qual eu posso dificultar o meu “eu futuro” ou até um colega de cometer o mesmo erro? Sim! E uma das maneiras seria: escrever testes para sua aplicação!

O desejo e urgência para corrigir esse bug deve ser o mesmo para evitar que a próxima pessoa repetisse o erro. Ao inserirmos testes na aplicação, nós estamos de alguma forma protegendo o nosso trabalho bem como o dos nossos colegas também. Ou seja, tornando o processo de inserir bugs mais difícil.

Sempre que um novo bug é descoberto na aplicação, podemos criar um teste específico para detectá-lo. Dessa maneira, à medida que adicionamos mais testes, nosso sistema se torna progressivamente mais robusto e menos suscetível a erros. Percebeu que isso é muito mais produtivo que apenas criticar a pessoa ou até você mesmo?

Conclusão

Enxergar os erros como oportunidades de melhoria no processo de desenvolvimento, nos permite identificar as causas reais e implementar soluções eficazes. A criação de testes é uma das estratégias poderosas para tornar o sistema mais robusto e resiliente a novos bugs, fortalecendo continuamente o processo de desenvolvimento de software.

Referências

Livro "A startup enxuta: Como usar a inovação contínua para criar negócios radicalmente bem-sucedidos" do Eric Ries.

Backup sem estresse: Como criar o dump do seu BD PostgreSQL no Docker de forma simples

Ramon Borges — Mon, 27 Nov 2023 15:30:00 +0000

Introdução

Nesta postagem, exploraremos um guia prático para a criação de dumps de banco de dados PostgreSQL em contêineres Docker. Abordaremos o acesso ao container, a utilização do pg_dump e a exportação dos dados para fora do contêiner.

Acessar container Docker

Para iniciar, é crucial acessar o contêiner que hospeda o banco de dados PostgreSQL. Você pode usar o comando docker exec para entrar no ambiente do contêiner. Este comando executa um novo comando em um contêiner em execução.

docker exec -it ID_CONTAINER /bin/bash

O -it permite que você interaja com o terminal dentro do contêiner. O ID_CONTAINER é o identificador do container que possui o banco de dados. O /bin/bash permite que um shell Bash seja iniciado dentro do contêiner, o que proporciona uma interface de interação com o ambiente do contêiner.

Gerar Dump utilizando pg_dump

Com o acesso ao contêiner estabelecido, é hora de gerar o dump do banco de dados. Utilizaremos a ferramenta pg_dump, que é padrão no PostgreSQL e oferece opções para personalizar o processo de backup. Para gerar o arquivo com o backup, execute o comando abaixo:

pg_dump -U username -d dbname -f NOME_DO_ARQUIVO_DUMP.sql

Onde,

-U username: Nome de usuário para conectar-se ao banco.
-d dbname: Especifica o nome do banco de dados ao qual deseja conectar-se.
-f file: Nome do arquivo que receberá o script com o dump.

Será solicitado a você a senha do banco de dados. Ao inserir a senha, o arquivo com o dump será exportado para o container. Mas, como eu tenho acesso a esse arquivo, que se encontra dentro do meu container?

Exportar arquivo para fora do container

Após a conclusão do dump, sairemos do contêiner. Para isso, basta executar o comando exit.

Em seguida, utilizaremos o comando cp para exportar o arquivo de dump do contêiner para o sistema de arquivos local. Para isso, basta executar o comando abaixo:

docker cp idcontainer:/caminho/no/container/NOME_DO_ARQUIVO_DUMP.sql /caminho/no/host/local/

Para facilitar o nosso entendimento, vou dar um exemplo. Digamos que você tem um container com id 6abfa0ee2d87, contendo o arquivo de dump meu_dump_2023.sql, e você deseja exportar para o seu diretório local. Você deveria executar o seguinte comando:

docker cp 6abfa0ee2d87:meu_dump_2023.sql .

Conclusão

Com estes passos simples, você pode criar dumps de banco de dados PostgreSQL em ambientes Docker de maneira simples. Este processo é fundamental para a segurança e a continuidade dos dados, proporcionando uma abordagem prática e segura para backups em contêineres.

Referências

Nest JS: 4 motivos que me fizeram escolher este framework para o desenvolvimento de aplicações backend Node Js

Ramon Borges — Tue, 16 May 2023 23:49:57 +0000

Introdução

Bom, estou escrevendo este post pois quero compartilhar um pouquinho sobre um framework que descobri esse ano. Estou trabalhando com ele a pouco tempo, mas desde do começo, já me chamou muita atenção. Gostaria de dizer para você quais foram os 4 principais motivos que me fizeram escolher este framework. Senhoras e Senhores, este é o Nest JS.

Mas antes, o que é esse Nest JS?

Nest JS é um framework de desenvolvimento back-end em Node.js que utiliza conceitos e técnicas de programação orientada a objetos e programação funcional para criar aplicações escaláveis e modularizadas. Ele usa TypeScript como linguagem principal e possui uma arquitetura modular, com uma estrutura de pastas organizada que facilita a criação e manutenção de projetos complexos.

Já ouvi falar de um tal de Next.js, é a mesma coisa?

Next e o Nest são coisas totalmente diferentes. Next.js é um framework de desenvolvimento web em JavaScript, utilizado para criar aplicações front-end com React. Nest JS é um framework de desenvolvimento back-end em Node.js. O foco desse artigo é falar sobre o Nest JS (o que tem o 's' 😅).

Inspiração do Nest JS

O Nest JS é inspirado em alguns dos conceitos e estruturas do Angular, como a injeção de dependência, os decoradores e os módulos. O criador do Nest JS, Kamil Myśliwiec, também contribuiu para o desenvolvimento do Angular.

No entanto, o Nest JS é voltado para o desenvolvimento de aplicações back-end em Node.js, enquanto o Angular é voltado para o desenvolvimento de aplicações front-end em JavaScript.

Vamos finalmente para os motivos que me fizeram escolher o Nest JS, para implementar aplicações backend com Node JS.

Motivo 1: Framework opinado

Um framework opinado é um framework que faz fortes suposições sobre qual as melhores práticas para desenvolvimento de software e arquitetura da sua aplicação.

Seguir essas opiniões e convenções devem acelerar o tempo de desenvolvimento, já que agora, precisamos nos preocupar apenas com o desenvolvimento das regras de negócio. Isso também é conhecido como "Convention Over Configuration".

Sem dúvida, essa característica foi essencial para mim, ao escolher o Nest JS. Imagina que você já teve contato com os conceitos de autorização e autenticação, mas nunca implementou um login do zero. A documentação do Nest JS, já te apresenta quais as boas práticas ao desenvolver esse tipo de funcionalidade. Não é ótimo?

Motivo 2: Inversão de Controle/Injeção de dependência

Por um período, utilizei uma biblioteca chamada Inversify. Ela permite inserir o conceito de Injeção de dependências/Inversão de controle dentro de uma aplicação Node. Demorei um bom tempo para entendê-la. O grande problema é que você precisava preencher alguns arquivos, sempre que criava uma nova classe que deveria ser injetada. Você fazia isso configurando dois arquivos dentro da aplicação (quantas vezes esqueci de adicionar as novas classes, e a aplicação não rodava kkk).

Descobri que o Nest JS, já tinha por padrão o conceito de Injeção de dependências/Inversão de controle. Você só precisava fazer uma importação da classe em questão dentro da campo providerse adicionar uma anotação @Injectable(). Pronto! Você já era capaz de injetar uma classe dentro de um construtor.

Sem dúvida, saber que o Nest já utilizava os conceitos de Inversão de Controle/Injeção de Dependência, me chamou atenção positivamente.

Motivo 3: Ótima documentação

Pode ser apenas uma impressão minha, mas achei bem agradável e amigável essa documentação, principalmente para quem está começando com este framework. Não foi difícil entender as soluções apresentadas em cada seção. Basicamente, boa parte do que precisei implementar, consegui fazer utilizando apenas as informações da documentação do Nest JS.

Ela conta com um repositório no github, que tem a implementação da maior parte dos conceitos explicados. Você tem acesso a implementação ao fim de cada capítulo (figura abaixo).

Se quiser acessar o repositório com todas as implementações, clique aqui.

Motivo 4: Variedade de técnicas e receitas disponíveis

Outro ponto a se destacar é que o Nest JS disponibiliza na sua documentação, uma série de técnicas e receitas. Você consegue implementar "todo" tipo de aplicação que imaginar.

Técnicas:

Configuração de envs, banco de dados, mongo, validação, caching, serialização, versionamento de API, agendamento de tasks, filas, logging, cookies, eventos, session, Graphql, Websockets, etc.

Arquiteturas:

Microservices, MVCs, Monorepos, etc.

Receitas:

Passport, Swagger, Health checks, CQRS, Prisma, Serve static, Automock, CRUD generator.

Descobri uma série de bibliotecas e conceitos que eram desconhecidos para mim, e que aumentaram o meu leque de opções como desenvolvedor (por exemplo, conceito de monorepo).

Conclusão

Este artigo apresentou o Nest JS, um framework back-end escalável e modularizado em Node.js, que utiliza programação orientada a objetos e funcional. Destacou-se sua opinião, facilidade de injeção de dependência, ótima documentação e variedade de técnicas disponíveis.
Em resumo, o Nest JS pode ser uma excelente escolha para desenvolvedores que buscam um framework robusto e produtivo para seus projetos.

Referências

Documentação oficial

Dominando Promises em JavaScript: Encadeamento, Promise.all e tratamento de erros

Ramon Borges — Fri, 28 Apr 2023 00:09:42 +0000

Introdução

Este é o nosso último post da série Ecmascript 6 (posso ouvir um aahhhhhh daqui 😆). Nessa segunda parte, falaremos um pouco sobre encadeamento de promises, execução de múltiplas promises utilizando o .then() e uma dica de ouro ao utilizar promises. Vamos lá?!

Promise.all

A função Promise.all() permite executar múltiplas promises simultaneamente e retornar um único valor quando todas elas forem resolvidas. Isso é útil quando você precisa executar várias tarefas assíncronas e só deseja prosseguir quando todas elas tiverem sido concluídas.

const promise1 = new Promise((resolve) => {
  setTimeout(() => {
    resolve('Promise 1 resolved');
  }, 100);
});

const promise2 = new Promise((resolve) => {
  setTimeout(() => {
    resolve('Promise 2 resolved');
  }, 200);
});

Promise.all([promise1, promise2])
  .then((results) => {
    console.log(results);
  });

// Result: ["Promise 1 resolved", "Promise 2 resolved"]

Vale destacar que, se qualquer uma das promises passadas for rejeitada, Promise.all assincronamente é rejeitada com o valor da promise rejeitada, independentemente se outras promises foram resolvidas.

const promise1 = new Promise((resolve) => {
  setTimeout(() => {
    resolve('Promise 1 resolved');
  }, 100);
});

let promise2 = Promise.resolve("Promise 2 rejected");

Promise.all([promise1, promise2])
  .then((results) => {
    console.log(results);
  }).catch(e=>{
    console.log(e)
  });

// Result: Promise 2 rejected

Encadeamento de promises

O encadeamento de promises permite executar uma série de tarefas assíncronas em uma ordem específica. Isso é útil quando você precisa executar uma tarefa após a conclusão de outra tarefa assíncrona. Para organizar essa sequência, utilizamos o manipulador .then(). É como se você chegasse para alguém dizendo: “Primeiramente, você precisa fazer isso, então faça aquilo, então faça esta outra coisa, então…, então…” e assim por diante.

⚠️ Atenção

Não esqueça de escrever um retorno dentro do .then(), caso contrário, ele não irá funcionar corretamente.

Vamos para um exemplo. Suponha que você precise buscar as informações do usuário e, em seguida, buscar as informações de seus pedidos. Você pode usar o encadeamento de promises para executar essas duas tarefas em ordem, esperando que a primeira seja concluída antes de executar a segunda.

const fetchUserData = (userId) => {
  return fetch(`https://api.example.com/users/${userId}`)
    .then(response => response.json());
};

const fetchUserOrders = (userId) => {
  return fetch(`https://api.example.com/users/${userId}/orders`)
    .then(response => response.json());
};

fetchUserData(1)
  .then(user => {
    console.log('Dados do usuário:', user);
    return fetchUserOrders(user.id);
  })
  .then(orders => {
    console.log('Pedidos do usuário:', orders);
  })
  .catch(error => {
    console.error('Ocorreu um erro:', error);
  });

A nossa saída será:

Dados do usuário: 
user: {
    // informações do usuário
}

Pedidos do usuário: 
orders: [
    {
        // informações do pedido 1
    },
    {
        // informações do pedido 2
    }
]

Erro handling

Uma regra de ouro é: “Seja responsável e faça o tratamento de erros corretamente”. Imagine o seguinte código abaixo:

function makeRequest() {
  try {
    fetch('foo')
      .then(response => {
        const result = JSON.parse(response);
        console.log(result);
      })
  } catch (error) {
    console.log(error);
  }
}

O try/catch não irá se capaz de lidar com o erro se o JSON.parse falhar. Isso está acontecendo dentro da promise. Nós devemos chamar o .catch para conseguir tratar esse erro:

function makeRequest() {
  try {
    fetch('foo')
      .then(response => {
        const result = JSON.parse(response);
        console.log(result);
      })
      .catch(error => {
        console.log(error);
      });
  } catch (error) {
    console.log(error);
  }
}

Finally handler

Nós temos algo chamado finally handler, que é chamado independente se nossa promise foi resolvida ou rejeitada. Digamos que a promise abaixo seja rejeitada:

fetch('foo')
    .then(() => {
        console.log("Consulta realizada com sucesso!");
    })
    .catch(() => {
        console.log("Erro ao consumir dados da API");
    })
    .finally(()=>{
      console.log("Fim da requisição!")
    })

A nossa saída será:

"Erro ao consumir dados da API"
"Fim da requisição!"

Conclusão

Bom pessoal, este é o fim da nossa série sobre Ecmascript 6. Terminamos essa série trazendo mais algumas informações sobre promises. Verificamos o funcionamento do Promise.all, que nos permite executar múltiplas promises simultaneamente. Também vimos a possibilidade de executar uma série de tarefas assíncronas em uma ordem específica, utilizando o encadeamento de promises. Além disso, lidamos com o tratamento de erros em promises de uma forma correta. Por fim, falamos sobre o finally, que nos permite executar algo independente se a nossa promise foi resolvida ou rejeitada. O que acho dessa série? Alguma sugestão? Nos vemos na próxima!

Para saber mais

Entendendo Promises: Como funcionam e seus benefícios em JavaScript

Ramon Borges — Thu, 06 Apr 2023 23:42:00 +0000

Introdução

Esse é o nosso penúltimo artigo da série Ecmascript 6. Iremos tratar sobre promises. Esse tema será dividido em duas partes. Nessa primeira, iremos falar sobre conceitos importantes e benefícios. A ideia é compartilhar algumas anotações minhas durante a leitura do livro EcmaScript 6 Succinctly, que me permitiram compreender um pouquinho sobre promises.

Compreensão

Explicação sobre como as Promises funcionam

Promises fornecem um padrão de implementação para lidar com programação assíncrona em Javascript sem a necessidade de usar callbacks. Uma promise representa um valor que nós podemos lidar em algum momento no futuro.

Para ficar mais claro, imagine que você é uma criança que pediu ao seu pai uma bola de presente. Ele lhe diz que irá te dar uma bola, mas não pode te entregar imediatamente, pois precisa comprá-la na loja. Ele então promete que trará a bola para você assim que puder.

Nesse exemplo, a promise é a promessa do pai de trazer a bola, que representa um valor (a bola) que você poderá lidar em algum momento no futuro (quando ele trouxer a bola para você).

Benefícios do uso de Promises em relação a outros métodos assíncronos

As promises oferecem benefícios significativos em relação aos callbacks, por exemplo. Uma das principais vantagens é que o contrato da promise é imutável, ou seja, nenhum outro handler registrado pode alterar o valor.

Aqui está um exemplo de código JavaScript que ilustra como uma promise pode ser usada para garantir que o valor seja recebido independentemente de quando um handler for registrado para ele:

let promise = new Promise((resolve, reject) => {
  // simula um valor que será retornado após 1 segundo
  setTimeout(() => resolve("valor retornado"), 1000);
});

// registra um handler para a Promise após 2 segundos
setTimeout(() => {
  promise.then((valor) => {
    console.log(`Valor recebido: ${valor}`);
  });
}, 2000);

// registra outro handler para a Promise imediatamente
promise.then((valor) => {
  console.log(`Outro valor recebido: ${valor}`);
});

Neste exemplo, uma promise é criada com uma função que retorna um valor após 1 segundo. Em seguida, dois handlers são registrados para a promise, um imediatamente e outro após 2 segundos. No entanto, como o contrato da promise é imutável, o valor retornado nunca será alterado e, portanto, ambos os handlers receberão o mesmo valor.

Além disso, com as promises, temos a garantia de receber o valor, independentemente de quando nos registrarmos para recebê-lo, mesmo que já esteja resolvido. Isso contrasta com os eventos, uma vez que, quando um evento é acionado, não é possível acessar o seu valor em um momento posterior.

E quando uma promessa não é cumprida?

Até agora, nós só resolvemos promises. Mas e quando rejeitamos uma? A rejeição de uma promise ocorre quando há algum problema para cumprir a promessa, como falha na conexão com um servidor ou algum erro no código.

Voltemos ao exemplo do pai e filho. Imagine que você é uma criança que pediu ao seu pai para ir ao parque de diversões. Ele concorda em levá-lo, mas diz que só poderá fazê-lo se não chover. No entanto, o tempo vira e começa a chover, o que significa que seu pai não pode cumprir sua promessa de levá-lo ao parque. Seu pai, então, rejeita sua promessa e explica que ele não pode cumprir o que havia prometido, pois as condições climáticas mudaram.

Nesse exemplo, a promise é a promessa do pai de levá-lo ao parque, e o reject é a decisão de não cumprir a promessa devido a uma condição não satisfeita (o mau tempo). No contexto do código, você pode tratar essa situação, usando o método catch() na promise, que permite capturar o erro e tratar a rejeição.

const promise = new Promise((resolve, reject) => {
  const a = 10;
  const b = 'abc';
  if (typeof a === 'number' && typeof b === 'number') {
    resolve(a + b);
  } else {
    reject('Os valores precisam ser números!');
  }
});

promise.catch(error => {
  console.error(error);
});

Conclusão

No geral, o uso de promises é uma forma eficiente e moderna de lidar com operações assíncronas em JavaScript. Comparado aos callbacks, as promises oferecem uma série de benefícios, como a imutabilidade do contrato da promise e a garantia de que receberemos o valor, mesmo se já tiver sido resolvido.

Além disso, aprendemos que uma promessa pode ser rejeitada, quando alguma condição básica não é atendida. Uma boa prática é utilizar o método catch a fim de tratar o erro (aprenderemos mais sobre tratamento de erros no próximo artigo).

Você já usou promises no seu código? Quando escrevia um código, tinha consciência do que estava fazendo? Deixa eu saber nos comentários, até a próxima!

Para saber mais acesse:

ECMAScript 6 Succinctly

Melhorando a manutenibilidade e escalabilidade do código com Módulos ES6

Ramon Borges — Wed, 22 Mar 2023 13:00:00 +0000

Continuando nossa série de artigos sobre ES6 (leia o último aqui), vamos falar hoje sobre módulos. O uso de módulos é uma das funcionalidades mais importantes introduzidas no EcmaScript 6.

Ele permite que você organize seu código em pequenos pedaços independentes, tornando ele mais modular e fácil de manter. Módulos fornecem suporte para exportar e importar valores sem poluir o namespace global.

Nós já tínhamos essa capacidade no JavaScript através de bibliotecas de terceiros como AMD e CommonJS, mas o ECMAScript 6, quando lançado, também trouxe essa habilidade.

Desenvolvimento

O recurso de exportação de módulos ES6 permite que você separe as preocupações em módulos diferentes, tornando o código mais modular. Por exemplo, você pode criar um módulo que contenha apenas funções de validação, outro que contenha funções para manipulação de dados e assim por diante.

export function validateCPF(cpf) {
    // code here
}

export function validateEmail(email) {
    // code here
}

export function transformToUTC(data) {
   // code here
}

Como os módulos são independentes, eles podem ser reutilizados em diferentes partes do projeto, o que beneficia a escalabilidade.

O recurso de exportação padrão (default) permite que você exporte um único valor ou objeto de um módulo, tornando mais simples a sua importação em outros lugares do código.


// tools.js
export default function calculator(x, y, option) {
    if (option === 1) {
        return sub(x, y);
    } else {
        return add(x, y);
    }
}

function add(x, y) {
    return x + y;
}

function sub(x, y) {
    return x - y;
}

import calculator from './tools.js';

console.log("Result: " + calculator(1, 3, 2));
// Result: 4

Ao utilizar o recurso de importação de módulos ES6, você pode usar o chamado wildcards. Ele permite que você importe um módulo inteiro e acesse todos os recursos por meio de uma notação * as algum-nome


// basic-operations.js
export function add(x, y) {
    return x + y;
}

export function sub(x, y) {
    return x - y;
}

export var pi = 3.1415;

import * as calc from './basic-operations.js';
console.log('Result: ' + calc.add(1, 2));

// Result: 3

Conclusão

Em resumo, os módulos ES6 são uma funcionalidade poderosa do JavaScript que podem melhorar significativamente a manutenibilidade e escalabilidade do código. Eles permitem uma melhor organização do código, simplificam o gerenciamento de dependências e permitem a reutilização do código em diferentes projetos e contextos. Com o uso correto dos recursos de exportação, importação, exportação padrão e wildcards, é possível criar um código mais modular, legível e fácil de manter.

Para mais informações

Ecmascript 6: Uma introdução

Ramon Borges — Wed, 08 Mar 2023 13:00:00 +0000

Introdução

Hoje, iniciaremos um pequeno mergulho dentro do Ecmascript 6. A ideia de criar essa série, veio depois de iniciar a leitura do e-book ECMAScript 6 Succinctly - By Matthew Duffield. Entendi que seria uma boa compartilhar minhas anotações e o que tenho aprendido sobre.

Este artigo é o primeiro de uma série de 3, que irá percorrer os recursos do Ecmascript 6.

Desenvolvimento

O ES6 possui uma série de features interessantes (falaremos nos próximos posts). Porém, nesse primeiro, iremos focar em algumas perguntas e conceitos introdutórios.

O que é ES6?

Ecmascript 6 (ES6) ou ECMAScript 2015 é a 6º edição do padrão de especificação da linguagem ECMAScript. Ela define quais são os padrões para a implementação de JavaScript (se você já utilizou o ecossistema Java, deve estar familiarizado com os conceitos de especificação e implementação).

Qual a diferença entre JavaScript e ES6?

Provavelmente, já deve ter ficado claro no parágrafo anterior. Mas para destacar, em poucas palavras, podemos dizer que ECMAScript é uma especificação de linguagem, ou seja, ela define os padrões para uma linguagem de programação, e o JavaScript é a implementação desses padrões.

Transpilação e ES6

Nem todos os navegadores suportam todas as features do ES6. Portanto, é necessário que o seu código ES6 seja transpilado para uma versão compatível com todos os navegadores. Transpilar significa simplesmente converter seu código ES6 para ES5, dessa forma ele poderá ser lido por todos os navegadores. O transpilador mais popular para ES6 é o Babel.

Conclusão

Neste artigo, nós aprendemos sobre o ECMAScript 2015 ou ES6, que é responsável por definir os padrões para implementação JavaScript. Nós também percebemos a diferença entre JavasScript e ES6. Por fim, aprendemos sobre o funcionamento do transpilador e sua utilidade para o ES6.

Espero que tenham gostado. Qualquer dúvida, sugestão ou correção, estou a disposição. Nos vemos no próximo post!

Fontes

ECMAScript 6 Succinctly - Matthew Duffield

3 estratégias para organizar nosso código de maneira mais profissional

Ramon Borges — Mon, 31 Jan 2022 23:40:08 +0000

A nossa principal tarefa como desenvolvedor é resolver problemas. A nossa principal ferramenta para alcançar essa meta é o nosso código.

Um código não profissional, tem o poder de nos atrasar consideravelmente, nos fazendo trabalhar mais lentamente. Além disso, nesse contexto de código ruim, qualquer alteração pode ser acompanhada de bugs. Isso é péssimo!

Como podemos superar isso? Como organizar o nosso código de maneira mais profissional?

Os amigos inseparáveis

Se em algum momento da vida teve contato com orientação a objetos, já deve ter ouvido falar sobre coesão e acoplamento. Estes são dois conceitos fundamentais neste paradigma. Idealmente, um bom código é composto de alta coesão e baixo acoplamento. Talvez, podemos dizer que uma das características de um código profissional esteja resumida nesta frase.

As 3 estratégias

Gostaria de listar três estratégias que certamente nos ajudarão na caminhada de produzir códigos com alta coesão e baixo acoplamento (ou seja, código mais profissional).

Nem tudo precisa estar público

Quanto mais aberto for cada um dos nossos contextos, mais a nossa base de código se tornará uma emaranhado de objetos. Certamente a manutenção desse código será mais difícil, já que existe uma ligação muito grande entre todo o código (alto acoplamento). Isso pode fazer com que a alteração em um ponto do sistema propague a necessidade de mudanças em outros. Nós precisamos resistir a tentação de deixar tudo público! Isso diminui as chances de criar dependências desnecessárias para as nossas classes.

Cada um no seu quadrado

Os pacotes devem conter todas as classes de um contexto específico. O código que serve a um propósito comum deve se manter unido. Isso mantém nosso código mais coeso. Baixa coesão significa que o código que compõem alguma funcionalidade pode estar espalhado por toda a base de código, em diversos contextos. Isso dificulta tanto a legibilidade como a manutenibilidade.

Programando para interfaces

Como então um contexto pode conversar com outro sem deixar todas as classes públicas? Uma das maneiras de resolver esse problema é permitir que os contextos se comuniquem através de interfaces e que na medida do possível, apenas elas sejam publicas. Ela será a porta de entrada do seu contexto.

Conclusão

Este foi um primeiro passo para o desenvolvimento de um código mais profissional. Certamente a aplicação dessas estratégias, permitirá desenvolver um código melhor, mais fácil de manter e mais adaptável a novos requisitos. Espero que tenha gostado do conteúdo, até a próxima 🤙!

📃 Para saber mais

Créditos foto: Fundo foto criado por evening_tao - br.freepik.com

Minha experiência no hacktoberfest 2020

Ramon Borges — Tue, 17 Nov 2020 21:32:07 +0000

Achei interessante compartilhar um pouco das minhas experiências durante a participação no hacktoberfest. Este post além de ser um registro histórico, onde poderei reviver as experiência que vivi, também tem o intuito de incentivar você a participar de eventos como esse. Bom, gostaria de iniciar falando um pouco sobre o que é o Hacktoberfest.

O que é o Hacktoberfest?

É um evento que dura todo o mês de outubro e tem o objetivo de celebrar a contribuição em projetos open-source. Este evento é aberto a todas as pessoas ao redor do mundo. Ele é organizado pela DigitalOcean (uma provedora americana de infraestrutura em nuvem).

Como funciona?

O primeiro passo é se inscrever no site do HacktoberFest. Pronto! A partir daí você está apto para iniciar a sua jornada em busca de no mínimo 4 pull requests em qualquer repositório do github classificado com o tópico HacktoberFest. Esses pull requests devem ser feitos durante o mês de outubro.

Encontrando repositórios para contribuir

A minha busca começou no dia 1 de outubro. Procurei alguns repositórios, mas sem sucesso. Uma semana depois, iniciei novamente a procura. Busquei por repositórios com o tópico hacktoberFest.

A partir daí, veriquei aqueles que estavam com alguma issue aberta, mas ainda sem alguém responsável pelo desenvolvimento. Inseri alguns filtros de acordo com as linguagens que tinha interesse (agrupei os repositórios filtrados neste link).

Depois de uma ligeira procura descobri o meu primeiro repositório: codeezzi/utility.

Minhas contribuições

codeezzi/utility

Utility foi criado para ser um site de conversão de unidades simples e fácil de usar, além de várias ferramentas utilitárias. Ele é um site estático feito totalmente com HTML, CSS e JS.

Resolvi duas issues nesse repositório:

Criar um conversor de velocidades.
Criar um gerador de séries matemáticas.

Este link dá acesso ao site estático.

Depois de realizar essas duas contribuições, encontrei um outro repositório chamado fengyuanyang/JavaTDD.

fengyuanyang/JavaTDD

JavaTDD é um repositório criado para incentivar os programadores a construírem código utilizando Test Driven Developer. Resolvi duas issues nesse repositório.

Finalmente, no dia 26 de outubro consegui o desejado 4º pull request!🎉

Pontos positivos

Contato com inglês

Todos nós que trabalhamos na área de tecnologia sabemos da importância do Inglês. No hacktoberfest, toda comunicação que realizei, seja para solicitar ao dono do projeto uma issue, escrever a mensagem dos commits e dos pull requests, ler as diretrizes de cada projeto eram feitas em inglês. Isso foi uma boa oportunidade de treinar o meu inglês.

Github

Já uso git há um tempão, mas não tinha muita segurança com o comando fork, pois geralmente nos projetos que trabalho nunca preciso usar. Durante esse mês de outubro foi possível exercitar mais esse processo de "forkear" um repositório.

Contato com outros programadores

Olha que interessante, o dono do repositório JavaTDD é de Taiwan e do repositório Utility é da Índia. Tive oportunidade de estar em contato com programadores de outras partes do mundo.

Desenvolvimento de habilidades fora do ambiente de trabalho

Durante um bom tempo da minha carreira, o meu aprendizado e a melhoria de minhas habilidades em programação vinham apenas dos problemas que enfretava no meu dia a dia de trabalho.

Durante esse hacktoberfest, por exemplo, tive a oportunidade de desenvolver algumas atividades utilizando JS, uma linguagem que não tenho tanto contato no meu dia a dia. No outro repositório, foi possível aplicar TDD, algo também que ainda não tinha aplicado no meu trabalho.

Conclusão

O Hacktoberfest 2020 chegou ao fim. Certamente foram 30 dias bem desafiadores. Cada pull request enviado e aceito gerava um sentimento de felicidade! A oportunidade de contribuir em repositórios e perceber que as suas contribuições foram úteis para alguém do outro lado do mundo, é muito bom.

Sem dúvida esse é um dos motivos que mais me fazem querer participar novamente. Já estou contando as horas para a próxima edição. Espero que você também esteja lá 😉. Até mais!!!