Gabriel Schade Cardoso

Elastic Map Reduce - EMR - Arquitetura Geral

Mon, 21 Dec 2020 00:00:00 +0000

Olá pessoa!

Depois de falarmos sobre Hadoop, que tal começar a falar sobre EMR, um dos serviços AWS que utiliza tudo que vimos no post anterior!

O que é o EMR? Bom, pra começar a sigla significa Elastic Map Reduce, ele é um serviço que provê uma plataforma de clusters gerenciados para processar e analisar grandes quantidades de dados.

Quase sempre quando temos um volume grande de dados nos deparamos com problemas para dar vazão ao processamento desses dados de forma eficiente, EMR utiliza Hadoop para quebrar esse problema em jobs menores e distribuí-los entre vários nós de processamento.

Podemos aplicar EMR, por exemplo, para processarmos uma quantidade grande de logs, processamentos de machine learning e ETL (Extract, Transform e Load). Tudo isso podendo controlar o quanto queremos escalar (ou não) nossos clusters.

Se você não viu o post passado, recomendo acessar este link, afinal vamos utilizar vários conceitos mencionados lá, mas dessa vez, claro, sob o contexto do EMR.

Arquitetura

Existem algumas pequenas diferenças entre a arquitetura de um cluster Hadoop e de um cluster EMR, vamos dar uma olhada geral na arquitetura:

É possível notar algumas diferenças, mas calma, vamos por partes.

Primeiro ponto que pode chamar atenção é: todo o cluster está necessariamente dentro de uma mesma AZ (availability zone), entraremos em mais detalhes sobre isso ao longo do post, mas é importante por agora termos na cabeça que não há chamadas entre diferentes AZs em um mesmo cluster.

Segundo ponto: Nossos nós secundários sumiram, agora eles viraram Core e Task nodes, existem algumas diferenças entre os dois, mas podemos considerar que tanto os tasks quanto os core nodes são sim nós secundários.

Terceiro ponto: Agora temos essas caixinhas chamadas Instance Group, o que é isso?

Instance Groups

Instance groups é um conceito bem simples, basicamente é uma forma de organizar um grupo, ou coleção de instâncias EC2 e tratá-las como uma unidade única.

Um cluster EMR pode conter até 50 instance groups, onde apenas uma delas pode ser uma Master Instance Group, contendo seu nó principal. Uma Core Instance Group contendo multíplos Core nodes e por fim, você pode criar até 48 Task Instance Groups, onde cada um pode conter multíplos Task nodes.

Por que criar multíplos Task nodes ao invés de simplesmente aumentar o número de instâncias? No EMR, cada instance group utiliza um único tipo de instância EC2 para todos os nós. Então caso você queira utilizar diferentes tipos de instâncias, a opção de criar um novo grupo pode ser bastante útil.

Agora assim como fizemos no post de Hadoop, vamos destrinchar cada um dos tipos de nós de um cluster EMR!

Master Node

Todo cluster EMR possui apenas um único Master Node, o que pode não parecer a melhor coisa do mundo, afinal, ele acaba sendo um ponto único de falha, mas existem formas de mitigar isso, podemos falar sobre isso em um post futuro.

Este nó é responsável por gerenciar os recursos do cluster, isso inclui: coordenar e distribuir a execução paralela entre os nós secundários; Gerenciamento do sistema de arquivos (falaremos sobre os tipos de sistemas de arquivos mais para frente, não se preocupe com isso agora), e ah, você ainda lembra do Resource Manager? Pois é, é aqui que ele fica no EMR, com todas as responsabilidades descritas no post anterior.

Por fim, o Master Node também é responsável por monitorar a saúde dos Core e Task nodes.

Core Node

Um Core Node é basicamente o mesmo que os nós secundários que aprendemos no post anterior. São responsáveis por executar tarefas enviadas pelo Master Node, eles armazenam dados utilizando o sistema de arquivos.

Também é aqui que fica o Node Manager e o Application Master normalmente, assim como os nós secundários do Hadoop, com as mesmas funções e responsabilidades.

Existem algumas operações extras que podem ser realizadas aqui, mas novamente, isso ficará para um post futuro.

Task Node

Se o Core Node é o mesmo que um nó secundário, o que diabos é um Task Node? Bom, na prática o Task Node também é um nó secundário, mas com algumas particularidades.

Começando com o fato de ser opcional, ou seja, você pode ter um cluster sem que ele tenha um Task Node. Além disso, esses nós não possuem nenhum acesso ao sistema de arquivos.

Para que servem? - Bom, o nome é bastante sugestivo, estes nós podem ser adicionados ou removidos de um cluster em execução para trazer mais poder computacional à eles. Imagine um cenário em que você precisa adicionar mais memória ou CPU durante uma execução, sem a flexibilidade do Task Node você poderia se colocar em uma situação onde não há recursos suficientes e teria de reiniciar o cluster alterando as configurações de seus Core Nodes.

Bom, o post de hoje era isso!

Espero que tenham gostado, qualquer dúvida, correção ou sugestão, deixem nos comentários!

E até o próximo post!

Introdução à Apache Hadoop

Mon, 14 Dec 2020 00:00:00 +0000

Olá pessoa!

Depois de um bom tempo fora, estou de volta!

Depois de uma virada na minha carreira, agora vamos começar uma série sobre serviços AWS e tecnologias envolvidas!

O primeiro assunto que quero tratar é o Apache Hadoop, sim, eu sei, não é um serviço AWS, mas vai servir de base para o próximo assunto, então vamos começar por ele.

O que é o Apache Hadoop? Bom, uma forma de resumir ele é simplesmente dizer que ele é um framework open-source que permite processar grandes quantidades de dados de forma distribuída entre clusters de computadores. Ele é projetado principalmente para escalabilidade, ou seja, podemos utilizá-lo em clusters com centenas ou até milhares de máquinas ao invés de utilizarmos uma super máquina para fazer tudo. Além disso, Hadoop também é projetado para detectar e lidar com falhas nos nós de processamento na camada de aplicação.

Vamos fazer um overview dos componentes do Hadoop, seus módulos e como eles interagem entre si.

Normalmente um Hadoop cluster é composto por um nó principal(master) e N nós secundários(slave).

O nó principal é responsável por gerenciar os recursos do cluster a agendar as tarefas entre os nós secundários usando Hadoop Distribuited File System (HDFS).

Os nós secundários são responsáveis por executar tarefas em conjunto com o nó principal e por seus pares.

Vamos agora falar da arquitetura do Hadoop! Ele é dividido entre módulos, não vou falar de todos aqui, mas vamos focar nos que considero mais importante.

Hadoop Core

Como o nome sugere, o módulo core contém as bibliotecas e utilitários consumidos pelos outros módulos, ou seja, ele funciona como uma peça base dentro da arquitetura Hadoop.

Ele é responsável por coisas como: abstrair o sistema de arquivos do sistema operacional e iniciar o Hadoop própriamente dito.

Em alguns locais você também pode ver o nome desse módulo como Hadoop Common, eles são basicamente a mesma coisa.

Hadoop Distribuited File System (HDFS)

Os nomes dos módulos são bastante sugestivos, nessa altura você já deve ter percebido que o HDFS é um sistema de arquivos distribuído, certo? Mas o que isso quer dizer?

