<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Diogo Magalhães Machado on Medium]]></title>
        <description><![CDATA[Stories by Diogo Magalhães Machado on Medium]]></description>
        <link>https://medium.com/@diogommartins?source=rss-fff15274c61f------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*GwgieAS7YEkS5zO3H1H8oA@2x.jpeg</url>
            <title>Stories by Diogo Magalhães Machado on Medium</title>
            <link>https://medium.com/@diogommartins?source=rss-fff15274c61f------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 22:44:53 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@diogommartins/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Amora Data Build Tool]]></title>
            <link>https://medium.com/stonetech/amora-data-build-tool-d7b92acbc687?source=rss-fff15274c61f------2</link>
            <guid isPermaLink="false">https://medium.com/p/d7b92acbc687</guid>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[big-data]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Diogo Magalhães Machado]]></dc:creator>
            <pubDate>Thu, 17 Mar 2022 19:11:57 GMT</pubDate>
            <atom:updated>2022-03-17T19:11:57.009Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Xn3UK-N9unJVTN0FXh5IEA.png" /></figure><p>Para entendermos o problema que o <strong>Amora</strong> se propõe a resolver, precisamos primeiro entender o contexto de trabalho onde ele surgiu. Trabalho na <a href="https://pagar.me/">Pagar.me</a>, uma empresa da <a href="https://www.stone.com.br/">Stone Co.</a>, no contexto de prevenção a fraudes de transações financeiras por meios eletrônicos, em um time de dados composto por Analistas de Dados, Cientistas de Dados e Engenheiros e Engenheiras de Software.</p><p>No time de dados, lidamos com a extração, carregamento, transformação, organização e catalogação de dados, para geração de insumos para treino de modelos de <em>machine learning</em> de prevenção a fraude, inteligência de negócios e <em>analytics</em>.</p><p>Do ponto de vista de <em>stack</em> de tecnologias, usamos <a href="https://cloud.google.com/"><strong>Google Cloud Platform</strong></a> como provedor de plataforma de computação de nuvem e <a href="https://cloud.google.com/bigquery"><strong>Google Big Query</strong></a> como <em>Data Warehouse</em>, onde armazenamos dados de pagamento e entrega, dados pessoais de pessoas físicas e jurídicas, resultados de análises de antifraude, fluxos de transações, <a href="https://pagar.me/blog/estorno-de-pagamento/">operações de estorno</a>, <a href="https://ajuda.stone.com.br/recebimentos/o-que-e-chargeback"><em>chargeback</em></a><em>s</em>, etc.</p><p>Uma vez no <em>Data Warehouse</em>, do ponto de vista de um membro do time, o processo de extrair valor dos dados no Big Query tende a se resumir a criar 1-N consultas SQL de transformação e agregação desses dados para criação de <a href="https://cloud.google.com/bigquery/docs/tables"><strong>tabelas</strong></a><strong>e </strong><a href="https://cloud.google.com/bigquery/docs/views"><strong>views</strong></a>. No começo, <em>views</em> foram criadas e alteradas diretamente através do <a href="https://console.cloud.google.com/bigquery">console do Big Query</a>. Com o passar do tempo, os problemas dessa abordagem em um time, se tornaram óbvios:</p><ul><li>C<strong>ontrole de versão</strong>: é comum que mais de uma pessoa trabalhe sobre um modelo de dados e que esse modelo sofra mudanças ao longo do tempo. Modelos de dados exigem um trabalho de desenvolvimento de código. Código não versionado tende a gerar os mesmos problemas, independente do contexto.</li><li><strong>Garantias de qualidade</strong>: <em>Garbage in, Garbage out.</em> Dados ruins geram modelos de dados ruins, que podem resultar em predições incorretas ou numa visão distorcida do estado atual negócio. Não tínhamos garantia de qualidade através de testes automatizados.</li><li><strong>Documentação</strong>: software não documentado gera barreiras de adoção, aumentando a carga cognitiva, fazendo com que novos usuários e desenvolvedores tenham que reinterpretar o código exposto de acordo com os seus conhecimentos e vieses. Quando estamos falando de modelos de dados, queremos descrições completas, explícitas e sem ambiguidades do <em>dataset</em> e suas colunas.</li><li><strong>Modularização</strong>: sem o ferramental adequado para reuso de código, é inevitável que <em>copy/paste</em> ocorra. Sem reuso, a adoção de correções e atualização de definições se torna problemática e custosa.</li></ul><blockquote>Ex.: Digamos que os modelos de dados A, B e C fazem uso do CPF do comprador. Esse dado, por sua vez, não está no formato desejado, podendo conter separadores estéticos (ex.: 453.178.287-91). Para resolver esse problema, ao criar o modelo A, João criou uma expressão regular para transformar 453.178.287-91 → 45317828791. O modelo B foi desenvolvido por Joana, que teve contato com o modelo A e copiou a implementação de João. O modelo C, feito por Maria, que não teve contato com nenhum dos outros modelos, desenvolveu uma nova implementação para resolver o mesmo problema. Com o passar do tempo, João descobriu um problema na sua implementação no modelo A e a corrigiu. Nesse cenário, a correção não é replicada para o modelo B e também não podemos saber se o mesmo problema afetou a solução utilizada em C.</blockquote><p>O tempo de desenvolvimento de mudanças e implementação de novas <em>features</em> está diretamente ligado com a manutenibilidade do <em>software</em> em questão. Isso não é diferente no processo de análise de dados. Os problemas a serem resolvidos são os mesmos, mas em um contexto diferente, que ainda carece do ferramental adequado.</p><h3>Sobre os Ombros de Gigantes</h3><p>Para endereçar esses problemas, testamos e adotamos o <a href="https://www.getdbt.com/">DBT</a>. Passamos então a escrever modelos de dados e suas respectivas transformações utilizando uma combinação de SQL com <a href="https://docs.getdbt.com/docs/building-a-dbt-project/jinja-macros">macros Jinja</a>. Isso nos possibilitou reuso de código, uso de estruturas de controle, iteração, configuração externalizada, múltiplos ambientes e um ciclo de integração contínua com testes de dados e garantias de qualidade que não tínhamos antes. Com um processo estável de contribuição e validação de qualidade, passamos a ter centenas de modelos de dados com boa cobertura de testes e documentação web acessível a todos.</p><p>Com modelos cada vez mais complexos, ao longo do ciclo de desenvolvimento, erros se tornam mais frequentes e para maioria deles, dependemos de tentativa de execução no BigQuery para percebê-los. Entendemos que o ambiente de desenvolvimento e ciclo de feedback ainda estava longe do ideal. Havia espaço para melhora.</p><h3>Amora</h3><p>Após estressarmos o uso do DBT, formamos uma opinião sobre o que gostamos e o que poderia ser melhor. Como na maioria dos times de dados, usamos Python, linguagem de programação que se tornou o padrão da indústria em projetos de dados e machine <em>learning</em>. Estamos acostumados com a ótima ergonomia de desenvolvimento que a linguagem nos oferece e gostaríamos de ter as mesmas facilidades na manipulação de grandes volumes de dados. A solução que combina SQL com Jinja2 tem um ambiente de desenvolvimento deficiente:</p><ul><li>Falta de link entre o schema de dados e o ambiente de desenvolvimento. Sem isso, a IDE não consegue oferecer autocomplete de código.</li><li>Erros sintáticos não são detectados no ambiente de desenvolvimento, nem no processo de compilação.</li></ul><p>Amora nasceu da ideia de criar uma prova de conceito capaz de utilizar Python para criar um ambiente ergonomicamente mais confortável para analistas e engenheiros de dados descreverem modelos de dados e suas respectivas transformações. Com o Amora, descrevemos o esquema dos dados através de anotações de tipos (<a href="https://diogommartins.medium.com/python-3-e-type-hints-40e80a9e8214">PEP484</a>) e transformações de dados através de SELECTs com <a href="https://github.com/sqlalchemy/sqlalchemy">https://github.com/sqlalchemy/sqlalchemy</a>. Amora então é capaz de transformar <strong>código Python</strong> em <a href="https://cloud.google.com/bigquery/docs/jobs-overview">Jobs</a> de transformação de dados que rodam no <em>Data Warehouse</em>.</p><p><a href="https://github.com/mundipagg/amora-data-build-tool">GitHub - mundipagg/amora-data-build-tool: Amora Data Build Tool enables analysts and engineers to transform data on the data warehouse (BigQuery) by writing Amora Models that describe the data schema using Python&#39;s &quot;PEP484 - Type Hints&quot; and select statements with SQLAlchemy. Amora is able to transform Python code into SQL data transformation jobs that run inside the warehouse.</a></p><h3>Preparando ambiente</h3><p>Para instalar o amora em um novo projeto, sigas as instruções da documentação oficial: <a href="https://mundipagg.github.io/amora-data-build-tool/#installation">https://mundipagg.github.io/amora-data-build-tool/#installation</a></p><h3>AmoraModel</h3><blockquote>💡 Caso prefira, os modelos/exemplos abaixo estão disponíveis no repositório oficial do amora no GitHub: <a href="https://github.com/mundipagg/amora-data-build-tool/tree/main/examples/amora_project">https://github.com/mundipagg/amora-data-build-tool/tree/main/examples/amora_project</a></blockquote><p>Um modelo de dados Amora é definido como uma subclasse de amora.models.AmoraModel. Uma forma de expressar o <a href="https://mundipagg.github.io/amora-data-build-tool/models/#data-schema">esquema de dados</a>, o modo de <a href="https://mundipagg.github.io/amora-data-build-tool/models/#model-configuration">materialização</a> e, opcionalmente, uma declaração de transformação.</p><p>Para esse exemplo, usaremos <a href="https://support.apple.com/en-ca/guide/iphone/iph5ede58c3d/ios">dados exportados do app Apple Health</a>, que concentra dezenas de tipos de dados, dos quais usaremos apenas os dados de frequência cardíaca. Pra isso, vamos criar os modelos Health e HeartReate.</p><pre>from datetime import datetime</pre><pre>from amora.types import Compilable<br>from amora.models import (<br>    AmoraModel,<br>    ModelConfig,<br>    PartitionConfig,<br>    MaterializationTypes,<br>)<br>from examples.amora_project.models.health import Health<br>from sqlmodel import Field, select</pre><pre>class HeartRate(AmoraModel, table=True):<br>    __tablename__ = &quot;heart_rate&quot;<br>    __depends_on__ = [Health]<br>    __model_config__ = ModelConfig(<br>        description=&quot;Dados de batimento cardíaco coletados pelo Apple health&quot;,<br>				materialized=MaterializationTypes.table,<br>        partition_by=PartitionConfig(<br>            field=&quot;creationDate&quot;, data_type=&quot;TIMESTAMP&quot;, granularity=&quot;day&quot;<br>        ),<br>        cluster_by=[&quot;sourceName&quot;],<br>        labels={&quot;freshness&quot;: &quot;daily&quot;},<br>    )</pre><pre>    creationDate: datetime<br>    device: str<br>    endDate: datetime<br>    id: int = Field(primary_key=True)<br>    sourceName: str<br>    startDate: datetime<br>    unit: str<br>    value: float</pre><pre>    @classmethod<br>    def source(cls) -&gt; Compilable:<br>        return select(<br>            [<br>                Health.creationDate,<br>                Health.device,<br>                Health.endDate,<br>                Health.id,<br>                Health.sourceName,<br>                Health.startDate,<br>                Health.unit,<br>                Health.value,<br>            ]<br>        ).where(Health.type == &quot;HeartRate&quot;)</pre><p>No exemplo acima, podemos observar as partes descritas anteriormente:</p><h3>Esquema de dados</h3><pre>creationDate: datetime = Field(description=&quot;Data de inserção dos dados&quot;)<br>device: str = Field(description=&quot;Dispositivo de origem dos dados&quot;)<br>endDate: datetime = Field(description=&quot;Data do fim da medida&quot;)<br>id: int = Field(primary_key=True, description=&quot;Id único da medida&quot;)<br>sourceName: str = Field(description=&quot;Origem dos dados&quot;)<br>startDate: datetime = Field(description=&quot;Data do início da medida&quot;)<br>unit: str = Field(description=&quot;Unidade de medida&quot;)<br>value: float = Field(description=&quot;Valor observado&quot;)</pre><h3>Configuração de materialização</h3><pre>__model_config__ = ModelConfig(<br>      description=&quot;Dados de batimento cardíaco coletados pelo Apple health&quot;,<br>      materialized=MaterializationTypes.table,<br>      partition_by=PartitionConfig(<br>          field=&quot;creationDate&quot;, data_type=&quot;TIMESTAMP&quot;, granularity=&quot;day&quot;<br>      ),<br>      cluster_by=[&quot;sourceName&quot;],<br>      labels={&quot;freshness&quot;: &quot;daily&quot;},<br>  )</pre><h3>Declaração de transformação</h3><pre>@classmethod<br>def source(cls) -&gt; Compilable:<br>    return select(<br>        [<br>            Health.creationDate,<br>            Health.device,<br>            Health.endDate,<br>            Health.id,<br>            Health.sourceName,<br>            Health.startDate,<br>            Health.unit,<br>            Health.value,<br>        ]<br>    ).where(Health.type == &quot;HeartRate&quot;)</pre><p>Esse código é suficiente para que o Amora entenda que:</p><ul><li>O modelo HeartRate deve ser criado como uma tabela particionada no BigQuery</li><li>A coluna creationDate deve ser usada como campo de particionamento</li><li>Os dados devem ser agrupados através da coluna sourceName</li><li>A declaração de transformação necessária para gerar a tabela</li><li>O esquema final dos dados gerados pela transformação</li><li>Os modelo de dados necessário para a transformação de dados, Health</li></ul><p>A partir dessa definição, podemos usar a <a href="https://mundipagg.github.io/amora-data-build-tool/cli/">CLI</a> do amora para transformar código Python em uma tabela no BigQuery.</p><h3>CLI</h3><p>Ao instalar o amora como dependência, o comando amora é disponibilizado no seu ambiente. Para uma lista completa dos comandos, com documentação, basta executar amora —help.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dzUg0EremtJhfUCWWjDeUA.gif" /><figcaption>amora help</figcaption></figure><h3>amora compile</h3><p>Para compilar o modelo que acabamos de escrever em código SQL, vamos usar o comando compile</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0eTVAI5uC5wkqPOYmWrEhA.gif" /><figcaption>amora compile</figcaption></figure><h3>amora materialize</h3><p>Para criar a tabela no <em>Data Warehouse</em>, vamos usar o comando materialize. Se quiser uma visualização da ordem que a materialização ocorrerá, basta passar a flag —draw-dag . Como o amora é capaz de entender a dependência entre os modelos, os modelos são criados na ordem correta. Também significa que no futuro, podemos paralelizar a execução e tornar todo o processo mais veloz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZAjNlA0NuDpXngI3-P_oww.gif" /><figcaption>amora materialize</figcaption></figure><h3>amora test</h3><p>Agora que já temos os dados no <em>Data Warehouse</em>, precisamos nos certificar de que temos dados de qualidade. Vamos aos testes!</p><p>No amora, testes também são escritos como código Python, onde cada teste é uma afirmação sobre uma determinada característica dos dados. Sobre os dados de batimentos cardíacos, as seguintes afirmações devem ser verdadeiras:</p><ul><li>O valor observado por uma coleta de frequência cardíaca não pode ser negativo.</li><li>Como HeartRate é derivado de Health, as linhas de HeartRate devem estar contidas em Health</li><li>A unidade de medida deve ser count/min</li><li>A coluna endDate deve ser uma data futura a startDate</li></ul><pre>from amora.tests.assertions import (<br>    relationship,<br>    that,<br>    is_non_negative,<br>    has_accepted_values,<br>    expression_is_true,<br>)<br>from examples.amora_project.models.health import Health<br>from examples.amora_project.models.heart_rate import HeartRate</pre><pre>def test_value_is_non_negative():<br>    assert that(HeartRate.value, is_non_negative)</pre><pre>def test_relates_to_health():<br>    assert relationship(from_=HeartRate.id, to=Health.id)</pre><pre>def test_unit_accepted_values():<br>    assert that(HeartRate.unit, has_accepted_values, values=[&quot;count/min&quot;])</pre><pre>def test_end_date_after_start_date():<br>    assert expression_is_true(HeartRate.endDate &gt;= HeartRate.startDate)</pre><p>Uma asserção de dados é uma <em>query</em> que busca por problemas no <em>dataset</em>. Por exemplo, a afirmação <a href="https://mundipagg.github.io/amora-data-build-tool/tests/assertions/#amora.tests.assertions.is_non_negative">is_non_negative</a> vai buscar por valores em que HeartRate.value seja &lt; 0.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/516/1*tTuTT5tFISKBlkZoDWAi2w.png" /><figcaption>amora test — Fluxo de asserção de dados de um teste</figcaption></figure><p>Se nenhuma linha for retornada, nenhum erro foi encontrado. Caso contrário, o retorno são valores que invalidam a afirmativa. Testes de dados são realizados dessa forma pois costuma ser mais fácil buscar por problemas do que pela ausência deles e, em caso de erros, é mais útil ter em mãos exemplos de valores que invalidam a afirmativa.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q2LGK-YrnOKltRpT2Ec-pw.png" /><figcaption>amora test — Exemplo de falha em teste</figcaption></figure><p>Existe um custo financeiro atrelado ao escaneamento dos dados no Big Query, e ao final dos testes, Amora disponibiliza um relatório de estimativa de custos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rmuVTIhLWKi43wezf_p2Pw.png" /><figcaption>amora test — Exemplo de relatório de custos</figcaption></figure><p>Como testes Amora são testes Python construídos utilizando p<a href="https://github.com/pytest-dev/pytest/">ytest</a>, você pode executar os testes como você já está habituado a executar qualquer outro teste. Seu <em>debugger</em> e todas as facilidades que você tem no seu ferramental de testes podem ser usadas. Se preferir, basta rodar os testes usando a CLI amora test, que a execução dos testes será paralelizada em múltiplos processos, usando <a href="https://github.com/pytest-dev/pytest-xdist">pytest-xdist</a>.</p><p>Espero ter conseguido deixar um gosto do que é possível construir! Se quiser saber mais, acompanhar e colaborar com o projeto, não deixe de dar uma estrela no GitHub: <a href="https://github.com/mundipagg/amora-data-build-tool">https://github.com/mundipagg/amora-data-build-tool</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d7b92acbc687" width="1" height="1" alt=""><hr><p><a href="https://medium.com/stonetech/amora-data-build-tool-d7b92acbc687">Amora Data Build Tool</a> was originally published in <a href="https://medium.com/stonetech">stonetech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pronto pra produção?]]></title>
            <link>https://diogommartins.medium.com/pronto-pra-produ%C3%A7%C3%A3o-aafac3d7c157?source=rss-fff15274c61f------2</link>
            <guid isPermaLink="false">https://medium.com/p/aafac3d7c157</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[reliability-engineering]]></category>
            <category><![CDATA[technical-debt]]></category>
            <category><![CDATA[coding]]></category>
            <dc:creator><![CDATA[Diogo Magalhães Machado]]></dc:creator>
            <pubDate>Wed, 24 Feb 2021 07:34:41 GMT</pubDate>
            <atom:updated>2021-02-24T18:14:20.297Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*d-FCgOjFXeZTY32m.jpg" /></figure><p>Como desenvolvedores, escrevemos código na firma para resolver algum problema de negócio para que ela consiga se manter atendendo clientes/usuários, idealmente entregando algum valor pra sociedade e ganhando dinheiro com isso. Manter aplicações em produção, que precisam constantemente mudar para acompanhar as necessidades de negócio, ser confiáveis, disponíveis e previsíveis ao longo do tempo de vida é algo que exige esforço e planejamento constantes.</p><p>Para um negócio que depende diretamente de Engenharia de Software para crescer, existem vários indicadores de performance que estão diretamente ligados ao nosso trabalho, mas vou citar só alguns convenientes pro ponto que quero abordar. 😝</p><ul><li><strong>Lucratividade: </strong>Custo de operação é um vetor muito importante para definição do lucro ao longo do tempo. Dinheiro não é infinito e a maioria dos negócios digitais apostam em crescimento da base de usuários e na <a href="https://pt.wikipedia.org/wiki/Economia_de_escala">Economia de escala</a>. Com o advento das clouds, nunca foi tão fácil gastar mais dinheiro do que o necessário para resolver determinado problema. Além disso, se iterações no software exigem uma fricção maior do que a necessária, por falta de conhecimento dos responsáveis e/ou qualidade da base de código, o desenvolvimento se torna mais demorado e mais caro.</li></ul><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FN6lYcXjd4pg&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DN6lYcXjd4pg&amp;image=http%3A%2F%2Fi.ytimg.com%2Fvi%2FN6lYcXjd4pg%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/90db707bed0e4383aa7ef40fdc09c8ab/href">https://medium.com/media/90db707bed0e4383aa7ef40fdc09c8ab/href</a></iframe><ul><li><strong>Disponibilidade:</strong> Estamos acostumados a sempre ter acesso a uma tela pronta para ser operada, seja um notebook, celular, TV, … Quando a bateria acaba, ficamos sem sinal ou esgotamos nosso plano de dados, a experiência não é a mesma, né? Se o produto existe, mas não pode ser utilizado, não há entrega de valor. Na era do imediatismo, problemas crônicos de disponibilidade tendem a gerar estresse e abalo de confiança podendo representar um risco para sobrevivência e sucesso de um produto.</li><li><strong>Nível de qualidade de serviço: </strong>Lá pra 2018, morando no centro do Rio de Janeiro, eu tinha uma TV 4K e uma internet nada estável de 2Mb da Oi. Consegue imaginar como era tentar ver algum video em 4K no YouTube? Só fui de fato usufruir da imagem da TV mais de 1 ano depois, após um upgrade no plano de internet. O Software desenvolvido precisa atender e acompanhar as expectativas dos clientes.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/418/0*tSDCJWIjNxshfa-X.jpg" /></figure><ul><li><strong>Ticket médio: </strong>Já pagou por algo que depois se arrependeu ou a conta de um restaurante que foi mal atendido? Você provavelmente não voltou mais no restaurente. Assim como o desenvolvimento de novas features em um software pode levar o seu produto a ter um valor de mercado maior ou a expandir o público alvo, uma experiência ruim ou incompleta pode levar a perda de clientes, valor de mercado mais baixo ou até mesmo cenários mais graves, como perda de dinheiro em ações judiciais.</li><li><strong>Índice de Turnover: </strong>O mercado de engenharia de software está extremamente aquecido no mundo todo. Isso significa que o tempo de vida do software tende a ser maior do que a permanência dos desenvolvedores. Se um software depende de um humano específico para ser desenvolvido e operado com eficiência, dá pra imaginar o que acontece quando esse desenvolvedor não estiver mais presente, né?</li></ul><p>Ao longo do tempo, fui criando opinião sobre o conjunto de boas práticas que julgo necessárias para garantir um impacto positivo nesses indicadores. Quando entro em contato com um novo software que eu tenha que interagir ou criar, tento responder algumas perguntas:</p><h3>👩🏻‍💻 Ciclo de desenvolvimento</h3><ul><li>Existem testes adequados do tipo lint (análise estática de código)? Quais os cenários não cobertos?</li><li>Existem testes fim-a-fim adequados?</li><li>Existem testes adequados para validar os pontos de integração com outros serviços?</li><li>O código-fonte é versionado?</li><li>Existe um guia de contribuição para que novos desenvolvedores saibam como abordar a base de código?</li><li>Existe uma política de <strong>code review</strong> para garantir que mais de um desenvolvedor seja responsável pela validação de qualidade das mudanças?</li><li>O processo de build e teste é automatizado? Rodam a cada commit na ferramenta de CI?</li><li>Existe uma política de cobertura de testes? O nível de cobertura é conhecido?</li><li>Códigos que reduzem a cobertura de testes podem ser mergeados na branch principal?</li></ul><h3>🔧 Gerenciamento de Configuração</h3><ul><li>É possível alterar a configuração da aplicação sem uma nova build?</li><li>É possível alterar a configuração da aplicação sem um novo deploy?</li><li>Existe versionamento de configuração?</li><li>É possível indentificar qual era a configuração da aplicação em determinado momento?</li><li>Configurações contendo dados sensíveis são tratadas de forma adequada?</li></ul><h3>🚀 Pipeline de Deploy</h3><ul><li>Existe um pipeline de deploy automatizado?</li><li>Existe uma fase de homologação em um ambiente replicado?</li><li>Todo o ambiente está replicado ou só parte dele?</li><li>Testes em ambiente de homologação são realizados antes de liberados para produção? (end-to-end, carga, etc.)</li><li>O ambiente de homologação tem algum acesso ao ambiente de produção ou são ambientes totalmente isolados?</li><li>Existe deploy canário na pipeline? Quando uma nova versão da aplicação vai para o ambiente de produção, ela substitui gradualmente a versão anterior ou é liberada para toda a base de clientes?</li><li>Existe um procedimento rápido para pular etapas de qualidade em caso de emergência?</li><li>Existe uma forma fácil de fazer rollback de uma versão defeituosa caso necessário?</li></ul><h3>🏎 Escalabilidade e desempenho</h3><ul><li>Qual a escala de crescimento quantitativo/qualitativo do serviço? Qual foi o crescimento de uso nos últimos meses?</li><li>Tecnologias de abstração e alocação de recursos fazem parte da solução?</li><li>Quais são os requisitos de recursos do serviço (CPU, RAM, etc….)?</li><li>Quanta CPU uma instância precisa? Lida bem com múltiplos núcleos?</li><li>Quanta RAM uma instância precisa?</li><li>Qual o tráfego que 1 instância consegue lidar? Quantos clientes é possível atender?</li><li>Existem requisitos de recursos específicos como acesso a disco, rede de alto desempenho, acesso a GPU, …?</li><li>Quais os gargalos de recurso da aplicação?</li><li>A aplicação precisa ser escalada verticalmente, horizontalmente ou ambos?</li><li>Existe política que garanta escalabilidade automática de recursos?</li><li>Qual o percentual ideal de uso de cada recurso? (Usado / Disponível)</li><li>Quanto custa manter uma instância em produção?</li></ul><h3>🏗 Dependências</h3><ul><li>Quais as dependências dessa aplicação?</li><li>Existe verificação automática de atualização de dependências de pacotes?</li><li>As dependências estão listadas de forma a gerar builds determinísticas?</li><li>São implementados mecanismos de quebra de circuito para as dependências?</li><li>As dependências são escaláveis e de desempenho equivalente ao necessário pelo aplicação?</li><li>Se são escaláveis, elas vão escalar automaticamente quando a aplicação demandar por mais recursos?</li></ul><h3>📈 Tráfego</h3><ul><li>Os padrões de tráfego são previsíveis?</li><li>Os padrões de tráfego são bem entendidos pelo time?</li><li>As mudanças no serviço são programadas de acordo com o tráfego?</li><li>O aumento abrupto de tráfego é tratado de forma adequada?</li><li>O tráfego pode ser redirecionado para outros ambientes em caso de problemas físicos em um Datacenter?</li></ul><h3>📝 Logging</h3><ul><li>O log reflete o estado do serviço em qualquer momento?</li><li>O log é financeiramente escalável?</li><li>Os logs são corretamente separados em níveis adequados?</li><li>O serviço grava todas as informações relevantes para depuração de problemas?</li><li>Por quanto tempo logs são retidos?</li><li>Os logs são facilmente indexáveis, buscáveis e agrupáveis (log estruturado, em json…)?</li><li>É possível rastrear os eventos em todo o sistema a partir de um log específico de alguma aplicação?</li><li>Os nossos logs salvam informações sensíveis? Se sim, é possível controlar o acesso a essas informações?</li></ul><h3>📊 Métricas</h3><ul><li>Quais são as principais métricas de saúde? Consigo saber através de dados e com facilidade se a aplicação está fazendo o que deveria ou se tem algo de errado?</li><li>Quais são as métricas de servidor e infra?</li><li>As métricas existentes são confiáveis e refletem a realidade do serviço em qualquer momento?</li><li>As métricas possuem visualizações para serem monitoradas e possuem alertas?</li></ul><h3>⚠️ Alertas</h3><ul><li>Existem alertas para todas as métricas principais?</li><li>Todos os alertas definidos estão configurados com níveis adequados?</li><li>Os alertas são configurados de forma em que o time seja notificado antes que haja uma interrupção de serviço?</li><li>Existem instruções para triagem e atuação nos alertas?</li><li>Os responsáveis por atuarem em um determinado evento são capacitados e alinhados com a forma de agir sobre o incidente?</li></ul><h3>🔨 Processamento de Tarefas</h3><ul><li>A aplicação está escrita em linguagem de programação compatível com as necessidades de escala e desempenho?</li><li>Os desenvolvedores responsáveis entendem os fluxos de processamento de tarefas da aplicação?</li><li>Existem limitações de escalabilidade conhecidas na forma como a aplicação processa as tarefas?</li></ul><h3>📂 Armazenamento</h3><ul><li>Que tipos de dados a aplicação precisa armazenar?</li><li>Qual o schema dos tipos de dados armazenados?</li><li>A aplicação faz mais operações de escrita, leitura ou ambos?</li><li>O armazenamento é escalado horizontalmente ou verticalmente?</li><li>O armazenamento é compartilhado com outras aplicações?</li><li>O armazenamento é replicado?</li><li>O que acontece em caso de falha em uma instância de armazenamento?</li><li>Há armazenamento de informações sensíveis? Há controle de acesso para essas informações?</li><li>Quantas transações são feitas por minuto ou segundo?</li><li>Qual a taxa de crescimento dos dados a serem armazenados?</li><li>Existe uma política de expurgo de dados?</li></ul><h3>🔄 Ciclo de Vida</h3><ul><li>A aplicação passa por um período de warmup durante a inicialização?</li><li>Tráfego é direcionado para a instância durante o warmup?</li><li>A aplicação responde adequadamente a sinais de interrupção do SO?</li><li>Existe graceful shutdown?</li><li>O graceful shutdown pode ser realizado dentro do tempo de tolerância?</li></ul><h3>🤯 Caos, catástrofes e falhas</h3><ul><li>Existem falhas conhecidas? Quais as falhas são comuns no ecossistema da aplicação?</li><li>Como as falhas e interrupções impactam o negócio?</li><li>Quais falhas internas podem derrubar a aplicação?</li><li>Quais falhas de dependência podem afetar a aplicação?</li><li>Existe um ponto único de falha? Ele pode ser eliminado ou contornado?</li><li>São realizados testes de carga regulares?</li><li>Os teste de carga incluem teste de caos?</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/0*733_WBTVI_wv4h8Y.jpg" /><figcaption>Só porque eu gosto da cara desse moleque</figcaption></figure><p>⚠️ Essa é uma lista viva e contribuições nos comentários são bem vindas! <br>Nem todas as perguntas se aplicam a todos os casos e é importante sempre se questionar o que faz sentido para cada caso.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aafac3d7c157" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como eu enxergo meu relacionamento com trabalho]]></title>
            <link>https://diogommartins.medium.com/como-eu-enxergo-meu-relacionamento-com-trabalho-ef5bc37d0b7c?source=rss-fff15274c61f------2</link>
            <guid isPermaLink="false">https://medium.com/p/ef5bc37d0b7c</guid>
            <category><![CDATA[work-life-balance]]></category>
            <category><![CDATA[developer-relations]]></category>
            <category><![CDATA[society]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[work]]></category>
            <dc:creator><![CDATA[Diogo Magalhães Machado]]></dc:creator>
            <pubDate>Tue, 25 Dec 2018 22:10:37 GMT</pubDate>
            <atom:updated>2018-12-25T22:10:37.519Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eQx3w_IuTKiABJ592mGMGg.jpeg" /><figcaption>PythonBrasil 2018</figcaption></figure><p>Pra não correr o risco de ser mal interpretado, eu preciso começar falando sobre a minha origem pra dar um pouco de contexto e não correr o risco de ser julgado como startupeiro, workaholic ou seguidor de guru empreendedor de palco.</p><h3>Contexto</h3><p>Filho único de uma família de classe média moradora da Praça Seca, subúrbio do Rio de Janeiro. Minha mãe, hoje aposentada, era uma professora de História que sempre deu aula em colégios públicos dos mais diversos. Meu pai, que sempre foi autônomo e terminou sua carreira como motorista de van, nos anos 90 tinha um pequeno comércio na Zona Norte e ganhava um dinheiro extra revendendo mercadorias contrabandeadas do Paraguai, que comprava fazendo longas viagens de ônibus do RJ até lá. Foi uma infância feliz e apesar de suburbanos, o trabalho duro do meu pai e a visão dos meus pais de sempre me proporcionar o melhor, me possibilitaram desde cedo o contato com tecnologia.</p><p>Essas viagens ao Paraguai foram o que possibilitaram que eu tivesse o meu primeiro computador, um 486, aos 7 anos de idade. Nem meu pai nem minha mãe tinham contato ou interesse por tecnologia, mas tenho certeza de que conseguiam ver que ali que tava o futuro. Nessa mesma época, meu padrinho cursava Engenharia Elétrica com ênfase em computação na UERJ, me ensinou a dar os primeiros passos por esse universo. Foi a era do DOS e do Windows 3.11 instalado em vários disquetes.</p><p>O tempo passou, meus pais se divorciaram e eu fiquei com a minha mãe. Dentre outros motivos, a falta de dinheiro, de casa própria e de pensão para ajudar a me sustentar, levaram minha mãe a voltar para a casa dos pais e a trabalhar em até 3 escolas ao mesmo tempo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*sG1_K770A5MaTalPLfacWg.jpeg" /><figcaption>Odilon e Neuza</figcaption></figure><p>Meus avós maternos são originalmente de Campo Grande. Minha avó, senhora de doçura inacreditável, trabalhou como enfermeira e virou dona de casa após o casamento. Meu avô, policial civil, homem de caráter íntegro, sempre presente e preocupado com meu bem estar e futuro intelectual e profissional. Meu avô não foi muito longe na educação formal, mas leu bastante, vivia com o jornal na mão e sempre teve um olhar crítico do mundo.</p><p>Introvertido e de poucos amigos, minha maior companhia sempre foi ele, o computador. Sem dinheiro pra desperdiçar, fui aprendendo a direcionar minha mãe a comprar peças no mercado cinza do Edifício Central e do Shopping São Luiz (famoso shopping dos peixinhos de Madureira) e eu fazia os <em>upgrades</em>. Assim como programação, fui aprendendo inglês sozinho, primeiro com os jogos, depois com filmes pirateados sem legendas em português, até chegar na adolescência, onde eu já fazia a tradução e legendas de animes e filmes inteiros (de inglês pra português, claro…) e adicionando as legendas esperando horas no ffmpeg.</p><p>Minha primeira internet banda larga foi a easyline, uma internet predial. Era uma empresa pequena que disponibilizava uma banda muito boa pra época e uma infraestrutura de rede bem duvidosa. Todos os clientes estava na mesma rede e a limitação de banda por usuário era inexistente — você tinha tanta banda quando conseguisse usar. Nessa época eu vivia no <a href="https://pt.wikipedia.org/wiki/Internet_Relay_Chat">IRC</a>, escrevia e editava bots por diversão e ia descobrindo uma infinidade de coisas nas comunidades ou sozinho, lendo tutoriais pela internet.</p><p>O modelo de rede da easyline era perfeito pra jogar Counter-Strike em LAN com os vizinhos, mas tava longe de ser uma distribuição justa entre os usuários. Eles &quot;melhoraram&quot; o modelo e, sabe-se lá porque, passaram a implantar a limitação de banda atrelada a endereços IP. Curioso com as alternativas ao mundo Microsoft, eu já fazia dual boot no computador entre Windows e Linux (conectiva, mandriva, kurumin, …). Era uma bosta pra instalar todos os drivers e ter tudo funcionando no Linux — o que rendia xingamentos da minha mãe que também usava o computador — mas a dificuldade fazia parte da graça e acabei aprendendo a tapear o provedor tendo múltiplas interfaces virtuais pra aumentar a banda dos meus downloads.</p><p>Nessa época, eu já sabia o básico de HTML e como fazer layouts e links com tabelas e imagens construídas e recortadas em programas como Photoshop e Corel Draw. Tudo pirateado mesmo. O dinheiro só dava pra hardware, comprar software estava fora de cogitação e software livre é um conceito que eu só entenderia de fato anos depois. Controle de versão também &quot;não existia&quot; e tudo era compartilhado em .zip e .rar… E o &quot;deploy&quot;? Alguém lembra de usar FTP ou aquelas interfaces horríveis de hospedagens como do kit.net, hpg, bol, geocities, e etc ?</p><h4>Educação</h4><p>Minha mãe nunca economizou em edução e mesmo se sacrificando, nunca deixou de me colocar em colégios particulares. Nada muito caro, mas obviamente muito melhor que os colégios públicos do Rio.</p><p>Chegando no ensino médio, era a época do ápice de popularidade do ensino técnico, o que levou minha mãe a me matricular em Telecomunicações no Colégio Lemos de Castro em Madureira e me arrependi pelos próximos anos de não ter tido voz ativa em escolher Informática, que obviamente era minha preferência. Ali, a maior parte das coisas era teórica e superficial, o que não me dava prazer em aprender quase nada. Gostava muito das poucas aulas em laboratório, seja manipulando diretamente as placas e criando circuitos simples ou fazendo o mesmo nos computadores. A parte mais legal sempre foi juntar componentes para interagirem de uma forma e ordem específica e ter como consequência algum trabalho ou automação!</p><p>Nessa mesma época, fiz um curso de <a href="https://www.autodesk.com.br/products/3ds-max/overview">3D Studio Max</a> no colégio que me deixou maravilhado. Já adorava jogos e animações 3D e poder criar formas e animações mesmo que de forma bem rústica, fazia com que os meus olhos brilhassem. Meu trabalho final no curso foi uma animação de uma viagem ao redor do sistema solar. Fiz todos os planetas, a animação de câmera, etc. Ficou uma bosta, demorava horas pra renderizar no meu computador, mas eu gostei.</p><p>No final do ensino técnico, fiz meu primeiro estágio, no Campo dos Afonsos em Sulacap. Fazia manutenção em equipamentos de radiocomunicação e radares de aeronaves de transporte da FAB. Parece complexo, mas nem é tanto assim. Existiam manuais bem claros e com testes de unidades muito bem definidos e o meu papel era basicamente utilizar os instrumentos disponíveis e debugar os equipamentos seguindo os testes até achar algum problema, substituir o componente ou módulo e refazer os testes até tudo passar. Nos equipamentos de comunicação, ainda tinha a etapa mais legal, que era o teste de aceitação com a torre de comando da base rsrs. Eu não recebia 1 centavo por isso e dependia totalmente do meu avô e da minha mãe pro meu sustento.</p><p>Terminei o ensino médio técnico com nenhuma vontade de seguir telecomunicações.</p><p>Passei um tempo meio perdido na vida, minha mãe não tinha condições de pagar um pré vestibular e eu não tinha muitas chances de passar no vestibular sozinho. Meu padrinho ajudou, pagou 6 meses de pré-vestibular e eu acabei passando no vestibular para <a href="http://bsi.uniriotec.br/bsi/index.html">Sistemas de Informação na UNIRIO</a>.</p><p>Aprendi muito sobre TI lá, mas acredito que aprendi mais ainda sobre a vida e sobre mim mesmo. Tive a certeza de que não consigo aprender ou me dedicar pra fazer alguma coisa que eu não acredite que faz sentido pra mim de forma direta ou indireta. Aprendi o abismo absurdo que existe entre bons e maus professores e o efeito que isso tem em quem quer aprender. A diferença entre eles era sempre óbvia: um amava o que fazia e o outro não. Essa diferença de energia sempre foi óbvia pra mim com o meu contato com minha mãe. Sempre vi o quão amada a minha mãe era em sala de aula pelos alunos e por colegas de profissão, seja dando aula de História ou na sala de recursos, onde cuidava de alunos com necessidades especiais. Salário de professor sempre foi uma merda, mas ela sempre deu o melhor de si por amar a profissão.</p><p>Repeti cálculo 3 vezes até cursar com um professor que de fato tinha paciência pra entender a minha dificuldade, me ensinar e me mostrar a utilidade. Não era bom aluno e acabei sendo rejeitado como monitor de programação por não ter CR suficiente… Passei pela perda dos meus avós, que no final da vida, tive o prazer de retribuir o carinho e cuidado que tiveram comigo. Sofri com a minha avó esquecendo quem eu era após uns 10 anos convivendo com Alzheimer e com meu avô doente ficando acamado e dependendo de mim e da minha mãe para tudo.</p><p>Foi um processo de muitos anos onde na maioria dos dias eu acabava aprendendo mais nas ~4 horas que passava por dia no caminho Praça Seca - Urca - Praça Seca do que de fato em sala de aula ou trabalhando. Lia bastante sobre tudo, seja em livros físicos ou no smartphone. Assistia palestras de todos os eventos possíveis, lia documentações e tutoriais, aprendia sobre linguagens, frameworks, bancos de dados, algoritmos, micro serviços e sempre quis entender tudo sobre o que me despertava interesse.</p><h4>Esclarecimento e Trabalho</h4><p>Aprender sobre tecnologia e desenvolvimento nunca foi um fardo pra mim e a linha divisória entre trabalho e lazer sempre foi quase inexistente. Aprender e por em prática nunca foi o problema, o método e o objetivo é que podiam ser um problema. Eu infelizmente demorei bastante tempo pra amadurecer esse pensamento, mas a fórmula é relativamente simples: Não delegar aos outros a responsabilidade do meu aprendizado ou crescimento. Só eu posso dizer o que funciona melhor pra mim, só eu posso dizer o que eu quero ou não aprender e fazer, e o comprometimento de entrega pra fazer alguma coisa da melhor forma possível só vem se eu olhar pra mim mesmo como responsável por isso. Precisei passar por uma depressão e um bom tempo de terapia pra tirar essa e outras conclusões.</p><p>Como essa lógica se encaixa no trabalho? Vamos considerar que você precisa trabalhar pelo menos 35 anos pra se aposentar. Em uma conta de padaria, considerando um trabalho de 40 horas semanais, 35 anos são 1825 semanas, o que dá <em>73.000 fucking horas</em>. Esse número assusta e é <strong>tempo pra caralho</strong> se você olhar pra trabalho como uma forma de trocar seu tempo por dinheiro. Afinal de contas, trocar tempo por dinheiro é uma péssima ideia, principalmente na indústria que eu estou inserido. Falei sobre meus antepassados e sobre o meu contexto justamente pra mostrar que me comparando com eles, eu sou sim, privilegiado por poder optar não fazer essa troca.</p><blockquote>Essa conta obviamente só vale se você conseguir passar todo esse tempo como desenvolvedor. O que não parece algo estatisticamente realista [<a href="https://insights.stackoverflow.com/survey/2018#developer-profile-age">1</a>][<a href="https://www.businessinsider.com/silicon-valley-age-programmer-2015-4">2</a>][<a href="https://www.businessinsider.com/what-happens-to-older-developers-2014-3">3</a>][<a href="https://medium.com/s/story/aging-in-the-tech-industry-6a0e116bdf09">4</a>]</blockquote><p>Não me leve a mal, dinheiro é muito importante, mas a curto prazo não tem que ser o fator mais importante (afinal de contas, quem ganha dinheiro <strong>mesmo</strong> é CNPJ, não CPF). Sendo assim, não faz sentido trabalhar com algo que além do retorno financeiro adequado, não proporcione a possibilidade de aprender coisas novas, melhorar as habilidades que você já tem e consequentemente aumentar mais ainda seu valor de mercado.</p><blockquote>&quot;O senhor só o é porque é reconhecido como tal pela consciência do escravo e também porque vive do trabalho desse escravo. Nesse sentido, ele é uma espécie de escravo de seu escravo.&quot; — Hegel em <a href="https://portalvermelhoaesquerda.wordpress.com/2016/08/16/hegel-a-dialetica-do-senhor-e-do-escravo/">A dialética entre o senhor e o escravo</a>.</blockquote><p>Acho que esse é um dos textos filosóficos mais úteis pra refletir sobre relações de trabalho e a relação de dominado e dominador, patrão e empregado. Por mais que todo um romance tenha sido criado e que palavras bonitas sejam usadas como <em>colaborador </em>e<em> associado</em> sejam usados substituir palavras como <em>empregado</em> e <em>funcionário </em>e denotar mudanças nas relações de trabalho, a relação de poder na maior parte dos casos não é tão horizontalizada assim.</p><p>O modelo dos nossos antepassados era mais simples: estude, trabalhe e receba dinheiro por isso até se aposentar, muitas vezes, no mesmo lugar onde começaram e sem qualquer possibilidade de ascensão social. Hoje em dia, principalmente na nossa indústria, isso funciona de forma bem diferente. É muito comum ter pessoas constantemente trocando de emprego e até mesmo de carreira, profissões deixam de existir, novas são criadas e o que eu observo é que essa relação de &quot;lealdade&quot; e conformidade de ambas as partes não existe mais.</p><p>A forma que eu acredito ser mais proveitosa pra alguém na minha situação colher resultados positivos é a seguinte:</p><ol><li>Faça com que o fruto do seu trabalho entregue valor para o crescimento da sua carreira. Enxergue você mesmo como um produto e itere sobre ele fazendo melhorias incrementais e constantes. Olhe pra empresa que você trabalha como seu cliente e faça com que o seu produto esteja o mais diretamente ligado possível com o valor que a sua empresa gera. Se você é um desenvolvedor, essa não tem que ser a parte difícil. Escolha um bom problema a ser resolvido e ao invés de resolver tarefas, foque-se em resolver os problemas certos do negócio e levar as pessoas a quererem o mesmo. Dessa forma, cada vez mais a empresa vai ser dependente do seu trabalho e não o contrário;</li><li>Junte-se com pessoas que vejam o mundo da mesma forma que você, que você respeite, que possa ser totalmente aberto e honesto, que queiram resolver os mesmos problemas e ir pro mesmo caminho. A lógica de colaboração sempre vai fazer sentido e ser vitoriosa a longo prazo. As pessoas com quem você trabalha tem que ser seus parceiros, não seus concorrentes e todos devem crescer juntos. Afaste-se de pessoas tóxicas e tente não ser uma.</li><li>Você pode ter um chefe (se tiver &quot;sorte&quot;, vai ter um líder), mas ele não é nem capaz nem responsável pelo seu desenvolvimento. Um bom chefe te dá oportunidades que te ajudam com o item 1 e visibilidade das suas conquistas e avanços;</li><li>Nunca deixe de estudar e aprender. A educação é o maior instrumento de transformação social e você não precisa de ninguém além de você mesmo pra isso.</li></ol><p>Trabalhar possibilita pra mim e pras pessoas ao meu redor um horizonte de escolhas muito mais amplo do que os meus pais tiveram e do que a anos atrás eu podia imaginar ter pra mim. Hoje, com 31 anos, me sinto no auge da minha performance e ainda levemente arrependido por não ter, a 10 anos atrás, a cabeça que tenho hoje.</p><p>Sigo, com gosto, trabalhando bastante. Trabalho bastante porque faço o que eu amo e trabalho pra quem eu mais amo nesse mundo: eu mesmo.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ef5bc37d0b7c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Asyncworker — Microframework de consumers assíncronos em Python]]></title>
            <link>https://diogommartins.medium.com/asyncworker-microframework-de-consumers-ass%C3%ADncronos-em-python-f97cf64c6d1b?source=rss-fff15274c61f------2</link>
            <guid isPermaLink="false">https://medium.com/p/f97cf64c6d1b</guid>
            <category><![CDATA[asyncio]]></category>
            <category><![CDATA[asynchronous]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[rabbitmq]]></category>
            <category><![CDATA[development]]></category>
            <dc:creator><![CDATA[Diogo Magalhães Machado]]></dc:creator>
            <pubDate>Sun, 04 Nov 2018 22:40:24 GMT</pubDate>
            <atom:updated>2018-11-04T22:40:24.407Z</atom:updated>
            <content:encoded><![CDATA[<h3>Asyncworker — Microframework para consumers assíncronos em Python</h3><p>Na <a href="http://www.sieve.com.br/">Sieve</a>, as formas mais comuns de integração entre serviços são através de chamadas síncronas via requisições HTTP, ou de chamadas assíncronas a workers <a href="https://www.amqp.org/">AMQP</a>. Para HTTP, clientes ou servidores, utilizamos <a href="http://aiohttp.readthedocs.io/">aiohttp</a> para tudo. Atualmente, utilizamos o <a href="https://github.com/B2W-BIT/async-worker">asyncworker</a> na construção de novos workers e no processo de modernização de aplicações existentes.</p><p>Nesse post, vou tentar mostrar através de exemplos práticos por que criamos e utilizamos o asyncworker. Pra isso, vamos considerar como exemplo uma aplicação que consome mensagens de uma fila no <a href="https://www.rabbitmq.com/">rabbitmq</a> e indexa essas mensagens em um <a href="https://www.elastic.co/products/elasticsearch">Elasticsearch</a>.</p><p>Primeiro, nós precisamos de uma instância do rabbitmq rodando. Vamos fazer isso com <a href="https://www.docker.com/get-started">docker</a>:</p><pre>docker run -d -p 5672:5672 -p 15672:15672 -e RABBITMQ_DEFAULT_VHOST=/ --name rabbitmq rabbitmq:3.7.8-management-alpine</pre><p>No rabbit, a porta 5672 é utilizada para AMQP e a 15672 para interface de gerenciamento HTTP. Essa imagem tem usuário e senha padrão como guest/guest. Você consegue acompanhar o processo de start da aplicação através dos logs:</p><pre>docker logs -f rabbitmq</pre><h3>Producer</h3><p>Como queremos escrever um consumer com o asyncworker, agora que já temos uma instância do rabbitmq rodando, precisamos criar e alimentar uma fila, escrevendo um <em>producer</em> para dar algum trabalho para o nosso <em>consumer</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y59f8WEFCnVTTWQp3QP4JQ.png" /><figcaption>Fila <strong><em>words_to_index</em></strong> com o binding: exchange=default e routing_key=words</figcaption></figure><p>Nosso <em>producer</em> vai publicar uma mensagem nesta fila, contendo uma palavra a ser indexada no Elasticsearch pelo nosso <em>consumer</em>. Como input, vamos utilizar uma lista de palavras: <a href="https://s3.amazonaws.com/diogo.martins/public/portuguese-brazil.txt"><strong>https://s3.amazonaws.com/diogo.martins/public/portuguese-brazil.txt</strong></a></p><p>Esse arquivo contém uma palavra por linha, ~1 milhão de palavras e 11,4mb. Como não queremos ler todo o arquivo de uma vez e nem precisamos de todas as linhas pra esse exemplo, vamos fazer o streaming da parte do corpo que precisamos e vamos usar <em>aiohttp</em> pra isso.</p><pre>pip install aiohttp==3.4.4</pre><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/295925e0539c13b2f7151297e0d905ee/href">https://medium.com/media/295925e0539c13b2f7151297e0d905ee/href</a></iframe><p>Agora que já conseguimos ler linha a linha a lista de palavras, tudo que precisamos é nos conectar ao <em>rabbitmq</em> e publicar cada uma das mensagens na fila <em>words_to_index</em>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d9073a511593a80ad9049e5ec1c445b3/href">https://medium.com/media/d9073a511593a80ad9049e5ec1c445b3/href</a></iframe><p>Após rodarmos o script, podemos observar que 10000 mensagens foram produzidas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DEHixp3avmCOSDsrSXAJpw.png" /></figure><h3>Consumer</h3><p>Vamos começar instalando as dependências:</p><pre>pip install async-worker==0.5.0 aioelasticsearch==0.5.2</pre><p>Agora vamos subir uma instância de Elasticsearch, para que o nosso consumer consiga indexar as mensagens:</p><pre>docker run -d -p 9200:9200 -p 9300:9300 -e “discovery.type=single-node” --name elasticsearch docker.elastic.co/elasticsearch/elasticsearch:6.4.2</pre><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/97058cb6c493c1f7ced1d68e50d124ba/href">https://medium.com/media/97058cb6c493c1f7ced1d68e50d124ba/href</a></iframe><p>O código é bem simples, mas tem bastante coisa acontecendo por debaixo dos panos:</p><ul><li><a href="https://www.rabbitmq.com/confirms.html#acknowledgement-modes">ack / reject</a> automático de mensagens. Nesse caso, se o handler rodar com sucesso, todas as mensagem sofrerão ACK. Caso uma exceção não tratada seja capturada pelo asyncworker, todas as mensagens sofrerão REJECTe voltarão para a fila;</li><li>Reconexão automática em caso de perda de conexão;</li><li>Um consumer é criado para cada rota do handler e mensagens são <em>empurradas </em>pelo rabbitmq, neste caso, com <a href="https://www.rabbitmq.com/consumer-prefetch.html">prefetch</a> de 512 mensagens;</li><li>Recebemos dados em lote. Configuramos nossa rota com a opção de bulk de 256 mensagens, ou seja, o nosso handler será chamado com uma lista de 256 mensagens, o que é perfeito para o nosso caso em que queremos fazer um insert em bulk no elasticsearch.</li></ul><p>Neste exemplo, estamos consumindo mensagens somente da fila <em>words_to_index</em>, mas existem casos onde queremos tratar mensagens de filas diferentes da mesma forma. Pra isso, basta adicionarmos mais elementos à lista de rotas deste handler:</p><pre>@app.route([<strong>&quot;</strong>queue_name1<strong>&quot;</strong>, &quot;queue_name2&quot;, &quot;queue_name3&quot;], vhost=<strong>&quot;/&quot;</strong>)</pre><p>Já utilizarmos o asyncworker de forma estável em diversos serviços em produção e, comprovadamente, atende o seu principal objetivo: Ser simples e fazer com que o desenvolvedor se foque nas regras de negócio da aplicação e abstraia as peculiaridades de comunicação.</p><p>O que mostrei aqui é só uma parte do que é possível fazer com o asyncworker hoje, e ainda vamos adicionar muitas funcionalidades ao projeto, então recomendo à todos <a href="https://github.com/B2W-BIT/async-worker">que acompanhem o projeto</a>. Se você gostou, nos ajude colaborando no projeto ou dando uma estrela no github =)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f97cf64c6d1b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Aiologger - Logger assíncrono para Python e asyncio]]></title>
            <link>https://diogommartins.medium.com/aiologger-logger-ass%C3%ADncrono-para-python-e-asyncio-ba0b20a7b31e?source=rss-fff15274c61f------2</link>
            <guid isPermaLink="false">https://medium.com/p/ba0b20a7b31e</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[logging]]></category>
            <category><![CDATA[asynchronous]]></category>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Diogo Magalhães Machado]]></dc:creator>
            <pubDate>Mon, 29 Oct 2018 22:41:44 GMT</pubDate>
            <atom:updated>2018-10-30T01:03:41.857Z</atom:updated>
            <content:encoded><![CDATA[<p>Acho que todo desenvolvedor e equipe passam por etapas de amadurecimento bem parecidas ao longo da geração de logs de sistemas:</p><ol><li>Aplicações geram nenhum ou quase nenhum log;</li><li>Escrevemos aplicações verbosas demais, com logs provavelmente muito extensos e voltados para outros humanos;</li><li>Passamos a gerar logs estruturados, serializados para algum formato de fácil consumo e indexação em algum sistema de gerenciamento de logs, como JSON, <a href="https://msgpack.org/">msgpack</a>, etc;</li><li>Começamos a extrair valor através de métricas geradas a partir de dados logados.</li></ol><p>Nesse ponto, logs se tornam essenciais em qualquer aplicação. Bons logs podem nos ajudar no processo de debugging, a medir a saúde e performance, a detectar anomalias e, em geral, nos ajudam a operar sistemas.</p><p>Na <a href="http://www.sieve.com.br/">Sieve</a>, meu time na <a href="http://somos.b2wdigital.com/bit/">B2W Digital</a>, começamos a usar Python assíncrono com <a href="https://docs.python.org/3/library/asyncio.html">asyncio</a> na massiva maioria das aplicações a mais ou menos 2 anos. Ao mesmo tempo que aplicações eram desenvolvidas, novas métricas de operação se mostravam necessárias e cada vez mais logs precisavam ser gerados.</p><blockquote>Se quiser saber sobre asyncio, recomendo começar por <a href="https://medium.com/diogommartins/concorr%C3%AAncia-e-paralelismo-threads-m%C3%BAltiplos-processos-e-asyncio-parte-1-fbbdd2309d74">esse post aqui</a>.</blockquote><p>Como qualquer outra coisa na nossa aplicação, logar não é uma operação gratuita. Logar tem um custo de performance, e esse custo pode ser bem caro se você gerar grandes volumes de logs com o módulo builtin <a href="https://docs.python.org/3/library/logging.html">logging</a> em uma aplicação assíncrona.</p><p>Para demonstrar isso, vamos começar com um exemplo de código simples:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4574d419559ad549ff303693ff9e8494/href">https://medium.com/media/4574d419559ad549ff303693ff9e8494/href</a></iframe><p>Tudo o que esse código faz é criar 10000 corotinas que vão imprimir no <a href="https://en.wikipedia.org/wiki/Standard_streams#Standard_output_(stdout)"><em>stdout</em></a><em> </em>, de forma concorrente,<em> </em>a string &quot;Hello world !&quot; utilizando o logger padrão do python.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Gd8bzemkJOxgC0ZVIU_Dww.png" /><figcaption>exemplo_sem_aiologger.py — Diagrama de concorrência do pycharm</figcaption></figure><p>Usando o diagrama de concorrência do pycharm, percebemos que o código passa uma boa parte do tempo lidando com operações de lock. Locks são mecanismos de sincronização de programação multithread. Se você está usando asyncio, muito provavelmente você não tem logs sendo gerados em mais de um thread e esse tipo de mecanismo não precisa estar presente na sua aplicação.</p><p>Além disso, como estamos escrevendo para um file descriptor (stdout), essa é uma operação de I/O e, como tal, com asyncio, devemos tratá-la de forma não bloqueante.</p><blockquote>Em unix, para que isso seja possível, significa que devemos fazer a chamada de open com a flag <a href="https://www.gnu.org/software/libc/manual/html_node/Open_002dtime-Flags.html">O_NONBLOCK</a></blockquote><p>Vamos ver como o próprio <a href="https://docs.python.org/3/library/asyncio-dev.html#logging">logger usado pelo asyncio</a> se comporta?</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/20be1468a79e97c825b181200fba06b3/href">https://medium.com/media/20be1468a79e97c825b181200fba06b3/href</a></iframe><pre>&gt;&gt;&gt; True</pre><p>A função <a href="https://docs.python.org/3/library/os.html#os.get_blocking">os.get_blocking</a> verifica se o file descriptor foi aberto em modo bloqueante, ou seja, verifica pela flag O_NONBLOCK. Isso significa que, por padrão, o log gerado pelo próprio asyncio é bloqueante.</p><p>Apesar dos avanços que Python tem feito nos últimos anos com relação a programação assíncrona, ainda estamos bem longe de ter um ecossistema completo. Ao contrário de Go e Javascript, que já nasceram assíncronas por natureza, ainda temos um bom caminho a percorrer. Asyncio foi lançado sem alternativas oficiais para funções básicas como por exemplo <a href="https://docs.python.org/3/library/functions.html#open">open</a> e <a href="https://docs.python.org/3/library/functions.html#print">print</a>, dando margem para implementações não oficiais da comunidade.</p><h3>Aiologger</h3><p>Como o Logger padrão opera de forma bloqueante e ineficiente para aplicações asyncio, <a href="https://github.com/B2W-BIT/aiologger">aiologger</a> nasceu com o objetivo de substituí-lo de forma eficiente e não bloqueante. Se você já está acostumado com o `logging.Logger` e asyncio, não vai estranhar em nada a interface. Basta adicionar await nas chamadas a debug, info, warn…</p><p>Voltando ao nosso exemplo inicial, o mesmo código com aiologger seria:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bd58382a7a030ba6765cf4fa679f5cbd/href">https://medium.com/media/bd58382a7a030ba6765cf4fa679f5cbd/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eHzCPteBH1AOQ1FY6i7ehA.png" /></figure><p>Como o aiologger remove o uso de locks, não existe mais tempo de espera.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8d61fa05982b13f0b84f44079a3e8a6f/href">https://medium.com/media/8d61fa05982b13f0b84f44079a3e8a6f/href</a></iframe><pre>&gt;&gt;&gt; Hello stderr !<br>&gt;&gt;&gt; Hello stdout !<br>&gt;&gt;&gt; False<br>&gt;&gt;&gt; False</pre><p>E agora escrevemos no stdout/stderr de forma não bloqueante.</p><p>Se você se interessou pelas vantagens, recomendo muito que confira a documentação. Já utilizamos o aiologger em diversas aplicações em produção e é comprovadamente estável. Sabemos que diversas coisas podem melhorar e estamos sempre abertos a sugestões e pull requests!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ba0b20a7b31e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Python 3 e Type Hints]]></title>
            <link>https://diogommartins.medium.com/python-3-e-type-hints-40e80a9e8214?source=rss-fff15274c61f------2</link>
            <guid isPermaLink="false">https://medium.com/p/40e80a9e8214</guid>
            <category><![CDATA[development]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Diogo Magalhães Machado]]></dc:creator>
            <pubDate>Mon, 08 Oct 2018 23:57:57 GMT</pubDate>
            <atom:updated>2018-10-09T01:53:45.031Z</atom:updated>
            <content:encoded><![CDATA[<p>O uso de type hints no meu dia-a-dia de desenvolvedor se deu desde que comecei a utilizar Python 3. De lá pra ca, pela falta de divulgação, infelizmente não vi muita coisa mudar com relação a adoção de uma das features que considero mais legais e úteis do Python moderno.</p><p>Na <a href="http://somos.b2wdigital.com/bit/">B2W Digital</a>, onde trabalho atualmente, temos um grupo com mais ou menos 40 pessoas que usam Python para alguma coisa. Perguntei rapidamente para as pessoas quem usava ou não e quem nem sabia do que se tratava. 9 pessoas responderam e dessas, 5 <em>não sabia do que se tratava</em>, 3 <em>não usam</em> e somente 1 pessoa <em>conhecia e usava</em>. O cenário do meu time de 6 desenvolvedores que usam Python diariamente, para quase tudo, é bem diferente: todos conhecem e enxergam o valor. Pra tentar mudar um pouco esse cenário, resolvi fazer o mesmo que fiz com <a href="https://medium.com/diogommartins/concorr%C3%AAncia-e-paralelismo-threads-m%C3%BAltiplos-processos-e-asyncio-parte-1-fbbdd2309d74">asyncio</a> e compartilhar conteúdo em forma de texto e <a href="https://2018.pythonbrasil.org.br/programacao/#day21">palestra</a>.</p><p>Ao longo desse post, abordarei os seguintes pontos pra tentar te convencer a também adotar type hints:</p><ul><li>Como Python se situa com relação a tipos</li><li>As vantagens de tipos explícitos e bem definidos</li><li>Como usar Type Hints</li><li>Como utilizar um verificador estático de tipos</li><li>Ecossistema</li></ul><h3>Tipagem Estática vs Tipagem Dinâmica</h3><p>Na <strong>Tipagem Estática</strong>, os tipos são verificados <strong>antes</strong> do tempo de execução. Ou seja, o programador deve especificar o tipo de cada variável ou a linguagem deve prover algum tipo de <a href="https://en.wikipedia.org/wiki/Type_inference">sistema de inferência</a>.</p><p>Já na <strong>Tipagem Dinâmica</strong>, os tipos são verificados <strong>durante</strong> a execução, o que significa que os tipos são associados a valores encontrados em tempo de execução e não a nomes pré definidos no momento de escrita do código fonte.</p><h3>Tipagem Forte vs Tipagem Fraca</h3><p>Em linguagem com <strong>tipagem forte</strong>, todas as operações entre tipos diferentes deve ser explicitamente definidas e operações não definidas entre tipos vão resultar em um erro. Mas o que isso significa na prática? Vamos usar Python, uma linguagem fortemente tipada, para dar alguns exemplos.</p><p>Como o operador __and__ de uma string é utilizado para operações de concatenação, quando tentamos utilizar com um int, o interpretador vai retornar um erro em runtime.</p><pre>&gt;&gt;&gt; “5” + 3</pre><pre>TypeError: can only concatenate str (not “int”) to str</pre><p>O mesmo acontece se a gente tentar diminuir 3 de uma string ‘5’, porque em Python, a operação de subtração entre strings e inteiros simplesmente não faz sentido.</p><pre>&gt;&gt;&gt; “5” — 3</pre><pre>TypeError: unsupported operand type(s) for -: ‘str’ and ‘int’</pre><p>O mesmo vale para operação de subtração entre duas strings:</p><pre>&gt;&gt;&gt; “5” — “3”</pre><pre>TypeError: unsupported operand type(s) for -: ‘str’ and ‘str’</pre><p>Ser fortemente tipada foi uma escolha consciente de design da linguagem que preza por comportamentos <strong>explícitos</strong>. Problemas como esse são fáceis de se resolver porque uma erro é levantado exatamente no local em que uma operação inválida acontece.</p><p>Já nas linguagens <strong>fracamente tipadas</strong>, o tipo de um valor vai depender de como ele é usado. Ou seja, o compilador ou interpretador podem decidir em tempo de compilação ou tempo de execução como lidar com uma variável. Existe um conjunto de regras pra isso e mesmo sendo um sistema determinístico, isso pode gerar muita estranheza e confusão.</p><p>Para dar alguns exemplos sobre o comportamento de linguagens fracamente tipadas, vamos usar JavaScript pela popularidade. Vamos executar as mesmas operações que fizemos nos exemplos com Python e observar a diferença nos resultados.</p><p>A operação + entre uma string e um inteiro faz com que o interpretador trate o número como uma string e execute uma concatenação.</p><pre>&gt;&gt;&gt; “5” + 3</pre><pre>“53”</pre><p>Já numa operação — entre uma string e um inteiro, ele trata os dois como números e executa uma subtração algébrica.</p><pre>&gt;&gt;&gt; “5” — 3</pre><pre>2</pre><p>Quando o mesmo operador é utilizado entre duas strings, ele assume que são números e também executa, sem erros, uma subtração algébrica.</p><pre>&gt;&gt;&gt; “5” — &quot;3&quot;</pre><pre>2</pre><p>A escolha de criar Javascript como uma linguagem fracamente tipada também foi consciente e normalmente tá ligada com o desejo de se escrever menos. O preço que se paga por isso é que a lógica fica mais complexa porque muitos dos comportamentos ficam escondidos em regras de conversão <strong>implícitas</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/928/1*3-GS_8FiWh2KCKZ9H_wDbg.png" /><figcaption>Exemplos de linguagens no eixo de tipos</figcaption></figure><p>É importante que a gente tenha noção de que o conceito de forte e fraco não é um conceito binário, e sim contínuo. Um bom exemplo disso é que definimos Python como uma linguagem fortemente tipada, tem <em>int</em> e <em>float</em> como tipos primitivos, mas permite a operação de adição sem que seja necessária uma conversão explícita de tipos.</p><pre>&gt;&gt;&gt; 5 + 5.5</pre><pre>10.5</pre><p>Para Python, o que significa ser dinamicamente tipada?</p><ul><li><strong>Verificações de tipo só existem em run time</strong>: Como não precisamos definir o tipo de nada e as verificações de tipo também só existem em tempo de execução, é possível escrever código <strong>sintaticamente válido mas semanticamente incorretos</strong>. Em Python, esse tipo de erros normalmente são combatidos com testes, mas também podem ser evitados de outras formas.</li><li><strong>Menos verboso e menos rígido</strong>: Como linguagem, Python foi criada com o objetivo de ter uma <strong>sintaxe mais enxuta </strong>e menos rígida onde desenvolvedores se preocupariam mais com a lógica do que com as formalidades. Não se importando com as otimizações<strong> </strong>de performance e segurança possíveis em um sistema estático, se preocupando em ser uma linguagem boa não para os computadores, mas para os desenvolvedores. É de se imaginar que a definição do que é <em>“bom para o desenvolvedor”</em> também mude em alguns pontos e que uma linguagem viva como Python se adapte. Ao longo do tempo, Python mudou, cresceu e está em constante evolução. Hoje milhares de desenvolvedores utilizam Python no desenvolvimento de sistemas bem mais complexos e extensos do que antes.</li><li><strong>IDEs dependem de inferências</strong>: Um programador com background em alguma linguagem estaticamente tipada como Java, Haskell e Go que tenha que desenvolver algo maior do que um simples script em Python, vai estranhar a falta de ajuda das IDEs. Sem uma definição clara de tipos, as IDEs ficam totalmente dependentes de inferências, o que limita o seu poder de ajuda.</li></ul><h3>Vantagens de declarações explícitas de tipos</h3><ul><li>As definições de tipos ao longo do código acabam servindo como uma forma de <strong>Documentação</strong>, especificando de forma clara determinados contratos e regras de tipos. Ao contrário da documentação que já geramos em texto usando <a href="https://www.python.org/dev/peps/pep-0257/">docstrings</a>, que inevitavelmente acabam contendo erros e podendo ficar ultrapassadas com a mesma velocidade em que a sua aplicação vai crescendo e mudando, a especificação de tipos faz parte do código e deve permanecer correta. Por exemplo: Se você mudar o tipo do argumento de uma função sem mudar a documentação relacionada ao tipo, nada vai acontecer, mas se você fizer o mesmo com type hints, o seu analisador estático vai acusar um erro.</li><li>Também pode ser utilizada para <strong>Otimização</strong> de código pois informações de tipos são muito importantes para otimizações em tempo de compilação.</li><li>Te dão a <strong>Segurança</strong> de que é possível analisar o programa e que o sistema de tipos vai permitir que sejam detectados códigos que não fazem sentido e são um erro. Por exemplo, é fácil detectar que 12 dividido pela string “banana” é algo que não faz sentido se não existirem regras de como dividir um inteiro por uma string.</li><li><strong>Code-complete melhor</strong> é um dos meus motivos preferidos. Minha memória constantemente me deixa na mão e não quero ter que depender dela ou ter que abrir um outro arquivo ou documentação para saber como devo chamar uma função ou o que posso fazer com um objeto. O mesmo acaba valendo para <strong>refatorações</strong>.</li><li><strong>É mais fácil de se achar em uma codebase extensa</strong>. Um bom exemplo disso é que a partir de qualquer lugar é possível navegar para a definição de uma classe ou para o contrato de um método, sem precisar saber nada da estrutura de um projeto ou de suas dependências. Essa característica também faz com que seja muito útil para etapa de <strong>code review</strong>, fazendo com que seus pares consigam se localizar rapidamente sem um contexto muito amplo da sua aplicação.</li></ul><p>Se você chegou até aqui mesmo sem ter lido 1 linha de código com type hints é porque consegui pelo menos despertar o seu interesse em usar tipos explícitos em Python. Essa ideia não é nova e vale a pena a gente se situar com relação as discussões e o histórico:</p><ul><li><strong>2006</strong>: <a href="https://www.python.org/dev/peps/pep-3107/">PEP-3107</a> introduziu uma sintaxe para anotações de tipos em funções</li><li><strong>2008: </strong>Python 3.0 é lançado com o suporte a sintaxe de Function Annotations</li><li><strong>2014: </strong>Duas PEPs são criadas tendo Guido como um dos autores: <a href="https://www.python.org/dev/peps/pep-0483/">PEP-483</a> <strong>-</strong>The theory of Type Hints e <a href="https://www.python.org/dev/peps/pep-0484/">PEP-484</a> — Type Hints</li><li><strong>2014: </strong>Guido lança primeira versão do mypy, para análise estática de tipos.</li><li><strong>2015: </strong>Se tornou parte da linguagem a partir do Python 3.5</li><li><strong>2016: </strong>Python 3.6 é lançado contendo todas as features da <a href="https://www.python.org/dev/peps/pep-0484/">PEP-484</a></li></ul><h3>Começando a usar Type Hints</h3><p>Vamos começar definindo uma função soma, que espera dois argumentos, <em>a</em> e <em>b</em> e retorna a soma desses dois argumentos.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6b70666dc90cda2b611e0e259d472a31/href">https://medium.com/media/6b70666dc90cda2b611e0e259d472a31/href</a></iframe><p>A partir do nome da função, podemos inferir que ela espera dois números e que retorna a soma algébrica desses dois números. Vamos deixar esse contrato mais explícito usando Type Hints, <strong>anotando</strong> os tipos dos argumentos e o tipo do retorno.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/83b246eff1f6faf389527057eb29314c/href">https://medium.com/media/83b246eff1f6faf389527057eb29314c/href</a></iframe><p>Vamos então escrever 3 chamadas para essa função com casos possíveis de utilização:</p><ol><li>Primeiro da forma como a gente espera que ela seja chamada: com dois inteiros;</li></ol><pre>soma(6, 4)</pre><p>2. Depois com um dos argumentos com o tipo incorreto;</p><pre>soma(6, ‘6’)</pre><p>3. E então a gente tenta &quot;somar&quot; o retorno de uma chamada válida a essa função com uma string</p><pre>soma(6, 4) + ‘Xablau’</pre><p>No mesmo arquivo, ficaria assim:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/cf6a3536e651095fcd2a76650a4a0599/href">https://medium.com/media/cf6a3536e651095fcd2a76650a4a0599/href</a></iframe><p>Esse é um exemplo bem simples, pra que fique bem claro o que funcionaria e o que a gente sabe que vai gerar algum tipo de erro em tempo de execução. Vamos ver como a gente pode se defender para encontrar esse tipo de erro antes.</p><h3>Mypy</h3><p><a href="https://pypi.org/project/mypy/">Mypy</a> é um analisador estático para tipos, desenvolvido inicialmente pelo <a href="https://en.wikipedia.org/wiki/Guido_van_Rossum">Guido</a>, que utiliza as informações de type hints para validar o seu código e procurar por bugs. Pra começar a usar o mypy é só instalá-lo como qualquer pacote python.</p><p>Com pipenv</p><pre>pipenv install mypy</pre><p>ou com pip</p><pre>pip install mypy</pre><p>Depois da instalação, você vai ter o mypy como executável em linha de comando, e vai poder rodar suas validações de tipos sem de fato executar o seu programa:</p><pre>mypy typehints-exemplo3.py</pre><p>O mypy vai retornar uma lista com cada um dos erros:</p><pre>typehints-exemplo3.py:5: error: Argument <strong>2</strong> to “soma” has <strong>incompatible type</strong> “str”; expected “int”</pre><pre>typehints-exemplo3.py:6: error: <strong>Unsupported operand</strong> types for + (“int” and “str”)</pre><ol><li>Como chamamos a função passando uma <strong>str</strong> como segundo argumento e o argumento foi definido como <strong>int</strong>, isso é um erro.</li><li>Um erro também é levantado quando tentamos somar o resultado da execução da função, que é um <strong>int</strong>, com uma <strong>str</strong>.</li></ol><p>E o que aconteceria se acidentalmente a gente tivesse definido a função com o tipo de retorno errado?</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/eec7cb9478a6b516a8af677123e1a3c4/href">https://medium.com/media/eec7cb9478a6b516a8af677123e1a3c4/href</a></iframe><pre>mypy typehints-exemplo4.py</pre><p>Não tem problema. O mypy também vai te ajudar com isso porque ele é capaz de fazer inferência de tipos e dizer que a soma do argumento <strong>a</strong> com <strong>b</strong>, não pode ser uma string. A verificação de tipos nos ajuda a evitar que erros como esses aconteçam.</p><pre>typehints-exemplo4.py:2: error: Incompatible return value type (got “int”, expected “str”)</pre><p>Essa inferência faz com que mesmo que você não defina o tipo de uma variável, uma vez que você a inicializa com um tipo, assume-se que ela deve continuar com esse tipo ao longo do seu ciclo de vida.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ca7abab63bbcd3ae074a8a75f82e8cc1/href">https://medium.com/media/ca7abab63bbcd3ae074a8a75f82e8cc1/href</a></iframe><pre>mypy typehints-exemplo5.py</pre><pre>typehints-exemplo5.py:2: error: Incompatible types in assignment (expression has type “str”, variable has type “int”)</pre><p>O mesmo aconteceria se declarássemos explicitamente o tipo de x:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/04879f77cbe0b8a64c7e61675fc587d4/href">https://medium.com/media/04879f77cbe0b8a64c7e61675fc587d4/href</a></iframe><pre>mypy typehints-exemplo8.py</pre><pre>typehints-exemplo8.py:2: error: Incompatible types in assignment (expression has type “str”, variable has type “int”)</pre><p>A mesma lógica se aplica a tipos mais complexos e por default, Mypy também faz inferência de tipos em containers homogêneos.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ac84b08cd1c085a4ad9631fdf8230846/href">https://medium.com/media/ac84b08cd1c085a4ad9631fdf8230846/href</a></iframe><p>Então mesmo se não declararmos explicitamente a variável points como sendo uma <em>List[Tuple[int, int]]</em>, ele vai inferir que é o que você espera e vai ajudar a gente dizendo que muito provavelmente não queremos uma tupla de strings dentro desse container.</p><pre>mypy typehints-exemplo6.py</pre><pre>typehints-exemplo6.py:2: error: Argument 1 to “append” of “list” has incompatible type “Tuple[str, str]”; expected “Tuple[int, int]”</pre><p>Ou seja, teríamos o mesmo efeito com uma declaração explícita:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/138dc1d0cea91e8abdcda17361589527/href">https://medium.com/media/138dc1d0cea91e8abdcda17361589527/href</a></iframe><pre>mypy typehints-exemplo7.py</pre><pre>typehints-exemplo7.py:5: error: Argument 1 to “append” of “list” has incompatible type “Tuple[str, str]”; expected “Tuple[int, int]”</pre><p>Nesse último exemplo, usei o módulo typing para descrever esse tipo</p><h3>Stubs (.pyi)</h3><p>Existem alguns momentos pelos quais as vezes não é conveniente que a gente anote os tipos no mesmo arquivo que contém a implementação. É possível utilizar tudo que já mostrei até agora sem tocar no seu arquivo <em>.py</em> existente. Para isso, existem os arquivos <em>.pyi</em>, que funcionam como arquivos de header.</p><p>Esses arquivos são escritos com a sintaxe normal do Python 3, mas sem conter nenhuma lógica de inicialização de variáveis, implementação de função, ou de valores default. Valores default e implementação são substituídos pela constante <a href="https://docs.python.org/3/library/constants.html#Ellipsis">Ellipsis</a> ...</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5136118a9e08a474c1e32dd2a272ea38/href">https://medium.com/media/5136118a9e08a474c1e32dd2a272ea38/href</a></iframe><p>Dessa forma conseguimos anotar os tipos e usar todas as features que já mostrei, sem tocar no código existente.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/33f91b1aafee623336c8564cc81858c8/href">https://medium.com/media/33f91b1aafee623336c8564cc81858c8/href</a></iframe><h3>__annotations__</h3><p>Assim como a documentação de uma função em python é um atributo de uma função (<a href="https://docs.python.org/3/library/inspect.html#types-and-members">__doc__</a>), as anotações de tipo também ficam disponíveis em tempo de execução. Conseguimos acessar essas anotações através do atributo <a href="https://docs.python.org/3/library/inspect.html#types-and-members">__annotations__</a></p><p>Vamos usar a função soma como exemplo, mas vamos também declarar uma variável livre <strong>x</strong>, que é uma string. Então se a gente mandar imprimir no console o valor de <strong>__annotations__.</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6ad9481272fadf47ebc4da10d6e92e01/href">https://medium.com/media/6ad9481272fadf47ebc4da10d6e92e01/href</a></iframe><p>O resultado vai ser um dicionário <strong>K-&gt;V</strong> onde os valores de <strong>K</strong> são os nomes dos parâmetros e <strong>V</strong>, as respectivas anotações. Também existe uma chave reservada <em>return</em> para a anotação do tipo de retorno da função.</p><pre><br>{‘a’: &lt;class ‘int’&gt;, ‘b’: &lt;class ‘int’&gt;, ‘return’: &lt;class ‘int’&gt;}</pre><pre>{‘x’: &lt;class ‘str’&gt;}</pre><p>O mesmo atributo também existe em classes, módulos, métodos, etc. Como estamos no mesmo arquivo, utilizamos somente __annotations__ para acessar o dicionários com os tipos anotados para pegar a anotação de <strong>x</strong>.</p><p>Ter a possibilidade de acessar essas informações em runtime abre uma infinidade de possibilidades! Um bom exemplo é o <a href="https://pydantic-docs.helpmanual.io/">pydantic</a>.</p><blockquote>Vale lembrar que como os arquivos <em>.pyi</em> não são lidos pelo interpretador, o que é definido lá, não é acessível pelo atributo __annotations__</blockquote><h3>Módulo Typing</h3><p>As PEPs <a href="https://www.python.org/dev/peps/pep-0483">483</a>,<a href="https://www.python.org/dev/peps/pep-0484">484</a> e <a href="https://www.python.org/dev/peps/pep-0526">526</a> definem uma sintaxe para como podemos expressar tipos possíveis em python. O módulo <a href="https://docs.python.org/3/library/typing.html">typing</a> é built-in a partir do Python 3.5 e traz um conjunto de tipos para serem utilizados em definições mais complexas.</p><p>Vamos ver alguns exemplos do que a gente pode expressar com esse módulo.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d02f528871010eb4939478934cddf954/href">https://medium.com/media/d02f528871010eb4939478934cddf954/href</a></iframe><pre>class Produto(NamedTuple)</pre><p>Definimos uma classe Produto, que herda de <a href="https://docs.python.org/3/library/typing.html#typing.NamedTuple"><em>typing.NamedTuple</em></a>, um tipo que se comporta como <a href="https://docs.python.org/3/library/collections.html#collections.namedtuple">collections.namedtuple</a>, mas em uma versão que leva consigo as informações de tipo dos atributos.</p><pre>preco: Union[Decimal, float]</pre><p><em>preco: Union[Decimal, float]</em> significa que o atributo <em>preco</em> é um tipo que pode tanto ser um <em>Decimal</em> quanto um <em>float.</em></p><pre>def total_carrinho(produtos: List[Produto]) -&gt; Union[Decimal, float]:</pre><p>Então definimos uma função que dado uma lista de produtos, retorna ou <em>Decimal</em> ou <em>float</em>.</p><p>Vamos então criar uma lista de produtos e chamar essa função.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/86440f0bd193531d5fede46a8cc64b35/href">https://medium.com/media/86440f0bd193531d5fede46a8cc64b35/href</a></iframe><p>Na <strong>linha 6</strong>, fazemos uma chamada a função <em>total_carrinho</em> passando a lista de produtos que nós criamos.</p><pre>mypy typehints-exemplo13.py</pre><pre>typehints-exemplo13.py:19: error: Argument 1 to “total_carrinho” has incompatible type “Tuple[Produto, …]”; expected “List[Produto]”</pre><p>Já na <strong>linha 7</strong>, passamos uma <a href="https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences">tupla</a>, com esses mesmos produtos. Como definimos na assinatura da função que esperamos uma <em>List[Produto]</em>, essa chamada é uma chamada inválida.</p><pre>return sum(p.preco for p in produtos)</pre><p>Considerando a implementação da função, sabemos que não precisamos ser tão específicos e que uma chamada a função é válida tanto para <em>List[Product] </em>quanto para <em>Tuple[Produto, …]</em> ou qualquer outra coisa que seja iterável. O módulo typing oferece mecanismos para definições genéricas como <em>Iterable</em>, Iterator, Mapping, AsyncIterable, etc…</p><pre>def total_carrinho(produtos: Iterable[Produto])-&gt; Union[Decimal, float]:</pre><p>O módulo typing também permite que a gente adicione semântica aos nossos tipos utilizando <a href="https://docs.python.org/3/library/typing.html#typing.NewType">NewType</a>.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/69cb0fdbeac8849785945103be9f7365/href">https://medium.com/media/69cb0fdbeac8849785945103be9f7365/href</a></iframe><p>Essas definições podem ser úteis tanto para dar mais clareza ao significado de cada tipo, quanto para garantia de regras de negócio.</p><pre>typehints-exemplo14.py:11: error: Argument 1 to “velocidade” has incompatible type “int”; expected “Metros”</pre><p>Nesse caso, por exemplo, o mypy nos impede de passar a distância sem a unidade.</p><pre>typehints-exemplo14.py:12: error: Argument 1 to &quot;velocidade&quot; has incompatible type &quot;Pes&quot;; expected &quot;Metros&quot;</pre><p>Assim como nos impede de passar a unidade incorreta.</p><p>Esse exemplo pode fazer a gente pensar que é muito trabalho desnecessário e na maior parte das vezes, é mesmo. Mas no contexto correto, esse tipo de checagem pode evitar muitos problemas como o da <a href="https://motherboard.vice.com/en_us/article/qkvzb5/the-time-nasa-lost-a-mars-orbiter-because-of-a-metric-system-mixup">Mars Climate Orbiter</a>, um projeto de mais de 300 milhões de dólares que caiu em marte porque parte do código usou sistema imperial e outra parte o sistema internacional de medidas.</p><p>O módulo typing é muito completo e possui uma documentação (<a href="https://docs.python.org/3/library/typing.html">https://docs.python.org/3/library/typing.html</a>) com exemplos de uso claros para todos os tipos mais comuns do dia-a-dia da maior parte das pessoas e é leitura que vale muito a pena.</p><h3>Ecossistema</h3><ul><li><a href="https://mypy.readthedocs.io/en/stable/index.html">Mypy</a> é essencial para verificação estática de tipos e pode/deve ser utilizado em conjunto com seus testes unitários tanto ao longo do desenvolvimento quanto no seu CI</li><li><a href="https://github.com/google/pytype">pytype</a> também é um analisador estático de tipos que atualmente dá suporte para Python ≥2.7 e ≤ 3.5. É mantido pela Google e consegue gerar algumas anotações de tipos para código sem anotações.</li><li><a href="https://github.com/dropbox/pyannotate">PyAnnotate</a> criado por Guido e mantido pela dropbox, coleta informações de tipo em tempo de execução, observando como funções são chamadas e o que elas retornam, criando um stub (.pyi) no final.</li><li><a href="https://www.jetbrains.com/pycharm/">Pycharm</a> é uma IDE desenvolvida pela Jetbrains que dá total suporte as PEPs de type hints do seu código e nos módulos built-in para garantir auto complete, te informar de erros, etc.</li><li><a href="https://github.com/python/typeshed">typeshed</a> é uma coleção de stubs para módulos built-in e de terceiros. Também foi criado pelo Guido e é mantido pela comunidade python.</li><li><a href="https://pydantic-docs.helpmanual.io/">Pydantic</a> utilizada a sintaxe de anotações de tipo para validação de esquema de dados e gerenciamento de configuração</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a41558dec72f44afc008434ba42e170f/href">https://medium.com/media/a41558dec72f44afc008434ba42e170f/href</a></iframe><h3>Experimente!</h3><p>Anotações de tipo são sempre opcionais, então <strong>você pode escolher anotar algumas coisas e outras não</strong>. Isso significa que o argumento de que<strong> “</strong>vai ficar verboso d+” não é verdade. Você pode usar o bom senso para julgar o que de fato é necessário e traz benefícios pra você e pra qualidade do seu código.</p><p>Se performance é algo importante pra você, fica tranquilo porque type hints<strong> não alteram em nada a performance. </strong>Ou seja, você não vai ganhar nada e nem perder nada usando type hints e o interpretador não vai utilizar essa informação pra nada. Caso você não queria nem pagar o preço de manter o dicionário de anotações em runtime, tudo bem, é só utilizar os arquivos de stubs (.pyi).</p><p>Ao longo do post, espero ter conseguido mostrar que com pouco esforço dá pra começar a utilizar type hints no seu código e começar a colher os benefícios da tipagem estática, sem abrir mão da tipagem dinâmica. Espero ter sido útil para que você escreva código mais fácil de se entender e manter.</p><blockquote>Agradecimentos especiais pro meu querido <a href="https://etandel.xyz/">Elias Tandel</a> que aceitou colaborar comigo produzindo conteúdo e dando essa palestra comigo na <a href="http://pythonrio.python.org.br/">PythonRio</a> e <a href="https://2018.pythonbrasil.org.br/programacao#day21">PythonBrasil</a></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=40e80a9e8214" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Concorrência e Paralelismo — Threads, múltiplos processos e AsyncIO — Parte 2]]></title>
            <link>https://medium.com/diogommartins/concorr%C3%AAncia-e-paralelismo-threads-m%C3%BAltiplos-processos-e-asyncio-parte-2-8e539c59a16a?source=rss-fff15274c61f------2</link>
            <guid isPermaLink="false">https://medium.com/p/8e539c59a16a</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[asyncio]]></category>
            <category><![CDATA[programação-assíncrona]]></category>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[concurrency]]></category>
            <dc:creator><![CDATA[Diogo Magalhães Machado]]></dc:creator>
            <pubDate>Sun, 23 Apr 2017 00:01:05 GMT</pubDate>
            <atom:updated>2017-04-23T00:01:05.149Z</atom:updated>
            <content:encoded><![CDATA[<p>No <a href="https://diogommartins.wordpress.com/2017/04/07/concorrencia-e-paralelismo-threads-multiplos-processos-e-asyncio-parte-1/">post anterior</a> falei sobre a diferença entre concorrência e paralelismo, classificação de processos e soluções para implementar aplicações com código concorrente. Se você ainda não leu esse post, recomendo que você comece por lá.</p><p>É muito comum ver programadores escreverem código para executar uma tarefa qualquer, decidirem empiricamente que o desempenho não está adequado e que podem resolver isso fazendo com que exatamente o mesmo código seja executado em uma CPU mais rápida, ou por mais de uma CPU. <em>Surpreendentemente</em>, a situação não muda e a quantidade de recursos computacionais alocados para tarefa continua não sendo proporcional ao benefício. Neste momento, se o último post serviu de alguma coisa, deve estar óbvio que a solução lida com o problema de forma inadequada.</p><p>Antes de dar um exemplo mais concreto pra essa situação, vamos à revisão de definição:</p><ul><li><strong>Concorrência</strong>: Conjunto de tarefas sendo executadas de forma intercalada em um mesmo intervalo de tempo. É uma forma de <strong>lidar</strong> com muitas coisas ao mesmo tempo e está ligado a forma de se <strong>estruturar</strong> tarefas.</li><li><strong>Paralelismo</strong>: Execução simultânea de um conjunto de tarefas, que podem ou não estar relacionadas. É uma forma de <strong>fazer</strong> muitas coisas ao mesmo tempo e está ligado a forma de se <strong>executar</strong> tarefas.</li></ul><h3>Cenários de tarefas I/O Bound</h3><h4>Realizar 1 requisição HTTP</h4><p>Nossa tarefa é realizar uma requisição HTTP para o site <a href="http://www.americanas.com/">http://www.americanas.com</a> e imprimir o resultado no stdout. Que em python, a solução mais simples seria:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7ed086651259280262a41d3a633f65fe/href">https://medium.com/media/7ed086651259280262a41d3a633f65fe/href</a></iframe><p>O módulo <a href="http://docs.python-requests.org/en/master/">requests</a> é uma dependência e pode ser instalado com o comando pip install requests.</p><p>Essa execução pode ser representada da seguinte forma:</p><figure><img alt="Screen Shot 2017-04-16 at 5.58.55 PM.png" src="https://cdn-images-1.medium.com/max/1024/0*ILCTZOHt0BZVw-St.png" /><figcaption>Fig.1: Simulação de requisição de 1 url</figcaption></figure><p>Não existe situação de concorrência e não há nenhuma tarefa que poderia ser executada pela aplicação no tempo ocioso da CPU. Nesse caso, o tempo gasto com operações de CPU é bem menor, e o custo dessas operações é sempre o mesmo independe de fatores externos. Já o tempo gasto na barra verde pode ser determinado por diversos fatores, como:</p><ul><li>Tamanho do conteúdo</li><li>Latência da rede</li><li>Banda de download do cliente</li><li>Banda de upload do servidor</li></ul><p>Essa é claramente uma operação <a href="https://diogommartins.wordpress.com/2017/04/07/concorrencia-e-paralelismo-threads-multiplos-processos-e-asyncio-parte-1/">I/O bound</a>. O que será que acontece quando tentarmos realizar não 1, mas 4 requisições?</p><h4>Realizar 4 requisições HTTP</h4><p>O intuito aqui é realizar a mesma tarefa no cenário anterior, porém, para 4 urls diferentes. Vamos alterar o código:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e2e515cd1436163f42dfff1a7b18c07d/href">https://medium.com/media/e2e515cd1436163f42dfff1a7b18c07d/href</a></iframe><p>Desta vez temos temos 4 urls, e o trabalho continua se dando de forma sequencial. Da mesma forma que no exemplo1. Como podemos ver abaixo, desta vez fica mais aparente que a CPU passa boa parte do tempo esperando que uma requisição termine até que possa começar a realizar outra.</p><figure><img alt="Screen Shot 2017-04-16 at 6.29.39 PM.png" src="https://cdn-images-1.medium.com/max/1024/0*wJhZ_7Ril2hg0oVb.png" /><figcaption>Fig.2: Simulação de requisição de 4 urls de forma sequencial</figcaption></figure><p>Você que leu o <a href="https://diogommartins.wordpress.com/2017/04/07/concorrencia-e-paralelismo-threads-multiplos-processos-e-asyncio-parte-1/">post anterior</a>, já deve imaginar que uma forma não escalável de se atacar esse problema seria usar múltiplos processos, não é? Mesmo assim, vamos fazer só por diversão.</p><h4>Solução com multiplos processos</h4><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/dc2f41a303f778faf2c867d3ca2f79b5/href">https://medium.com/media/dc2f41a303f778faf2c867d3ca2f79b5/href</a></iframe><p>Esse é um exemplo bem simples e que não envolve compartilhamento de estados entre os processos. Na linha #19, criamos um <em>worker</em> para cada CPU disponível e na linha #20, dividimos o trabalho de entre cada um deles.</p><p>Vamos fazer uma simulação “inocente” da execução. Desconsiderar todos os custos adicionais de se criar e manter processos adicionais (como falamos no post anterior), e considerar que o código se comportará da seguinte forma em um ambiente com 4 núcleos:</p><figure><img alt="Screen Shot 2017-04-16 at 7.01.49 PM.png" src="https://cdn-images-1.medium.com/max/934/0*4sgSXATk98xtUf3T.png" /><figcaption>Fig.3: Simulação inocente da solução de requisições por múltiplos processos.</figcaption></figure><h4>Solução com múltiplas threads</h4><p>E o que aconteceria se adaptássemos esse mesmo código para utilizar múltiplas threads? Tudo que você precisa fazer é mudar um import.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/28d4198f8a5c40fdafad33aa715a4648/href">https://medium.com/media/28d4198f8a5c40fdafad33aa715a4648/href</a></iframe><p>Assim como citei com o caso de múltiplos processos, não entrarei no mérito de discutir todos os <em>overheads</em> criados por cada uma dessas abordagens. Não é o propósito aqui, e você pode <a href="http://lmgtfy.com/?q=multi+thread+overhead">achar facilmente conteúdo sobre isso</a> pela internet.</p><figure><img alt="Screen Shot 2017-04-16 at 7.56.31 PM.png" src="https://cdn-images-1.medium.com/max/1024/0*sTXJ_urNnFYZNx9g.png" /><figcaption>Fig.4: Simulação inocente de requisições com múltiplas threads.</figcaption></figure><p>Como já vimos anteriormente, cada vez que uma thread pede um um recurso de I/O o controle, com mudança de contexto, pode ser passado para uma nova thread que então será executada até pedir por I/O, etc…</p><h4>E se precisássemos realizar 4.000 requisições HTTP?</h4><p>Digamos que cada umas das 4000 requisições tenham o mesmo custo <strong>T</strong>, ou seja, todas levam o mesmo tempo desde o momento em que um <strong>Request</strong> HTTP sai do cliente, até o momento em que todo o html está disponível e tempos um <strong>Response</strong>.</p><p>Uma solução sequencial repetiria, 4 mil vezes, o gráfico mostrado na <strong>Figura 1 </strong>e podemos dizer que seu custo seria <strong>4000 * T</strong>.</p><figure><img alt="Screen Shot 2017-04-16 at 9.01.45 PM.png" src="https://cdn-images-1.medium.com/max/1024/0*ZMTG3vDU2GP5KUlO.png" /><figcaption>Fig.5: Simulação ingênua de muitas urls com múltiplos processos</figcaption></figure><p>A solução com múltiplos processos, como já vimos, implementa o mesmo código da solução sequencial, mas dividido por <strong>P</strong> núcleos. Sendo assim, desconsiderando todos os custos relacionados a criação e manutenção de processos, repetiria o mesmo custo da solução sequencial, dividido pelos <strong>P</strong> núcleos, ou seja, <strong>(4000 * T) / P</strong>. A solução multi thread apresentada tem o mesmo custo aproximado, já que a quantidade de threads estava atrelada à quantidade de núcleos disponíveis.</p><p>E se juntássemos múltiplos processos com múltiplas threads?</p><p>Cada um dos <strong>P</strong> processos poderia ter <strong>P</strong> threads e, em teoria, existiria um custo total de <strong>((4000 * T) / P) / P)</strong>.</p><p>Parece bom? Não é. E se tivéssemos que realizar 400.000 ou 4.000.000 de requisições? Com essas quantidades, conseguimos ver que é claramente possível aumentar o custo total elevando o valor de <strong>T</strong>, mas não é tão fácil aumentar o valor de <strong>P</strong>, fazendo com que o peso do numerador seja muito mais alto, gerando por consequência um <strong>custo</strong> alto. Vale lembrar também que o benefício de múltiplos processos não cresce linearmente para quantidades de processos &gt; quantidade de núcleos, e que para múltiplas threads, o crescimento de benefício também não é linear e temos que lidar com todas as coisas citadas no <a href="https://diogommartins.wordpress.com/2017/04/07/concorrencia-e-paralelismo-threads-multiplos-processos-e-asyncio-parte-1/">post anterior</a>.</p><p>Nesse caso, é claro que há algo de errado ou subutilizado na arquitetura da nossa solução, se na maior parte do tempo em que nossa solução está rodando, a CPU está ociosa ou trabalhando em questões não relacionadas a aplicação em si — que é criar uma <em>request</em> e tratar sua <em>response</em>. Então, qual é a alternativa?</p><h3>Asynchronous I/O</h3><p>Introduzida por <a href="https://en.wikipedia.org/wiki/Guido_van_Rossum">Guido</a> na <a href="https://www.python.org/dev/peps/pep-3156/">PEP 3156</a> em 2012 (sim, 2012. Não é algo tão novo, né?) e acompanha as distribuições python &gt;=3.4 desde 2013 no módulo asyncio que, a grosso modo, provê uma forma de se escalonar eficientemente aplicações <strong>I/O bound</strong> com código concorrente, em uma única thread. O módulo asyncio possui muitas outras features, e recomendo que se você tiver interesse de ir mais a fundo, leia a <a href="https://docs.python.org/3/library/asyncio.html">documentação oficial</a>.</p><blockquote>Vale dizer que features semelhantes existem em vários outras linguagens, como: Go, Java, Javascript, C#, C++, Objective-C e muitas outras.</blockquote><h4>Coroutines</h4><p>Para que seja possível implementar um modelo de programação concorrente, é preciso que seja possível quebrar uma tarefa em pedaços que podem ser executados independentemente. Corotinas, em português, são funções que podem ser suspensas em determinados pontos de execução para serem retomadas depois, mantendo todos os estados de quando foi suspensa. Nós também podemos definir corotinas como um conjunto de sub-rotinas (instruções), que permitem vários pontos de entrada, de suspensão e retomada de execução em certas partes do código, realizando uma troca de contexto. Em funções python, essa troca de contexto já se dava através da sintaxe yield, e em corotinas (&quot;funções assíncronas&quot;), utilizando a sintaxe yield from introduzida na <a href="https://www.python.org/dev/peps/pep-0380">PEP 380</a> ou await(python &gt;=3.5).</p><p>Em python &gt;=3.5, são funções declaradas com async def e em python &lt;3.5, funções geradoras decoradas com @asyncio.coroutine.</p><h4>Loop de Eventos</h4><p>Corotinas são executadas em um loop de eventos. Loops de eventos, por sua vez, são os responsáveis por:</p><ul><li>controlar e manter o agendamento de corotinas e seus pontos de suspensão e retomada toda vez que uma corotina necessitar de tempo para execução de uma tarefa;</li><li>lidar com sinais do sistemas operacional;</li><li>transmitir dados através da rede;</li><li>prover abstrações para transporte para diversos canais de comunicação;…</li></ul><figure><img alt="sj46yn.jpg" src="https://cdn-images-1.medium.com/max/512/0*kGbTlNgJgg0VFhdt.jpg" /><figcaption>Fig.6: Ok, vamos voltar aos exemplos!</figcaption></figure><h4>Realizar 1 requisição HTTP</h4><p>Vamos voltar ao primeiro exemplo e escrever o mesmo código com asyncio. Para isso, vamos utilizar a biblioteca aiohttp.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6025aa275c5c1826653a66e78fdb233f/href">https://medium.com/media/6025aa275c5c1826653a66e78fdb233f/href</a></iframe><p>Nesse caso, escrevemos muito mais para chegar a mesma solução, mas muito mais foi feito nessas 10 linhas de código. Algumas linhas são bem importantes:</p><ul><li><strong>#4</strong>: Definimos uma corotina chamada get_and_print</li><li><strong>#9</strong>: Instanciamos o nosso loop de eventos</li><li><strong>#10</strong>: Dizemos que o loop deve rodar até que a coroutine get_and_print termine</li><li><strong>#6</strong> e <strong>#7</strong>: async with, assim como with, nada mais é do que um gerenciador de contexto.</li><li><strong>#8</strong>: Utilizamos await para dizer que a corotina pode suspender sua execução neste ponto e retornar somente quando tiver o resultado da <a href="https://docs.python.org/3/library/asyncio-task.html#future">future</a> response.text()</li></ul><p>Em questões de desempenho e melhor uso da CPU, para o caso de uma aplicação cujo único propósito é fazer uma requisição para uma única url e imprimir na tela, tudo isso não faz sentido e é meramente didático. Vamos avançar um pouco e ver como faríamos o mesmo para 4 urls.</p><h4>Realizar 4 requisições HTTP</h4><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/85afed1cae8d48641c9561a43b12954a/href">https://medium.com/media/85afed1cae8d48641c9561a43b12954a/href</a></iframe><p>Agora nós temos duas corotinas: fetch responsável por agendar e esperar a finalização de tarefas individuais de requisições e get_and_print, que reage a uma response e imprime em <em>stdout</em>.</p><p>Algumas linhas também valem ser comentadas aqui:</p><ul><li><strong>#19</strong>: Inicializamos ClientSession somente uma vez. Esse objeto encapsula um pool de conexões <a href="https://en.wikipedia.org/wiki/HTTP_persistent_connection">keep-alive</a> que podemos tirar vantagem. Recomendo que você leia mais sobre na <a href="http://aiohttp.readthedocs.io/en/stable/client_reference.html">documentação oficial</a>,</li><li><strong>#20</strong>: Criamos um gerador de corotinas a serem executadas. Uma para cada url.</li><li><strong>#21</strong>: Utilizamos a função asyncio.gather para agregar várias corotinas e esperar pela finalização das mesmas. Ou seja, é uma forma de se esperar pela execução concorrente de diversas corotinas até que todas cheguem ao fim. O resultado será uma lista, onde cada um dos itens é o resultado das corotinas ou, como utilizamos o return_exceptions=True, também pode ser uma exception não tratada durante sua execução.</li></ul><p>O que tudo isso significa?</p><figure><img alt="Screen Shot 2017-04-17 at 2.11.04 AM.png" src="https://cdn-images-1.medium.com/max/1024/0*-0LrPDX3R7LHb2R5.png" /><figcaption>Fig.7: Simulação de múltiplas urls com asyncio</figcaption></figure><ul><li>Significa que o programa não é escrito para esperar até que tenha uma resposta da rede. Toda vez que uma corotina tem que esperar por um recurso, o controle é cedido de volta para o loop que pode alocar uma outra tarefa;</li><li>Nós programadores escrevemos “callbacks” que devem ser executados quando o resultado de uma chamada a rede terminar;</li><li>Estruturando bem a solução do problema, conseguimos garantir o melhor escalonamento possível de tarefas I/O bound.</li></ul><p>E se quiséssemos que a execução do loop não parasse quando a fetch terminasse? Para fins didáticos, vamos reescrever o mesmo programa para utilizar o método run_forever.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8cebd3c4c023eeaceda6bb63c75d7b51/href">https://medium.com/media/8cebd3c4c023eeaceda6bb63c75d7b51/href</a></iframe><ul><li><strong>#24</strong>: Usamos o método loop.create_task para agendar a chamada de fetch para quando o loop estiver rodando.</li><li><strong>#25</strong>: Dizemos que o loop deve rodar até que o método stop seja chamado. Ou seja, se quisermos que o programa termine após a execução de todas as tarefas, basta chamar loop.stop na linha <strong>#22</strong>.</li></ul><h3>Conclusão</h3><p>Desenvolver assincronamente é, de fato, algo estranho no começo se compararmos com um fluxo sequencial de desenvolvimento. Exige uma mudança de mindset e, como qualquer outra coisa, prática. Não pare por aqui!</p><p>Todos os códigos estão disponíveis <a href="https://github.com/diogommartins/concorrencia_e_paralelismo_blog_post">no meu github</a>. Se gostou desse post, tente dar uma olhada <a href="http://www.diogommartins.com/">no meu site pessoal</a>. =)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8e539c59a16a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/diogommartins/concorr%C3%AAncia-e-paralelismo-threads-m%C3%BAltiplos-processos-e-asyncio-parte-2-8e539c59a16a">Concorrência e Paralelismo — Threads, múltiplos processos e AsyncIO — Parte 2</a> was originally published in <a href="https://medium.com/diogommartins">diogommartins</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Concorrência e Paralelismo — Threads, múltiplos processos e AsyncIO — Parte 1]]></title>
            <link>https://medium.com/diogommartins/concorr%C3%AAncia-e-paralelismo-threads-m%C3%BAltiplos-processos-e-asyncio-parte-1-fbbdd2309d74?source=rss-fff15274c61f------2</link>
            <guid isPermaLink="false">https://medium.com/p/fbbdd2309d74</guid>
            <category><![CDATA[parallel-computing]]></category>
            <category><![CDATA[concurrency]]></category>
            <category><![CDATA[asynchronous]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[asyncio]]></category>
            <dc:creator><![CDATA[Diogo Magalhães Machado]]></dc:creator>
            <pubDate>Sat, 22 Apr 2017 05:44:01 GMT</pubDate>
            <atom:updated>2017-04-22T05:44:01.556Z</atom:updated>
            <content:encoded><![CDATA[<p>Antes de mais nada, gostaria de dizer que esse não é um post para iniciantes em programação, muito menos para iniciantes em Python. Vou abordar alguns assuntos e dar algumas explicações, considerando que você já possui certos conhecimentos prévios — que não vou explicar aqui. Fique a vontade para utilizar os comentários, ou entrar em contato direto comigo para tirar dúvidas ou pedir informações sobre como adquirir esses outros conhecimentos, se for o caso.</p><h3>Concorrência e paralelismo</h3><p>Pode parecer a mesma coisa, mas não é. Vamos as definições:</p><h4>Paralelismo</h4><p>Acontece quando duas ou mais tarefas são executadas, literalmente, ao mesmo tempo. Necessita, obviamente, de um processador com múltiplas cores, ou múltiplos processadores para que mais de um processo ou thread seja executado ao mesmo tempo.</p><h4>Concorrência</h4><p>Quando duas ou mais tarefas podem começar a ser executadas e terminar em espaços de tempo que se sobrepõem, não significando que elas precisam estar em execução necessariamente no mesmo instante. Ou seja, você tem concorrência quando:</p><ul><li>mais de uma tarefa progride ao mesmo tempo em um ambiente com múltiplos CPUs/núcleos;</li><li>ou no caso de um ambiente single core, duas ou mais tarefas podem não progredir no mesmo <em>exato momento, </em>mas mais de uma tarefa é processada em um mesmo <em>intervalo de tempo, </em>não esperando que uma tarefa termine por completo antes de dar início a outra.</li></ul><p>É a possibilidade do processador executar instruções ao mesmo tempo que outras operações, como, por exemplo I/O, permitindo que tarefas sejam executadas concorrentemente pelo sistema. A concorrência é o princípio básico para permitir o projeto e implementação de sistemas multitarefas.</p><blockquote>Sistemas multitarefas são sistemas em que mais de um programa pode estar em execução ao mesmo tempo. Ou seja, é o contrário do monotarefa, onde somente um programa pode estar em execução por vez, deixando o processador dedicado exclusivamente a essa tarefa.</blockquote><p>Em sistemas monotarefa, o processador é subutilizado e fica ocioso na maior parte do tempo esperando por outros componentes, como I/O.</p><figure><img alt="Screen Shot 2017-04-03 at 12.49.58 AM.png" src="https://cdn-images-1.medium.com/max/1024/0*tPMnR7sVSdXwbG0x.png" /><figcaption>Fig. 1: Situação típica de uma aplicação monotask</figcaption></figure><p>Já em sistemas multitarefas, podemos utilizar o tempo de processamento ocioso para trocar de contexto e executar outras tarefa.</p><figure><img alt="Screen Shot 2017-04-05 at 10.21.53 PM.png" src="https://cdn-images-1.medium.com/max/1024/0*8eUD3qtqcEmCnwaI.png" /><figcaption>Fig. 2: Exemplo de situação multitask.</figcaption></figure><p>Na figura 2, podemos observar que quando a <strong>tarefa 1</strong> pede por algum recurso externo, que tornaria o processador ocioso, utilizamos o tempo de processador para realizar outra tarefa, chamada de <strong>tarefa 2</strong>. Quando o recurso requisitado por tarefa 1 estiver pronto, podemos retomar a execução, pausando <strong>tarefa 2</strong>, etc… Dessa forma, podemos escalonar o uso de CPU.</p><p>Essa utilização concorrente da CPU deve ser implementada, de forma que as pausas e retomadas no uso de CPU mantenha idêntico o estado de uma determinada tarefa.</p><h4>Classificação de Processos</h4><p>Processos podem ser classificados como CPU Bound ou I/O Bound, de acordo com a utilização de <strong>CPU</strong> ou <strong>I/O</strong>. Saber distinguir entre as duas situações é muito importante para conseguirmos arquitetar adequadamente uma solução.</p><h4>CPU Bound</h4><figure><img alt="Screen Shot 2017-04-05 at 1.18.09 AM.png" src="https://cdn-images-1.medium.com/max/1024/0*vSh1ONO-PXzKYEme.png" /></figure><p>Um tipo de computação em uma aplicação, cujo maior fator determinante para o tempo no qual ela vai levar para terminar, é determinado pela velocidade da CPU, pois passam a maior parte do tempo em estado de execução, utilizando o processador. Ou seja: CPUs mais rápidos fazem com que a computação seja mais rápida, terminando em um tempo menor. São exemplos de atividades/aplicações com soluções CPU Bound:</p><ul><li>Computações matemáticas intensas</li><li>Algoritmos de busca e ordenação em memória</li><li>Processamento e reconhecimento de imagem</li></ul><h4>I/O Bound</h4><figure><img alt="Screen Shot 2017-04-05 at 1.21.29 AM.png" src="https://cdn-images-1.medium.com/max/1024/0*tgpqeQ3vR3pK_LQL.png" /></figure><p>Ao contrário de computações CPU Bound, passa a maior parte em estado de espera por realizar muitas operações de I/O. Esse tipo de computação é, obviamente, determinado pelo tempo gasto esperando por operações de input/output. São exemplos de atividades/aplicações I/O Bound, e suas velocidades de execução pouco são afetadas por :</p><ul><li>Transferência de dados pela rede</li><li>Copiar/Mover arquivo em disco</li><li>Consultar um banco de dados remoto</li><li>Consultar uma API HTTP</li></ul><h4>CPU e I/O Bound</h4><p>Aplicações que fazem uso intenso de CPU e dispositivos de I/O. São exemplos:</p><ul><li>Compressão de arquivos</li><li>Desfragmentação de disco</li></ul><h3>Processos e Threads</h3><h4>Múltiplos processos</h4><p><em>Múltiplos processos, </em>ou <em>processos independentes, </em>é uma maneira simples e sem vínculo de se implementar a concorrência. O processo criador não possui nenhuma relação com o processo criado e gera a criação de um novo Processos Control Block (PCB), possuindo contextos de software e hardware completamente diferentes, assim como espaços de endereçamento de memória. Por esse motivo, o compartilhamento de estado de objetos de uma aplicação, e comunicações em geral entre processos, são operações muito custosas e devem ser evitadas.</p><h4>Subprocessos</h4><p>Em python, chamados simplesmente de múltiplos processos. Subprocessos são processos criados com vínculo hierárquico, ou seja: O processo criador é chamado de pai e, novos processos, de filho. Subprocessos não são independentes, e sua existência é condicional a existência do processo pai. A finalização do processo pai -por qualquer motivo-, automaticamente finaliza o processo filho. Subprocessos também podem ter outros Subprocessos.</p><p>A criação de processos e subprocessos é sempre um custo para o sistema operacional como um todo. É preciso alocar contexto de hardware, contexto de software e espaço em memória para cada um.</p><p>Em python, utiliza-se o módulo built-in <a href="https://docs.python.org/3.6/library/multiprocessing.html">multiprocessing</a> para criar novos processos e aproveitar todo os núcleos disponíveis.</p><p>Normalmente, faz-se uso de múltiplos processos sempre que for possível dividir o trabalho de uso intenso de CPU (<strong>CPU Bound</strong>), a ser executado de forma cooperativa sem que seja necessária comunicação entre as partes (ou seja, sem compartilhamento de estado). Operações no modelo MapReduce são um bom exemplo de uso.</p><h4>Threads</h4><p>Threads foram criadas com o intuito de reduzir a criação, troca de contexto de processos (que como já falamos anteriormente, é algo custoso) e para economizar outros recursos do sistema. Threads estão sempre associadas a um único processo, que por sua vez, pode possuir múltiplas threads. Threads compartilham o processador da mesma maneira que um processo, ou seja: <strong>cada thread tem o seu próprio contexto de hardware</strong>, mas threads de um mesmo processo <strong>compartilham entre si</strong> o mesmo contexto de software e <strong>memória</strong>. Resumindo: Basicamente, forçando um pouco a barra, threads são como se fossem “processos leves” que compartilham memória entre si.</p><p>Como threads de um mesmo processo compartilham o mesmo gerenciamento de memória, não existe proteção por parte do SO a acesso de memória, sendo possível que mais de uma thread acesse e manipule o mesmo endereço de memória ao mesmo tempo. O uso desorganizado obviamente causaria inconsitências, e mecanismos de controle devem ser implementados para threads colaborem ordenadamente. Essa ordem é comumente aplicada através de exclusão mútua, que também ganha o nome de <em>mutex</em> (mutual exclusion semaphores), semáforos binários ou, o mais popular, <strong>Lock</strong>. O que nos leva ao famigerado, mistificado, mas pouco entendido <a href="https://docs.python.org/3.6/glossary.html#term-global-interpreter-lock">Global Interpreter Lock (GIL)</a>.</p><p>GIL, nada mais é do que um Lock em nível de interpretador. Ou seja, o GIL existe para proteger a memória do INTERPRETADOR (aquele que lê o texto do seu código, parseia as instruções e estruturas lógicas e transforma em bytecode), e faz com que todas as threads tenham que <a href="https://docs.python.org/3.6/library/threading.html#threading.Lock.acquire">adquirir</a> esta lock por baixo dos panos, pra garantir a integridade das estruturas básicas. Isso parece causar um grande overhead e uma grande sensação de que, na verdade, você acaba não tendo multiplas threads de fato, tendo por consequência possivelmente com um código mais lento do que single thread, o que não é verdade. Threads são sempre mais lentas e ruins por culpa do GIL? NÃO! Especificamente em python, se esse é o caso, você está utilizando threads pra coisa errada. Existem várias situações onde threads podem ser empregadas para ganho de performance em aplicações <strong>I/O Bound</strong>. Inclusive, a documentação é muito clara sobre isso. Infelizmente, muitas pessoas que tive contato ao longo do meu tempo de programador Python, insistem em criticar laranjas por não terem gosto de banana.</p><blockquote><strong>CPython implementation detail:</strong> In CPython, due to the <a href="https://docs.python.org/3.6/glossary.html#term-global-interpreter-lock">Global Interpreter Lock</a>, only one thread can execute Python code at once (even though certain performance-oriented libraries might overcome this limitation). If you want your application to make better use of the computational resources of multi-core machines, you are advised to use <a href="https://docs.python.org/3.6/library/multiprocessing.html#module-multiprocessing"><em>multiprocessing</em></a> or <a href="https://docs.python.org/3.6/library/concurrent.futures.html#concurrent.futures.ProcessPoolExecutor"><em>concurrent.futures.ProcessPoolExecutor</em></a>. However, threading is still an appropriate model if you want to run multiple I/O-bound tasks simultaneously.</blockquote><p>Threads em python são pthreads (posix thread) reais, e podemos criá-las utilizando uma interface de baixo nível <a href="https://docs.python.org/3.6/library/_thread.html#module-_thread">_thread</a> e, em mais alto nível, <a href="https://docs.python.org/3.6/library/threading.html#module-threading">threading</a>.</p><p>No próximo post vou abordar a teoria envolvida no funcionamento do Asynchronous I/O (asyncio), onde ele se encaixa nesses cenários, e dar alguns exemplos práticos de código com comparativos.</p><p>Meu objetivo é que ao final você saiba conscientemente escolher a bicicleta certa para cada tipo de ambiente.</p><figure><img alt="Screen Shot 2017-04-05 at 5.19.37 AM" src="https://cdn-images-1.medium.com/max/1024/0*bAr6TxjrvHPqO3cU.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fbbdd2309d74" width="1" height="1" alt=""><hr><p><a href="https://medium.com/diogommartins/concorr%C3%AAncia-e-paralelismo-threads-m%C3%BAltiplos-processos-e-asyncio-parte-1-fbbdd2309d74">Concorrência e Paralelismo — Threads, múltiplos processos e AsyncIO — Parte 1</a> was originally published in <a href="https://medium.com/diogommartins">diogommartins</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>