Forem: Textos em Português

Como eu uso IA de graça para transformar podcasts em lições práticas

Fabio Hiroki — Thu, 18 Sep 2025 15:43:45 +0000

Vamos ser honestos: o quanto do último podcast que você ouviu você realmente lembra?

Se você é como a maioria das pessoas, a resposta provavelmente é "não muito". Passamos horas toda semana consumindo conselhos incríveis e transformadores das pessoas mais inteligentes do mundo, apenas para que tudo desapareça de nossas mentes em 48 horas. A lacuna entre ouvir e fazer é gigantesca.

Aqui está o truque de IA gratuito que eu uso para consertar isso.

O Truque: De Podcast a Plano de Ação em 60 Segundos

Aqui está o único passo que você precisa:

Pegue a URL do YouTube do podcast que você quer analisar.
Abra o NotebookLM do Google e clique em “Create New“ (Criar Novo).
Clique em “Youtube” e cole a URL como uma nova fonte.
Use este prompt no chat:

Você é um analista de tecnologia especialista em traduzir conceitos amplos em conselhos acionáveis para engenheiros de software. Meu objetivo é extrair as ideias mais relevantes e aplicáveis desta fonte para o meu trabalho.

Instruções:
Analise a fonte fornecida da perspectiva de um engenheiro de software. Identifique os 3 principais conceitos, modelos mentais ou estratégias que são mais aplicáveis ao campo da engenharia de software.

Para cada conceito que você identificar, apresente-o usando a seguinte estrutura clara e concisa. Não me faça perguntas; forneça a informação diretamente.

🚀 Conceito 1: [Nome do Conceito]

Explicação Simples: Em 1-2 frases, o que é este conceito em termos simples, de acordo com o podcast? Forneça uma citação direta do palestrante que melhor encapsula a ideia.

Relevância para Engenheiros: Por que este conceito é particularmente relevante para o desenvolvimento de software, dinâmica de equipe, resolução de problemas ou arquitetura de sistemas?

Aplicação Prática: Forneça um exemplo concreto de como posso aplicar este conceito no meu trabalho esta semana. (ex: uma pergunta a ser feita em uma revisão de código, um princípio para projetar uma nova funcionalidade, uma maneira de me comunicar com minha equipe).

A verdadeira mágica aqui está na primeira linha: "Você é um especialista..." Isso é chamado de "prompt com persona", e é a chave para obter resultados hiper-relevantes.

Você pode, e deve, alterar isso para se adequar à sua própria vida e trabalho. Dica Pro: Você pode usar uma LLM para editar o prompt para você.

Colocando à Prova: Um Exemplo do Mundo Real

Eu executei exatamente esse fluxo de trabalho em um podcast recente de Lenny Rachitsky sobre o Mercado Livre:

Aqui está o resultado do NotebookLM:

Como um analista de tecnologia especialista, analisei a fonte fornecida para identificar os conceitos mais relevantes e aplicáveis para engenheiros de software. Aqui estão os três principais, apresentados com conselhos práticos para o seu trabalho:

🚀 Conceito 1: Propriedade Integrada de Produto e Engenharia

Explicação Simples: No Mercado Livre, há uma indefinição deliberada das linhas entre as funções de engenharia e produto, com uma forte ênfase nos engenheiros assumindo uma propriedade significativa das decisões de produto. O objetivo não é determinar a propriedade pelo cargo, mas por quem é mais adequado para a função, muitas vezes os próprios líderes de engenharia. Como afirma Sebastian Barrios, “é difícil separar onde a engenharia para e o produto começa, e não sentimos que apenas ter um título deveria determinar quem é o dono”.
Relevância para Engenheiros: Este conceito é profundamente relevante para o desenvolvimento de software porque impulsiona os engenheiros para além da mera implementação técnica, para uma compreensão holística do produto, dos usuários e das necessidades do negócio. Ele fomenta um senso mais profundo de responsabilidade pelo sucesso do produto, garantindo que a viabilidade técnica se alinhe perfeitamente com o valor para o usuário e os objetivos de negócio. Espera-se que os engenheiros combinem a compreensão do “que é tecnicamente possível” com “quais são as necessidades do negócio, quais são as necessidades dos usuários, o que os usuários estão fazendo, como vou medir isso”.
Aplicação Prática: Ao projetar ou implementar uma nova funcionalidade esta semana, envolva-se ativamente com seu contexto de negócio e de usuário. Antes de escrever o código, pergunte a si mesmo: “Como o usuário experimentará esse fluxo, e ele o está entendendo?”. Considere o impacto pretendido da funcionalidade no usuário e como seu sucesso seria medido, em vez de focar apenas nos requisitos técnicos.

🚀 Conceito 2: Viés por Expertise Técnica Profunda

Explicação Simples: O Mercado Livre valoriza muito os engenheiros que possuem conhecimento técnico profundo e estão intimamente familiarizados com os detalhes da tecnologia que usam. Há um “forte viés para a engenharia, para ser técnico, para estar a fundo nos detalhes”. Isso significa uma baixa tolerância para compreensão superficial ou para depender de outros para especificidades técnicas.
Relevância para Engenheiros: Para engenheiros de software, este modelo mental enfatiza a importância crítica do domínio técnico. Ele promove a construção de sistemas robustos e escaláveis e permite que os engenheiros liderem discussões de forma eficaz, sem precisar consultar outros para obter informações técnicas fundamentais. Essa compreensão técnica profunda é crucial para a resolução eficiente de problemas, decisões de arquitetura e manutenção de uma alta qualidade nas implantações.
Aplicação Prática: Em sua próxima discussão técnica ou revisão de código, esteja preparado para articular os detalhes técnicos subjacentes da sua solução ou de um componente que você está revisando. Em vez de dizer “preciso verificar com fulano para entender os detalhes,” esforce-se para fornecer você mesmo uma explicação abrangente da tecnologia, suas escolhas e suas implicações.

🚀 Conceito 3: Incentivo à Tomada de Risco e Aprendizado com Falhas de 'Mercado'

Explicação Simples: A empresa fomenta uma cultura onde as equipes são encorajadas a correr riscos e não são penalizadas por lançar funcionalidades que possam falhar devido à recepção do mercado ou a ideias falhas. Sebastian Barrios afirma, “nós realmente empoderamos nossas equipes para cometer erros, tipo, ninguém vai ser demitido por lançar algo que não funcionou no sentido de que talvez o mercado não estivesse pronto ou tivéssemos a ideia errada sobre onde implementar”. Isso contrasta com uma baixa tolerância a falhas relacionadas à má qualidade ou a interrupções do sistema.
Relevância para Engenheiros: Essa estratégia é vital para a inovação no desenvolvimento de software. Ela permite que os engenheiros experimentem novas ideias e funcionalidades, fomentando a criatividade e um ciclo de aprendizado rápido, sem o medo paralisante de repercussões negativas por resultados fora da qualidade técnica. Ela apoia diretamente uma “alta velocidade de execução” em um mercado dinâmico, priorizando o aprendizado e a adaptação.
Aplicação Prática: Esta semana, ao propor uma nova funcionalidade ou uma mudança significativa, enquadre-a como um experimento com hipóteses claras sobre a recepção do usuário ou do mercado. Seja explícito sobre as suposições que estão sendo testadas e como o sucesso ou o fracasso (em termos de adequação ao mercado, não de qualidade técnica) fornecerá um aprendizado valioso para iterações futuras. Essa abordagem encoraja visões ousadas e pivôs rápidos se as suposições iniciais se mostrarem incorretas.

Apenas a Ponta do Iceberg

E esse é o cerne do truque. É um sistema simples e repetível para transformar o consumo passivo em crescimento ativo.

O NotebookLM é uma ferramenta poderosa que pode fazer muito mais, mas eu queria manter este artigo curto e focado no único fluxo de trabalho que mais me deu resultados.

Se você achou isso útil e está interessado em mais conteúdo como este, por favor, me avise! A melhor maneira de fazer isso é deixar um comentário ou clicar no botão 👏 abaixo.

Ficarei feliz em compartilhar mais dicas e truques sobre como uso IA para aprendizado e produtividade. Me diga o que você gostaria de ver a seguir.

Perseguindo uma Vida Melhor: Como Consegui um Emprego em Tecnologia no Exterior

Fabio Hiroki — Tue, 17 Jun 2025 15:43:54 +0000

Você já sonhou em se mudar para outro país — começar do zero em um lugar novo, com novas oportunidades e uma melhor qualidade de vida? Para muitos engenheiros de software, a ideia de trabalhar no exterior é ao mesmo tempo empolgante e intimidadora. Eu sei, porque já passei por isso.

Nasci e cresci no Brasil, um país em desenvolvimento onde, mesmo como engenheiro de software, a vida traz seus próprios desafios. Embora a profissão possa oferecer um salário confortável, o dia a dia era frequentemente ofuscado por preocupações com segurança — coisas simples como usar o celular em público ou caminhar para casa à noite se tornavam fontes de ansiedade. Quando comecei a pensar em formar uma família, essas preocupações cresceram ainda mais. Eu sabia que não queria que meu filho crescesse em um lugar onde a segurança estivesse sempre na minha mente.