Bom, ele é o modo de armazenamento base do framework, isso significa que ele pode armazenar arquivos gigantescos através de diversas máquinas em um cluster. Cada arquivo é armazenado como um sequência de blocos de mesmo tamanho (com exceção do último) e são duplicados para garantir tolerância à falhas. Tanto o tamanho dos blocos como o fator de duplicação são completamente configuráveis.

Isso tudo provendo uma alta taxa de transferência (throughput) para acesso dos dados para processamento e análise de grandes volumes de dados.

Hadoop Yarn

Esse é um dos nomes não tão claros, YARN significa (Yet Another Resource Negotiator), este módulo basicamente serve para o agendamento de jobs e resource-management do cluster.

Vamos dar uma olhada nos componentes do YARN:

Resource Manager

O primeiro componente é parte do nó principal, o Resource Manager, ele é um agendador para alocação de recursos no cluster para executar processos que podem competir entre si. Isso porque um mesmo cluster Hadoop pode executar multiplos processos, como mais de um MapReduce ou até mesmo processos diferentes como MapReduce + Spark.

Node Manager

Em cada nó secundário temos um Node Manager, este componente responde diretamente instruções do Resource Manager. Ele é responsável por gerenciar os recursos do nó secundário de maniera mais local, enquanto que o Resource Manager se preocupa com isso no contexto do cluster.

Application Master

Este componente também faz parte dos nós secundários, ele é responsável por negociar recursos com o Resource Manager e Node Manager para executar e monitorar os Containers.

Container

Todo o processamento de dados e onde a aplicação realmente executa são nos Containers dos nós secundários que são executados pelo Application Master.

Os containers também são responsáveis por garantir acessos de memóra e CPU à aplicação.

MapReduce

MapReduce é um framework para processar grandes volumes de dados utilizando processamento paralelo distribuido em um cluster. Esse processamento pode ser desestruturado (utilizando um sistema de arquivos) ou estruturado (utilizando um banco de dados).