Então veio a pandemia, que só aumentou minha frustração e sensação de inquietação. Foi então que tomei uma decisão: buscar oportunidades no exterior, em países que oferecessem não apenas um emprego, mas uma vida mais segura e equilibrada.

Neste artigo, compartilharei minha jornada, desde o planejamento e a preparação até a busca por emprego — até o momento em que recebi minha primeira oferta. Se você já considerou fazer uma mudança semelhante, ou se está apenas curioso sobre o que é necessário para se mudar como engenheiro de software, espero que minha história inspire e oriente você.

Planejamento e Pesquisa: Mantendo Simples

Olhando para trás, admito que minha fase de planejamento não foi tão meticulosa quanto alguns recomendariam. Não passei meses comparando todos os países ou construindo planilhas detalhadas. Em vez disso, adotei uma abordagem mais direta — alguns diriam até imprudente.

Meus principais critérios eram simples:

Empresas em países desenvolvidos
Patrocínio de visto disponível
Bom equilíbrio entre trabalho e vida pessoal

Com esses filtros em mente, concentrei minha busca de emprego na Europa. Pulei as análises profundas de comparações de custo de vida e caminhos complexos de imigração — pelo menos no início. Minha prioridade era encontrar empresas dispostas a patrocinar meu visto, já que esse era o maior obstáculo para a mudança.

Claro, à medida que comecei a receber respostas de empregadores e aprendi mais sobre o processo, comecei a pesquisar os detalhes — como salários locais, sistema de saúde e como seria a vida em cada cidade. Mas, no começo, deixei meu desejo por uma vida mais segura e equilibrada me guiar, mantendo o planejamento intencionalmente simples para evitar me sentir sobrecarregado.

Olhando para trás, percebo que, embora um plano mais detalhado pudesse ter ajudado, às vezes tomar ação é o passo mais importante. Para quem está pensando em fazer uma mudança semelhante, não deixe o perfeccionismo te impedir de começar. Você sempre pode refinar seu plano ao longo do caminho.

Preparação e Busca de Emprego: Preparando-se e Agindo

Com a Europa como meu alvo e o patrocínio de visto como uma exigência, meu próximo passo foi preparar meus materiais de candidatura e começar a buscar oportunidades.

Atualizando Meu Currículo e Presença Online

Eu sabia que um currículo forte e um perfil no LinkedIn eram cruciais para chamar a atenção dos recrutadores. Atualizei ambos para incluir métricas específicas que demonstravam o impacto do meu trabalho. Em vez de apenas listar responsabilidades, adicionei números e resultados — como melhorias no desempenho de aplicativos, redução de tempo de inatividade ou aumento no engajamento de usuários. Isso ajudou a mostrar aos recrutadores não apenas o que fiz, mas como meu trabalho fez a diferença.

Focando em Empresas que Patrocinam Vistos

Concentrei minha busca de emprego em empresas na Europa que ofereciam patrocínio de visto. Usei quadros de empregos e filtros para identificar essas oportunidades e prestei atenção às avaliações de empresas e ao equilíbrio entre trabalho e vida pessoal.

Começando Antes de Me Sentir Totalmente Preparado

Embora eu não me sentisse 100% preparado para as entrevistas, decidi começar a me candidatar mesmo assim. Sabia que esperar o “momento perfeito” poderia significar perder oportunidades reais. Todas as minhas entrevistas foram em inglês, que não é minha língua materna, então essas primeiras entrevistas se tornaram sessões de prática extremamente valiosas. Elas me ajudaram a ficar confortável falando sobre minha experiência e habilidades em um ambiente profissional — algo que eu não fazia muito antes. Essa experiência aumentou minha confiança e habilidades de comunicação, mesmo enquanto continuava a estudar e melhorar. Reconheço que essa abordagem não funciona para todas as empresas, especialmente aquelas com processos de recrutamento longos ou altamente competitivos. Mas, para mim, agir cedo foi uma forma de aprender fazendo, em vez de esperar até me sentir completamente pronto.

Lidando com Candidaturas e Entrevistas: Aprendendo na Prática

Uma vez que comecei a me candidatar, o processo real começou. Cada candidatura exigia atenção cuidadosa, mas as entrevistas foram onde as coisas ficaram interessantes — e, às vezes, desafiadoras.

O Processo de Candidatura

Sempre que havia a opção de enviar uma carta de apresentação, eu aproveitava para personalizá-la de acordo com os produtos, missão e objetivos da empresa. Aprendi que uma carta de apresentação bem elaborada e personalizada pode fazer uma grande diferença — ela ajuda você a se destacar entre outros candidatos e mostra aos recrutadores que você fez sua lição de casa e está genuinamente interessado em contribuir para o sucesso da empresa.

Experiências em Entrevistas

Todas as minhas entrevistas foram em inglês, o que adicionou uma camada extra de complexidade. Meu inglês estava longe de ser “perfeito”, e às vezes eu não entendia completamente o que o entrevistador dizia. Mesmo assim, consegui me comunicar bem o suficiente para transmitir minhas ideias. Na maioria das vezes, os entrevistadores foram pacientes e compreensivos.

Essa experiência me ensinou que você não precisa esperar até que seu inglês esteja perfeito para começar a fazer entrevistas. O que importa é ser capaz de se expressar com clareza e confiança, mesmo que cometa erros ao longo do caminho.

Enquanto me candidatava, também estudava todos os dias — praticar algoritmos, estruturas de dados, design de sistemas e perguntas comportamentais se tornou parte da minha rotina. Durante as entrevistas, prestei muita atenção à linguagem corporal e às reações dos entrevistadores. Se uma resposta minha não gerava uma reação positiva ou parecia errada, eu considerava isso um feedback indireto. Isso me ajudou a identificar áreas onde precisava melhorar e a focar meus estudos para entrevistas futuras.

Aprendendo com Rejeições

Nem toda entrevista resultou em uma oferta. Houve rejeições, e às vezes o feedback era difícil de ouvir. Mas tentei ver cada uma como uma oportunidade de aprendizado. Prestei atenção às perguntas com as quais tive dificuldade e as usei para guiar minhas sessões de estudo. Com o tempo, fiquei melhor em antecipar o que os entrevistadores queriam e como me apresentar como um candidato forte.

Recebendo uma Oferta e Reflexões

Após semanas de candidaturas, entrevistas e muito estudo, finalmente recebi uma oferta de uma empresa na Europa. Esse momento marcou um marco importante na minha jornada — não apenas porque significava que eu poderia me mudar, mas porque validou todo o esforço e persistência que investi.

A Oferta e o Que Ela Significou

Quando a oferta chegou, senti uma mistura de empolgação e alívio. Depois de tanta incerteza — especialmente como alguém que nunca havia vivido ou trabalhado no exterior antes —, foi reconfortante saber que minhas habilidades e experiência foram reconhecidas. A empresa estava disposta a patrocinar meu visto, o que significava que eu poderia finalmente começar a planejar minha mudança e um novo capítulo para minha família.

Olhando para Trás no Processo

Olhando para trás, percebi o quanto aprendi — não apenas sobre tópicos técnicos, mas sobre mim mesmo e do que sou capaz. Superei barreiras linguísticas, me adaptei a diferentes estilos de entrevista e lidei com rejeições com resiliência. Cada passo, mesmo os mais difíceis, me tornou mais forte e mais preparado para os desafios à frente.

Principais Lições

Aqui estão as lições mais importantes que aprendi ao longo do caminho:

Comece Antes de Estar Pronto: Não espere o “momento perfeito”. Comece a se candidatar e fazer entrevistas o quanto antes — você aprenderá e melhorará com cada experiência.
Personalize Sua Candidatura: Sempre envie uma carta de apresentação personalizada quando possível. Mostre aos recrutadores que você entende a empresa e como pode contribuir.
Use Entrevistas como Prática: Mesmo que esteja nervoso ou seu inglês não seja perfeito, use cada entrevista como uma chance de aprender e crescer.
Preste Atenção ao Feedback: Observe as reações dos entrevistadores e use-as como feedback indireto para guiar seus estudos e preparação.
Permaneça Persistente: Rejeições fazem parte do processo. Aprenda com elas, ajuste sua abordagem e continue.

Este artigo é uma visão geral da minha experiência em conseguir um emprego no exterior. Se você quiser que eu mergulhe mais fundo em alguma parte específica — como estudei, como organizei minhas candidaturas, como gerenciei meu tempo enquanto trabalhava em tempo integral, ou qualquer outro tópico —, por favor, deixe um comentário! Seu feedback me ajudará a decidir no que focar em artigos futuros.

Vamos aprender e crescer juntos!

Curso gratuito de Typescript 2025 - Aula 002

Leandro Lopes — Sun, 05 Jan 2025 20:17:40 +0000

Na aula anterior, configuramos nosso ambiente de desenvolvimento e mergulhamos nos Tipos Primitivos do Typescript.

Na aula de hoje, vamos aprender a trabalhar com Objetos e Arrays em Typescript.

Introdução

Nessa aula, vamos aprender sobre Objetos e Arrays em Typescript. Vamos explorar diferentes formas de como podemos criar objetos e arrays em nossos projetos com Typescript.

Objetos Literais

Uma das formas mais simples de criar um objeto é através de objetos literais. Essa abordagem é particularmente útil quando você já tem conhecimento prévio das propriedades do objeto, uma vez que não é possível adicionar novas propriedades posteriormente.

const objeto = {
  chaveA: 'value',
  chaveB: 'value',
};

objeto.chaveC = 'value';

Index Signature

Uma forma de criar objetos dinâmicos é utilizando Index Signature. Essa abordagem é especialmente útil quando não sabemos antecipadamente quais serão as propriedades do objeto.

const objeto: { [key: string]: string } = {
  chaveA: 'value A',
  chaveB: 'value B',
};

objeto.chaveC = 'value C';

console.log(objeto);

Record

Outra forma que temos de criar objetos dinâmicos em Typescript é utilizando Record. O Record é um dos Utility Type da caixa de ferramentas do Typescript. Vamos explorar mais sobre os Utility Types mais adiante. Por enquanto, o que você precisa saber é que ao utilizar Record, precisamos especificar o tipo para a chave (key) e para o valor (value) do objeto entre <>.

const objeto: Record<string, string> = {
  chaveA: 'value A',
  chaveB: 'value B',
};

Array Literais

A forma mais simples de criar um array é usando um array literal, que é uma lista de elementos separados por vírgulas dentro de colchetes.

const arrayDeNumeros: number[] = [1, 2, 3];
const arrayDeString: string[] = ['Josh', 'Patrick', 'Lamar'];
const arrayDeStringENumeros: (string | number)[] = [1, 'Alice', 55];

console.log(arrayDeString);
console.log(arrayDeNumeros);
console.log(arrayDeStringENumeros);

Array Constructor

Você também pode usar o construtor Array para criar um novo array.

const arrayDeNumeros: Array<number> = [1, 2, 3];
const arrayDeString: Array<string> = ['Josh', 'Patrick', 'Lamar'];
const arrayDeStringENumeros: Array<string | number> = [1, 'Alice', 55];

console.log(arrayDeString);
console.log(arrayDeNumeros);
console.log(arrayDeStringENumeros);

Você pode acessar o código da aula, acessando o link abaixo:
https://github.com/d3vlopes/curso-typescript/tree/aula-002

Próxima aula

Na próxima aula, vamos explorar as funções em Typescript. Vamos aprender como definir o tipo dos parâmetros, tipo de retorno e muito mais!

Deixe um comentário e compartilhe essa publicação com sua rede para dar uma força e ajudar mais pessoas a aprender Typescript.

Curso gratuito de Typescript 2025

Leandro Lopes — Sun, 05 Jan 2025 19:52:08 +0000

Para ajudar você a conquistar seus objetivos em 2025 como Desenvolvedor de Software, estou disponibilizando um curso completo de Typescript totalmente GRATUITO!

📚 O que você vai aprender?
🔷 Aula 001 - Tipos Primitivos
🔷 Aula 002 - Objetos e Arrays
🔷 Aula 003 - Funções
🔷 Aula 004 - Outros tipos
🔷 Aula 005 - Union Types, Type Assertion e Literal Types
🔷 Aula 006 - Inferência de tipo
🔷 Aula 007 - Interface e Types
🔷 Aula 008 - Generics
🔷 Aula 009 - Utility Types
🔷 Aula 010 - Classes (Parte 1)
🔷 Aula 011 - Classes (Parte 2)
🔷 Aula 012 - Dicas Extras
🔷 Aula 013 - Desafio prático

Você vai aprender tudo que você mais vai utilizar ao trabalhar com Typescript no seu dia a dia de forma prática.

Se você já conhece Javascript, o Typescript será um divisor de águas na sua carreira, trazendo mais segurança e escalabilidade ao seu código.

Setup

Antes de iniciar a aula, precisamos primeiro configurar o setup do nosso ambiente de desenvolvimento, instalando e configurando algumas ferramentas que vamos utilizar.

Instalação do Node

Se você não tiver o Node instalado em sua máquina, você pode acessar https://nodejs.org/en/download e fazer a instalação conforme o seu sistema operacional.

Instalação do VS Code

Irei utilizar o VS Code como editor, você pode baixar ele acessando https://code.visualstudio.com.

Instalação do Typescript

Com o Node instalado, podemos inciar o projeto e configurar o Typescript.

Crie uma pasta e abra o terminal nessa pasta recém criada e rode o seguinte comando pressionando ENTER:

npm init -y && code .

O comando irá criar um arquivo package.json e abrir o VS Code na pasta. No VS Code click em View > Terminal para abir o terminal integrado.

Agora, no terminal integrado do VS Code, rode o seguinte comando:

npm i -D typescript

Esse comando vai instalar o Typescript como uma dependência de desenvolvimento no nosso package.json.

Crie um arquivo chamado tsconfig.json e adicione a seguinte configuração ao arquivo:

{
  "compilerOptions": {
    "rootDir": "./src",
    "outDir": "./dist",
    "target": "ES2020",
    "strict": true,
    "noEmitOnError": true
  }
}

O arquivo tsconfig.json serve para configurar o compilador do Typescript, existe diversas configurações que podemos fazer, nesse momento estamos interessado apenas nas seguintes configurações:

rootDir - Define o caminho para os arquivos Typescript.
outDir - Define a pasta de saida para os arquivos Javascript.
target - Define a versão do Javascript que o compilador deve utilizar para compilar os arquivos.
strict - Habilita o strict mode.
noEmitOnError - Não executa a compilação, caso tenha algum erro de tipo.

Você pode conhecer todas as opções disponíveis, acessando https://www.typescriptlang.org/docs/handbook/compiler-options.html

Acesse o arquivo package.json e crie um novo script para build com o comando:

npx tsc && node ./dist/index.js

O navegador assim como o Node não entende Typescript, precisamos compilar o código Typescript para Javascript para que ele possa entender e executar. Esse comando vai compilar nosso código Typescript para Javascript para que a gente possa executar ele no Node.

Lembre-se, no fim todo o nosso código Typescript vai virar Javascript. Typescript é apenas uma ferramenta utilizada no desenvolvimento para melhorar a segurança de tipo e escalabilidade do nosso código.

Para finalizar, crie uma pasta chamada src e um arquivo index.ts com o seguinte código:

console.log('Hello World')

Agora, vamos testar se está tudo funcionado. Abra o terminal e rode:

npm run build

Ao rodar, se tudo estiver certo, você deve ver no terminal Hello World.

Sempre que quiser ver algo no console, vai ser preciso rodar esse comando para compilar o arquivo para Javascript, beleza?

Tipos primitivos

Em TypeScript, existem seis tipos primitivos que são: string, number, boolean, symbol, bigint, null e undefined.

const nome: string = 'Leandro'; // Qualquer tipo de string: '' "" ``
const idade: number = 10; // 10, 1.57, -5.55
const adulto: boolean = true; // true ou false
const simbolo: symbol = Symbol('symbol-id');
const big: bigint = 10n;
const nulo: null = null;
const indefinido: undefined = undefined;

String