Mas por que se chamar MapReduce? - O nome se refere às duas principais tarefas: Map e Reduce. Se você já utilizou alguma biblioteca de programação funcional já deve ter se deparado com estes métodos (menos em C#, que eles se chamam respectivamente Select e Aggregate).

Note que eu utilizei a palavra “principais”, isso quer dizer que existem mais tarefas? - Sim.

O MapReduce possui as seguintes tarefas: Input, Split, Map, Shuffle, Reduce e Result.

Vamos entender o que cada fase é responsável por.

Input: Nesta etapa temos apenas a entrada de dados, normalmente desestruturada; Split: Nesta etapa a entrada é dividida entre múltiplos nós, simplesmente para acelerar o processamento; Map: Nesta etapa cada registro da entrada é transformada em um key value pair, neste ponto o Resource Manager irá atribuir os recursos necessários aos nós para realizar o processamento distribuído, como resultado dessa fase, uma saída intermediária é gerada; Shuffle: Nesta etapa a saída intermediária é processada para que cada key value pair seja enviado para um local específico para seu processamento final; Reduce: Nesta etapa obtemos a saída da etapa Shuffle e a processamos com a função Reduce, fazendo com que os dados possam ser agregados, filtrados e assim por diante; Result: Nesta etapa o programa pode escrever o arquivo de saída.

Vamos fazer um exemplo, imagine que você está utilizando o MapReduce em uma conta do GitHub, com múltiplos repositórios, escritos em linguagens diferentes, poderíamos ter essa pipeline de execução conforme a imagem a seguir:

Bom, o post de hoje era isso!

Espero que tenham gostado, qualquer dúvida, correção ou sugestão, deixem nos comentários!

E até o próximo post!

Café Debug: Algoritmos e Estrutura de Dados!

Thu, 13 Aug 2020 00:00:00 +0000

Olá pessoa!

Eu participei de mais um podcast Café Debug, dessa vez sobre algoritmos e estrutura de dados!

Neste episódio eu, Jéssica Nathany e meu grande amigo André Santana conversamos sobre a importância de algoritmos e estrutura de dados.

Segue o episódio:

Queria também aproveitar para agradecer o convite e que venham mais parcerias!

Bom, o post de hoje era isso!

Espero que tenham gostado, qualquer dúvida, correção ou sugestão, deixem nos comentários!

E até o próximo post!

Um projeto novo: Elidriel - Meu JRPG

Tue, 02 Jun 2020 00:00:00 +0000

Olá pessoa!

Se você já ouviu minha história em algum podcast ou por aí no YouTube, já sabe que comecei na área por conta da minha vontade de desenvolver jogos. Bom, esse é meu novo projeto.

Como falei na chamada do post, desde que me lembro tenha a vontade de desenvolver um jogo. Entre todas as escolhas acabei decidindo por começar um projeto para o gênero que mais gosto: “JRPG”.

Ok, eu não sou japonês, então é claro que não é exatamente um JRPG. Mas bebe das mesmas fontes e tem as mesmas características. A minha ideia é fazer minha versão dos RPGs antigos, lá pelo SNES, como Final Fantasy IV, v e VI.

Por motivos óbvios, é claro que eu não espero que saia na mesma qualidade que estes clássicos, até porque, é um projeto de um homem só.

Como cheguei no ponto em que tenho uma build estável com todas as mecânicas implementadas, achei que era a hora de lançar. Você terá aproximadamente 5 horas de gameplay e eu espero muito que a experiência seja satisfatória (e desafiadora).

Você pode fazer o download neste link e se divertir!

De qualquer modo, aqui vai um resumão do jogo com prints, personagens e sinopse, eu espero que você goste!

Projeto - Elidriel

CGA - Vencedor categoria Aventura

4º Lugar (Demo 1) - Projeto Valente Verão 2020

4º Lugar (Demo 1) - Protótipo Premiado 18

Gênero: RPG / Fantasia

Data de início: Dezembro 2018

Introdução

Este projeto é meu passatempo, mas estou tomando todo cuidado possível em seu desenvolvimento, para que mesmo tendo as limitações de um projeto tocado por uma pessoa só, ele tenha seu valor e possa prover uma experiência legal ao jogador.

Sinopse

Onde a paz reinava por séculos um atentado ao governante atual muda tudo, a ascenção do chanceler Arthur O’Caddler ao poder torna a seita do Grifo de Platina lei e todos os julgados pecadores, se tornam condenados e foras da lei.

Ada, uma ex agente do império exilada no vilarejo Valefor, recebe de surpresa a visita de um velho amigo que mudará tudo. Kell membro ativista contra o império convoca Ada para uma missão e nela encontram novos aliados e seu envolvimento com o divino e com as forças de Elidriel mudam seus destinos mudam para sempre.

Os heróis não estão mais envolvidos apenas na guerra humana, existe algo maior. Uma ligação entre a seita do Grifo de Platina e os Eternos de Elidriel podem decidir o destino de toda a humanidade.

Personagens

Ada

Ex membro do grupo militar fantasma.

O grupo fantasma sofreu uma perseguição agressiva pelo império após a posse do chanceler, tendo boa parte de seus integrantes mortos.

Por sorte Ada recebeu ajuda de Kell, um guerreiro de Ankrah e com isso conseguiu sobreviver.

Atualmente, declarada como morta, ela vive exilada na cidade de Valefor. Ada é uma pessoa gentil e ponderada, tem um perfil conciliador e tenta ter uma perspectiva sobre tudo antes de tomar suas decisões. Ela se importa com seus amigos e é capaz de criar vínculos com facilidade.

Kell

Um dos líderes da Armada, um grupo formado por soldados de Ankrah e Hetios que atua contra o chanceler e o império.

Possui uma força física acima da média e é capaz de utilizar uma lança como poucos.

Kell é taxado de extremista e até de terrorista por alguns, mas mesmo com isso, ele continua lutando contra a desigualdade e o ódio disseminado pelo chanceler e seu império. Ele possui um ódio latente no peito por conta das cicatrizes de seu passado, o que o faz, por vezes, perder a razão e partir para a força bruta.

Erling

É um alquimista formado na universidade de Alberta.

Se auto declara o melhor alquimista do mundo. É capaz de combinar suas habilidades mágicas com a tecnologia de Alberta.

Possui um grande senso de humor, é muito despreocupado e possui uma confiança excessiva que pode causar problemas.

Emmy

Emmy teve uma infância muito feliz em Alberta, ao longo de sua vida ela percebeu que possuia uma conexão muito forte com o Elidriel, mas sem saber o real motivo por trás disso. (Isso será revelado ao longo do jogo e não quero estragar a surpresa).

Esse vínculo faz com que ela possua um conjunto de habilidades únicas!

Emmy é uma pessoa hostil, ela tem dificuldades em confiar nas pessoas e julga a Armada e o Império como lados de uma mesma moeda. Passou por um longo período sendo prisioneira do império, isso fez com que ela criasse uma raiva latente dentro de si, e ao mesmo tempo uma paixão forte pela liberdade.

Mecânicas e Sistemas

Temperamento das Criaturas

As batalhas são iniciadas ao encontrar-se com a criatura no mapa.

O comportamento das criaturas no mapa podem variar de acordo com seu temperamento, enquanto algumas podem querer evitar batalhar, outras poderão lhe seguir a todo custo!

Cada criatura possui um dos quatro temperamentos possíveis: dócil, normal, agressivo e parado.

Elas podem ser identificadas de acordo com a cor do ícone acima do inimigo.

Dócil: Estas são as criaturas mais dóceis, elas sempre tentarão fugir de você, para iniciar uma batalha é necessário seguí-las. Geralmente estas batalhas são mais fáceis, mas podem existir criaturas poderosas que não gostam de batalhar.

Normal: Estas criaturas vagam livremente pelo ambiente e tentam aproximações curtas, geralmente é fácil evitá-las.

Agressivo: Estas criaturas são as mais selvagens, sempre que o virem tentarão uma aproximação para iniciar uma batalha. São as mais difíceis de evitar e o seguem por mais tempo.

Parado: Estas criaturas geralmente são as mais poderosas, é comum estarem protegendo um tesouro ou alguém. Irão se manter imovéis e a batalha só será iniciada por sua iniciativa.

Talentos

Cada um dos protagonistas possui um talento próprio, isso são habilidades que podem ser utilizadas fora de batalhas para interação com o ambiente.

É possível visualizar no canto esquerdo da tela uma barra contendo o nome do talento do líder da equipe e a energia para utilizá-lo. Você só pode utilizar o talento quando a energia estiver no máximo, ao esgotar-se ela reiniciará automaticamente.

Ada - Modo Furtivo: O talento de Ada permite que ela ande por locais sem ser notada por criaturas ou outras pessoas, utilizada em missões de espionagem ao longo do projeto.

Kell - Super Força: Permite empurrar ou quebrar objetos que estão bloqueando o caminho.

Erling - Detecção Mágica:: Permite visualizar ítens e passagens ocultas no mapa.

Emmy - Manipulação Temporal: Permite alterar a forma que o tempo passa em determinados objetos (incluindo na pescaria).

Ferramentas

As ferramentas são um equipamento especial do projeto, assim como os talentos elas permitem que os personagens interajam com o ambiente de diferentes formas. Você pode utilizar apenas a ferramenta equipada no líder da equipe.

Outra característica das ferramentas é que cada um dos personagens possui um nível de habilidade em cada uma delas, este nível aumenta conforme o uso da ferramenta específica:

Batalha

O jogo utiliza batalha lateral com uma mecânica de manipulação de turnos, através de técnicas você pode alterar a ordem das ações dos personagens e dos inimigos, cancelar ações e até mesmo realizar mais de uma ação no mesmo turno.

Além disso, o jogo conta com um sistema de atordoamento de inimigos, você possui mecânismos para explorar as fraquezas do oponente e remover a resistência de sua defesa.

Normalmente a resistência é representada por uma barra branca abaixo do HP do inimigo, ao acertar o inimigo com um golpe que causa dano significativo à resistência o inimigo entrará no estado de Pressionado, neste estado a barra fica com uma colocaração rosada e os danos na resistência aumentam significativamente.

Quando você quebra toda a resistência de um inimigo com sucesso a barra ficará vermelha, ele entrará no estado Atordoado e ficará duas ações sem jogar.

Galeria

Você pode fazer o download neste link via Google Drive e neste link via MediaFire.

Eu espero muito que você se divirta nessas 5 horas e por favor, deixe seu feedback aqui!

Bom, o post de hoje era isso!

Espero que tenham gostado, qualquer dúvida, correção ou sugestão, deixem nos comentários!

E até o próximo post!

Café Debug: Programação funcional, um jeito diferente de programar!

Sun, 10 May 2020 00:00:00 +0000

Olá pessoa!

Eu participei do podcast Café Debug sobre programação funcional, que tal dar uma olhada?

Neste episódio eu e a queridíssima Jéssica Nathany conversamos sobre programação funcional. Ok, mas qual parte?

Passamos uma visão macro por quase tudo sobre o tema nesse bate papo super tranquilo.

Segue o episódio:

Queria também aproveitar para agradecer o convite e que venham mais parcerias!

Bom, o post de hoje era isso!

Espero que tenham gostado, qualquer dúvida, correção ou sugestão, deixem nos comentários!

E até o próximo post!

5 coisas que eu queria que tivessem me contado no início da carreira

Tue, 14 Apr 2020 00:00:00 +0000

Olá pessoa!

Eu participei da live do Geek Hunter um tempão atrás, que tal tirar um tempo para dar uma olhada nela?

Nesta live tentei passar um pouco da minha experiência para quem está começando agora.

Nela eu falo sobre cinco coisas que acho que é importante ter ciência desde o início da carreira, mas lembrando claro, que isso tem muito a ver com a minha experiência pessoal e não é necessariamente uma verdade para todo mundo.

Segue o vídeo:

Queria também aproveitar para agradecer o convite para participar e que venham mais parcerias!

Bom, o post de hoje era isso!

Espero que tenham gostado, qualquer dúvida, correção ou sugestão, deixem nos comentários!

E até o próximo post!

Hipsters ponto tech: Algoritmos e estrutura de dados

Wed, 12 Feb 2020 00:00:00 +0000

Olá pessoa!

Se você viu o post passado, sabe que minha vida deu uma boa mudada, sei não estou dando tanta atenção por aqui, mas a frequência de publicações voltará a aumentar assim que tudo estabilizar novamente.

Para quem não viu, semana passada participei do Hipsters ponto tech!

No podcast falamos sobre um assunto que adoro discutir por aqui: Algoritmos e estrutura de dados!

É importante? Não é? Como ganhar 1 milhão de dólares resolvendo um problema de computação?

Discutimos essas coisas por lá, dá uma conferida no episódio:

Atenção

Como você está em um dispositivo móvel a visualização do gráfico pode ser comprometida, acesse este link para ver o gráfico em tela cheia.

Queria também aproveitar para agradecer o convite para participar e que venham os próximos!

Bom, o post de hoje era isso!

Espero que tenham gostado, tenham todos um feliz novo e um ótimo recomeço e que final de 2020 eu e você possamos comemorar mais um monte de conquistas!

E até o próximo post!

Minha Retrospectiva 2019

Tue, 07 Jan 2020 00:00:00 +0000

Olá pessoa!

Esse ano foi demais, teve muita, mas muita coisa boa acontecendo.

Passou aqui pelo blog aproximadamente 200 mil visitas únicas e 20 mil leituras lá no medium. Além de palestras ao vivo, viagens para 7 países diferentes e algumas conquistas que me enchem de orgulho!

Como não pretendo fazer esse post muito longo, vamos direto para os highlights!

Microsoft MVP Summit

O primeiro grande highlight do ano certamente foi o Microsoft MVP Summit, um evento que rola todo ano lá na matriz da Microsoft em Seattle, onde os Microsoft MVPs do mundo todo são convidados para uma série de palestras técnicas e anúncios do que chega de novo para o próximo ano nas tecnologias Microsoft.

Como recebi esse prêmio ano passado, esse foi o meu primeiro ano no evento e apesar de ter escutado reclamações, para mim tudo foi fantástico! Não tem como descrever a experiência de conhecer uma galera tão foda.

As pessoas que constroem as ferramentas que eu usava no dia a dia para trabalhar. E não só isso, ter a oportunidade de se encontrar com outros MVPs do Brasil e do mundo.

Fiz diversas amizades nessa viagem e sem dúvida nenhuma, esse evento vai ficar na memória!

Antes do primeiro dia de evento fiz um passeio rápido por Toronto, foi só um diazinho, mas deu para aproveitar algumas coisas, como a CB Tower por exemplo, uma das maiores torres do mundo! (E vencer o medo de altura, como faz?)

Depois de um dia de passeio, o evento começou pra valer!

Teve muito conteúdo e claro, uma dose de realidade para ver o quanto a gente ainda precisa aprender. De quebra, ainda tive a oportunidade de conhecer o estúdio do Channel 9, um canal de vídeos de treinamentos da Microsoft.

Aproveitando Seattle, fiz mais alguns rolês, até porque ninguém é de ferro né? Teve Space Needle, museu da cultura pop e tudo mais que tinha direito.

Eventos Técnicos de Abril

Abril foi um mês com alguns eventos bem legais, logo no início palestrei sobre Machine Learning no InterOP, lá em Florianópolis. Um pouco depois, junto com a galera da Qualyteam, organizei o evento de lançamento do Visual Studio 2019 em Balneário Camboriu e por último e não menos importante, aconteceu o TDC (The Developer’s Conference) mais um vez em Floripa.

Neste último evento tive a honra de ministrar quatro palestras e ser coordenador das trilhas .NET e INSPIRE.

A INSPIRE é uma trilha fantástica focada em introduzir jovens e adolescentes à área de tecnologia. Falei isso alguma vezes no evento e acho que vale repetir aqui: O objetivo disso não é dizer que a área de tecnologia é o único caminho, mas sim, mostrar para os jovens que se eles quiserem seguir essa área, tem gente disposta a estender a mão.

Tenho muito orgulho de ter participado disso e aqui fica um vídeo para quem tiver curiosidade sobre essa trilha do evento:

Além disso, esse TDC também teve um outro momento bastante especial para mim.

Apesar de participar do evento há alguns anos, foi a primeira vez que tive a honra de poder palestrar no palco principal. Minha palestra foi sobre reconhecimento de letras em libras através de algoritmos de machine learning (AI).

Nerdologia

Ainda em abril decidi fazer este post sobre como o Doutor Estranho dos Vingadores poderia navegar pelas possibilidades vistas pela jóia do tempo de maneira eficiente.

Esse post foi feito com base em um vídeo do Nerdologia, que na minha visão é um dos melhores canais do YouTube. E imagine a minha felicidade quando fui citado por lá?

Bem no finalzinho o Átila, biólogo, pesquisador e pessoa que me deixou maluco ao me citar, comenta sobre esse meu post.

Para me deixar ainda mais animado, isso tudo aconteceu em um dos vídeos que mais gosto (mas talvez eu tenha um pouco de viés né?)

Open Source e Publicações iMasters e no Microsoft Tech

Também foi em 2019 que a minha biblioteca de programação funcional a Tango, “explodiu”. Nesse ano a biblioteca atingiu a marca de mais de 55 mil downloads, tendo uma média de 50 instalações por dia.

É inacreditável pensar que 50 instalações são feitas todos os dias de algo que eu criei.

Ainda em 2019 que comecei a publicar artigos pelo site iMasters e desde então aproximadamente 17 mil pessoas começaram a ler meus posts por lá! É sempre muito maneiro poder alcançar mais gente.

No blog da Microsoft, o Microsoft Tech minha ação foi bem mais pontual. Tive só um post publicado por lá, mas confesso que é um dos que eu mais tenho orgulho de ter feito aqui no blog.

Este post sobre IA aplicada à uma base de dados de pokémon deu um trabalho monstro, mas acho que o resultado ficou bem bacana, se ainda não viu, dá uma conferida lá.

Intercâmbio na Irlanda e Viagens

Em maio foi onde o maior ponto de virada aconteceu, eu e minha esposa viemos para Dublin, Irlanda para fazer um intercâmbio para melhorar o inglês.

Isso significou: largar o emprego e ficar longe da família e de amigos. Mas é impossível não se sentir super privilegiado por ter uma oportunidade dessas.

Porque apesar do que eu falei, isso tornou possível conhecer muito mais gente, muito mais lugares, culturas e ter várias novas experiências.

Desde que cheguei aqui, minha esposa e eu visitamos: Amsterdam (um diazinho só), Londres, Paris e Belfast. É até difícil de descrever o quão transformador isso foi e está sendo para mim.

Renovação do Programa Microsoft MVP

Em julho recebi a notícia que minha premiação como Microsoft MVP tinha sido renovada, mais uma vez na categoria Developer Technologies. Fiquei muito feliz em receber o prêmio por mais um ano, apesar de ser um pouco de vaidade, sempre dá um quentinho no coração ser reconhecido por compartilhar conhecimento.

Mesmo estando bem feliz com a premiação, me mantive no programa por bem pouco tempo após a renovação. Já em outubro, eu mesmo fiz a ligação pedindo para ser desligado do programa da Microsoft.

Normalmente sair do programa MVP seria uma coisa muito triste, mas neste caso específico foi por conta de uma conquista, então definitivamente não era tempo de ficar triste, mas sim, de celebrar!

Me tornei um Amazonian

Bom, o motivo de eu ter saído do programa Microsoft MVP é por ter recebido (e aceitado, claro) uma oferta para trabalhar como software engineer na Amazon aqui em Dublin!

Eu não consigo descrever o tamanho dessa conquista, de verdade. Parece surreal.

Foi uma mudança gigantesca de carreira, troquei praticamente todo o conjunto de tecnologias que eu estava acostumado a trabalhar, mas sabe do que mais? Está sendo maravilhoso.

Eu sei que pode soar um pouco clichê, mas sair da zona de conforto e conseguir impactar literalmente milhões/bilhões de pessoas é inacreditavelmente recompensador.

Que venha 2020

Novo ano, novos tempos e eu não quero cair no papo de auto-ajuda, mas esse ano foi de fato, recheado de realizações e vitórias. Eu sei que não é assim tão simples, e que o caminho pode ser mais difícil pra uns do que para os outros, mas corre atrás do sonho, sério.

Eu sei que tive a sorte de conhecer muita gente incrível ao longo da minha carreira e isso foi algo que abriu muitas portas. Além disso, também tento ser ciente de que tive a sorte de ter muitos privilégios: nasci em uma família classe média, o que já implica em: nunca passar fome, não viver em uma área perigosa, nunca faltou grana em casa (até tivemos momentos de bastante fartura) e todas essas coisas.

Além disso, eu sei que também tive a sorte de ter os pais que tive. Apesar das dificuldades, meus pais fizeram de tudo e mais um pouco para que eu tivesse uma educação de qualidade. Eles terem se importado tanto com isso é uma coisa que eu até vou tentar, mas acho que nunca vou ser capaz de retribuir.

Eu não quero tentar politizar nada, mas é impossível falar de educação sem falar dos tempos atuais, em que infelizmente várias teorias da conspiração, obscurantismos e movimentos anticiência (terra plana, antivacina e por aí vai) vem ganhando força.

Sério, se você realmente quer fazer algo contra “o sistema”, estudar e entender como a ciência funciona ainda é uma das maiores revoluções que você pode fazer.

Eu compartilho o pouco do que sei aqui no blog, porque foi saber esse pouquinho, que tornou possível que, eu, o filho da dona de casa Eulália e do pescador João, morasse na Europa e começasse trabalhar como software engineer em uma das maiores empresas do mundo.

Mais uma vez: corre atrás do seu sonho.

Tá, talvez eu tenha caído um pouco no auto-ajuda, mas de qualquer forma, se eu puder ajudar uma pessoa com essa mensagem, já valeu a pena.

Bom, o post de hoje era isso!

Espero que tenham gostado, tenham todos um feliz novo e um ótimo recomeço e que final de 2020 eu e você possamos comemorar mais um monte de conquistas!

E até o próximo post!

Construindo Uma Lista Encadeada (Linked List)

Wed, 13 Nov 2019 00:00:00 +0000

Olá pessoa!

Vamos continuar a série sobre estrutura de dados? -Dessa vez com listas encadeadas (ou listas ligadas).

Este é o terceiro post sobre estrutura de dados aqui no blog, dessa vez falaremos sobre listas encadeadas ou Linked Lists.

Se ainda não leu, recomendo que você também leia o post sobre pilhas e filas.

Agora vamos ao assunto do post.

Linked List

O conceito principal de listas encadeadas ou linked lists é bastante simples, nessa estrutura de dados os elementos não são armazenados em memória contígua, assim como um array. Mas peraí, o que é uma memória contígua?

Em poucas palavras, memória contígua é um bloco de memória subsequente alocado de uma vez só. Esse é um dos motivos pelo qual normalmente precisamos explicitar o tamanho de um array para alocá-lo. O programa irá reservar um bloco contínuo de acordo com o tamanho do array.

Por que fazemos isso? A resposta simples é, porque é, de maneira geral, mais rápido. Afinal, o programa não irá precisar procurar fisicamente na memória o próximo elemento, ele está alocado fisicamente ao lado do anterior.

Maaaas, se a memória não é alocada de maneira unificada, como saberemos onde está o próximo elemento?

As listas encadeadas são baseadas em máquinas de ponteiros, de maneira MUITO resumida, isso significa que cada elemento possui o endereço da memória (ponteiro) para o elemento seguinte.

Se você acompanhou os posts anteriores, deve ter notado que quando criamos a Stack e a Queue já utilizamos essa abordagem, isso quer dizer que elas também eram listas encadeadas?

Não exatamente, porque possuíam comportamentos encapsulados que as definem como pilhas e filas, mas a maneira como os nós estavam organizados era exatamente igual à uma lista encadeada.

Diferente das pilhas e filas, nós podemos acessar qualquer elemento da lista encadeada, sem exceção.

LinkedListNode

Para esta estrutura de dados, talvez o nó seja mais importante do que a própria estrutura. Isso fica ainda mais evidente quando resolvemos exercícios sobre listas encadeadas, normalmente nos é oferecido apenas um nó, ao invés de um objeto com a lista. Isso porque através do primeiro nó, podemos percorrer a lista completa.

Vamos definir essa classe, ela é bastante simples, basta armazenarmos o valor e o ponteiro para o próximo nó.

class LinkedListNode{
    constructor(value){
        this._value = value;
        this._next = null;
    }

    set next(value){
        this._next = value;
    }

    get next(){
        return this._next;
    }

    get value(){
        return this._value;
    }
}

Estrutura Principal

Como mencionei antes, em vários momentos não precisamos de uma estrutura principal para trabalharmos com listas encadeadas, mas para deixar o post um pouco mais completo, vamos criá-la:

class LinkedList{
    constructor(value) {
        this._head = null;
        this._size = 0;
        
        if (value !== undefined) {
            this.append(value);
        }
    }
}

Podemos dar uma pequena incrementada, fazendo com que nosso construtor também aceite um array como parâmetro:

class LinkedList {
    constructor(value) {
        this._head = null;
        this._size = 0;
        
        if (value !== undefined) {
            if (Array.isArray(value)) {
                for(let element of value)
                    this.append(element);
            }else{
                this.append(value);
            }
        }
    }
}

Você já deve ter notado que estamos usando o método append que ainda não existe, mas não se preocupe com isso agora. Vamos só assumir que ele adiciona um elemento na última posição da lista encadeada.

Agora vamos criar as propriedades para mantermos a lista:

get size() {
    return this._size;
}

get isEmpty() {
    return this.size === 0;
}

get head() {
    return this._head;
}

set head(value) {
    this._head = value;
}

As propriedades são bastante simples de entender, temos uma que define o tamanho da lista, uma para identificar se a lista está vazia ou não e a outra para identificar o primeiro elemento da lista. Só isso.

Agora vamos começar a implementar os métodos!

Vamos precisar de algumas operações nessa classe: adicionar um novo elemento em qualquer posição, remover um elemento de uma posição e claro, obter o valor de um elemento em uma posição específica.

Um ponto de atenção aqui é que tanto para adicionar um novo elemento, quanto para remover, precisaremos antes, encontrar a posição para fazer isso. Portanto, é justo começarmos a implementação pelo método de busca.

Get - O(n)

Esse é um ponto que define a principal diferença entre uma lista encadeada e uma lista “normal”. Em uma lista normal podemos acessar o elemento em complexidade O(1), basta sabermos seu índice. No caso da lista encadeada precisamos necessariamente começar no primeiro elemento e percorrer a lista até o índice informado.

O que nos leva ao pior caso, onde percorremos a lista completa: O(n).

Nossa função de busca não irá definir comportamento nenhum, ela simplesmente vai retornar o nó atual e o nó anterior (para a operação de exclusão).

Para fazer isso, basta utilizarmos um laço de repetição e continuarmos obtendo o próximo elemento da lista até chegarmos no índice definido:

_getByIndex(index) {
    let previousNode = null;
    let currentNode = this.head;
    while (index > 0) {
        previousNode = currentNode;
        currentNode = currentNode.next;
        index--;
    }

    return [currentNode, previousNode];
}

Com este método implementado, podemos criar uma variação para retornar apenas o valor do nó informado de maneira bastante simples:

get(index) {
    let [currentNode,_] = this._getByIndex(index);
    return currentNode.value;
}

Agora vamos para as operações onde a lista encadeada brilha!

Insert - O(1) / O(n)

Diferente de uma lista comum, na lista encadeada a operação de inserção possui complexidade constante. Isso porque em uma lista comum teríamos que copiar todos os elementos do array para o próximo índice, enquanto que na lista encadeada apenas reorganizamos os ponteiros.

Assim como fizemos no método de busca, primeiro vamos implementar um método que esconde boa parte da complexidade de inserção. Este método recebe por parâmetro o nó anterior ao nó que será adicionado e o valor do novo nó. Com isso podemos reorganizar os ponteiros e fazer com que a lista continue íntegra.

Além disso, precisamos lembrar de duas coisas: alterar o valor da propriedade head nos casos onde o nó anterior ao nó que será inserido seja nulo e incrementarmos a propriedade size:

insert(node, value) {
    let newNode = new LinkedListNode(value);

    if (node == null) {
        newNode.next = this.head;
        this.head = newNode;
    }
    else {
        let next = node.next;
        node.next = newNode;
        node.next.next = next;
    }

    this._size = this._size + 1;
    return node;
}

Agora que este método está implementado precisamos implementar o insertAt, método que recebe o valor a ser inserido e o índice para inserção. Podemos obter o nó através da função de busca criada anteriormente:

insertAt(value, index) {
    let [_,previous] = this._getByIndex(index);
    this._insert(previous, value);
}

Também podemos criar métodos para inclusão no início (add) e fim (append) da lista:

add(value){
    this.insert(null, value);
}

append(value) {
    this.insertAt(value, this._size);
}

Importante

O método insert e add possuem complexidade O(1), o método insertAt e append possuem complexidade O(n), visto que utilizamos internamente o método de busca. No entanto, vale lembrar que é muito comum utilizarmos os nós diretamente, como já mencionei antes, por conta disso, a complexidade de uma lista encadeada é comumente referida como O(1), porque nos casos onde você possui o nó, ela é de fato constante. Isso também vale para a função de exclusão.

Remove - O(1) / O(n)

Para a função de exclusão, iremos implementar apenas a função baseada no índice, ela é bastante simples em termos de entendimento. Basta localizarmos o nó que desejamos excluir e o nó anterior (a função getByIndex já nos entrega isso) e reorganizarmos os ponteiros, veja:

remove(index) {
    let [currentNode, previousNode] = 
        this._getByIndex(index);

    if (previousNode !== null) {
        previousNode.next = currentNode.next;
    } else {
        this._head = currentNode.next;
    }

    this._size = this._size - 1;
}

Com isso completamos nossas funcionalidades básicas de uma lista encadeada. No entanto ainda podemos criar interfaces para melhorar o consumo dela.

A primeira coisa é fazer ela ser iterável através do for of como fizemos no array no construtor, veja:

*values() {
    let current = this.head;
    while (current !== null) {
        yield current.value;
        current = current.next;
    }
}

[Symbol.iterator]() {
    return this.values();
}

Agora podemos percorrer os elementos como se ela fosse um array normal:

let linkedList = new LinkedList([10,2,3,5,0]);
for(let node of linkedList){
    console.log(node);
}

//10
//2
//3
//5
//0

Legal né?

Ainda podemos finalizar com o famoso toArray, onde simplesmente iremos percorrer os nós e inserir seus respectivos valores em um array:

toArray(){
    let array = [];
    for(let node of this)
        array.push(node);

    return array;
}

Bom, o post de hoje era isso!

Espero que tenham gostado, qualquer dúvida, correção ou sugestão, deixem nos comentários!

E até mais.

Async em F#

Mon, 23 Sep 2019 00:00:00 +0000

Olá pessoa!

Que tal entendermos como funciona uma pipeline usando o Async em F#?

A ideia principal deste post é cobrir os fundamentos básicos para programação assíncrona em F#.

Ué, mas F# não é .NET? -É só utilizarmos Tasks!

Ok, F# é sim .NET e você pode sim utilizar Task, mas temos alguns probleminhas nisso. O primeiro é que a classe Task foi feita para trabalhar com o delegate Action. No C# até temos uma conversão implícita entre uma função void e esse delegate, mas isso não é verdade para F#, então teríamos que converter na mão.

Outro ponto que é inclusive mais importante que esse primeiro é o fato de que geralmente operações mais longas em F# são realizadas através de pipelines, veja um exemplo:

let atualizarCliente =
    verificaSeClienteExiste
    >> verificaNomeOuSobrenomeEmBranco
    >> verificaFormatoEmail
    >> verificaFormatoCPF
    >> transformarInicialNomeEmMaiusculo
    >> atualizarClienteNoBanco
    >> transformarListaEmResposta

Não precisamos entender o código interno da função, basta entendermos que geralmente um funcionalidade é implementada através da composição de diferentes funções menores.

Simplesmente não conseguimos utilizar um await como no C#, porque todas as chamadas resultam em uma única expressão e não vários statements.

Uma outra diferença que vale a pena ser destacada aqui é que uma Task em .NET produz um valor depois de seu processamento e se encerra, enquanto um Async é apenas um bloco que explicitamente precisa ser avaliado. Isso significa que, se você quiser o fazer qualquer tipo de cache no resultado, é necessário fazer isso explicitamente.

Como último lembrete, como praticamente tudo no C# e F# são “conversáveis”, temos transformações do tipo Task para o tipo Async dentro do módulo Async através das funções: Async.StartAsTask e Async.AwaitTask.

Existem mais complexidades no meio disso e até alguns comportamentos inesperados que podem acontecer quando utilizamos Tasks dentro do F# sem prestar as devidas atenções, mas isso fica para um outro post.

Para deixar o código com mais cara de F#, temos outro recurso para programação assíncrona chamado Async. Ele é trazido para o F# no formato de um computation express, eu falei disso brevemente aqui no blog neste post.

Vamos começar fazendo um exemplo bastante simples e depois disso, vamos paralelizar sua execução. A tarefa será simplesmente lermos o HTML de alguns sites diferentes, só isso.

Para podermos fazer isso, precisamos importar o namespace System.Net e System.IO:

open System.Net
open System.IO

Depois disso, vamos criar uma função que receba uma URL por parâmetro e fazer uma requisição para a página:

let fetchUrl url =
    let request = WebRequest.Create (Uri url)
    use response = request.GetResponse()
    use stream = response.GetResponseStream()
    use reader = new StreamReader( stream)
    let html = reader.ReadToEnd()
    printfn "finished reading %s" url
    html

Esse código é relativamente simples, mas vamos lembrar de algumas coisas aqui:

Estamos fazendo uma requisição HTTP normal para obter a página informada na URL;
Estamos usando o ReadToEnd para simplificar, mas no “mundo real”, leia linha por linha sempre que possível, isso pode evitar problemas com consumo de memória.
Entender a diferença entre o let e o use é bastante importante. Sempre que você tiver um recurso que implemente a interface IDisposable você deve utilizar o use para que o método Dispose seja chamado quando o programa encerrar a execução do escopo.

Agora vamos ao método main para executar essa função passando diferentes endereços:

let main argv =
    let sites = [
        "https://www.github.com/"
        "https://www.google.com/"
        "https://www.amazon.com/"
        "https://gabrielschade.github.io/"
    ]
    
    sites
    |> List.map(fetchUrl)
    |> ignore

Assim como em C#, podemos utilizar um Stopwatch para medirmos o tempo de execução dessa tarefa:

let sites = [
    //...
]

let stopwatch = new Diagnostics.Stopwatch()
stopwatch.Start()

sites
|> List.map(fetchUrl)
|> ignore

printfn "Elapsed Time: %i" stopwatch.ElapsedMilliseconds

Vamos executar para ver o resultado:

Agora vamos tornar essa execução paralela com alguns ajustes. Para manter duas funções separadas, vamos copiar a função original e renomeá-la para asyncFetchUrl.

Depois disso, vamos envolvê-la no computation express async. Pera, como assim?

Calma, eu explico. Todo computation express precisa de um contexto, esse contexto é definido pelo nome do computation e por chaves envolvendo o bloco, veja:

let asyncFetchUrl url = async{
    let request = WebRequest.Create (Uri url)
    use response = request.GetResponse()
    use stream = response.GetResponseStream()
    use reader = new StreamReader( stream)
    let html = reader.ReadToEnd()
    printfn "finished reading %s" url
    html
}

Até aqui nossa função praticamente não mudou, certo? -Mais ou menos.

Se formos checar o tipo dela, podemos verificar que ele passou de: string -> string para string -> Async<unit>. Peraí, por que unit se a última linha estamos retornando o html?

Na verdade, quando estamos dentro de um computation precisamos explicitar a palavra reservada return, veja:

let asyncFetchUrl url = async{
    let request = WebRequest.Create (Uri url)
    use response = request.GetResponse()
    use stream = response.GetResponseStream()
    use reader = new StreamReader( stream)
    let html = reader.ReadToEnd()
    printfn "finished reading %s" url
    return html
}

Agora sim temos um método que retorna Async<string>. Vamos testar?

Foi super rápido! Mas também não fez nada…

O motivo disso é bastante claro, lembra que no início do post eu falei que o bloco Async precisa ser explicitamente avaliado? Então… Esse é o problema. Tudo que nossa função está fazendo é envolvendo um bloco de código para identificá-lo como assíncrono.

Na prática o que temos é uma lista de Async<string> que precisa ser executada. Existem diversas formas de fazer isso, uma delas é executando um a um em ordem, ou seja, realizando as tarefas de forma síncrona:

 sites
|> List.map(asyncFetchUrl)
|> List.map(fun asynchronous -> Async.RunSynchronously asynchronous)
|> ignore

É claro que isso é só para demonstrar que precisamos explicitamente executar um Async, porque não faz absolutamente NENHUM sentido executarmos todos eles um a um de forma síncrona.

O que podemos fazer utilizando o módulo Async é transformar nossa lista de Asyncs em um único Async com uma lista de tarefas, ou seja, podemos paralelizar nossas chamadas:

sites
|> List.map(asyncFetchUrl)
|> Async.Parallel
|> Async.RunSynchronously
|> ignore

Agora sim! Note que a ordem das respostas está diferente e o tempo está relativamente menor.

Maaaaas, ainda não estamos fazendo as coisas de maneira síncrona, na prática cada um das chamadas ainda estão bloqueando suas respectivas threads durante a operação de requisição. Estamos paralelizando várias funções síncronas.

É como se estivessemos usando em C# uma chamada à um método async, que internamente não realiza nenhuma outra chamada assíncrona, ou seja, um async sem um await (não por opção, mas por não poder utilizar).

Então vamos alterar nossa função asyncFetchUrl mais uma vez, incluindo UM caracter: ! e alterando uma chamada:

let asyncFetchUrl url = async{
    let request = WebRequest.Create (Uri url)
    use! response = request.AsyncGetResponse() //use! && AsyncGetResponse
    use stream = response.GetResponseStream()
    use reader = new StreamReader( stream)
    let html = reader.ReadToEnd()
    printfn "finished reading %s" url
    return html
}

Vamos executar de novo:

Agora sim! Mas o que aconteceu?

Bom, agora estamos de fato utilizando uma chamada assíncrona e liberando que o programa continue executando. Além disso, note que estamos utilizando o Bang (!) após o use. Isso significa que estamos escolhando a função Use do computation express ao invés da função do use padrão do F#.

Vamos entender melhor sobre a sintaxe do Bang (no contexto Async, afinal sua funcionalidade pode mudar de acordo com o computation express):

Sintaxe Bang(!)

Essa sintaxe existe para qualquer computation express, mas vamos focar nas funcionalidades providas pelo Async.

Dentro de um escopo Async devemos utilizar o operador Bang (!) sempre que interagirmos com algo assíncrono, em muitos casos o ! funcionará como um await para essa sintaxe. Vamos ver o que podemos com esse operador:

Do

O do normalmente funciona como um statement isolado, ele é quase que um caso especial de let onde não precisamos atribuir um resultado. Na prática utilizamos o do para executar uma função que não retorna nada, ou seja, que retorna um unit.

let print text =
    printfn "%s" text

let functionDoExample() =
    do print "Hello World"

O que geralmente nos faz estranhar o do é por que ele pode ser completamente omitido e o código continua funcionando da mesma maneira:

let functionDoExample() =
    print "Hello World"

No entanto, apesar de podermos omití-lo em nosso código tradicional, precisamos saber da existência dele no caso de processamentos assíncronos, isso porque ele se torna útil quando precisarmos realizar um “await”. Nesse caso, precisamos da sintaxe bang (do!).

Vamos fazer a prova real disso, primeiro usaremos o Async.Sleep sem o do!:

let wait seconds = async{
    printfn "before working"
    Async.Sleep (seconds * 1000)
    printfn "after working"
}

[<EntryPoint>]
let main argv =
    printfn "started"
    Async.RunSynchronously (wait 20)
    printfn "finished"

Ao executar podemos notar que o resultado é imediato, mesmo que o código esteja dizendo para aguardarmos 20 segundos. Isso porque não estamos realizando um “await”, ou seja, não estamos esperando a operação terminar.

Simplesmente inserindo o do! podemos notar que a função agora precisa esperar o Sleep.

let wait seconds = async{
    printfn "before working"
    do! Async.Sleep (seconds * 1000)
    printfn "after working"
}

Isso é especialmente útil quando precisamos orquestrar processamentos assíncronos ou paralelos.

Let

Como você já deve saber em F#, o let funciona como uma forma de atribuirmos ou vincularmos um valor de função ou um valor discreto para uma variável. No contexto Async podemos utilizar o let! sempre que precisarmos esperar uma operação assíncrona que retorna valor terminar, ele é basicamente o mesmo que o do! com operações que retornam valor.

Geralmente aqui usa-se exemplos fakes para simplificar, mas vamos lá, não vai ser complicado. Vamos fazer uma função assíncrona para utilizar a API do GitHub e obtermos o número de repositórios públicos de um perfil.

Primeiro vamos instalar o pacote Fsharp.Data:

Install-Package FSharp.Data

Agora basta criarmos os types providers, se você não sabe o que eu estou falando, acessa este post e depois volta aqui!

Agora vamos criar o tipo para o perfil do github:

[<Literal>]
let githubUrl = "https://api.github.com/users/gabrielschade"
type GitHubProfile = JsonProvider<githubUrl>

E vamos fazer nossa função assíncrona a partir usando a função AsyncLoad do nosso tipo:

let printNumberOfRepos userName = async {
    let baseUrl = "https://api.github.com/users/"
    let url = sprintf "%s%s" baseUrl userName
    let! data = GitHubProfile.AsyncLoad url
    printfn "%s Repos: %i" userName data.PublicRepos
}

Note que se não utilizarmos o let! na chamada assíncrona nós nem conseguimos acessar a propriedade PublicRepos, porque estaríamos lidando com um Async<GitHubProfile> ao invés de um GitHubProfile.

O interessante disso é que o bang faz com que a operação seguinte dentro do bloco precise esperar a conclusão do AsyncLoad, mas isso não é necessariamente verdade para quem chamar essa função. Vamos fazer um teste:

[<EntryPoint>]
let main argv =
    printfn "started"
    Async.Start (printNumberOfRepos "gabrielschade")
    printfn "finished"

Qual o resultado esperado aqui?

Bom, como a função Start não determina que a thread precise aguardar o término do processamento, o resultado será esse:

É claro que podemos aguardar o processamento se quisermos, basta alterarmos a função Start para RunSynchronously. Além disso, também podemos fazer o mesmo que o exemplo anterior e carregarmos essas informações de diferentes usuários, veja:

[<EntryPoint>]
let main argv =
    let users = [
        "gabrielschade"
        "google"
        "microsoft"
        "dotnet"
    ]

    printfn "started"
    users
    |> List.map printNumberOfRepos
    |> Async.Parallel
    |> Async.RunSynchronously
    |> ignore

    printfn "finished"

Como já utilizamos o use! anteriormente e ele é praticamente o mesmo que o let!, com o adendo do Dispose, vamos omití-lo aqui, mas é sempre bom lembrarmos da existência dele!

use resource = disposableValue 
async {
    use resource = disposableValue 
    use! resource = asyncDisposableValue
}

Match

O match é a palavra reservada para realizarmos o tão famoso pattern matching, essa é uma inclusão relativamente nova na linguagem, mas agora temos um syntax sugar para realizarmos um await dentro da expressão do pattern matching utilizando match!

match functionOrValue with
| option1 -> //...
| _ -> //...

async{
    match functionOrValue with
    | option1 -> //...
    | _ -> //...

    match! asyncFunctionOrValue with
    | option1 -> //...
    | _ -> //...
}

É importante ressaltar que isso é apenas um atalho sintático para o código abaixo:

async{
    let! value = asyncFunctionOrValue
    match value with
    | option1 -> //...
    | _ -> //...
}

Vamos fazer uma função nova que ao invés de imprimir o número de repositórios ela simplesmente retorna-os. Por enquanto vamos simplesmente fazer uma outra versão da função para simplificar as coisas, mas a forma mais correta seria criarmos um pipeline de execução.

Mas para mantermos as coisas um pouquinho mais simples, vamos simplesmente gerar uma outra função, conforme código:

let getNumberOfRepos userName = async{
    let baseUrl = "https://api.github.com/users/"
    let url = sprintf "%s%s" baseUrl userName
    let! data = GitHubProfile.AsyncLoad url
    return data.PublicRepos
}

É basicamente a mesma função, com um return ao invés do printfn. Agora vamos utilizar o match!:

let evaluateRepos userName = async {
    let print value =
        printfn "%s: %s" userName value

    match! getNumberOfRepos userName with
    | value when value > 2000 -> print "Fantastic"
    | value when value > 1000 -> print "Huge"
    | value when value > 100 -> print "Great"
    | _ -> print "Meh"
}

Agora é só alterarmos a função lá na main e vermos o novo resultado:

[<EntryPoint>]
let main argv =
    //...
    users
    |> List.map evaluateRepos //<-
    |> Async.Parallel
    |> Async.RunSynchronously
    |> ignore
    //...

Return

Por fim, temos o return que é um pouco diferente do resto. Mas nada super complicado. Diferente dos anteriores o return já faz parte do bloco async, peraí, como assim?

Como mostrei nos exemplos acima, podemos utilizar os comandos: let, use, do e match fora de um computation express sem problemas, na verdade, utilizamos eles toda hora!

No caso do return ele só existe aqui dentro mesmo, e o que pode tornar isso confuso, é que além dele, também temos sua versão com o bang: return!. O que isso quer dizer?

Bom, o return é o que faz com que um valor seja “envelopado” em um objeto Async, por exemplo:

async{
    return 10
}

Se avaliarmos essa expressão, ela retornará Async<int>. Lembram do meu post sobre os conceitos de programação funcional utilizando Stranger Things?

Pois é, lá falamos sobre o conceito do return, que nesse caso é literalmente o uso da palavra return. Já vimos isso em uma das funções criadas anteriormente: getNumberOfRepos, conforme código:

let getNumberOfRepos userName = async{
    let baseUrl = "https://api.github.com/users/"
    let url = sprintf "%s%s" baseUrl userName
    let! data = GitHubProfile.AsyncLoad url
    return data.PublicRepos
}

Originalmente o campo PublicRepos é do tipo int, mas ao analizarmos a função veremos que ela retorna um tipo Async<int>. Isso porque precisamos sinalizar para quem irá consumir a função que ela ainda não foi executada e que trata-se de uma operação assíncrona, mesmo não estando diretamente ligada com o retorno.

No nosso exemplo acima, a operação assíncrona é a busca das informações no perfil do GitHub, uma operação necessário para obtermos o número de repositórios, mesmo que ela não seja o retorno direto.

Agora vamos imaginar uma outra situação. Para fins de exemplo, vamos fazer com que a cada novo usuário que obtermos o número de repositórios precisaremos esperar um determinado tempo.

let waitAndDo seconds userName = async {
    return 1
}

Para fazer isso vamos reaproveitar a lista de usuários do GitHub e utilizarmos o índice dos elementos como tempo. Para obtermos o índice e o elemento vamos utilizar a função List.mapi ao invés de List.map, além disso, vamos imprimir todos os números retornados pela função waitAndDo, conforme código.

[<EntryPoint>]
let main argv =
    //...
    users
    |> List.mapi (fun index user -> waitAndDo index user)
    |> Async.Parallel
    |> Async.RunSynchronously
    |> Array.iter (printfn "%i")
    //...

Se executarmos da forma que está iremos imprimir o número 1 quatro vezes. Precisamos alterar a função para realizar sua tarefa real. O que faremos é simplesmente esperarmos o tempo em segundos e depois vamos imprimir o número de repositórios do usuário usando a função.

let waitAndDo seconds userName = async {
    do! Async.Sleep (seconds * 1000)
    return getNumberOfRepos userName
}

Ao fazermos isso o compilador já irá reclamar do nosso pipeline. A partir de agora a última parte Array.iter esperando um inteiro irá causar problemas. Você consegue descobrir o motivo?

Na prática o que está acontecendo é o seguinte: a função getNumberOfRepos já retorna um Async<int>, logo, quando utilizamos o return novamente estamos criando um objeto do tipo Async<Async<int>>.

Para não encapsularmos o resultado novamente em um Async utilizamos a versão bang do return, ou seja, return!:

let waitAndDo seconds userName = async {
    do! Async.Sleep (seconds * 1000)
    return! getNumberOfRepos userName
}

E a partir de agora tudo funciona conforme o esperado!

E essa é a bang sintax do Async!

Apesar de ter muito mais coisa para explorar, como cancelamentos, workflows aninhados e por aí vai. Mas por enquanto ficaremos por aqui.

Espero que tenham gostado, qualquer dúvida, correção ou sugestão, deixem nos comentários!

E até mais.