Uma string é qualquer coisa entre aspas. Pode ser aspas simples ('’), duplas ("”) ou crase ().

Number

Aqui não tem distinção: inteiros, decimais, positivos, negativos, tudo é tratado como number.

Boolean

O clássico verdadeiro ou falso.

Symbol

Um pouco abstrato, mas symbol é um identificador único. Pense nele como uma impressão digital para objetos.

Bigint

Se um number já é grande, o bigint é quase infinito. Use para lidar com números que nem calculadora científica resolve.

Null

Representa uma variável que não possui valor.

Undefined

Representa um valor não inicializado.

Você pode acessar o código da aula, acessando o link abaixo:
https://github.com/d3vlopes/curso-typescript/tree/aula-001

Próxima aula

Na próxima aula, vamos aprender sobre Objetos e Arrays em Typescript.

💡 Dúvidas ou problemas?
Teve algum problema com a configuração do setup? Ficou com alguma dúvida sobre a aula? Coloca aqui nos comentários, vamos juntos construir um material de qualidade e acessível a todos.

Usei o Android sem apps Google por dois meses 📱

Higor Silva — Wed, 27 Dec 2023 01:21:35 +0000

Texto originalmente escrito em 29 de janeiro de 2022

No dia 27 de novembro, comecei minha jornada um tanto estranha para quem é de fora do mundo da tecnologia: Comecei a usar o Android (que é um sistema da Google) sem os apps da Google. O quão bizarro ou maravilhoso pode ser usar o sistema do robozinho verde mais privativo? Essas são minhas conclusões:

Mas afinal, qual o motivo dessa experiência?

O ponto é simples: abra o “My Activity” da sua conta na Google e veja tudo o que você fez. Reconhece aqueles aplicativos que você abriu? Como o Google sabe de tudo isso? Como ele coleta esses dados e pra quê ele usa isso?

Existe uma forma para que a Google pare de coletar meus dados? A resposta é sim, mas exige alguns passos mais avançados. Então basta eu trocar meu sistema operacional, certo? Bem…

Quando o assunto é sistemas operacionais mobile, você deve imaginar em apenas dois nomes: O Android e o iOS (também conhecido como “o do iPhone”). Ambos são muito práticos e são os sistemas que todas as pessoas estão acostumadas a usar no seu dia a dia. Mas existem outros também, embora sejam mais para nichos e usos específicos.A maioria deles são baseados em Linux, como o Ubuntu Touch, o PureOS da Librem, Sailfish OS e o postmarketOS.

Mas uma coisa que esses sistemas alternativos pecam é na comodidade. Vários apps não possuem uma versão para aquele sistema operacional. WhatsApp, Uber, entre outros não existem. Você pode instalar uma camada de compatibilidade do Android, mas envolve processos mais avançados e em casos extremos, é necessário até patchear/recompilar o kernel.

Agora se você usar Android, nem precisa se preocupar com isso. Basta baixar o app e usar. Mas o Google vai continuar coletando dados. É aqui que temos o pulo do gato.

Segundo ponto: Privacidade sem largar a comodidade

Muitos aplicativos necessitam do Google Play Services, um app da Google que funciona como um conjunto de bibliotecas para os apps funcionarem… Ok, vejamos de outro modo.

Para alguns apps funcionarem, eles necessitam de alguns códigos que só existem no Google Play Services. Acesso a GPS, uso de alguns serviços na nuvem, etc. Sem o Google Play Services, o seu Uber não vai detectar sua localização e seu WhatsApp não vai receber notificação. Você só receberá mensagens quando abrir o app. Bem incoveniente, né?

Para contornar esse problema, existe um substituto ao Play Services: O Projeto MicroG, mantido pelo desenvolvedor alemão Marvin Wißfeld. Essa implementação é de código aberto e não conta com os rastreadores da Google. Existem algumas formas de instalação, mas…

Terceiro ponto: O sistema funcionaria de forma idêntica ao original. Porém…

Entrando em termos mais técnicos, o que fiz foi: Baixar a variante da LineageOS (sistema operacional baseado no Android Open Source Project) chamada LineageOS for MicroG. Explico mais sobre como fazer isso em um post futuro.

Baixando o LineageOS for MicroG, tudo já vinha configurado. Bastava “flashear” o sistema e tudo certo. E… Foi exatamente isso que aconteceu. Não foi necessário configurar mais nada, só precisei logar minha conta da Google para o YouTube.

A loja de aplicativos não é a Play Store, mas por padrão vem o F-Droid: Uma loja de aplicativos Android com o diferencial de ter apenas aplicativos de código aberto. E não, você não encontrará o WhatsApp, por exemplo. Para isso, é necessário o download de outra loja: Aurora Store. Nele, você pode logar em uma conta anônima e usar a Play Store sem rastreio algum. Todos os aplicativos estão lá.

Inclusive, caso queira substituir aplicativos proprietários para código aberto, você pode conferir esse guia no GitHub.

Após algumas semanas usando o Android dessa maneira, algumas coisas curiosas aconteciam. App do Uber simplesmente parou de pegar minha localização. Minha cidade não é lá tão grande mas caso eu estivesse em um local desconhecido, teria que usar métodos neandertais para me localizar: Pedir informação.

Da mesma maneira que o Uber me deixou na mão, o WhatsApp parou de receber notificação. Algumas mensagens urgentes eu simplesmente não via pois não tenho costume de abrir o WhatsApp a não ser que eu receba notificação ou queira mandar mensagem pra alguém. Mas notificações não chegavam, o que me forçava abrir o app algumas vezes e me deparar com mensagens de uma hora atrás no limbo.

Como quis me desapegar de aplicativos do Google, usei outros alternativos daquela lista lá. Todos funcionam muito bem e alguns uso até hoje depois da experiência. Mas eu uso bastante meu computador e os serviços da Google funciona tudo pela nuvem. Um texto que escrevi no Google Keep poderá ser acessado depois no meu computador e vice versa. Eu tive que abrir mão disso e foi bem sofrido.

Outro ponto negativo foi que o app que gerencia o MicroG simplesmente não abria mais. Caso eu quisesse adicionar uma nova conta do Google, não poderia. Ligar/desligar algumas funções? Esquece.

Conclusão: Valeu a pena?

Se você quiser mais privacidade e considera o uso das bibliotecas da Google pelo MicroG, esteja ciente que tem altas chances de que nem tudo irá funcionar. Algumas vezes é necessário apenas marcar uma opção nas configurações, outras nem solução você terá. Não tenho nada contra a Google e uso seus serviços sem problema nenhum.

Na minha experiência houve mais contras do que prós, então não tive problema em voltar a usar meu celular como sempre usei. Inclusive, em um próximo post eu mostro como é meu celular, meus aplicativos e como organizo minha vida digital.

Abraços e se cuidem.

Autenticação no Next.js com Usuário e Senha e criando Rotas Privadas.

Paulo Ricardo F. S. Junior — Mon, 20 Jun 2022 19:46:51 +0000

Introdução

Autenticação de usuários e acesso restrito a rotas privadas é fundamental para qualquer aplicação, neste artigo/guia vou descrever o passo a passo para realizar a autenticação de usuários que estejam cadastrados na sua base de dados, e que seja necessário realizar o login através de um backend personalizado ou API externa com um login de e-mail e senha.

Recentemente estava desenvolvendo um projeto, onde surgiu essa necessidade, e pesquisando sobre o assunto, notei que não existem conteúdos com exemplos claros, principalmente se precisar tratar os erros do backend personalizado na sua pagina de login, então decidi juntar essas informações em um único artigo.

Para iniciar o exemplo, vou partir da premissa de que você já possui uma aplicação Next.js com a estrutura do NextAuth. Caso não, você pode iniciar um novo projeto e configura-lo de forma simples com esse guia:

Getting Started | NextAuth.js

The example code below describes how to add authentication to a Next.js app.

next-auth.js.org

Estrutura de Pastas

Seguindo os padrões do Next.js você tem:

📁 pages

📁 api

📁 auth

[…nextauth].ts

Login com Email e Senha

pages/api/auth/[…nextauth].ts

O arquivo nextauth é o responsável por realizar o login, nele vamos configurar os providers, no caso do exemplo, vamos utilizar o Credentials Provider, pode ser configurado outros providers junto com o Credentials Provider, você pode consultar em: Next

Precisamos adicionar no arquivo […nextauth].js, cada parte será explicada posteriormente:



export default NextAuth({
  providers: [
    CredentialProvider({
      name: "credentials",
      credentials: {
        email: {
          label: "Email",
          type: "email",
          placeholder: "Email: exemplo@exemplo.com",
        },
        password: { label: "Senha", type: "password" },
      },
      authorize: async (credentials) => {
        try {
          const user = await api.post("/users/getByEmail", {
            email: credentials.email,
            password: credentials.password,
          });

          if (user) {
            const userAccount = user.data;

            return userAccount;
          } else {
            return null;
          }
        } catch (error) {
          const message = error.response.data.message; 
          throw new Error(message);
        }
      },
    }),
  ],
  callbacks: {
    jwt: async ({ token, user }) => {
      if (user) {
        token.id = user.id;
      }

      return token;
    },
    session: ({ session, token }) => {
      if (token) {
        session.id = token.id;
      }
      return session;
    },
  },
  secret: "jwttoken",
  pages: {
    signIn: "/login", 
    error: "/login", 
  },
  jwt: {
    secret: "jwttoken",
  },
});

Name: Nome a ser exibido no formulário de login;

Credentials: As credenciais são usadas para gerar o formulário na pagina de login, se não tiver uma pagina de login personalizada, o NextAuth cria uma pagina, basta acessar: localhost:3000/api/auth/SignIn. Pode Especificar os campos que espera que sejam enviados ex.: dominio, nome de usuario, senha etc. Essa pagina é padrão do Next Auth. Se possuir uma pagina de login personalizada redirecionaremos o usuário posteriormente.

Authorize: Função que faz a chamada API para realizar o login, é nessa função que vai a lógica para consultar o backend personalizado, ou até mesmo acessar uma rota criada nas API Routes da sua aplicação Next.js

Nessa função o retorno caso a resposta do seu backend ou API sejam inválidos, deve ser nulo.
O Next Auth espera no retorno dessa função um objeto de User ou NULO.
No exemplo eu realizei a consulta na rota definida dentro de um TRY CATCH, faço uma verificação condicional, se existir o usuário eu retorno ele, se não, retorno nulo.
No meu caso, a minha rota de backend retorna um json com error caso o usuário ou senha sejam inválidos, eu capturo esse erro no CATCH e por padrão do Next Auth o usuário sera redirecionado para a pagina de erro, assim como o a pagina de login personalizada, esse comportamento sera tratado a seguir.

Callbacks: Nesse ponto é criado o Token JWT utilizando o ID do usuário, lembrando que minha API retorna um Objeto de User com ID, EMAIL e NOME.

Nessa mesma lógica é gerado uma SESSION utilizando o Token gerado, essa sessão fica salva no Cookies e é verificada sempre que o usuário acessar a aplicação, quando o usuário realizar o signOut ou o token expirar a sessão é encerrada.

Pages: Nesse objeto vamos realizar os redirecionamentos para as paginas personalizadas prevenindo o comportamento padrão.

SignIn: Pagina padrão gerada pelo Next Auth, aqui vamos indicar o caminho para a nossa pagina de Login personalizada. No exemplo eu tenho uma pagina em pages/login.tsx
Error: Essa é a pagina que o usuário será redirecionado caso seja rejeitado o retorno da chamada API com erro. Como estamos enviando o erro, eu redireciono o usuário para a pagina de login, e iremos capturar esse erro na nossa pagina de login personalizada.
SignOut: Pode ter uma pagina personalizada caso queira redirecionar o usuário quando ele realizar Logout da sua aplicação, ou para a pagina de Login.

Pagina de Login Personalizada

Nesse exemplo utilizarei uma pagina de login personalizada, pode ser encontrada em “pages/login.tsx”.

A pagina foi criada utilizando ChakraUI com YUP para validação dos campos e React Hook Form para manipular o formulário.

Você pode criar interfaces com Chakra UI acessando: ChakraUi

A sua pagina de login personalizada terá um manipulador de envio de formulario que usará a função signIn do Next Auth para realizar o login do usuário. No meu caso, tenho a função handle signIn, estou utilizando SubmitHandler do useForm.



const handleSignIn: SubmitHandler<SignInFormData> = async (values) => {
    const res = await signIn("credentials", {
      redirect: false,
      email: values.email,
      password: values.password,
      callbackUrl: `${window.location.origin}`,
    });

    if (res.error) {
      toast({
        title: `${res.error}`, 
        status: "error",
        duration: 4000,
        isClosable: true,
      });
    }

    if (res.url) Router.push(res.url);
  };

signIn: Essa função recebe como parâmetro o nome do Provider, definido em “name” no tópico anterior, e um objeto com propriedades.

redirect: false, por padrão essa propriedade é true, setamos ela como false, para conseguir capturar a resposta da Função signIn.
- Ela retorna uma Promise com a seguinte estrutura:



{
    error: string || undefined,
    status: number,
    ok: boolean,
    url: url || null
}

Email e Password: Enviamos os valores esperados no Provider.
CallbackUrl: Especifica para qual URL o usuário será redirecionado após entrar.

Como definimos redirect como false, ele não irá redireicionar o usuário caso o login seja bem sucedido, por isso fazemos uma verificação condicional se existe uma URL, se sim, utilizamos o Router.push, passando a URL, definida em CallbackURL.

Se houver erro no login, que esta sendo enviado do Provider, recebemos ele, e mostramos em um Toast.

Logout da Aplicação.

Para realizar o logout, utilize o método signOut(), para que seja concluído o fluxo de saída e encerrada a sessão do usuario.

Esse metodo recarrega a pagina quando concluído, e o usuário será redirecionado para pagina de Login. É possivel especificar uma URL para redirecionar o usuário como no exemplo a seguir:



import { signOut } from "next-auth/react"

export default () => <button onClick={() => 
    signOut({ callbackUrl: 'http://localhost:3000/login' })}>Sign out</button>

Session Provider

Na sua pagina do _app.ts deverá envolver o seu componente com o Session Provider para garantir que todas paginas tenha acesso ao Next Auth:



import { SessionProvider } from 'next-auth/client'

export default function App ({ Component, pageProps }) {
  return (
    <SessionProvider session={pageProps.session}>
      <Component {...pageProps} />
    </SessionProvider>
  )
}

Rotas Privadas

A proteção de rotas é crucial em qualquer aplicação que possa ser acessada apenas com Login, a seguir iremos criar rotas protegidas utilizando a lógica do Next Auth.

Existem algumas formas de verificar se o usuário possui uma sessão ativa e então exibir o conteúdo da pagina, porém a forma como o Next.js trata getServerSideProps e getInitialProps, todo carregamento de página protegida irá realizar uma solicitação do lado do servidor para determinar se a sessão é válida anter de gerar a página solicitada(SSR), isso aumenta a carga do servidor, mas há uma opção para fazer solicitações do cliente, se nenhuma sessão for identificada após o carregento inicial, você determinará a ação apropriada.

Função Auth

Vamos modificar o arquivo _app.js:



import { SessionProvider, useSession, signIn } from 'next-auth/react';
export default function App({
  Component,
  pageProps: { session, ...pageProps },
}) {
  return (
    <SessionProvider session={session}>
      {Component.auth ? (
        <Auth>
          <Component {...pageProps} />
        </Auth>
      ) : (
        <Component {...pageProps} />
      )}
    </SessionProvider>
  )
}

function Auth({ children }) {
  const { data: session, status } = useSession()
  const isUser = !!session?.user
  React.useEffect(() => {
    if (status === "loading") return
    if (!isUser) signIn()
  }, [isUser, status])

  if (isUser) {
    return children
  }


  return <div>Loading...</div>
}

A Sessão esta sendo buscada, se não houver nenhum usuário o useEffect vai redirecionar.

Se o status for loading, a condicional não faz nada enquanto estiver no estado de carregamento.
Se o usuário não estiver autenticado, o usuário é forçado a entrar na pagina de Login, através da função signIn().

Manipulação da Sessão do Cliente personalizada.

Dessa forma será exibido um status de carregamento na verificação inicial e todas transições de paginas serão do lado do cliente, eliminando a necessidade de verificar com o servidor e gerar novamente as páginas.

Nas paginas protegidas é só adicionar:



export default function Dashboard() {
  const { data: session } = useSession()
  return <h1>Pagina Protegida</h1>
}

Dashboard.auth = true

Estamos usando Dashboard.auth = true para verificar se o usuário está autenticado, para todas as paginas que queremos proteger é só adicionar auth = true.

Referências: Protected Routes

Espero que esse guia possa te ajudar!

Concorrência em banco de dados explicada de forma simples

Fabio Hiroki — Tue, 15 Feb 2022 18:18:54 +0000

Nesse artigo vou mostrar conceitos básicos para lidar com requisições simultâneas criando uma aplicação web de um banco. Quando estamos programando tem algumas armadilhas que precisamos nos atentar especialmente porque não são cenários fáceis de testar.

Escopo da aplicação do banco

Nossa aplicação de exemplo armazenará contas bancárias que poderão transferir dinheiro entre elas. Ela será construída usando PHP, Symfony e o mapeamento objeto-relacional (ORM) Doctrine, mas você não precisa conhecer essas tecnologias, apenas o banco de dados Postgres.

Entidade conta bancária (Account)

A conta bancária guardará o nome do dono e a quantidade final de dinheiro.

CREATE TABLE "public"."bank_account" (
    "id" int4 NOT NULL,
    "name" varchar(255) NOT NULL,
    "amount" int4 NOT NULL,
    PRIMARY KEY ("id")
);

API para transferência de dinheiro

O endpoint para transferir dinheiro entre duas contas irá receber três variáveis por query parameters:

from: id da conta origem
to: id da conta destino
amount: quantidade a ser transferida

Então para transferir 100 da conta 1 para conta 2, podemos usar a seguinte requisição:

http://localhost:8000/move?from=1&to=2&amount=100

Repositório Conta Bancária

Para que o endpoint acima funcione, precisamos do seguinte repositório:

class BankAccountRepository extends ServiceEntityRepository
{
    public function __construct(ManagerRegistry $registry)
    {
        parent::__construct($registry, BankAccount::class);
    }

    public function transferAmount($from, $to, $amount): void
    {
        // Busca as contas bancárias a serem atualizadas
        $fromAccount = $this->find($from);
        $toAccount = $this->find($to);

        // Atualiza a quantidade delas
        $fromAccount->setAmount($fromAccount->getAmount() - $amount);
        $toAccount->setAmount($toAccount->getAmount() + $amount);

        // Persiste as duas entidades
        $this->getEntityManager()->persist($fromAccount);
        $this->getEntityManager()->persist($toAccount);
        $this->getEntityManager()->flush();
    }
}

Traduzindo para SQL, temos o seguinte (editado a partir do SQL gerado pelo Doctrine para fins de legibilidade):

SELECT * FROM bank_account WHERE id = 1; -- origem
SELECT * FROM bank_account WHERE id = 2; -- destino
START TRANSACTION;
UPDATE bank_account SET amount = ? WHERE id = 1; -- origem
UPDATE bank_account SET amount = ? WHERE id = 2; -- destino
COMMIT;

Controlador Conta

Do lado do controlador, temos que extrair os query parameters da requisição e repassá-los para o repositório:

class BankAccountController extends AbstractController
{
    #[Route('/move', name: 'bank_account')]
    public function transfer(Request $request, BankAccountRepository $repository): Response
    {
        $from = $request->query->get('from');
        $to = $request->query->get('to');
        $amount = $request->query->get('amount');

        $repository->transferAmount($from, $to, $amount);

        return new Response(sprintf('from %s to %s amount %s', $from, $to, $amount));
    }
}

Vamos testar!

Vamos criar contas de teste no banco de dados:

INSERT INTO "public"."bank_account" ("id", "name", "amount") VALUES
(1, 'Alice', 1000),
(2, 'Bob', 0);

E transferir 100 de Alice para Bob:

curl http://localhost:8000/move?from=1&to=2&amount=100

Verificando os dados no banco podemos observar que o resultado está correto:

| id | name  | amount |
|----|-------|--------|
|  1 | Alice |    900 |
|  2 | Bob   |    100 |

Fácil, certo? A partir de agora podemos melhorar essa implementação criando testes unitários, de integração e tudo continuará funcionando corretamente.

O que tem de errado?

Para identificar o problema, vamos usar o Apache HTTP server benchmarking tool (ab) para fazer várias requisições na nossa aplicação.

O primeiro teste terá o seguinte cenário:

Alice começa com o montante 1000
Bob começa com o montante 1000
Alice faz 10 transferências de 100 para Bob, uma de cada vez
Resultado final esperado:
- Alice: 0
- Bob: 1000

Nós podemos usar o seguinte comando, onde o parâmetro n é o número total de requisições e c é o número de requisições simultâneas:

ab -n 10 -c 1 'http://localhost:8000/move?from=1&to=2&amount=100'

Você terá que confiar em mim agora, mas posso garantir que ao rodar o comando acima Alice terá 0 e Bob terá 1000.

O segundo cenário será bem parecido, mas faremos 10 requisições simultâneas:

Alice começa com 1000
Bob começa com 0
Alice faz 10 transferências simultâneas com o montante de 100 para Bob
Resultado final esperado:
- Alice: 0
- Bob: 1000

Preciamos alterar o parâmetro c para 10:

ab -n 10 -c 10 'http://localhost:8000/move?from=1&to=2&amount=100'

O resultado nada agradável:

| id | name  | amount |
|----|-------|--------|
|  1 | Alice |    300 |
|  2 | Bob   |    700 |

Mas por quê? Basicamente há processos atualizando o montante enquanto há outros que estão lendo e mantendo o valor antigo na memória. Vamos imaginar dois processos concorrentes A e B atualizando apenas a conta de Alice:

1 - Processo A lê o valor 1000 na conta de Alice
2 - Processo B lê o valor 1000 na conta de Alice
3 - Processo A escreve 900 na conta de Alice
4 - Processo B escreve 900 na conta de Alice (deveria ser 800, que vergonha!)

Como corrigir?

Há mais de uma solução, mas a que eu vou mostrar será utilizando Pessimistic Locking para escritas e leituras. Isso significa que o banco de dados só permitirá uma escrita ou uma leitura por recurso, que nesse caso é a nossa entidade conta.

No Doctrine podemos fazer isso utilizando o seguinte código no repositório:

public function transferAmountConcurrently($from, $to, $amount): void
{
    $this->getEntityManager()->beginTransaction();
    $fromAccount = $this->find($from, LockMode::PESSIMISTIC_WRITE);
    $toAccount = $this->find($to, LockMode::PESSIMISTIC_WRITE);

    $fromAccount->setAmount($fromAccount->getAmount() - $amount);
    $toAccount->setAmount($toAccount->getAmount() + $amount);

    $this->getEntityManager()->persist($fromAccount);
    $this->getEntityManager()->persist($toAccount);
    $this->getEntityManager()->flush();
    $this->getEntityManager()->commit();
}

Agora temos que explicitamente demarcar o início da transação antes de adquirir o lock, o que faz sentido uma vez que o Doctrine não consegue saber quando a transação deveria ter começado.

Finalmente, a mesma solução em SQL:

START TRANSACTION;
SELECT * FROM bank_account WHERE id = 1 FOR UPDATE; # origem
SELECT * FROM bank_account WHERE id = 2 FOR UPDATE; # destino
UPDATE bank_account SET amount = ? WHERE id = 1; # origem
UPDATE bank_account SET amount = ? WHERE id = 2; # destno
COMMIT;

Para testar, vou criar uma nova rota no controlador existente BankAccountController:

#[Route('/move-concurrently', name: 'bank_account_concurrent')]
public function transferConcurrently(Request $request, BankAccountRepository $repository): Response
{
    $from = $request->query->get('from');
    $to = $request->query->get('to');
    $amount = $request->query->get('amount');

    $repository->transferAmountConcurrently($from, $to, $amount);

    return new Response(sprintf('from %s to %s amount %s', $from, $to, $amount));
}

E agora podemos testar usando o Apache benchmarking tool

ab -n 10 -c 10 'http://localhost:8000/move-concurrently?from=1&to=2&amount=100'

Pode confiar em mim, está funcionando agora: Alice possui 0 e Bob possui 1000.

O fim

Ao usar a estratégia de locking nós garantimos que o processo que adquiriu o lock está lendo o valor mais atualizado e então atualizando dado consitente baseado na última leitura. O código final está no Github.

fabiothiroki / symfony-bank-transaction

Obrigado pela leitura e espero que tenha gostado!

Introdução ao RabbitMQ e Symfony

Fabio Hiroki — Tue, 11 Jan 2022 17:26:09 +0000

Um dia eu estava tentando aprender os conceitos avançados do RabbitMQ, os casos de uso e as diferenças para os outros message brokers. Comecei lendo a boa documentação e então eu estava ansioso para experimentar em uma aplicação real.

Entretanto não foi tão simples de criar uma aplicação Symfony e conectar com o RabbitMQ. Os resultados da busca do Google não eram tão precisos e eu ainda precisei da ajuda do StackOverflow para instalar dependências adicionais.

Espero que eu tenha conseguido condensar toda a informação aqui e mostrá-la de uma forma simples e divertida.

O que eu vou construir?

Inicialmente eu pensei em criar uma aplicação web para explorar os diferentes padrões do RabbitMQ. Depois de sofrer com a integração do RabbitMQ com framework web popular, eu decidi dar um passo para trás e simplesmente só criar um endpoint que publica uma mensagem, e um consumidor que loga o conteúdo recebido. Então vamos construir!

Código final no github:

fabiothiroki / php-symfony-rabbitmq

php-symfony-rabbitmq

View on GitHub

Symfony

Mas por que Symfony? É um framework PHP popular e no final eu gostei de como ficou a integração e a arquitetura com o RabbitMQ.

Primeiramente eu instalei o Symfony CLI e através dele, criei uma aplicação web tradicional:

symfony new --full php-symfony-rabbitmq

Posso rodar minha aplicação através do seguinte comando no diretório do projeto:

symfony serve

Symfony messenger

Symfony Messenger é a abstração de mensageria provido por uma dependência separada. Vamos instalá-la!

composer require symfony/messenger

Seguindo a boa documentação, eu criei uma classe simples para encapsular a mensagem a ser publicada:

final class SampleMessage
{
    public function __construct(private string $content)
    {
    }

    public function getContent(): string
    {
        return $this->content;
    }
}

E a sua respectiva classe handler:

final class SampleMessangeHandler implements MessageHandlerInterface
{
    public function __invoke(SampleMessage $message)
    {
        // magically invoked when an instance of SampleMessage is dispatched
        print_r('Handler handled the message!');
    }
}

Agora para verificar que tudo está funcionando até agora, eu adicionei um endpoint simples para enviar uma mensagem:

final class SampleController extends AbstractController
{
    #[Route('/sample', name: 'sample')]
    public function sample(MessageBusInterface $bus): Response
    {
        $message = new SampleMessage('content');
        $bus->dispatch($message);

        return new Response(sprintf('Message with content %s was published', $message->getContent()));
    }
}

Ao testar o endpoint, verifico que a saída impressa pelo handler e pela resposta http está correta:

curl http://localhost:8000/sample

Handler handled the message!Message with content content was published

Onde está o RabbitMQ?

Até agora não temos nem um sinal do RabbitMQ, mas não se preocupe porque deixei todo o terreno preparado para introduzi-lo.

Instalação das dependências

Imagem docker

Vou utilizar o docker para subir uma instância do RabbitMQ porque é muito fácil dessa forma. Só é preciso instalar o Docker Compose e então editar o arquivo .docker-compose.yml no diretório do projeto PHP para adicionar um novo serviço:

version: '3'

services:
  rabbitmq:
    image: rabbitmq:3.9-management
    ports:
      - '5672:5672'
      - '15672:15672'

Ao rodar docker-compose up é possível verificar que a instância do RabbitMQ está rodando.

Extensão PECL AMQP

AMQP (Advanced Message Queuing Protocol), é o protocolo que sustenta o RabbitMQ. A instalação da sua extensão utilizando PECL (PHP Extension Community Language) foi um pouco difícil, pelo menos no MacOS:

Primeiro, instalei o HomeBrew:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Depois instalei rabbitmq-c:

brew install rabbitmq-c

O que por fim permitiu a instalação da extensão:

pecl install amqp

Quando foi pedido para digitar o caminho para librabbitmq, você precisa verificar qual é a versão instalada dentro do diretório /usr/local/Cellar/rabbitmq-c/. A minha versão era a 0.11.0:

Set the path to librabbitmq install prefix [autodetect] : /usr/local/Cellar/rabbitmq-c/0.11.0

Finalmente a última dependência:

composer require symfony/amqp-messenger

Que alívio! Agora posso voltar a programar.

Utilizando o poder da assincronicidade

Por padrão, o usuário e a senha criados na imagem docker são guest, o que coincidentemente é a linha exata que eu preciso descomentar no arquivo .env, que expõe a conexão ao RabbitMQ como uma variável de ambiente:

###> symfony/messenger ###
# Choose one of the transports below
# MESSENGER_TRANSPORT_DSN=doctrine://default
 MESSENGER_TRANSPORT_DSN=amqp://guest:guest@localhost:5672/%2f/messages
# MESSENGER_TRANSPORT_DSN=redis://localhost:6379/messages
###< symfony/messenger ###

Agora com essa nova variável, eu preciso dizer a aplicação quais mensagens deveriam ser tratadas por esse transporte.

Então no arquivo config/packages/messanger.yaml eu defino um novo transport e o tipo de mensagem a ser tratada:

framework:
    messenger:
        transports:
            # https://symfony.com/doc/current/messenger.html#transport-configuration
            async: '%env(MESSENGER_TRANSPORT_DSN)%'

        routing:
            # Route your messages to the transports
            'App\Message\SampleMessage': async

Nesse ponto eu posso testar o endpoint novamente:

curl http://localhost:8000/sample

E em outro terminal eu ligo o consumidor:

php bin/console messenger:consume async -vv

Esse comando imprime várias mensagens bem verbosas, mas as partes importantes são:
:

[messenger] Received message App\Message\SampleMessage
[messenger] App\Message\SampleMessage was handled successfully (acknowledging to transport).
[messenger] Message App\Message\SampleMessage handled by App\MessageHandler\SampleMessangeHandler

E para ter certeza que a aplicação está realmente usando o RabbitMQ, eu posso acessar o admin no endereço http://localhost:15672 e verificar esse gráfico bonito:

Conclusão

Finalmente eu tenho um setup básico do RabbitMQ e Symfony! Agora eu posso dar vida a vários side projects e explorar os padrões de mensageria. Espero que tenha gostado e também aprendido algo!

Padrão de projeto Adapter em PHP

Fabio Hiroki — Mon, 06 Dec 2021 20:38:40 +0000

Os usuários e usuárias estão amando sua aplicação e você quer dar a eles mais alegria. O que poderia trazer mais felicidade do que notificações por email?

Vamos dar boas vindas!

Nós queremos que nossos usuários e usuárias se sintam bem depois de se cadastrarem na nossa aplicação, então por que não enviar um email de boas vindas? Você já conhece um serviço de email confiável que tem um SDK fácil de instalar utilizando Composer. Tudo parece estar correndo bem até agora.

Infelizmente, ao integrar o SDK você nota que as classes não se encaixam muito bem. SignUpService contém apenas o destinatário e o conteúdo, enquanto ThirdPartyEmailClient espera parâmetros de configuração.

Nosso SDK hipotético possui a seguinte estrutura:

class ThirdPartyEmailClient
{
    public function __construct(
        private string $apiKey,
        private string $region,
    ) {
    }

    public function sendEmail(
        string $recipient,
        string $content,
    ): void {
        echo sprintf("Using apiKey %s and region %s", $this->apiKey, $this->region);
        echo sprintf("Sending email to %s and content %s", $recipient, $content);
    }
}

Faça funcionar

Se ThirdPartyEmailClient está pedindo por uma apiKey e region, vamos satisfazer seus pedidos. Nós podemos simplesmente injetar os dois parâmetros na classe SignUpService, ou mesmo colocando eles diretamente no código (hardcoding). Não seria um problema até você precisar depois enviar um email após o usuário atualizar o seu perfil, implementado em outra classe chamada ProfileService.

Bom, por enquanto você só está preocupado em implementar a funcionalidade corretamente porque você é um bom profissional e quer entregar o prometido. A solução por agora é copiar e colar os parâmetros na classe SignUpService. Bom trabalho!

Algo parece errado

Naquela noite você não conseguiu dormir por causa daquele código duplicado. A apiKey também está exposta em todos os lugares. Como resolver esse problema?

Faça funcionar melhor

Eis então que você se lembra do padrão Adapter. Ele serve para integrar classes que tem interfaces incompatíveis. O primeiro passo é criar a interface esperada pelo cliente:

interface EmailSenderAdapter
{
    public function sendEmail(string $recipient, string $content): void;
}

Agora você só precisa colocar ThirdPartyEmailClient numa classe que implementa a interface anterior:

final class ThirdPartyEmailSenderAdapter implements EmailSenderAdapter
{
    public function __construct(private ThirdPartyEmailClient $emailClient)
    {
    }

    public function sendEmail(string $recipient, string $content): void
    {
        $this->emailClient->sendEmail($recipient, $content);
    }
}

SignUpService agora está feliz porque tem um amigo que entende sua linguagem.

E para melhorar mais ainda, você decide adicionar um teste unitário!

Testando

public function testThirdPartyEmailSenderAdapterAdapterUsesCorrectClient(): void
{
    $emailClient = $this->createMock(ThirdPartyEmailClient::class);

    $emailAdapter = new ThirdPartyEmailSenderAdapter($emailClient);

    $emailClient->expects($this->once())
        ->method('sendEmail')
        ->with('email@email.com', 'I love design patterns');

    $emailAdapter->sendEmail(
        'email@email.com',
        'I love design patterns');
}

Você conseguiu!

Suas classes estão bem integradas, testadas e se um dia você precisar alterar o provedor de email, seria só necessário criar uma implementação nova de EmailSenderAdapter, e então a interface antiga pode ser trocada pela nova. Parabéns.

Código no Github.

fabiothiroki / php-design-patterns

A collection of design patterns written in PHP

php-design-patterns

A collection of design patterns written in PHP

Creational

Prototype

Structural

Adapter

View on GitHub

Captura de argumentos em testes PHP

Fabio Hiroki — Sat, 23 Oct 2021 08:10:30 +0000

Você já está se sentindo confiante com suas habilidades de teste e os seus colegas te invejam ao ouvir você falar de mocks e stubs. Mas agora, um novo desafio surge e você só pode verificar certas propriedades de um argumento, caso contrário seus testes falharão miseravelmente.

Um novo dia começa

Seu trabalho era implementar uma simples funcionalidade de cadastro de usuário. Como uma boa programadora, você planeja usar o padrão Repositório para poder separar a camada de persistência e mocká-la em testes unitários caso necessário.

Classe usuário

Não poderia ser mais simples, certo?

final class User
{
    public function __construct(
        private string $id,
        private string $name)
    {
    }

    public function getId(): string
    {
        return $this->id;
    }

    public function getName(): string
    {
        return $this->name;
    }
}

Repositório da entidade usuário

Não está persistindo de fato, mas vamos fingir que sim.

final class UserRepository
{
    public function save(User $user): void
    {
        echo sprintf('Persistindo usuário com id %s e nome %s', $user->getId(), $user->getName());
    }
}

Classe UserService

Agora temos uma reviravolta! Um requisito maluco diz que o campo id deve ser randômico. Bom, temos várias maneiras de fazer isso, então vamos prosseguir:

final class UserService
{
    public function __construct(private UserRepository $repository) { }

    public function createNewUser(string $name): void
    {
        $user = new User(uniqid(), $name);

        $this->repository->save($user);
    }
}

Legal, tudo está funcionando.

Não vamos nos esquecer dos testes

Nós queremos verificar quando UserService cria um User, se o UserRepostory está sendo chamado corretamente. Não nos importamos com a persistência agora, então podemos mockar o repositório e tudo deve funcionar.

public function testFailing(): void
{
    $repository = $this->createMock(UserRepository::class);

    $userService = new UserService($repository);

    $repository
        ->expects($this->once())
        ->method('save')
        ->with(new User('id não randômico', 'user'));

    $userService->createNewUser('user');
}

Infelizmente isso não funciona. O teste falha porque User com o id id não randômico não corresponde ao argumento passado pelo UserRepository que tem um id diferente cada vez que um novo usuário é criado.

Captura de argumento ao resgate!

No Java, nós temos essa mesa funcionalidade provida pelo Mockito:

Captura de argumento possibilita a verificação de apenas alguns valores do argumento ao invés de testar a equalidade do objeto inteiro.

No nosso exemplo, nós não nos precisamos testar realmente o valor do id porque ele é gerado randomicamente pelo próprio PHP através da função uniqid.

No final o teste usando captura de argumento fica assim

public function testRepositoryShouldCreateUserWithCorrectName(): void
{
    $repository = $this->createMock(UserRepository::class);

    $userService = new UserService($repository);

    $repository
        ->expects($this->once())
        ->method('save')
        ->will($this->returnCallback(function($user) {
            self::assertEquals('user', $user->getName());
        }));

    $userService->createNewUser('user');
}

Obrigado por ler até aqui, espero que tenha gostado e boa sorte com seus testes!

Padrão de projeto Prototype em PHP

Fabio Hiroki — Sun, 10 Oct 2021 16:38:09 +0000

Vamos imaginar que você está trabalhando em um eCommerce e recebeu a responsabilidade de implementar a seguinte funcionalidade:

Na tela do carrinho, o usuário deve ser capaz de adicionar mais de uma unidade de um produto já presente, e também alterar a sua cor.

Uma solução intuitiva nesse contexto poderia ser instanciar um novo objeto produto e setar todos os atributos iguais ao produto original. Mas isso parece ser muito verboso, e você precisaria saber todo o funcionamento interno da classe produto, o que parece quebrar o encapsulamento.

Prototype ao resgate!

Do refactoring.guru:

O Prototype é um padrão de projeto criacional que permite copiar objetos existentes sem fazer seu código ficar dependente de suas classes.

Isso significa que você não precisa usar o operador new nem se preocupar em como configurar uma instância copiada perfeitamente. Só precisa o usar o operador clone e o PHP vai resolver tudo sozinho.

Aplicação de exemplo

Versão final do código está no Github:

fabiothiroki / php-design-patterns

A collection of design patterns written in PHP

A classe Cart não faz parte do padrão de projeto, mas está presente aqui somente para demonstrar como o padrão se encaixaria numa aplicação real:

final class Cart
{
    /**
     * @var ProductPrototype[]
     */
    private array $products;

    public function addProduct(ProductPrototype $product): void
    {
        $this->products[] = $product;
    }

    /**
     * @return ProductPrototype[]
     */
    public function getProducts(): array
    {
        return $this->products;
    }
}

Como podemos observar, somos capazes de adicionar um novo produto e verificar quais produtos já estão adicionados.

abstract class ProductPrototype
{
    protected int $id;
    protected string $name;
    protected string $color;

    public function getId(): int
    {
        return $this->id;
    }

    public function getName(): string
    {
        return $this->name;
    }

    public function getColor(): string
    {
        return $this->color;
    }

    public function setColor(string $color): void
    {
        $this->color = $color;
    }
}

PHP já implementa Prototype nativamente porque todo objeto já aceita o operador clone por padrão. Nesse exemplo, criei a classe ProductPrototype só para ilustrar um caso real: para a classe Cart não importa qual o tipo específico de produto será adicionado, contanto que tenha os atributos id, name e color.

Apenas para simplificar esse exemplo, vou mostrar dois tipos de produto: Smartphone e Laptop:

final class Smartphone extends ProductPrototype
{
    public function __construct()
    {
        $this->id = 1;
        $this->name = 'Smartphone';
        $this->color = 'Default color';
    }
}

final class Laptop extends ProductPrototype
{
    public function __construct()
    {
        $this->id = 2;
        $this->name = 'Smartphone';
        $this->color = 'Default color';
    }
}

Explicando Prototype com testes unitários

O que o operador clone realmente faz? Ele copia uma instância com os mesmos atributos. Então no nosso exemplo, o produto clonado terá os mesmos valores de id, nome e cor do objeto original.

public function testSmartphoneClone(): void
{
    $smartphone = new Smartphone();

    $clonedSmartphone = clone $smartphone;

    self::assertEquals($clonedSmartphone->getId(), $smartphone->getId());
    self::assertEquals($clonedSmartphone->getName(), $smartphone->getName());
    self::assertEquals($clonedSmartphone->getColor(), $smartphone->getColor());
    self::assertEquals($clonedSmartphone, $smartphone);
    self::assertNotSame($clonedSmartphone, $smartphone);
}

Como podemos observar, se tivéssemos que clonar um objeto manualmente, teríamos que saber todas as propriedades a serem copiadas e como setá-las.

Perceba que esse teste não precisaria ser escrito numa aplicação real porque podemos assumir que o operador clone funciona corretamente, já que é provido pelo próprio PHP.

De volta ao nosso caso de uso

Finalmente podemos dar ao Cart a funcionalidade de aumentar a quantidade de um produto existente e alterar sua cor. Cart ficará ainda mais feliz porque não precisa se preocupar se estará recebendo uma instância de Laptop ou de Smartphone.

É só fazer uso do operador clone e adicionar o produto recém clonado:

public function testCartCanAddClonedProducts(): void
{
    $laptop = new Laptop();
    $cart = new Cart();

    $cart->addProduct($laptop);

    $clonedLaptop = clone $laptop;
    $clonedLaptop->setColor('White');
    $cart->addProduct($clonedLaptop);

    self::assertCount(2, $cart->getProducts());
    self::assertEquals($cart->getProducts()[1]->getId(), $cart->getProducts()[0]->getId());
    self::assertEquals($cart->getProducts()[1]->getName(), $cart->getProducts()[0]->getName());
    self::assertEquals('White', $cart->getProducts()[1]->getColor());
    self::assertEquals('Default color', $cart->getProducts()[0]->getColor());
}

Obrigado por ler até aqui, espero que você tenha entendido melhor sobre esse padrão de projeto e lembre-se de usá-lo quando necessário!

Melhore a testabilidade do seu código PHP

Fabio Hiroki — Sat, 25 Sep 2021 18:17:33 +0000

Introdução

Bem vindo ao meu artigo! Espero que você seja como eu e acredite no poder dos testes unitários, ou pelo menos saiba que eles são importantes. Resumindo, eu gosto deles porque me dão confiança que meu código está funcionando e ninguém mais fará alterações nele por engano.

Nesse artigo eu vou mostrar como combinar mocks e reflexão para escrever um teste que a princípio parecia impossível.

O código completo está no Github.

fabiothiroki / php-reflection-test

A simple example of unit tests using reflection

Desafio aceito

Eu havia acabado de começar num trabalho novo, numa empresa que usa PHP como linguagem principal. Peguei uma nova tarefa e estava muito animado para terminá-la (com testes, é claro!).

Mas, de repente, uma classe selvagem aparece! Ela não expunha uma dependência que eu precisava mockar. Eu poderia refatorar esse código pra receber a dependência através do construtor, mas decidi não seguir esse caminho porque eu era novo na empresa e não sabia se isso era um padrão aceitável ou qual foi o racional da pessoa que desenvolveu a classe originalmente.

Por outro lado, a solução alternativa que eu mostrar a seguir também não demandaria um esforço grande. Vindo de um background Java, eu sabia que isso poderia ser feito usando "reflexão".

Reflexão? O que?

Antes de irmos direto para o código precisamos entender o conceito de reflexão. Aqui vai a minha definição simples:

Reflexão é uma ferramenta que permite inspecionar o código e passar por cima da tipagem estática.

Por exemplo, nesse artigo vou utilizar reflexão para para alterar a instância de um atributo inacessível, de uma classe que não tem um método "setter" nem uma outra forma de acessá-la.

Por que você quer fazer isso?

Nesse exemplo, a classe Implementation contém um método público que faz uma chamada para a dependência inacessível. Então o teste que queremos fazer é: quando chamamos o método público de Implementation, estamos chamando a dependência com os argumentos corretos?

Me mostre o código

Classe abstrata

<?php
abstract class AbstractClass
{
    protected $unacessibleDependency;

    public function __construct()
    {
        $this->unacessibleDependency = new UnacessibleDependency();
    }

    abstract function doSomething(string $argument): void;
}

Como podemos observar, não há uma forma de acessar $unacessibleDependency externamente, a não ser que refatoremos essa classe, o que já disse anteriormente que não é o caminho que decidi não seguir.

Classe Implementation

<?php
class ImplementationClass extends AbstractClass
{
    public function doSomething(string $argument): void
    {
        $this->unacessibleDependency->doSomethingElse($argument);
    }
}

doSomething é o método que queremos testar.

Configuração do teste

Comece criando uma instância do sistema a ser testado (system under test ou SUT):

$this->implementation = new ImplementationClass();

Torne a unacessibleDependency da instância anterior acessível por meio da reflexão:

$reflectionClass = new ReflectionClass($this->implementation);
$property = $reflectionClass->getProperty('unacessibleDependency');
$property->setAccessible(true);

Crie uma instância mock de UnacessibleDependency para que possamos verificar se está sendo chamada:

$this->mockUnacessible = $this->createMock(UnacessibleDependency::class);

Então, substitua a dependência original pelo object mock:

$property->setValue($this->implementation, $this->mockUnacessible);

Por fim, a afirmação

$this->mockUnacessible->expects(self::once())
            ->method('doSomethingElse')
            ->with(self::equalTo('argument'));

$this->implementation->doSomething('argument');

Traduzindo para linguagem humana: quando doSomething é chamado com o parâmetro argument, doSomethingElse é também chamado com o mesmo parâmetro?

Agora nós temos nosso teste, e ninguém se feriu durante esse processo.

Conclusão

Existe uma forma de adicionar um teste unitário mesmo em cenários improváveis, mas essa técnica deve ser usado com cuidado porque nós podemos estar mascarando um design de código ruim. Se o código não está facilmente testável, então provavelmente não estamos seguindo as boas práticas de encapsulamento ou abstração.

Eu quero saber mais!

Para mais técnicas de melhoria de testabilidade de código, dê uma olhada no livro "Trabalho Eficaz com Código Legado" de Michael Feathers.