<?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[Popcodemobile - Medium]]></title>
        <description><![CDATA[Desenvolvedores de soluções mobile - Medium]]></description>
        <link>https://medium.com/popcodemobile?source=rss----265e4e4ea9f4---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Popcodemobile - Medium</title>
            <link>https://medium.com/popcodemobile?source=rss----265e4e4ea9f4---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 15:18:10 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/popcodemobile" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com" rel="hub"/>
        <item>
            <title><![CDATA[Sagas Architecture .NET]]></title>
            <link>https://medium.com/popcodemobile/sagas-architecture-net-d7d124d8581a?source=rss----265e4e4ea9f4---4</link>
            <guid isPermaLink="false">https://medium.com/p/d7d124d8581a</guid>
            <category><![CDATA[saga-pattern]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[net-core-6]]></category>
            <category><![CDATA[gateway]]></category>
            <dc:creator><![CDATA[Ricardo Alexandre Silva de Andrade]]></dc:creator>
            <pubDate>Mon, 19 Dec 2022 12:53:36 GMT</pubDate>
            <atom:updated>2022-12-19T12:53:36.213Z</atom:updated>
            <content:encoded><![CDATA[<h3>Sagas Architecture .NET</h3><p>O objetivo deste artigo é explicar um pouco o padrão Choreography da arquitetura Sagas, utilizando alguns frameworks em um ambiente de Clean Architecture e Micro Serviços. Como, na data de publicação deste artigo, é um assunto com pouco material relacionado, espero que este trabalho possa contribuir para o entendimento sobre o assunto.</p><h3>Principais features, frameworks e serviços utilizados nesse projeto:</h3><ul><li><a href="https://microservices.io/patterns/data/saga.html">Sagas Choreography Architecture</a></li><li>Arquitetura em Camadas</li><li>CQRS</li><li>Micro Serviços</li><li>Mensageria com <a href="https://www.rabbitmq.com/tutorials/tutorial-three-dotnet.html">RabbitMQ</a></li><li>Api Gateway com <a href="https://ocelot.readthedocs.io/en/latest/introduction/gettingstarted.html">Ocelot</a></li><li>Service Discovery com Eureka</li><li>Bancos de Dados Relacionais com PostgreSQL</li><li>Orquestração de Containers com Docker</li><li>Clean Architecture</li></ul><h3>Explicação Inicial</h3><p>O Saga Architecture é um padrão arquitetural que possui a finalidade de otimizar a comunicação entre os micro serviços a fim de manter a integridade do banco de dados. Bom, como assim?</p><p>Cada micro serviço tem o seu próprio banco de dados, e existem algumas operações que necessitam de transações entre micro serviços, cada um dando um commit no seu próprio banco. Por exemplo (e justamente o exemplo que implementamos nesse repositório do Github, cujo link está na conclusão desse artigo): Quando um usuário faz uma compra na internet, ele emite um pedido de compra (Serviço de Pedidos), esse pedido de compra precisa saber se todos os produtos estão disponíveis para venda (Serviço de Produtos).Por último, o processo é finalizado com a emissão de uma nota de pagamento (Serviço de Pagamento). Assumindo que todos esses serviços realizem alterações em seus próprios bancos de dados, o problema é: e se ocorrer alguma falha em qualquer uma dessas transações? Todos os commits feitos irão persistir nos seus bancos até que você tome uma medida contra isso. E é justamente aí que entra a arquitetura Saga.</p><p>Caso ocorra uma falha em qualquer uma dessas transações, todas as anteriores precisam dar um rollback. E o princípio para isso é: para cada transação implementada, deverá existir uma transação compensatória. Portanto, se eu faço uma compra e esta, por sua vez, reserva um produto no estoque até que eu pague por ela, eu preciso de uma ação de compensação que coloque de volta esse produto no estoque caso aconteça um problema com a emissão do boleto ou o período de pagamento determinado esteja expirado.</p><p>Aqui está uma imagem de contexto de como ficará a arquitetura da nossa aplicação:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/825/1*o0u6LvgbMBr8hTCZVq7XcA.png" /></figure><p>Ao iniciarmos os componentes, cada micro serviço irá registrar o seu endereço e porta no Discovery Service. Há uma vantagem importante aqui. Ao escalonarmos nossa aplicação horizontalmente, não precisaremos nos preocupar com endereços e portas, podemos deixar totalmente a cargo do Service Discovery. Prosseguindo, quando alguém realizar uma requisição ao Gateway, este, por sua vez, irá fazer uma requisição ao Discovery Service para saber o endereço do serviço desejado e, logo em seguida, irá redirecionar a requisição para o serviço em si. Ao salvarmos com sucesso uma alteração no banco de dados, o micro serviço irá enviar essa informação a uma fila específica ao Message Broker, que irá enviar a mensagem para o serviço que registrado e assim por diante.</p><h3>E como nós implementamos isso?</h3><p>Ponto primordial: os micro serviços precisam se comunicar, para que quando uma transação ocorra com sucesso, eles passem essa informação para o próximo micro serviço e caso a próxima transação falhe, os anteriores deem rollback. Para isso há duas abordagens para pensarmos:</p><ul><li>Requisição HTTP.</li><li>Eventos/Mensagens</li></ul><p>A primeira abordagem consiste em chamar a controladora do outro serviço sempre que a transação for concluída, e como toda abordagem, tem os seus contras. Nesta aplicação, como citado no review da arquitetura, estamos utilizando o Service Discovery para o registro de serviços e portanto não precisamos deixar nenhuma porta ou endereço ‘hard-coded’, mas isso seria um contra. Além disso, nessa abordagem, o serviço requisitado precisa obrigatoriamente estar disponível no momento em que for chamado. Com o plus de que você vai ter que fazer muito mais endpoints para lidar com esses casos.</p><p>A segunda abordagem foi a escolhida para este repositório. Nós não precisamos nos preocupar com endereços IP’s, portas ou se o serviço estará disponível no momento em que o anterior realizou sua transação.</p><p>Para realizar a comunicação entre os micro serviços, foi utilizado o RabbitMQ. O componente poderia ser substituído pelo SQS ou Kafka se fosse hospedado em Cloud. Ademais, foi utilizado o BackgroundService para rodar em segundo plano e ouvir quando as mensagens pertinentes àquele serviço chegaram. Novamente, se fosse hospedado em Cloud, poderíamos substituir essa abordagem por Lambda Functions ou Azure Functions.</p><p>Neste projeto, nós temos nosso serviço de mensageria chamado de MessageBroker. O código para o consumo do RabbitMq se encontra nele e todo serviço que queira publicar ou receber mensagens, precisa chamar ele. Além disso, nele estão concentrados os nomes das filas que os serviços irão publicar/consumir, com as models que irão publicar e retornar. Tudo que temos que fazer agora é: sempre que quisermos criar um novo evento, criar dentro de EventModels os seus atributos, e criar o nome de sua fila específica.</p><p>Para conseguirmos rodar os repositórios, recomendo utilizar o docker com o comando “docker-compose up” na raiz do projeto. Assim, você poderá fazer a seguinte requisição:</p><pre>[POST] http://localhost:9000/Order/Order/MakeOrder<br>{<br>    &quot;productId&quot;:1,<br>    &quot;quantity&quot;:1<br>}</pre><p>Veja que nós acessamos o Api Gateway, até porque os nossos serviços não são acessíveis externamente, apenas através do Gateway. O primeiro /Order, se refere ao serviço que o Api Gateway deve procurar no Service Discovery e o Order/MakeOrder é a rota para o endpoint da controladora. E devemos sempre seguir esse esquema.</p><h3>Docker</h3><p>Primeiro vamos analisar o Dockerfile de um microserviço e em seguida o docker-compose que faz a orquestração dos nossos containers.</p><pre>FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS base<br>ENV ASPNETCORE_URLS=http://+:9004<br>EXPOSE 9004<br>WORKDIR /app<br><br>FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build<br>WORKDIR /src<br>COPY [&quot;Services/Order/Order.csproj&quot;, &quot;Service/Order/&quot;]<br>COPY [&quot;Services/Order/Controllers/OrderController.cs&quot;, &quot;Service/Order/&quot;]<br>COPY [&quot;Services/Order/Program.cs&quot;, &quot;Service/Order/&quot;]<br>COPY [&quot;Application/Order/Application.Order.csproj&quot;, &quot;Application/Order/&quot;]<br>COPY [&quot;Domain/Order/Domain.Order.csproj&quot;, &quot;Domain/Order/&quot;]<br>COPY [&quot;MessageBroker/MessageBroker.csproj&quot;, &quot;MessageBroker/&quot;]<br>COPY [&quot;Infra/Order/Infra.Order.csproj&quot;, &quot;Infra/Order/&quot;]<br>RUN dotnet restore &quot;Service/Order/Order.csproj&quot;<br>COPY . .<br>WORKDIR &quot;/src/Service/Order&quot;<br># RUN dotnet build &quot;AspnetRunBasics.csproj&quot; -c Release -o /app/build<br><br>FROM build AS publish<br>RUN dotnet publish &quot;Order.csproj&quot; -c Release -o /app/publish<br><br>FROM base AS final<br>WORKDIR /app<br>COPY --from=publish /app/publish .<br>ENTRYPOINT [&quot;dotnet&quot;, &quot;Order.dll&quot;]</pre><p>As observações aqui são: por ser uma arquitetura em camadas, um dos princípios do Clean Architecture, nós precisamos referenciar<em> </em><strong><em>cada um dos csproj utilizados pelo nosso webapi dentro do nosso container</em></strong>. Sendo que a estrutura de arquivos e pastas devem ser <strong><em>as mesmas</em></strong>, caso contrário, quando fizéssemos o restore não conseguiríamos encontrar os arquivos referenciados no csproj. Além disso a variável de ambiente <strong><em>ASPNETCORE_URLS </em></strong>é uma escolha pessoal minha para o serviço rodar nessa porta, não sendo algo obrigatório.</p><pre>version: &#39;3.8&#39;<br><br>services:<br>  <br>  sagasDb:<br>    image: postgres<br>    volumes:<br>      - ./Database/init.sql:/docker-entrypoint-initdb.d/init.sql<br>    environment:<br>      - POSTGRES_PASSWORD=${DATABASE_PASSWORD}<br>      - POSTGRES_DB=Sagas<br>    networks:<br>      - database-network<br>    ports:<br>      - &quot;5432:5432&quot;<br><br>  messageBroker:<br>    image: rabbitmq:3-management<br>    hostname: &quot;rabbitmq&quot;<br>    healthcheck:<br>      test: rabbitmq-diagnostics -q ping<br>      interval: 5s<br>      timeout: 15s<br>      retries: 3<br>    networks:<br>      - message-network<br>      - services-network<br>    ports:<br>      - &quot;15672:15672&quot;<br>      - &quot;5672:5672&quot;<br>    environment:<br>      RABBITMQ_DEFAULT_USER: &quot;admin&quot;<br>      RABBITMQ_DEFAULT_PASS: &quot;password&quot;<br><br>  serviceDiscovery:<br>    image: steeltoeoss/eureka-server<br>    hostname: eureka-server<br>    networks:<br>      - discovery-network<br>    ports:<br>      - &quot;8761:8761&quot;<br><br>  gateway:<br>    image: ${DOCKER_REGISTRY-}apigateway<br>    restart: on-failure<br>    depends_on:<br>      serviceDiscovery:<br>        condition: service_started<br>    networks:<br>      - services-network<br>      - discovery-network<br>    build:<br>      context: .<br>      dockerfile: Services/ApiGateway/Dockerfile<br>    ports:<br>      - &quot;9000:80&quot;<br>    volumes:<br>      - ./Services/ApiGateway/appsettings.json:/app/appsettings.json<br>      - ./Services/ApiGateway/ocelot.json:/app/ocelot.json<br><br>  order-api:<br>    image: ${DOCKER_REGISTRY-}orderapi<br>    hostname: orderapi<br>    environment:<br>      - Eureka__Client__ServiceUrl=${SERVICE_DISCOVERY_URL}<br>      - Eureka__Client__ShouldRegisterWithEureka=true                   #Exemplo de como tulizar variáveis de ambientes para definir<br>      - Eureka__Client__ValidateCertificates=false                      # as configurações que estão dentro do appSettings.<br>      - Eureka__Instance__NonSecurePort=${ORDER_INSTANCE_NONSECUREPORT} # Exemplo de como utilizar um arquivo de variáveis<br>      - Eureka__Instance__HostName=${ORDER_INSTANCE_HOSTNAME}           # de ambiente a fim de não deixar variáveis expostas<br>      - Eureka__Instance__InstanceId=${ORDER_INSTANCE_INSTANCEID}       # e organizá-las melhor. O arquivo em questão <br>      - DatabaseConnection__ConnectionString=${DATABASE_CONNECTION}     # é o .env na pasta raiz.<br>    networks:<br>      - services-network<br>      - database-network<br>      - message-network<br>      - discovery-network<br>    depends_on:<br>      - serviceDiscovery<br>      - sagasDb<br>    build:<br>      context: .<br>      dockerfile: Services/Order/Dockerfile<br><br>  product-api:<br>    image: ${DOCKER_REGISTRY-}productapi<br>    hostname: productapi<br>    restart: on-failure<br>    networks:<br>      - services-network<br>      - database-network<br>      - message-network<br>      - discovery-network<br>    volumes:<br>      - ./Services/Products/appsettings.json:/app/appsettings.json #Exemplo de como utilizar volumes para definir o appSettings.<br>    depends_on:<br>      sagasDb:<br>        condition: service_started<br>      messageBroker:<br>        condition: service_healthy<br>      serviceDiscovery:<br>        condition: service_started<br>    build:<br>      context: .<br>      dockerfile: Services/Products/Dockerfile<br><br>  payment-api:<br>    image: ${DOCKER_REGISTRY-}paymentapi<br>    hostname: paymentapi<br>    restart: on-failure<br>    environment:<br>      - Eureka__Client__ServiceUrl=${SERVICE_DISCOVERY_URL}<br>      - Eureka__Client__ShouldRegisterWithEureka=true       <br>      - Eureka__Client__ValidateCertificates=false<br>      - Eureka__Instance__NonSecurePort=${PAYMENT_INSTANCE_NONSECUREPORT}<br>      - Eureka__Instance__HostName=${PAYMENT_INSTANCE_HOSTNAME}     # Nós precisamos colocar o hostname como o nome do<br>      - Eureka__Instance__InstanceId=${PAYMENT_INSTANCE_INSTANCEID} # próprio serviço, neste caso &quot;payment-api&quot;, pois é<br>      - DatabaseConnection__ConnectionString=${DATABASE_CONNECTION} # ele quem o gateway tentará chamar. Portanto quando<br>    networks:                                                       # nós passarmos nossa url: http://localhost:9000/Payment<br>      - services-network                                            # no qual 9000 é a porta do Gateway e Payment é o nome<br>      - database-network                                            # do serviço cadastrado no Service Discovery, o nosso Gateway<br>      - message-network                                             # irá traduzir &quot;Payment&quot; para &quot;payment-api&quot;.<br>      - discovery-network<br>    depends_on:<br>      sagasDb:<br>        condition: service_started<br>      messageBroker:<br>        condition: service_healthy<br>      serviceDiscovery:<br>        condition: service_started<br>    build:<br>      context: .<br>      dockerfile: Services/Payment/Dockerfile<br><br><br><br>networks:<br>  services-network:<br>  database-network:<br>  message-network:<br>  discovery-network:</pre><p>Vamos falar apenas do que vocês podem estranhar.<br>No sagasDb, foi utilizado o volume para mapeamento inicial do Script de criação do banco de dados de cada serviço.<br>Eu passei dados de configuração para dentro do container de duas formas distintas: variáveis de ambientes e volumes.<br>Por exemplo, no serviço de produtos eu passei o appSettings inteiro através de volumes. Mas se vocês olharem, nos outros serviços eu utilizei environments.<br>Há um arquivo .env na raiz do projeto que contem todas as variáveis de ambiente. Para acessarmos ela dentro do compose, nós utilizamos ${CHAVE_DA_VARIÁVEL}.<br>Precisamos utilizar health checks em alguns serviços, já que eles possuem uma relação de dependência. Dessa forma, sempre que um serviço falhar ao inicializar por depender de outro que ainda não terminou de ser inicializado, precisamos reiniciá-lo.<br>Foram criadas networks por recomendação do Docker, assim, apenas serviços que estão na mesma network podem se comunicar, oferecendo uma proteção extra à nossa aplicação, sendo que o serviço deve ter o mínimo de networks possíveis, apenas o essencial.<br>O resto é mais do mesmo.</p><h3>Service Discovery e Ocelot</h3><p>O Service Discovery realmente não possui muita magia. A imagem faz tudo pra você, o essencial aqui é como o Ocelot se comunica com ele. Só precisamos nos atentar em utilizar o pacote nuget correto dentro do csproj.<br>Vale ressaltar que nesse projeto foi utilizado o Eureka como Service Discovery mas há outra alternativa, que é o Consul, o mais utilizado dentre os dois.<br>O Ocelot funcionará como um Api Gateway para nós. <br>O Api Gateway funciona como um WebApi, porém sem uma controladora.<br>As configurações precisam ser feitas dentro do appSettings, e do Program.cs (lembrando que o repositório está com a versão 6.0 do .NET, portanto, optou-se por não utilizar a classe Startup). Ademais, precisamos criar um arquivo ocelot.json dentro dessa WebApi.</p><pre>builder.WebHost.ConfigureAppConfiguration(configuration =&gt; configuration<br>    .AddJsonFile(Path.Combine(&quot;appsettings.json&quot;), true, true)<br>    .AddJsonFile(Path.Combine(&quot;ocelot.json&quot;)));<br>builder.Services.AddOcelot().AddEureka();<br>builder.Services.AddDiscoveryClient(builder.Configuration);</pre><p>Essas 3 linhas de código fazem a mágica dentro do program.cs, que basicamente injeta as configurações do service discovery que nós iremos utilizar.</p><pre>&quot;Eureka&quot;: {<br>  &quot;Client&quot;: {<br>    &quot;ServiceUrl&quot;: &quot;http://serviceDiscovery:8761/eureka/&quot;,<br>    &quot;ValidateCertificates&quot;: false,<br>    &quot;ShouldRegisterWithEureka&quot;: false<br>  },<br>  &quot;Instance&quot;: {<br>    &quot;NonSecurePort&quot;: 80,<br>    &quot;HostName&quot;: &quot;Gateway&quot;,<br>    &quot;InstanceId&quot;: &quot;Gateway,Port:80&quot;,<br>    &quot;HealthCheckUrlPath&quot;: &quot;/api/values/healthcheck&quot;,<br>    &quot;StatusPageUrlPath&quot;: &quot;/api/values/status&quot;<br>  }<br>},<br></pre><p>O appSettings do Gateway para registrar a URL do Eureka e a instância do Gateway.</p><pre>{<br>  &quot;Routes&quot;: [],<br>  &quot;Aggregates&quot;: [],<br>  &quot;GlobalConfiguration&quot;: {<br>    &quot;BaseUrl&quot;: null,<br>    &quot;UseServiceDiscovery&quot;: true,<br>    &quot;DownstreamScheme&quot;: &quot;http&quot;,<br>    &quot;ServiceDiscoveryProvider&quot;: {<br>      &quot;Host&quot;: &quot;serviceDiscovery&quot;,<br>      &quot;Port&quot;: 8761,<br>      &quot;Type&quot;: &quot;Eureka&quot;,<br>      &quot;Token&quot;: null,<br>      &quot;ConfigurationKey&quot;: null<br>    },<br>    &quot;LoadBalancerOptions&quot;: {<br>      &quot;Type&quot;: &quot;RoundRobin&quot;,<br>      &quot;Key&quot;: null,<br>      &quot;Expiry&quot;: 0<br>    }<br>  }<br>}</pre><p>E aqui temos o ocelot.json. Percebam que “Routes” é apenas uma lista vazia, isso porque estou utilizando a feature de rotas dinâmicas do Ocelot. Uma segunda abordagem consiste em registrar dentro de “Routes” todo endpoint criado, de acordo com a documentação do Ocelot. Graças a Deus não precisamos, porque poderia ser deveras trabalhoso à medida que a aplicação crescesse. Então, apenas colocamos a configuração do servidor do Eureka dentro de “GlobalConfiguration” e o método de load balancing.<br>Percebam que o host “serviceDiscovery” é exatamente como está escrito o serviço de Service Discovery no docker-compose, pois esse é o método de uma aplicação conhecer o endereço de outra dentro do Docker.</p><h3>RabbitMq</h3><p>O RabbitMq irá atuar como o Message Broker. Obviamente o nosso sistema não precisa saber que nós estamos utilizando o RabbitMq como entregador de mensagens. Na verdade, de acordo com a Clean Architecture, isso não deveria importar. Por isso nós fazemos classes com interfaces de configuração e de implementação dos métodos de entrega e recebimento de mensagem. São bem Simples.</p><pre>public static class MessageBrokerConfig<br>{<br>    public static IModel ChannelConfig()<br>    {<br>        <br>        var channel = new ConnectionFactory() {HostName = &quot;messageBroker&quot;, UserName = &quot;admin&quot;, Password = &quot;password&quot;, Port = 5672}.CreateConnection();<br>        <br>        return channel.CreateModel();<br>    } <br>}</pre><p>Como citado anteriormente, o HostName recebe “messageBroker” porque é como o serviço foi nomeado no docker-compose. É uma classe bem simples, mas é válido observar um ponto aqui. A execução do receiver roda a partir de uma classe chamada BackgroundService, que é como se fosse um serviço de fundo do .NET, a qual precisa ser implementada utilizando um Singleton. Então, enquanto nossa aplicação está no ar, um serviço de fundo fica “escutando” mensagens que chegam.</p><p>Porém, é válido ressaltar que há outras abordagens que podem ser utilizadas, por exemplo, o <a href="http://masstransit-project.com/">Mass Transit</a>. Foi de minha intenção utilizar o RabbitMq do modo mais básico possível, apenas para dar a ideia do funcionamento, mas o uso do Mass Transit facilita o desenvolvimento, bem como o uso do <a href="https://docs.particular.net/nservicebus/sagas/">NServiceBus</a>.</p><pre>private readonly IModel _channel;<br><br>public MessageBroker(IModel channel)<br>{<br>    _channel = channel;<br>}<br>public void PublishMessage&lt;T&gt;(T command, string eventQueue, string exchange)<br>{<br>    var message = JsonSerializer.Serialize(command);<br>        var body = Encoding.UTF8.GetBytes(message);<br>        _channel.BasicPublish(exchange: exchange,<br>            routingKey: eventQueue,<br>            basicProperties: null,<br>            body: body);<br>}<br><br>public void ReceiveMessage&lt;T&gt;(string eventQueue, Action&lt;T&gt; appServiceCall)<br>{<br>    var consumer = new EventingBasicConsumer(_channel);<br>        <br>        consumer.Received += (model, ea) =&gt;<br>        {<br>            var body = ea.Body.ToArray();<br>            var message = Encoding.UTF8.GetString(body);<br>            T? commandEvent = JsonSerializer.Deserialize&lt;T&gt;(message);<br>            if (commandEvent != null)<br>                appServiceCall(commandEvent);<br>        };<br><br>        _channel.BasicConsume(queue: eventQueue,<br>            autoAck: true,<br>            consumer: consumer);<br>}</pre><p>E está é a classe que implementa os métodos de publicar e receber mensagens, foi utilizado apenas a documentação do RabbitMq.</p><pre>channel.ExchangeDeclare(QueueExchange.CreateProductExchange, ExchangeType.Fanout);<br>channel.ExchangeDeclare(QueueExchange.RollbackProductExchange, ExchangeType.Fanout);<br>channel.ExchangeDeclare(QueueExchange.CreatePaymentExchange, ExchangeType.Fanout);<br>channel.QueueDeclare(EventQueue.ValidateProductQueue,false, false, false, null);<br>channel.QueueDeclare(EventQueue.RollbackProductQueue, false, false, false, null);<br>channel.QueueBind(queue: EventQueue.ValidateProductQueue, exchange: QueueExchange.CreateProductExchange, routingKey: &quot;&quot;);<br>channel.QueueBind(queue: EventQueue.RollbackProductQueue, exchange: QueueExchange.RollbackProductExchange, routingKey: &quot;&quot;);</pre><p>Esse é a configuração de filas e exchanges utilizados no projeto, dentro da classe Products/Program.cs. É importante ler a documentação do próprio Rabbit mas, em resumo, é <em>possível </em>mandar mensagens para uma fila sem precisar de um “exchange”. Porém, não é o que o Rabbit recomenda. Digamos que ele faz o papel do carteiro. E as queues são as caixinhas de correios.</p><p>O que nós precisamos fazer é vincular o carteiro à sua respectiva caixinha, sendo que ele pode estar vinculado à mais de uma. E uma outra observação, é que uma “routing key” deveria ser necessária, porém não para o tipo Fanout de Exchange que nós estamos utilizando, então não precisamos ter uma.</p><h3>Conclusão</h3><p>De resto, a nossa arquitetura se resume ao Clean Architecture. A orquestração da comunicação de cada componente é a parte mais complexa desse projeto, já que cada componente possui suas próprias configurações, e é preciso ler a documentação de cada uma. Mas com esses recursos dá para fazer uma aplicação complexa e grátis. Se lembrem que esse é apenas um exemplo de configuração e de como os serviços funcionam, não deixem de inovar e melhorar cada vez mais. Aqui está o <a href="https://github.com/Ricardev/Sagas">repositório do github</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d7d124d8581a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/popcodemobile/sagas-architecture-net-d7d124d8581a">Sagas Architecture .NET</a> was originally published in <a href="https://medium.com/popcodemobile">Popcodemobile</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Mob Programming]]></title>
            <link>https://medium.com/popcodemobile/mob-programming-65dc3a38e71f?source=rss----265e4e4ea9f4---4</link>
            <guid isPermaLink="false">https://medium.com/p/65dc3a38e71f</guid>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[engenharia-de-software]]></category>
            <category><![CDATA[desenvolvimento-software]]></category>
            <dc:creator><![CDATA[Igor Sthaynny]]></dc:creator>
            <pubDate>Wed, 15 Jun 2022 17:37:52 GMT</pubDate>
            <atom:updated>2022-06-15T17:37:52.892Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/870/0*BfIln0tYuvn7uMDW" /></figure><p>Um dos grandes desafios das equipes ágeis é continuar desenvolvendo e entregando recursos dentro do prazo. Para garantir a qualidade de tais recursos, é necessário realizar um planejamento eficiente e principalmente participativo, mas nem sempre todos os participantes são agentes ativos nessa cerimônia. A falha em colaborar com todos os participantes pode comprometer o sprint, pois os membros da equipe de desenvolvimento podem não ter a mesma visão sobre o quadro geral</p><p>Imagina todas as pessoas brilhantes trabalhando na mesma coisa, ao mesmo tempo, no mesmo lugar e no mesmo computador. Como seria a construção de um produto de software com essa metodologia.</p><p>Nesse artigo, será tratado um pouco do Mob programming, que é uma abordagem de desenvolvimento de software onde toda a equipe trabalha na mesma coisa. Isso é semelhante à programação em par, onde duas pessoas se sentam no mesmo computador e trabalham em uma tarefa ou problema ao mesmo tempo. Um geralmente faz a codificação e o outro a “Navegação”.</p><h3>Idealização</h3><p>O conceito original vem de Woody Zuill. O Mob programming pretendia ser uma evolução da programação em pares, uma técnica na qual dois programadores trabalham juntos na mesma atividade. Na nossa realidade do Mob não seria apenas dois profissionais trabalhando juntos e mais, não mais uma única pessoa liderando a atividade até a sua conclusão. Como já entendido, uma abordagem inventada para otimizar as atividades técnicas de programação, mas já está sendo utilizada para diversas outras frentes de desenvolvimento de software, como definição de histórias, design de produtos, testes, negócios e planejamento.</p><h3>Funcionamento do Mob</h3><p>Então, o conceito é que toda a equipe se senta em torno de uma (ou duas) telas de bugs, e se revezam sentados no teclado e todos trabalham juntos para resolver um problema, desenvolver uma história de usuário ou o que a situação julgar. Existem muitos níveis para implementar a programação em multidões, então algumas equipes podem usá-lo para resolver um único problema ou bug, algumas equipes o usariam algumas vezes por semana, talvez em determinadas tarefas ou ocasiões e outros farão todo o possível e o usarão para tudo.</p><p>Então, quanto à configuração, a maioria das equipes implementar algo assim:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/798/0*_QSuAYgCV32YY1pD" /></figure><p>Para a condução das atividades, dois agentes são muito importantes e são os únicos membros participantes na programação em multidão:</p><ul><li><strong>Navegador:</strong> responsável por pensar, discutir e tomar decisões, é o agente que decide o que vai ser implementado numa decisão conjunta.</li><li><strong>Driver:</strong> responsável por traduzir o que os navegadores decidiram. Trabalho completamente mecânico de fazer o que os navegadores decidiram implementar. Há apenas um motorista de cada vez.</li></ul><p>Os princípios que regem tal dinâmica precisam ser sempre:</p><ul><li><strong>Gentileza:</strong> entender que um dos principais objetivos da Mob Programming é a imersão e o aprendizado coletivo, onde todos os colaboradores tiveram conhecimento de todas as atividades;</li><li><strong>Consideração:</strong> conhecer a real importância de todos os presentes no desenvolvimento do planejamento;</li><li><strong>Respeito:</strong> saber responder às dúvidas dos participantes, entendendo que nem sempre, todos têm o mesmo conhecimento e é sempre necessário tratar tais níveis de conhecimento com gentileza.</li></ul><p>No início haverá discussões, discussões sobre métodos, experiência e conhecimento, até coisas como velocidade de digitação, métodos de codificação e atalhos e macros. A maioria das pessoas tem seus PCs configurados de uma certa maneira que lhes permite trabalhar com mais eficiência, agora você está compartilhando um computador com uma quantidade X de outras pessoas. Mesmo esses pequenos problemas precisam ser resolvidos ao longo do tempo. É sempre importante lembrar os objetivos e os benefícios de fazer as coisas dessa maneira.</p><h3>Quais são os benefícios?</h3><p>Existem muitos benefícios, e estes se tornarão óbvios dependendo da equipe. Mas estes são alguns dos benefícios universais que posso ver com o uso desta metodologia:</p><h4>As equipes se aproximam.</h4><p>Trabalhar tão perto de um número de pessoas por 8 horas por dia vai forjar amizades ao longo do tempo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/870/0*7iycczBph3YuQG2v" /></figure><h4>A equipe se complementa com suas habilidades</h4><p>É comum diariamente ter especialistas em uma equipe, ou pessoas que se destacam em certas coisas. Não importa o quanto você tente construir uma equipe autônoma, é da natureza humana que alguns membros da equipe serão mais fortes em outras em determinadas áreas. Agora você pode pensar que isso é uma coisa negativa… mas na verdade não é. Normalmente as pessoas tentam esconder suas fraquezas e muitas vezes elas não são abordadas ou melhoradas. Nesta situação, a equipe trabalhará em conjunto para lidar com eles. Você descobrirá que com o tempo o campo de jogo fica nivelado e sua equipe começará a melhorar como uma unidade.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/583/0*b0kTkcOVvrSLc_AJ" /></figure><h4>A equipe se torna tomadora de risco.</h4><p>Ao enfrentar desafios, às vezes pode parecer assustador por conta própria; mas com a força total de sua equipe atrás de você. Praticamente todas as decisões serão discutidas, votadas e acordadas, então, se algo der errado, a equipe assume as consequências. Você descobrirá que isso pode erradicar qualquer cultura de culpa e até mesmo esse tipo de situação pode fortalecer o vínculo da equipe.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*na71mgpGK90iPz5N" /></figure><h4>A equipe fica mais feliz .</h4><p>Essa metodologia permite reduzir qualquer estresse na equipe e pode melhorar muito a moral. As equipes não sentirão mais responsabilidade exclusiva ou excessivas e todos os problemas serão resolvidos rapidamente em conjunto, para que você reduza as instâncias em que há um problema e ele passa despercebido ou não é tratado por um longo período de tempo. E todos nós sabemos o que acaba acontecendo nessas situações.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*TAPxNpBIEYTA30np" /></figure><h4>A equipe não precisa mais ir às reuniões .</h4><p>Se todos estão trabalhando na mesma coisa ao mesmo tempo, todos estão na mesma página e no loop, quantas reuniões você acha que serão canceladas. Claro que haverá algumas reuniões, não podemos nos livrar de todas, mas esse formato também significa que, como todos sabem tudo o que está acontecendo, qualquer membro da equipe pode ser um representante em qualquer reunião.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*n6DH2y5mItRaYohh" /></figure><h4>A equipe não tem dependências.</h4><p>Porque a equipe está interagindo como uma parceria, não importa se alguém está doente, vai de férias ou tem que sair em caso de emergência. A equipe vai lutar como uma unidade. Isso também tem vantagens quando as pessoas voltam de férias longas ou até mesmo novas pessoas para a equipe. Você descobrirá que eles rapidamente se tornarão parte da equipe socialmente e também suas habilidades chegarão ápice rapidamente.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/870/0*Vb69AVGiLCsyrs8L" /></figure><h4>A equipe se torna mais eficiente.</h4><p>Trabalhar de perto com os membros de sua equipe reduzirá qualquer sincronização que geralmente acontece dentro de uma equipe. Com os colegas em constante comunicação e no mesmo nível, as resoluções dos problemas serão maximizadas. Seus ciclos de feedback se tornam instantâneos e você verá as tarefas avançarem mais rapidamente e as melhorias implementadas mais rapidamente. Qualquer tipo de problema ou discussão pode ser feito em tempo real. A equipe também trabalhará muito mais e de forma mais eficaz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/683/0*jUKARn9ChVRb5rce" /></figure><h4>A equipe vai crescer.</h4><p>A equipe crescerá em conhecimento, socialmente, emocionalmente, tecnicamente e pessoalmente. Este é provavelmente um dos meus benefícios favoritos, mas trabalhando assim, sua equipe compartilhará tanto conhecimento e a colaboração estará no auge. Os pontos fortes estarão espalhados por toda a equipe e todos melhoraram. Uma pessoa aprenderá uma nova habilidade e será rapidamente aprendida pelo resto da equipe. Não é apenas relevante para as habilidades, mas para as tarefas relativas ao trabalho, os desenvolvedores aprenderão a implantar, os testadores aprenderão a codificar e até mesmo os colegas da parte comercial do negócio entenderão a arquitetura técnica e as restrições.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/606/0*ktGaB-JcXv0Bqmxn" /></figure><h4>A equipe se torna uma.</h4><p>Você passará de uma equipe de cada membro único fazendo as coisas de uma maneira diferente, para todos fazendo de uma maneira. Todos juntos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/626/0*1Fm-YTby8HkbwBX7" /></figure><h3>Considerações finais</h3><p>O mob programming não é uma bala de prata para resolver todos os problemas da equipe, mas é uma abordagem alternativa que pode ser usada ocasionalmente para combater problemas como: comunicação não assertiva, acúmulo de conhecimento em um membro que pode sair, tomando uma decisão individual e excesso de ego em membros da equipe.</p><p>Não há regras definidas para a programação de multidões, é mais uma abordagem experimental e não é para todos. Sua equipe pode não ter a cultura certa ou o tipo de trabalho que essa metodologia melhoraria a eficiência. Para a maioria das equipes, isso seria algo para usar de vez em quando, algo em sua ‘caixa de ferramentas’ para usar quando você tem um problema crítico de produção ou um obstáculo difícil de superar. Outras equipes podem usá-lo no início de um projeto e, à medida que avança, começam a se separar e a trabalhar individualmente.</p><p>Se você quiser experimentá-lo, é recomendado tentar em uma pequena tarefa ou bug. Também é bom tentar quando você tem um novo iniciante em sua equipe. Dessa forma, você pode ver antecipadamente se é benéfico para sua equipe sem se comprometer ou mudar completamente a maneira como você faz as coisas.</p><p>Agradeço sua atenção até aqui, sucesso na sua jornada. ❤</p><h3>Referências</h3><p>Hardy, A. (n.d.). <em>Mob Programming — What is it?. Mob Programming What is it? | by Ashley-Christian Hardy | Medium</em>. Ashley-Christian Hardy. Retrieved June 8, 2022, from <a href="https://achardypm.medium.com/mob-programming-what-is-it-a8699da1b583">https://achardypm.medium.com/mob-programming-what-is-it-a8699da1b583</a></p><p>Livyson. (2018, November 3). <em>Using Mob Programming in Sprint Planning | by Livyson | Medium</em>. Livyson. Retrieved June 8, 2022, from <a href="https://livyson.medium.com/using-mob-programming-in-sprint-planning-37506d63a769">https://livyson.medium.com/using-mob-programming-in-sprint-planning-37506d63a769</a></p><p>Woody, Baga, D., &amp; Lucian, C. (2018, January 8). Mob Programming — All the brilliant people working on the same thing, at the same time, in the same space, and on the same computer. Retrieved June 8, 2022, from <a href="https://mobprogramming.org/">https://mobprogramming.org/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=65dc3a38e71f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/popcodemobile/mob-programming-65dc3a38e71f">Mob Programming</a> was originally published in <a href="https://medium.com/popcodemobile">Popcodemobile</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lottie Files — A simbiose entre o designer e o desenvolvedor (Parte 1)]]></title>
            <link>https://medium.com/popcodemobile/lottie-files-a-simbiose-entre-o-designer-e-o-desenvolvedor-parte-1-a822a7e6950?source=rss----265e4e4ea9f4---4</link>
            <guid isPermaLink="false">https://medium.com/p/a822a7e6950</guid>
            <category><![CDATA[animation]]></category>
            <category><![CDATA[simbiose]]></category>
            <category><![CDATA[motion-designer]]></category>
            <category><![CDATA[lottie]]></category>
            <category><![CDATA[popcode]]></category>
            <dc:creator><![CDATA[Vinicius Machado Cruvinel]]></dc:creator>
            <pubDate>Fri, 20 May 2022 14:42:48 GMT</pubDate>
            <atom:updated>2022-05-20T14:42:48.095Z</atom:updated>
            <content:encoded><![CDATA[<h3>Lottie Files — A simbiose entre o designer e o desenvolvedor (Parte 1)</h3><p><a href="https://lottiefiles.com/">Lottie</a> Files é um formato de arquivo de animação baseado em JSON (Json based Animation), ele habilita os designers a disponibilizarem seus trabalhos, sejam animações ou imagens estáticas para qualquer plataforma com bastante facilidade.</p><p>A ideia é que os desenvolvedores recebam os arquivos no formato JSON que os possibilita utilizar essas animações ou imagens estáticas em seus aplicativos.</p><p><strong>O problema apresentado</strong></p><p>Observem que no título deste artigo utilizamos a palavra simbiose, segundo Lynn Margulis: “A simbiose pode ser definida como uma associação a longo prazo entre dois organismos de espécies diferentes e geralmente essa relação é benéfica para ambos os indivíduos ou não”.</p><p>Podemos então chegar ao entendimento que é um grande desafio integrar o trabalho do designer e do desenvolvedor, mas especificamente, o desenvolvedor Front End. O <a href="https://lottiefiles.com/">Lottie</a> Files vem fazer com que essa simbiose aconteça com mais facilidade e flexibilidade.</p><p><strong>Um pouco de história</strong></p><p>Para entender melhor vamos contar um pouquinho da história da animação no contexto das plataformas web.</p><p>Voltando no tempo, as primeiras animações nos primórdios da internet eram baseadas nos arquivos em gif, logo depois, com o advento do Flash elas ganharam um ar mais profissional e o designer começou a ganhar um grande espaço. As páginas web começaram a ganhar mais funcionalidades e começaram a embutir em sua apresentação regras de negócio que exigiam a necessidade de interagir conforme a lógica ali apresentada.</p><p>Embutir essa animação em uma página web era bem simples, mas se houvesse a necessidade de fazer uma interação com essa lógica surgiria então uma série de problemas:</p><ul><li>A interoperabilidade entre as tecnologias.</li><li>A separação e lacuna entre o trabalho do designer e do desenvolvedor.</li><li>A velocidade de carregamento das páginas ou aplicativos.</li><li>A falta de um padrão que não fosse proprietário.</li></ul><p><strong>A interoperabilidade entre as tecnologias</strong></p><p>Dos padrões que tínhamos disponíveis, o GIF era muito simples e com pouca qualidade e o Flash era mais profissional. Com ele era possível fazer lindas animações e até jogos, com o carregamento lento, se utilizava de um formato proprietário que era comumente alvo de críticas na questão da segurança. Outro grande problema é que ele dependia de um plugin, chamado de Flash player, que não foi bem aceito por algumas empresas, principalmente pela Apple, o que mais tarde acabou causando o fracasso do plugin e o triunfo do HTML5.</p><p><strong>A separação e lacuna entre designer e desenvolvedor</strong></p><p>O designer e o desenvolvedor pouco se falavam, o designer criava a animação, enviava para o desenvolvedor que apenas embutia a mesma em uma página web. No entanto, com o crescimento e evolução da web esse paradigma foi quebrado. A transformação de páginas, antes estáticas, agora tinham uma necessidade latente de ganharem funções dinâmicas e se comportarem mais como aplicativos. Essa tendência cresceu impulsionada pela necessidade que as empresas tinham de alimentar os seus sistemas tradicionais de TI , direcionando suas políticas de marketing.</p><p>Essa mudança forçou uma aproximação maior que combinasse o talento do designer para criar movimento e o desenvolvedor de aplicativos ou de sites que precisava embutir regras de negócio em sua aplicação. No entanto, os passos para se chegar em um resultado razoável eram custosos, fazendo com que muitos desistissem ou implementassem projetos que não eram concluídos e ficavam pela metade.</p><p><strong>A velocidade de carregamento dos aplicativos e sua segurança</strong></p><p>O desempenho sempre foi primordial para web, a banda larga, que hoje é uma realidade para grande parte da população mundial, no passado era quase inexistente e as animações em Flash se tornaram um terror no quesito tempo de carregamento e segurança.</p><p>Depois que o Flash foi abandonado as animações começaram a ser apresentadas pelo designer e construídas pelo desenvolvedor, passo a passo, quadro a quadro, pouco a pouco. O designer exportava imagem por imagem para que o desenvolvedor através do código desse vida aquela animação embutindo a regra de negócio necessária. Podemos dizer que o trabalho era de formiguinha e o nosso mundo de frequentes mudanças sempre quer tudo cada vez mais rápido. O fato é que o dinheiro nunca dorme e também não gosta de esperar.</p><p><strong>Falta de um padrão que não fosse proprietário</strong></p><p>As animações sempre foram um tema que despertou muita atenção, por isso, manter um padrão que fosse propriedade de apenas uma empresa acabou se tornando um problema. Depois do abandono do Flash, o HTML5 assumiu a direção desse fluxo, mas era notório que ainda faltava algo que pudesse trazer ganho de produtividade e se encaixasse na cultura de desenvolvimento com equipes utilizando ferramentas e processos ágeis. Pensando nisso, em 2015, um grupo de engenheiros que trabalhava na empresa Airbnb concebeu a ideia de exportar a animação para o formato JSON, que se tornou extremamente popular, aberto e amplamente utilizado e cada vez mais conhecido.</p><p><strong>Lottie files, apoio e características</strong></p><p>Para essas animações que eram exportadas em formato JSON deram nome de <a href="http://lottie">Lottie</a> Files. Entre 2018 e 2019, o apoio e investimento chega por parte da Microsoft e da Samsung. Em 2020, é criado um arquivo específico com formato .lottie com o intuito de poder agregar várias animações em um arquivo.</p><p>Porém, pode-se dizer que o grande marco e diferencial do <a href="https://lottiefiles.com/">Lottie</a> Files foi sem dúvidas a criação de um marketplace onde o designer pode se cadastrar, fazer suas animações, colocar à venda ou disponibilizar gratuitamente. Essa grande mudança popularizou o <a href="https://lottiefiles.com/">lottie</a> como formato e ajudou programadores deixando os aplicativos com visual mais rico, mesmo que o desenvolvedor não conheça as ferramentas de animação.</p><p>É importante ressaltar que o site fornece também material de apoio como tutoriais e um blog com notícias e artigos sobre o assunto. E com todo esse apoio veio também o amadurecimento da tecnologia, empresas detentoras de ferramentas como Figma, After Effects, Animator e entre outras, integraram-se ao <a href="https://lottiefiles.com/">Lottie</a> em seus principais aplicativos. Diversas linguagens de programação já incluíram em seus pacotes ferramentas ou plugins permitindo que o ecossistema do <a href="https://lottiefiles.com/">Lottie</a> venha crescendo e ganhando cada vez mais adeptos. Como exemplos temos abaixo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*N2Lv2RZpntqNrq1h" /></figure><p><strong>As vantagens sobre outros formatos como o PNG e o SVG</strong></p><p>Sobre esse assunto podemos destacar uma tabela comparativa fornecida pela documentação do <a href="https://lottiefiles.com/">Lottie</a> que compara suas características com os formatos SVG e PNG e está disponível no endereço <a href="https://lottiefiles.com/blog/engineering/difference-png-svg-lottie">https://lottiefiles.com/blog/engineering/difference-png-svg-lottie</a> e que destacamos a seguir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/911/0*EsQIkr0bf3Q9evPK" /></figure><p><strong>Considerações finais</strong></p><p>Adotar o <a href="https://lottiefiles.com/">Lottie</a> Files não é a única solução para tudo, todavia, desponta como um forte candidato a ser cada vez mais popular e cada vez mais evoluir e se firmar como uma poderosa opção. Quando falamos de grandes projetos sua flexibilidade para mudanças e customizações é um fator preponderante para essa escolha. Tirem suas próprias conclusões, as cartas do jogo estão na mesa.</p><p><strong>Referências</strong></p><p><a href="https://lottiefiles.com/blog/inspiration/the-flash-back-remembering-adobe-flash">https://lottiefiles.com/blog/inspiration/the-flash-back-remembering-adobe-flash</a></p><p><a href="https://lottiefiles.com/blog/inspiration/power-of-interactive-content">https://lottiefiles.com/blog/inspiration/power-of-interactive-content</a></p><p><a href="https://lottiefiles.com/blog/engineering/difference-png-svg-lottie">https://lottiefiles.com/blog/engineering/difference-png-svg-lottie</a></p><p><a href="https://iteo.medium.com/microinteraction-a-small-but-essential-design-element-a6d6c3db27d8">https://iteo.medium.com/microinteraction-a-small-but-essential-design-element-a6d6c3db27d8</a></p><p><a href="https://techcrunch.com/2022/05/03/lottiefiles-gets-37m-to-make-the-animation-format-even-more-ubiquitous/">https://techcrunch.com/2022/05/03/lottiefiles-gets-37m-to-make-the-animation-format-even-more-ubiquitous/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a822a7e6950" width="1" height="1" alt=""><hr><p><a href="https://medium.com/popcodemobile/lottie-files-a-simbiose-entre-o-designer-e-o-desenvolvedor-parte-1-a822a7e6950">Lottie Files — A simbiose entre o designer e o desenvolvedor (Parte 1)</a> was originally published in <a href="https://medium.com/popcodemobile">Popcodemobile</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Design System: conhecendo a proporção do processo.]]></title>
            <link>https://medium.com/popcodemobile/design-system-conhecendo-a-propor%C3%A7%C3%A3o-do-processo-4bd1ed156802?source=rss----265e4e4ea9f4---4</link>
            <guid isPermaLink="false">https://medium.com/p/4bd1ed156802</guid>
            <category><![CDATA[conhecimento]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[desenvolvimento-software]]></category>
            <category><![CDATA[padrões-de-projeto]]></category>
            <dc:creator><![CDATA[Igor Sthaynny]]></dc:creator>
            <pubDate>Wed, 11 May 2022 18:53:15 GMT</pubDate>
            <atom:updated>2022-10-30T17:56:30.936Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*C6khqLIBkzoQuvdU" /></figure><p>Uma vez que o novo projeto está alinhado, é hora de comunicar a ideia aos colaboradores. A maneira padrão em todo o setor de fazer isso é criar um resumo do projeto. Um resumo do projeto é basicamente um esboço do seu projeto e do trabalho que você deseja que seus colaboradores concluam. Parece bastante simples, mas existem 101 maneiras de escrever um. Imagina ter um catálogo para facilitar a apresentação do coração da sua aplicação ou ter algo para mostrar os padrões aplicados aos seus colaboradores com facilidade e uma curva de aprendizado alta.</p><blockquote>Ai fica a dúvida no ar…</blockquote><blockquote>Como fazer isso?</blockquote><blockquote>Como posso deixar isso padronizado?</blockquote><blockquote>Como deixar claro para os novos integrantes da equipe?</blockquote><p>Já imaginou que os produtos de muitas empresas são produzidos e atualizados um uma velocidade considerável, levando em consideração as dimensões dos seus projetos? Isso vem por ter uma padronização na sua construção de software que é conhecido com Design System (DS) para otimizar, padronizar e facilitar a construção de um projeto.</p><h3>O que é Design System(DS)?</h3><p>Não é nenhum segredo que os projetos adoram ter um bom “kit de interface” para o usuário. No entanto, além de apenas reunir “kits” de ferramentas e guias de estilo, parece que recentemente houve um foco crescente no DS destinado a unir produtos inteiros. Ultimamente, grandes empresas estão construindo equipes internas focadas especificamente no DS. As pessoas estão começando a perceber a importância do design sistêmico. Isso é encorajador. Quem sabe um dia teremos uma ferramenta de design que não assume que estamos começando do zero toda vez que abrimos um novo documento…?</p><p>Um DS (no que se refere a produtos de tecnologia) é mais do que uma estrutura, kit de ferramentas de interface do usuário ou biblioteca de componentes. É mais do que um guia de estilo ou um conjunto de diretrizes de código. É ainda mais do que a soma dessas partes. Um DS é um conjunto de regras em evolução que governa a composição de um produto.</p><p>Há muitas facetas em qualquer bom DS tende a começar com a cultura/missão da empresa e descendo até branding, copywriting, bibliotecas de componentes e outras linguagens de design. Os pontos de nível mais alto são indiscutivelmente os aspectos mais importantes de qualquer DS.</p><p>Depois de definir esses fatores críticos, você pode converter esse conhecimento em uma linguagem de projeto coeso.</p><p>Mas, afinal, o que é DS? <strong>Design System</strong> é uma coleção de componentes reutilizáveis, padronizados para determinado produto, site ou sistema web. Diferente de um style guide (guia de estilos), um DS vai além: unificando a linguagem de um determinado produto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*2atCJRJk2v1LMApY" /></figure><h3><strong>Qual o impacto da implementação de um DS em seu projeto?</strong></h3><blockquote>Construir produtos que as pessoas amam faz parte dos fundamentos do bom projeto para criar ótimas experiências para o nosso cliente, todos precisam contribuir para criar produtos de alta qualidade que inspirem os clientes, mas para conseguir tudo isso precisamos ter um bases sólidas dentro das equipes em toda a empresa, tudo é uma pequena peça do quebra-cabeça.</blockquote><p>Desde <strong>tipografia</strong>, <strong>layouts</strong> e <strong>grades</strong>, <strong>cores</strong>, <strong>ícones</strong>, <strong>componentes</strong> e <strong>convenções de codificação</strong>, até <strong>tom de voz</strong>, <strong>guia de estilo</strong>, <strong>documentação</strong>, um projeto está reunindo tudo isso de uma maneira que permite que toda a sua equipe aprenda, construa e cresça…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*9gVHOzWgySaWN8eM" /></figure><h4><strong>Futuro</strong></h4><p>Os sistemas de design nos darão a flexibilidade necessária para trabalhar com os dispositivos desconhecidos do futuro. Pode ser uma mudança no processo, mas não deve ser muita diferença no pensamento. Precisamos continuar experimentando e comunicando, pois boas experiências do usuário são o verdadeiro sinal de que os produtos são um sucesso. Não basta focar apenas no visual, precisamos alinhar primeiro os fundamentos, como documentação, ferramentas que usamos no dia a dia, no processo de construção, tudo isso é muito importante para construir uma base forte, bem como organizar seus arquivos, como nomeá-los, quais ferramentas todos estão usando, faça um inventário de todos esses pontos e comece a limpá-los e alinhar tudo.</p><p>Antes de iniciar qualquer trabalho em direção ao seu DS, converse com todos os principais interessados ​​que possam precisar fazer referência ou atualizar o sistema. Certifique-se de entender o que funciona bem hoje, quais desafios podem ser resolvidos por meio do sistema e como cada parte interessada gosta de trabalhar. Fazer com que todos participem no início e colaborar com eles durante todo o processo é essencial para o sucesso da linguagem que você está projetando.</p><p><strong>Lembre-se</strong>: Construir um DS é um longo processo cheio de tentativa e erro, testar, aprender, falhar…</p><p>Defina as bases antes de passar para implantação para ter um ponta pé inicial, sabemos que pode mudar no decorrer da construção.</p><p>Pontos para ter atenção:</p><blockquote><strong>Ferramentas</strong> que estamos usando atualmente,</blockquote><blockquote><strong>Nomenclaturas</strong> que estão sendo usadas no projeto nomes para os símbolos em esboços, estilos, espaçamentos, etc.</blockquote><blockquote><strong>Documentação</strong> regras e informações deixadas com facilidades no DS do projeto,</blockquote><blockquote><strong>Guia de estilo: </strong>Manter o padrão para o mapeamento DS &lt;-&gt; projeto.</blockquote><p>Você precisa configurar sua estação de trabalho antes de mergulhar no projeto, digamos que você seja um barman, antes do serviço você precisa configurar as garrafas, máquina de café, ingredientes prontos para os coquetéis etc. e bem configurado, aqui funciona da mesma forma.</p><h4><strong>Documentação</strong></h4><p>Documentar literalmente o DS é um desafio enorme, mas obter uma documentação de um software serve para auxiliar programadores, facilitando o uso e entendimento do software, principalmente quando esse software precisa de evoluções. Na construção do DS deve incluir explicações ou exemplos de funcionalidade, tanto nos protótipos quanto na implantação. Existem muitas maneiras de fornecer elementos com especificações que servem como documentação. Dê a eles uma ideia geral de como deve ser, juntamente com a funcionalidade no mesmo lugar. Comecei a documentar tudo até agora, desde o nome das pastas, nome do arquivo, processo de design, quais ferramentas usar durante o design e colaborativo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*6JNA0u9IHnMDTuPQ" /></figure><h3>Considerações Finais</h3><blockquote>“Um DS não deve ser simplesmente uma coleção de componentes de interface do usuário junto com alguma teoria de design”</blockquote><p>Com essas lições em mente, pensa-se que nas próximas gerações na construção de DS enfatize o aprendizado e o compartilhamento. Um DS não deve ser simplesmente uma coleção de componentes de interface do usuário junto com alguma teoria de design. Deve demonstrar como os padrões de design foram aplicados em produtos reais e documentar como outras equipes estenderam os padrões para casos de uso específicos. O objetivo com este DS é permitir que as equipes de produto concentrem seus esforços na solução das novas necessidades dos clientes e compartilhem essas soluções com o restante da empresa e projetos.</p><p>Agradeço sua atenção até aqui, sucesso na sua jornada. ❤</p><h4>Referências:</h4><p>CROSSMAN, Jeff. <strong>GE’s Predix Design System</strong>. 2016. Disponível em: <a href="https://medium.com/ge-design/ges-predix-design-system-8236d47b0891.">https://medium.com/ge-design/ges-predix-design-system-8236d47b0891.</a> Acesso em: 20 abr. 2022.</p><p>LOPES, Marco. <strong>Setup a design system</strong>. 2017. Disponível em: <a href="https://blog.prototypr.io/design-system-ac88c6740f53.">https://blog.prototypr.io/design-system-ac88c6740f53.</a> Acesso em: 20 abr. 2022.</p><p>TUITE, Colm. <strong>How to construct a design system</strong>. 2017. Disponível em: <a href="https://medium.com/free-code-camp/how-to-construct-a-design-system-864adbf2a117.">https://medium.com/free-code-camp/how-to-construct-a-design-system-864adbf2a117.</a> Acesso em: 20 abr. 2022.</p><p>TWINE. <strong>What makes a good project brief?</strong> 2016. Disponível em: <a href="https://medium.com/@jointwine/what-makes-a-good-project-brief-4e3da276f1a5.">https://medium.com/@jointwine/what-makes-a-good-project-brief-4e3da276f1a5.</a> Acesso em: 20 abr. 202.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4bd1ed156802" width="1" height="1" alt=""><hr><p><a href="https://medium.com/popcodemobile/design-system-conhecendo-a-propor%C3%A7%C3%A3o-do-processo-4bd1ed156802">Design System: conhecendo a proporção do processo.</a> was originally published in <a href="https://medium.com/popcodemobile">Popcodemobile</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Métricas Ágeis]]></title>
            <link>https://medium.com/popcodemobile/m%C3%A9tricas-%C3%A1geis-9472623240e4?source=rss----265e4e4ea9f4---4</link>
            <guid isPermaLink="false">https://medium.com/p/9472623240e4</guid>
            <category><![CDATA[kanban]]></category>
            <category><![CDATA[métricas]]></category>
            <category><![CDATA[scrum]]></category>
            <category><![CDATA[agile]]></category>
            <dc:creator><![CDATA[Victória Luísa Teixeira Lemos]]></dc:creator>
            <pubDate>Wed, 11 May 2022 18:53:04 GMT</pubDate>
            <atom:updated>2022-05-13T13:23:39.961Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/670/1*Ca-VF8eOKOSr9HTScz5eLg.png" /></figure><p>No mundo da agilidade, existem diversas métricas que podem ser colhidas de um time. Mas o que são as métricas ágeis?</p><p>Métricas ágeis são dados relacionados ao time e às entregas em todo o ciclo de desenvolvimento ágil de um projeto. Esses dados podem nos gerar insights para melhoria de produtividade da equipe. As métricas podem mostrar o progresso de um time, assim como o regresso.</p><h3>Quais métricas são importantes?</h3><p>A importância de um dado colhido depende do que você quer analisar no time, mas segue algumas dicas:</p><h3><strong>1. Gráfico de Burndown:</strong></h3><p>Quando se fala de Scrum, estamos falando de desenvolvimento por sprints, que são ciclos de desenvolvimento de um produto. O gráfico de burndown mede o quanto falta para entregar em uma sprint, ou seja, a quantidade de trabalho que ainda precisa ser concluída. A sua visualização e montagem é simples e de fácil entendimento .Ele é composto de dois eixos, sendo o eixo x representando o tempo da sprint, e o eixo y representando o trabalho em horas ou pontos, de acordo com o dado que o time usa.</p><p>Com esses dados, são feitas duas medições: Quanto deveria ser concluído no decorrer do ciclo, e quanto realmente está sendo concluído. Em outras palavras, o ritmo <strong>ideal/planejado </strong>de entregas, e o ritmo <strong>real</strong>. Segue abaixo um exemplo desse gráfico, onde ele está contando 75 dias, e foi planejado entregar 30 pontos de esforço nesses 75 dias:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y6WnvdM3qfLP3kZUvYw_0w.png" /></figure><p>Como preencher o gráfico?</p><p>&gt; Tenha em mãos a quantidade de pontos ou horas planejados no início da sprint, e a quantidade de dias que ela terá.</p><p>&gt; A linha <strong>ideal/planejada</strong> é criada da seguinte forma: Traça-se uma linha reta, começando no primeiro dia e na quantidade de pontos planejados na sprint, e finalizando no último dia da sprint e no ponto 0 do eixo y, ou seja, 0 pontos a serem concluídos (100% de entrega). A conta feita é a divisão entre quantidade de esforço planejada e quantidade de dias do ciclo (começando em 0), e em cada dia, subtrai-se esse resultado, da quantidade de pontos. Exemplo:</p><ul><li>30 pontos planejados em 15 dias de trabalho.</li><li>Dividindo 30 por 15, resulta em 2 pontos entregues por dia.</li><li>Cada dia finalizado, subtrai-se 2 pontos. Então no dia 0 temos 30 pontos restantes. No dia 1, o ideal é que tenhamos 28 pontos restantes, no dia 2, 26 pontos restantes e assim sucessivamente, até chegar no dia 15 e termos 0 pontos.</li></ul><p>&gt; A linha <strong>real </strong>é alimentada diariamente. Ao final de cada dia, pegamos o planejado e subtraimos a quantidade de horas ou pontos já entregues, resultando no total de trabalho restante. Exemplo:</p><ul><li>30 pontos planejados.</li><li>Dia 1 temos 0 pontos entregues, então calculamos 30–0, resultando em 30 pontos de trabalho restantes.</li><li>Já no dia 2, temos um total de 3 pontos entregues. Calculamos 30–3, resultando em 27 pontos de trabalho restantes.</li><li>No dia 3, entregamos 1 ponto, então temos 4 pontos entregues no total (3 do dia anterior + 1 do dia atual). 30–4, 26 pontos restantes.</li></ul><h3>2. Gráfico de Burnup</h3><p>Apesar de parecer o gráfico de burndown, e ambos mostrarem o progresso do time, o gráfico de Burnup é um pouco diferente.</p><p>Enquanto o Burndowm mostra quanto falta para chegar na meta planejada, Burnup mostra quanto o time já progrediu para alcançar o objetivo. Esse gráfico geralmente é usado para medir o progresso do projeto como um todo, mas pode também ser montado para ter a visualização apenas da sprint.</p><p>Da mesma forma que o gráfico de Burndown é criado, o Burnup parte de dois eixos, sendo o eixo horizontal representando o tempo, e o eixo vertical representando horas/pontos de esforço. A diferença é que o Burnup cresce, assim como seu nome diz. Ele começa em zero no primeiro dia da sprint (ou do projeto), e corre até a meta planejada, chegando último dia da sprint. Conforme os dias vão correndo, vai sendo relatado quantos pontos ou horas foram entregues. Segue exemplo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*I4DSWOg391QN_3OVEOSHuA.png" /></figure><h3><strong>3. Velocidade do time</strong></h3><p>A velocidade do time é uma das métricas mais importantes para o <strong>planejamento </strong>de entregas. É bastante usado quando é preciso prever a média de quanto a equipe consegue entregar em uma sprint, por exemplo.</p><p>Os dados usados geralmente são das últimas sprints finalizadas. Quanto mais dados coletados, maior é a precisão da velocidade, mas é mportante lembrar também que dados muito antigos podem não ser tão úteis, pois a chance de ser mais assertivo usando dados mais “novos”, é maior do que quando usamos dados de sprints finalizadas a mais tempo! Além disso, os times evoluem, pessoas entram e saem, então é necessário se atentar a isso também.</p><p>A ideia é olhar para as sprints passadas e analisar quanto o time conseguiu entregar, fazendo uma média e levando em conta alguns pontos importantes, como:</p><ul><li>Tivemos ausências significativas de membros do time (férias, atestado, entrada ou saída de colaboradores…)?</li><li>Tivemos impedimentos que impactaram nos resultados?</li><li>Quão assertivas foram nossas estimativas de pontos nas histórias das sprints analisadas?</li></ul><p>O time precisa estar envolvido nessa análise, pois ele, mais do que ninguém, consegue responder essas perguntas e discutir a velocidade de entrega. O que não pode ser feito, é comparar a velocidade entre times diferentes.<strong> </strong>Não se esqueçam: <strong>a velocidade de entrega de um time é única! </strong>Se um time com 5 pessoas entrega 40 pontos em uma sprint, não necessariamente outro time, também com 5 pessoas, precisa entregar 40 pontos. São pessoas diferentes, com ritmos de trabalho, conhecimento e senioridade diferentes!</p><h3>4. Cycle Time e Lead Time</h3><p>Ao falar de <em>cycle time</em> e <em>lead time</em>, estamos falando de histórias, <em>features </em>e <em>epics</em>. Esses dois indicadores medem diferentes etapas do processo.</p><p>Mas o que são esses indicadores?</p><p>Vamos lá! Pensando em histórias de usuário:</p><p><strong><em>Cycle Time</em>:</strong></p><ul><li><em>Cycle time</em> é o tempo que uma história leva desde o inicio do desenvolvimento, até o momento da entrega. Pensando num quadro de tarefas, o <em>cycle time</em> se inicia quando a história entra na coluna <em>in progress</em> e finaliza quando a história vai para a coluna <em>done</em> (essas nomenclaturas podem mudar de acordo com o que o time julga melhor). Segue uma imagem para facilitar o entendimento:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/442/1*3_mMCOU7mD7kCXc6xulkUQ.jpeg" /></figure><ul><li>Com o <em>cycle time</em> medido, podemos tirar algumas informações que sejam importantes para a melhoria do time, por exemplo: conseguir mensurar quanto tempo o time demora para implementar uma determinada tarefa ou funcionalidade, seja para estimar prazos de um novo projeto de forma mais assertiva, ou para ter como meta diminuir o tempo de desenvolvimento.</li><li>Estimar prazos de entrega é uma das etapas mais importantes para o cliente, pois ele quer o produto/projeto pronto. Então, ter esses dados de projetos anteriores, para usar de base em um novo projeto, evita que aconteça da estimativa de entrega ser muito diferente da realidade. Lembrando que cada projeto e cada equipe tem seu ritmo de trabalho, mas esses dados mensurados ajudam na estimativa.</li></ul><p><strong><em>Lead Time</em>:</strong></p><ul><li>Já o <em>lead time</em>, é o tempo levado desde quando a história ficou pronta para ser iniciada, até o momento da entrega. Pensando nas sprints, quando a história entra no backlog da sprint, o lead time é iniciado, e só finaliza quando a história for entregue. Como pode-se observar na imagem anterior, quando a tarefa entrar na coluna <em>to do</em>, ou seja, quando o time se comprometer a fazer, o <em>lead time</em> é iniciado, e encerra quando a história for entregue (coluna <em>done</em>).</li><li>Essa métrica pode medir o tempo que uma tarefa leva para passar em todas as etapas até ser concluída, como aespera para ser iniciada, desenvolvimento, testes e homologação. Assim, é possível levantar alguns questionamentos, por exemplo se o tempo estiver muito alto. Essa tarefa que está gerando um <em>lead time </em>alto, ainda é importante para o cliente? A tarefa se tornou “velha” ou ainda faz sentido de ser desenvolvida?</li><li>Com esses questionamentos, é possível eliminar histórias e tarefas que foram criadas e não fazem mais sentido para o produto, por exemplo, evitando que o time foque no desenvolvimento de funcionalidades que não serão mais utilizadas. Além disso, assim como o <em>cycle time, </em>o <em>lead time </em>ajuda a medir prazos de entrega, o que facilita na gestão dos projetos de uma empresa como um todo.</li></ul><p>É importante ressaltar que <strong>uma história/tarefa não volta para colunas anteriores</strong>, então se uma história começou a ser desenvolvida e foi bloqueada, ela permanece na coluna de desenvolvimento e o cycle time e lead time continuam contando.</p><p>Para finalizar, basicamente o <em>cycle time</em> está englobado dentro do <em>lead time</em>, e a diferença entre os dois indicadores é que o <em>cycle time</em> não pega o tempo que a história está esperando pra ser iniciada, enquanto o <em>lead time</em> pega. Ambas as métricas são importantes para se estimar a entrega de um projeto, visto que o cliente quer saber o tempo de entrega desde quando ele solicitar a funcionalidade, o que seria a medição do <em>lead time</em>, enquanto o time técnico está mais focado no <em>cycle time</em>, que é o tempo gasto para desenvolver.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/591/1*CIjbkg7g69qGc0roxu4MtA.png" /></figure><p>Bom, agora você consegue colher boas métricas para começar a analisar melhor as entregas do time! Existem outras métricas, como o gráfico CFD (<em>Cumulative Flow Diagram</em>), mas se você está começando a estudar sobre as métricas, não é o melhor caminho começar por ele, pois ele tem uma complexidade um pouco maior, e merece uma explicação bem detalhada!</p><p>Espero ter te ajudado no entendimento das métricas mais conhecidas, e que coloque em prática! 🚀🚀</p><p>Ficou com alguma dúvida? Pode comentar aqui embaixo, que a gente se ajuda 💙</p><p>Referências:</p><p><a href="https://www.digite.com/pt-br/agile/tempo-de-lead-e-tempo-de-ciclo/"><em>https://www.digite.com/pt-br/agile/tempo-de-lead-e-tempo-de-ciclo/</em></a></p><p><a href="https://www.atlassian.com/br/agile"><em>https://www.atlassian.com/br/agile</em></a></p><p><a href="http://oagilista.co/metricas-para-o-scrum/"><em>http://oagilista.co/metricas-para-o-scrum/</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9472623240e4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/popcodemobile/m%C3%A9tricas-%C3%A1geis-9472623240e4">Métricas Ágeis</a> was originally published in <a href="https://medium.com/popcodemobile">Popcodemobile</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Atomic Design com Flutter]]></title>
            <link>https://medium.com/popcodemobile/atomic-design-com-flutter-65452426ae9f?source=rss----265e4e4ea9f4---4</link>
            <guid isPermaLink="false">https://medium.com/p/65452426ae9f</guid>
            <category><![CDATA[engenharia-de-software]]></category>
            <category><![CDATA[flutter]]></category>
            <dc:creator><![CDATA[Igor Sthaynny]]></dc:creator>
            <pubDate>Tue, 10 May 2022 11:31:18 GMT</pubDate>
            <atom:updated>2022-05-10T11:31:18.419Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*N3nxSV2D4wIa5ofm" /></figure><p>O atomic design é uma analogia à tabela periódica, criado pelo Design Brad Frost, onde é utilizado uma metodologia modular para a criação e representação de componentes em sua interface ou projeto. É uma forma de organização de projeto que traz uma facilidade para o reuso do projeto gerado em seu software. O conceito atômico é mais utilizado para construção de interface e são poucas as tecnologias que a utilizam para a construção de sistemas de software.</p><p>Para ter uma ideia melhor sobre o conceito, vamos ver com mais detalhes a ideia por trás do atomic design e o que pode trazer de benefícios para a construção de um software.</p><h3>O que é o Atomic Design?</h3><p>O design atômico é uma metodologia para criar sistemas de software.</p><blockquote>“Não estamos projetando páginas, estamos projetando sistemas de componentes. — Stephen Hay”</blockquote><p>Como sabemos, tudo é construído por átomos, e os átomos fazem as moléculas, as moléculas fazem os organismos e os organismos fazem a vida, mas no mundo Flutter não existem átomos, existem widgets! então isso significa:</p><ul><li><strong>Átomos</strong>: widgets;</li><li><strong>Moléculas</strong>: grupo de widgets;</li><li><strong>Organismos</strong>: grupo de moléculas;</li><li><strong>Modelos ou templates</strong>:uma página com dados fictícios;</li><li><strong>Página</strong>: uma página com dados dinâmicos;</li></ul><p>Mas o que são esses termos no atomic design. O conceito vem de uma metáfora bastante conhecida da gente: átomos, moléculas, organismos, templates e páginas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*24jugfBGJAc_EBdO" /></figure><h3>O Átomo</h3><p>Um átomo é uma única célula, o bloco de construção básico ou, em termos de Flutter, um texto, alinhamento, centro ou um simples widget personalizado. Os blocos de construção mais básicos para seu aplicativo, esses Átomos são quase sempre um S<strong>tateless Widget</strong> e não fazem nenhum gerenciamento de estado. Todos esses elementos não podem ser divididos em partes menores sem perder o uso (por exemplo, por que você precisaria de um botão sem rótulo ou ícone?)</p><h3>A Molécula</h3><p>Depois de criar seus átomos, as coisas ficam mais interessantes quando os combinamos e os deixamos trabalhar juntos. Uma molécula é um grupo de átomos ligados e é a menor unidade fundamental de um composto. A molécula assume suas propriedades e, se necessário, tem seu estado efêmero e serve como espinha dorsal do nosso sistema de interface do usuário.</p><p>Isso faz com que as moléculas existam como widgets sem estado e com estado, dependendo da exigência de um estado para ser gerenciado. Às vezes, as moléculas já são elementos funcionais que podem ser colocados em qualquer lugar da página e funcionar por conta própria. Normalmente, eles precisam ser parte de um organismo, para realmente ter um valor.</p><p>Exemplo:</p><p>Alguns containers arredondados não seriam muito úteis, mas combiná-los como um indicador de página e eles podem fazer algo juntos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*qyZr7YyKgPgELDAC" /></figure><blockquote><strong>Nota importante:</strong> não há diretrizes muito rígidas no nível do átomo/molécula sobre como dividir seus elementos. Se você acredita que o campo de entrada com uma mensagem de erro e anotação faz sentido adicionar como um átomo, que assim seja. O mais importante é deixar claro para designers e desenvolvedores como você divide os elementos em seu sistema.</blockquote><h3>O organismo</h3><p>O organismo é a combinação de várias moléculas para formar uma seção relativamente complexa de nossa interface do usuário e podemos ver a interface final tomando forma na forma de um controle deslizante de página ou grade de produto que pode consistir na mesma molécula repetida várias vezes.</p><p>O organismo incentiva a criação de widgets autônomos, portáteis e reutilizáveis. Como o organismo é um widget autônomo, sua única necessidade é um contexto, pois a grade do produto ainda precisa do conjunto de dados para que possa ser constituído.</p><h3>O Modelo ou Templates</h3><p>A maioria dos modelos começa como <em>wireframes</em> e são ideais para testes de interface do usuário e onde vemos alguns rostos antigos novamente construindo a página que queremos usar. O modelo pode ser comparado a um fragmento do <em>Material Design</em>. O Material Design é um conjunto de diretrizes, também conhecido como guidelines, criada pela Google para padronizar todas as interfaces gráficas (contendo ícones, cores, formas e entre outro componentes padrões preparado para ser utilizado).</p><p>Um modelo é muito concreto e tem toda a lógica para permitir que os organismos trabalhem juntos. Portanto, o modelo contém uma abordagem de estado do aplicativo para definir os estados dos organismos fornecidos. Essencialmente, são páginas sem conteúdo real. Eles combinam organismos em um <em>layout</em> adequado.</p><h3>Páginas</h3><p>A página é a instância específica do modelo, fornecendo-lhe os dados corretos no contexto, assim, a página não é realmente um componente, mas o produto final na tela do aplicativo, por exemplo, as diferentes páginas de receitas que seu aplicativo de culinária contém. Todas as receitas funcionam a partir do mesmo modelo, mas os dados e o contexto fornecidos as tornam únicas. A diferença entre páginas e modelos são os conteúdos que são exibidos.</p><ul><li><strong>Modelo: </strong>Conteúdo estático;</li><li><strong>Página: </strong>Conteúdo dinâmico;</li></ul><p>Abaixo, deixa mais claro os conceitos visualmente:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*korlIKFE3sbv4Z00" /></figure><h3>Por que usar esse método?</h3><p>Brand menciona algumas e também as que eu já tive a oportunidade de vivenciar:</p><ul><li>Esse é o jeito o qual nós já estamos pensando no design e implementação desses elementos, mas talvez não de forma consciente e não de forma tão específica.</li><li>Os membros do time de design e do time do cliente conseguem visualizar melhor o sistema de design, sem necessariamente precisar ver todos os layouts salvos em .jpg em frente a eles.</li><li>A combinação desses dois documentos (<strong>style guide</strong> e <strong>biblioteca</strong> <strong>de padrões de interação</strong>), aliada à dinamicidade desses novo jeito de entregar a interface é uma ótima forma de centralizar a documentação em um único repositório e agilizar as etapas iniciais de wireframing e design visual.</li><li>Nesse formato, o sistema passa a ter maior escalabilidade. Você não está escolhendo breakpoints ou devices específicos para montar a sua interface, mas sim criando elementos que se comportam adequadamente a todos (ou quase todos) eles.</li></ul><p>Podemos observar que esse método é muito voltado para o reuso e em sistemas muito escaláveis tem grande chance de trazer um grande benefício na produção de uma aplicação escalável.</p><p>Então vamos falar sobre como usar essa lógica no Flutter?</p><h3>Deixe-me explicar com um exemplo simples</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*8f4mIpi-x8pA_Y4x" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*MxWX_rbSpYDpVJGN" /></figure><p>Como você pode ver, nosso código é muito mais limpo e legível dessa maneira.</p><h3>Considerações finais</h3><blockquote>O design atômico não se trata de projetar uma única instância ou página, trata-se de projetar com o quadro geral em mente — trata-se de projetar o núcleo do sistema.</blockquote><p>Algo que para a maioria será esquecido será a testabilidade dessa abordagem. Todas as suas moléculas e organismos são pequenos e têm um escopo específico e, portanto, extremamente fáceis de testar a unidade, com o benefício extra de reutilização através do aplicativo completo, aumentará a estabilidade do seu aplicativo em dez vezes. A abordagem atômica pode ser complementar ou ser utilizada no seu projeto com todo, é perceptível a utilização em Design System para facilitar o reuso.<br>Ter padrões em um projeto é importante para manter seu time e colaboradores que ingressaram em sintonia.</p><p>Agradeço sua atenção até aqui, sucesso na sua jornada. ❤</p><h3>Referências:</h3><p><em>Atomic Design: redesenhando os entregáveis de designers e desenvolvedores</em>. (n.d.). UX Collective. Retrieved May 5, 2022, from <a href="https://brasil.uxdesign.cc/atomic-design-redesenhando-os-entregaveis-de-designers-e-desenvolvedores-389750c7169e">https://brasil.uxdesign.cc/atomic-design-redesenhando-os-entregaveis-de-designers-e-desenvolvedores-389750c7169e</a></p><p>Bayat, H. B. (2021, nov 15). <em>Atomic Design with Flutter</em>. Medium. Retrieved mai 05, 2022, from <a href="https://itnext.io/atomic-design-with-flutter-11f6fcb62017">https://itnext.io/atomic-design-with-flutter-11f6fcb62017</a></p><p>Hacq, A. (2017). <em>Atomic design: how to design systems of components</em>. Medium. Retrieved may 5, 2022, from <a href="https://uxdesign.cc/atomic-design-how-to-design-systems-of-components-ab41f24f260e">https://uxdesign.cc/atomic-design-how-to-design-systems-of-components-ab41f24f260e</a></p><p>klerkx, s. (2020, February 14). <em>Atomic design with Flutter. Flutter is the newest cross-platform… | by stefan klerkx | Medium</em>. stefan klerkx. Retrieved May 5, 2022, from <a href="https://devaronius.medium.com/atomic-design-with-flutter-a8f69b68f39d">https://devaronius.medium.com/atomic-design-with-flutter-a8f69b68f39d</a></p><p>Meinberg, T. (2018, March 22). <em>Building Design Systems with Atomic Design | by Igor Syvets | Muzli</em>. Muzli — Design Inspiration. Retrieved May 5, 2022, from <a href="https://medium.com/muzli-design-inspiration/building-design-systems-with-atomic-design-93a13286f676">https://medium.com/muzli-design-inspiration/building-design-systems-with-atomic-design-93a13286f676</a></p><p>Toscano, J. (2015, October 8). <em>The Unicorn Workflow, Design to Code with Atomic Design Principles and Sketch</em>. Medium. Retrieved May 3, 2022, from <a href="https://medium.com/re-write/the-unicorn-workflow-design-to-code-with-atomic-design-principles-and-sketch-8b0fe7d05a37">https://medium.com/re-write/the-unicorn-workflow-design-to-code-with-atomic-design-principles-and-sketch-8b0fe7d05a37</a></p><p>Toscano, J. (2015, October 8). <em>The Unicorn Workflow, Design to Code with Atomic Design Principles and Sketch</em>. Medium. Retrieved May 5, 2022, from <a href="https://medium.com/re-write/the-unicorn-workflow-design-to-code-with-atomic-design-principles-and-sketch-8b0fe7d05a37">https://medium.com/re-write/the-unicorn-workflow-design-to-code-with-atomic-design-principles-and-sketch-8b0fe7d05a37</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=65452426ae9f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/popcodemobile/atomic-design-com-flutter-65452426ae9f">Atomic Design com Flutter</a> was originally published in <a href="https://medium.com/popcodemobile">Popcodemobile</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Git Flow: Otimizando seu fluxo de trabalho]]></title>
            <link>https://medium.com/popcodemobile/git-flow-otimizando-seu-fluxo-de-trabalho-fe508a14a7c9?source=rss----265e4e4ea9f4---4</link>
            <guid isPermaLink="false">https://medium.com/p/fe508a14a7c9</guid>
            <category><![CDATA[gitflow]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[engenharia-de-software]]></category>
            <dc:creator><![CDATA[Igor Sthaynny]]></dc:creator>
            <pubDate>Thu, 14 Apr 2022 11:14:14 GMT</pubDate>
            <atom:updated>2022-04-14T11:14:14.501Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1012/1*CGqMvsRdZ7R9iIDXe6NStQ.png" /></figure><p>O desenvolvimento de um produto de software moderno na grande maioria das vezes envolve uma equipe de desenvolvedores de software tendo cada membro seu papel bem definido. O versionamento de código é um processo que para auxiliar essas equipes com intuito de otimizar o controle de um produto de software.</p><p>Em geral, o gerenciamento de código fonte é uma grande ajuda para as equipes de engenharia de software, que reduz os custos de desenvolvimento, permitindo que os recursos de engenharia sejam executados com mais eficiência. SCM(Supply Chain Management) é essencial na era moderna do desenvolvimento de software. O git é uma das principais ferramentas para o versionamento de código no ambiente de desenvolvimento.</p><p>Se você já trabalha com o git como principal ferramenta de controle de versão, já deve ter visto várias abordagens de como utilizar e controlar branchs em um cenário de produção ou pessoal. E se você é novo com git, este fluxo irá te ajudar a ter maior familiaridade com as empresas, projetos open source costumam utilizar seus fluxos de trabalho. Este artigo tem o intuito de propor uma abordagem para a melhoria do fluxo de trabalho e otimização do versionamento do seu código.</p><h3>O que é Git Flow?</h3><p>O Git Flow é um modelo alternativo para criação e gerenciamento de ramificações do Git que consiste no uso de recursos de ramificações primárias. O Git Flow pode ser usado para projetos que têm um ciclo de lançamento agendado e para a prática recomendada de DevOps de entrega contínua. Este fluxo de trabalho não adiciona novos conceitos ou comandos além do necessário para o Fluxo de trabalho de ramificação de recursos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X0z7esarBY4e8f078Hdclg.png" /></figure><p><strong>É beleza, mas como funciona?</strong></p><p>Ao invés de uma única ramificação <strong>main</strong>, esse fluxo de trabalho usa duas ramificações para registrar o histórico do projeto. A ramificação <strong>main</strong> armazena o histórico do lançamento oficial, e a ramificação <strong>develop</strong> serve como uma ramificação de integração para recursos. Também é conveniente marcar todos os commits na ramificação<strong> main</strong> com um número de versão.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/611/0*tPdD0Se_pZIf0Xeo" /><figcaption>Git Flow Model Nvie</figcaption></figure><p>A <strong>main</strong> irá conter todo código já testado, versionado que será entregue ao cliente e a <strong>develop</strong> é onde todo fluxo de trabalho irá ocorrer antes de fazer o release versionado que será feito merge na <strong>main</strong>.</p><p>A <strong>develop</strong> deve sempre conter o código mais atual, onde as branchs de features serão ramificadas tendo ela como base.</p><p><strong>feature</strong>: para novas implementações.</p><p><strong>release</strong>: para finalizar o release e tags.</p><p><strong>hotfix</strong>: para resolver problema crítico em produção que não pode esperar novo release.</p><p><strong>bugfix</strong>: para resolver problema crítico em desenvolvimento que não pode ir para produção.</p><h3>Fluxos de trabalho com Git.</h3><p><strong>Como começar!</strong></p><p>Nos sistemas Mac OSX, você pode executar o `brew install git-flow`. No Windows, é necessário fazer <a href="https://git-scm.com/download/win">o download e instalar o git-flow</a>.</p><p>Após a instalação do Git Flow, é necessário dar o start no seu projeto, levando em consideração que o seu projeto já está clonado. Para isso, use o comando:</p><blockquote><strong>git flow init</strong></blockquote><p>Será apresentado as seguintes configurações:</p><blockquote><strong>Initialized empty Git repository in ~/project/.git/</strong></blockquote><blockquote><strong>No branches exist yet. Base branches must be created now.</strong></blockquote><blockquote><strong>Branch name for production releases: [main]</strong></blockquote><blockquote><strong>Branch name for “next release” development: [develop]</strong></blockquote><blockquote><strong>How to name your supporting branch prefixes?</strong></blockquote><blockquote><strong>Feature branches? [feature/]</strong></blockquote><blockquote><strong>Release branches? [release/]</strong></blockquote><blockquote><strong>Hotfix branches? [hotfix/]</strong></blockquote><blockquote><strong>Support branches? [support/]</strong></blockquote><blockquote><strong>Version tag prefix? []</strong></blockquote><p>Para deixar as configurações padrões é só da ENTER sempre de solicitado.</p><h3>Ramificação de recurso (Feature)</h3><p>A ramificação de recurso é utilizada quando projeto necessita da implementação de um novo artefato ou tarefa que gerará um entrega de valor.</p><p>Sem as extensões do git-flow:</p><blockquote><strong>git checkout develop</strong></blockquote><blockquote><strong>git checkout -b feature_branch</strong></blockquote><p>Ao usar a extensão do git-flow:</p><blockquote><strong>git flow feature start feature_branch</strong></blockquote><p>Continue seu trabalho e use o Git como de costume.</p><p>Quando você concluir o trabalho de desenvolvimento no recurso, a próxima etapa é mesclar a ramificação de recurso (<strong>feature</strong>) na de desenvolvimento (<strong>develop</strong>).</p><p>Sem as extensões do git-flow:</p><blockquote><strong>git checkout develop</strong></blockquote><blockquote><strong>git merge feature_branch</strong></blockquote><p>Usando as extensões do git-flow:</p><blockquote><strong>git flow feature finish feature_branch</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hl4Xwan1Oa1R_aO8SzGBdA.png" /></figure><h3>Ramificação de lançamento (release)</h3><p>Release é a entrega de um ou mais Incrementos do Produto prontos, gerados pelo Time de Desenvolvimento em um ou mais atividades concluídas e incrementadas. A realização de Releases ao longo do projeto tem três objetivos principais: obter feedback frequentemente, prover retorno ao investimento dos clientes e dar um senso de progresso a eles.</p><p>Criar esta ramificação dá início ao próximo ciclo de lançamento, portanto nenhum novo recurso pode ser adicionado depois deste ponto, apenas atualizações de segurança, geração de documentação e outras tarefas relacionadas ao lançamento devem ir nesta ramificação.</p><p>Para gerar essa ramificação:</p><p>Sem as extensões do git-flow:</p><blockquote><strong>git checkout develop</strong></blockquote><blockquote><strong>git checkout -b release/0.1.0</strong></blockquote><p>Ao utilizar extensões do git-flow:</p><blockquote><strong>git flow release start 0.1.0</strong></blockquote><p>Depois que a versão estiver pronta para o lançamento, vai ser feito o <strong>merge</strong> dela na ramificação <strong>main</strong> e na ramificação <strong>develop</strong> e, então, a ramificação release vai ser excluída. O processo de <strong>merge</strong> de volta para a ramificação <strong>develop</strong> é importante porque atualizações importantes podem ter sido adicionadas à ramificação <strong>release</strong> e elas devem ser acessíveis a novos recursos.</p><p>Para finalizar a ramificação de lançamento, use os seguintes métodos:</p><p>Sem as extensões do git-flow:</p><blockquote><strong>git checkout main</strong></blockquote><blockquote><strong>git merge release/0.1.0</strong></blockquote><p>Ou, com a extensão do git-flow:</p><blockquote><strong>git flow release finish ‘0.1.0’</strong></blockquote><p>Ramificações para correções</p><p>Existem dois tipos de correções realizadas no código que são o hotfix e bugfix:</p><p><strong>Bugfix</strong>: Quando ocorre um comportamento inesperado na ramificação de desenvolvimento, assim a correção será realizada antes de ser gerada a release do aplicativo.</p><p>Sem as extensões do git-flow:</p><blockquote><strong>git checkout develop</strong></blockquote><blockquote><strong>git checkout -b bugfix_branch</strong></blockquote><p>Ao usar a extensão do git-flow:</p><blockquote><strong>git flow bugfix start bugfix_branch</strong></blockquote><p>Continue seu trabalho e use o Git como de costume.</p><p>Hotfix: Quando ocorre um comportamento inesperado na ramificação principal (<strong>main</strong>), ou seja, na versão de lançamento. É aberta uma ramificação de correção para aplicar as medidas corretivas adequadas.</p><p>Sem as extensões do git-flow:</p><blockquote><strong>git checkout main</strong></blockquote><blockquote><strong>git checkout -b hotfix_branch</strong></blockquote><p>Ao utilizar extensões do git-flow:</p><blockquote><strong>git flow hotfix start hotfix_branch</strong></blockquote><p>Assim como acontece na finalização da ramificação release, é feito o <strong>merge</strong> da ramificação de <strong>hotfix</strong> tanto na ramificação <strong>main</strong> quanto na ramificação <strong>develop</strong>.</p><p>Sem as extensões do git-flow:</p><blockquote><strong>git checkout main</strong></blockquote><blockquote><strong>git merge hotfix_branch</strong></blockquote><blockquote><strong>git checkout develop</strong></blockquote><blockquote><strong>git merge hotfix_branch</strong></blockquote><blockquote><strong>git branch -D hotfix_branch</strong></blockquote><p>Ao utilizar extensões do git-flow:</p><blockquote><strong>$ git flow hotfix finish hotfix_branch</strong></blockquote><h3>Conclusão</h3><p>Atualmente a rotatividade de desenvolvedores(as) em times é alta, seja por movimentações internas em uma empresa, ou a saída e chegada novos(as). Isso reforça a importância do gerenciamento de projeto com código fonte.</p><p>A rotatividade é inevitável, já o tempo gasto em cada saída ou chegada de pessoas no projeto, pode ser minimizado a partir do gerenciamento do projeto com código fonte. Quanto mais projetos existirem, mais este gerenciamento pode contribuir.</p><p>Com isso, sabemos o quão é importante manter o código versionado e ter um fluxo de trabalho em constante evolução. Além do mais o versionamento é mais um dos diversos processos necessários que podem ser utilizados em controle e distribuição de softwares para facilitar os times.</p><p>Agradeço sua atenção até aqui, sucesso na sua jornada. ❤</p><h4>Referências:</h4><p><a href="https://mazer.dev/o-que-e-gerenciamento-de-codigo-fonte/#:~:text=Em%20geral%2C%20o%20gerenciamento%20de,moderna%20do%20desenvolvimento%20de%20software">https://mazer.dev/o-que-e-gerenciamento-de-codigo-fonte/#:~:text=Em%20geral%2C%20o%20gerenciamento%20de,moderna%20do%20desenvolvimento%20de%20software</a>.</p><p><a href="https://www.atlassian.com/br/git/tutorials/comparing-workflows/gitflow-workflow">https://www.atlassian.com/br/git/tutorials/comparing-workflows/gitflow-workflow</a></p><p><a href="https://medium.com/trainingcenter/utilizando-o-fluxo-git-flow-e63d5e0d5e04">https://medium.com/trainingcenter/utilizando-o-fluxo-git-flow-e63d5e0d5e04</a></p><p><a href="https://git-scm.com/download/win">https://git-scm.com/download/win</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fe508a14a7c9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/popcodemobile/git-flow-otimizando-seu-fluxo-de-trabalho-fe508a14a7c9">Git Flow: Otimizando seu fluxo de trabalho</a> was originally published in <a href="https://medium.com/popcodemobile">Popcodemobile</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Sound Null Safety no Flutter]]></title>
            <link>https://medium.com/popcodemobile/sound-null-safety-no-flutter-c97b4b628211?source=rss----265e4e4ea9f4---4</link>
            <guid isPermaLink="false">https://medium.com/p/c97b4b628211</guid>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[português]]></category>
            <category><![CDATA[null-safety]]></category>
            <category><![CDATA[sound-null-safety]]></category>
            <category><![CDATA[migration-guide]]></category>
            <dc:creator><![CDATA[Thiago Fontes]]></dc:creator>
            <pubDate>Thu, 06 May 2021 22:37:29 GMT</pubDate>
            <atom:updated>2021-05-10T11:11:43.526Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>“I call it my billion-dollar mistake. It was the invention of the null reference in 1965.” — Tony Hoare</blockquote><p>Esta frase é do inventor do <em>Null</em>, mas como é dito no video do Dev Fest LATAM sobre null safety no Flutter, talvez o único problema tenha sido não ter incluído nenhum tipo de <em>null safety</em> junto, afinal necessitamos de uma abstração que indique que algo não tem um valor ou é inválido em alguns casos.</p><p>O <em>Sound Null Safety</em> foi lançado na versão 2 do Flutter no dia 03 de Março de 2021 em conjunto com muitas outras novidades como as versões estáveis do Flutter web e desktop: <a href="https://developers.googleblog.com/2021/03/announcing-flutter-2.html">https://developers.googleblog.com/2021/03/announcing-flutter-2.html</a></p><p>Hoje a forma mais fácil de testar é via DartPad, não é necessário ter o Flutter instalado, tudo roda no navegador e será possível replicar e acompanhar a maioria dos exemplos deste artigo apenas usando o DartPad: <a href="https://nullsafety.dartpad.dev/">https://nullsafety.dartpad.dev</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J13Ah29BfvrEaEK3IDqm7g.png" /><figcaption>Figura 1: Exemplo de erro relacionado o atributo que pode assumir valor <em>Null</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/714/1*nXuSM0Yw9mRPL8akWIdj2A.png" /><figcaption>Figura 2: DartPad snippets</figcaption></figure><p>O DartPad ainda conta com alguns <em>snippets</em> para exemplificar e auxiliar no entendimento do <em>null safety</em> no Dart, como pode ser visto ao lado.</p><p>No caso deste artigo primeiro vamos entender a motivação e alguns conceitos importantes para poder seguir em frente com o código.</p><h3>Por que Null Safety é importante?</h3><p>Muitas pessoas se fazem essa pergunta e embora para alguns não pareça ter utilidade, o <em>Null Safety</em> ajuda a prevenir erros que só seriam percebidos em <em>runtime</em> e que se não forem identificados nos testes, vão com certeza aparecer em produção (lei de Murphy). O fato do programador agora receber estes erros antes da compilação graças ao <em>Dart analyzer</em> faz com que muitos erros sejam evitados. Segundo o time do Dart entre 80 e 90% das variáveis nunca assumem o valor null (Dev Fest LATAM Null safety in Dart, minuto: 3:35).</p><h3>Mas e o tal do Sound Null Safety? O que é isso?</h3><p>Segundo a documentação do Dart o <em>Null Safety</em> da linguagem é baseado em três princípios centrais:</p><blockquote><strong>- Non-nullable by default:</strong><em> A não ser que você explicitamente defina que um atributo pode ser </em><strong>null</strong><em> ela será considerada </em><strong>non-nullable.</strong><em> É explicado que essa decisão foi tomada após constatar com uma pesquisa que a maioria das APIs são </em>non-nullable<em> por padrão.</em></blockquote><blockquote><strong>- Incrementally adoptable:</strong><em> É possível escolher o quê e quando migrar para </em>null safety.<em> Será possível migrar pacotes individualmente e existem ferramentas para ajudar na migração.</em></blockquote><blockquote><strong>- Fully sound:</strong><em> O tipo de </em>null safety<em> que o dart adota é chamado de “</em>sound<em>”, a grande vantagem é que isto permite otimizações na compilação. Se o sistema de tipos definir que algo não pode ser nulo então esta definição será sempre válida. Uma vez que um projeto e suas dependências sejam migrados para </em>null safety<em> será possível aproveitar todos os benefícios, além de menos bugs também resultará em binários menores e execução mais rápida. O Sound Null Safety foi lançado na versão 2 do Flutter no dia 03 de Março de 2021.</em></blockquote><h3>Entendendo como funciona na prática, vamos ao código!</h3><p>Como foi dito anteriormente é preciso declarar explicitamente que um atributo pode assumir o valor <em>null</em>, para fazer isso usa-se o caractere “?” logo depois da definição do tipo como pode ser visto no exemplo da figura 1 onde o <em>Dart Analyzer</em>já informa ao programador que será necessário tratar o caso onde o atributo pode assumir o valor <em>null</em>.</p><p>A seguir temos a definição de dois atributos que <strong>não podem</strong> assumir valores nulos: peso e nome. Já o atributo apelido neste caso poderia assumir o valor <em>null.</em> Do ponto de vista de uma aplicação que registra o peso, nome e apelido de pessoas esta implementação faria sentido do ponto de vista que nem todo mundo tem um apelido e o atributo não fosse obrigatório.</p><pre>String nome;<br>String? apelido;<br>double peso;</pre><p>Se você tentou colocar o exemplo acima em uma classe no DartPad deve ter visto um erro como na figura a seguir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/866/1*s6PdDFGfs8ajaTh2SP7iww.png" /><figcaption>Figura 3: Erro ao definir variáveis</figcaption></figure><p>Logo de cara o <em>Dart Analyzer</em> já está informando que as variáveis nome e peso precisam de um valor. Você talvez pense “Nossa tá faltando o construtor, deve ser isso”, em parte sim, um construtor comum resolveria nosso problema, mas no Flutter por exemplo é muito comum usar parâmetros nomeados nos construtores e é aí onde temos outro problema, parâmetros nomeados são opcionais:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/758/1*VU6WRQ2zFCXC_BBJO0qL7g.png" /><figcaption>Figura 4: Erro ao se definir construtor com parâmetros nomeados</figcaption></figure><p>Como resolver este problema? Uma das novas sintaxes introduzidas foi a palavra reservada <em>required</em>, que é usada para explicitar que aquele argumento será obrigatório e não deve ser <em>null</em>;</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/488/1*irdPh4E_zzqVfTDVQzvJQg.png" /><figcaption>Figura 5: Uso do required com um construtor de parâmetros nomeados</figcaption></figure><p>Além destas duas novas sintaxes existem mais duas que são o “<em>late” </em>e o sinal de exclamação “!” o <em>late </em>é utilizado quando é preciso declarar uma variável, mas temos certeza de que ela será inicializado depois embora o Dart não consiga provar isso. Vamos assumir agora por exemplo que seria necessário calcular a massa de uma pessoa, e o peso seria um atributo desta classe que depende do valor da massa:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/866/1*E9eT_92EMy-WWCT_Hj3uZQ.png" /><figcaption>Figura 6: Erro ao tentar inicializar o peso no construtor.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/866/1*qPhE1OtdNN6Kuij_MunMUg.png" /><figcaption>Figura 7: Usando <em>late </em>para indicar que variável será inicializado posteriormente.</figcaption></figure><p>Já a exclamação será usada para fazer o Dart explicitamente ignorar que um valor pode ser <em>null </em>neste caso é como se não houvesse <em>Null </em>S<em>afety</em> e por isto é melhor evitar usar “!” o máximo possível no código, como pode ser visto é possível até inserir o valor <em>null</em> em uma variável que não deveria assumir este valor e apenas uma warning foi gerada neste caso, porém em casos mais complexos nenhum aviso seria exibido e a responsabilidade é toda do programador em tratar os valores para garantir que nada de errado aconteça:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/838/1*HYrqgFWV60cvuk0aDpwZ2A.png" /><figcaption>Figura 8: Inserindo <em>null</em> no peso da Pessoa</figcaption></figure><p>Para definir listas, mapas ou outros atributos com tipos dinâmicos, usa-se a sintaxe a seguir:</p><pre>// Lista e elementos não podem assumir valor null<br>List&lt;String&gt; listaA;<br>// Lista pode ser null, mas seus elementos não<br>List&lt;String&gt;? listaB;<br>// Lista não pode ser null, mas seus elementos podem ser null<br>List&lt;String?&gt; listaC;<br>// Tanto a lista quanto seus elementos podem ser null<br>List&lt;String?&gt;? listaD;</pre><h3>Migrando seu código existente para <em>null safety</em></h3><p>Bom antes de tudo, espere até que o <em>null safety </em>entre em uma release estável para migrar o seu código existente, mas caso você queira testar com projetos pessoais menores, todo o processo será descrito a seguir.</p><p>O ideal seria que todas as suas dependências já tivessem sido migradas para <em>null safety,</em> ou pode ser necessário fazer alterações futuras no código, mas mesmo sem tudo migrado ainda conseguimos prosseguir.</p><ul><li><strong>Atualizado o Flutter para a versão 2</strong></li></ul><pre>flutter upgrade<br>flutter --version</pre><p>Para checar o status das dependências, na pasta do projeto execute o comando a seguir:</p><pre>dart pub outdated --mode=null-safety</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5_chPnPRcx8NV417wVw1UA.png" /><figcaption>Figura 9: Exemplo de status das dependências de um projeto</figcaption></figure><p>Como pode ser visto na figura 10, no projeto testado ainda não havia uma versão <em>null safe</em> da <strong><em>data_connection_checker</em></strong> e será necessário “forçar” alguns passos por conta disso para poder ativar e testar <em>null safety</em> no projeto.</p><p>Com base na saída apresentada agora deve-se atualizar todas as dependências que possuem suporte pra <em>null safety</em> para suas respectivas versões no arquivo <strong>pubspec.yaml</strong> e depois rodar o comando: <strong>dart pub upgrade</strong>.</p><p>Para ativar o modo de null safety use o comando (caso todas as suas dependências tiverem sido migradas): <strong>dart migrate</strong></p><p>Não é recomendado que você atualize antes de ter suas dependencias migradas, mas se assim como no meu projeto de exemplo ainda existirem dependencias sem suporte ao <em>null safety </em>e você desejar atualizar. Será necessário passar a flag “ — skip-import-check” o comando ficaria assim: <strong>dart migrate — skip-import-check</strong></p><p>Se tudo correr bem um haverá um link ao final da execução levando para a interface da ferramenta de migração:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lltrhmdsp7RfQ1RT1_pJlA.png" /><figcaption>Figura 10: Exemplo de link produzido após executar a ferramenta de migração</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e03h4TW-7b8xIg-1UQJ0Sg.png" /><figcaption>FIgura 11: Interface web da ferramenta de migração</figcaption></figure><p>Como pode ser visto na Figura 12 no navegador será possível verificar todas as mudanças que foram feitas pela ferramenta também é possível editar caso não se concorde com algo. Ou adicionar “dicas” para a ferramenta de migração seguir numa segunda execução, para mais detalhes sobre isso consultar a documentação oficial: <a href="https://dart.dev/null-safety/migration-guide">https://dart.dev/null-safety/migration-guide</a>, ou o video sobre <em>null safety</em> do <em>Dev Fest LATAM</em> sobre o assunto: <a href="https://www.youtube.com/watch?v=b6YntQSKS7g">https://www.youtube.com/watch?v=b6YntQSKS7g</a> Pronto quando não forem encontrados nenhum problema com o código migrado basta clicar em “<em>APPLY MIGRATION</em>” no canto superior direito e finalizar o processo no terminal.</p><p>Se você for olhar o código na sua IDE provavelmente vai encontrar um monte de erros e warnings, mas não entre em pânico está tudo certo, ainda é preciso ativar o null safety para que ele entre em vigor, o comando para realizar esta tarefa no projeto é: <strong>dart — enable-experiment-non-nullable ./lib/main.dart</strong> na raiz do seu projeto, note que no meu caso foi usado o arquivo main.dart dentro da pasta lib, mas a depender de como o seu projeto está estruturado isso pode ser diferente.</p><p>Com isso agora não devem mais haver erros no projeto provenientes da análise estática em conflito com o código <em>null safe,</em> se todas suas dependências já haviam sido migradas já deve ser possível rodar o projeto sem problemas, caso contrário é preciso desabilitar o <em>sound null safety</em> passando a <em>flag: </em><strong><em>— no-sound-null-safety</em></strong>. Ou seja seu código foi escrito respeitando as novas sintaxes para ser <em>null safe,</em> mas até que todas as suas dependências sejam atualizadas também, não será possível ter toda a segurança e ganhos esperados ao compilar a aplicação.</p><h3>Fontes:</h3><ul><li>Sound null safety — <a href="https://dart.dev/null-safety">https://dart.dev/null-safety</a></li><li>Null safety in Flutter — <a href="https://flutter.dev/docs/null-safety">https://flutter.dev/docs/null-safety</a></li><li>Announcing sound null safety — <a href="https://medium.com/dartlang/announcing-sound-null-safety-defd2216a6f3">https://medium.com/dartlang/announcing-sound-null-safety-defd2216a6f3</a></li><li>Announcing Dart null safety beta — <a href="https://medium.com/dartlang/announcing-dart-null-safety-beta-87610fee6730">https://medium.com/dartlang/announcing-dart-null-safety-beta-87610fee6730</a></li><li>Dev Fest LATAM — Null safety in Dart — <a href="https://www.youtube.com/watch?v=b6YntQSKS7g">https://www.youtube.com/watch?v=b6YntQSKS7g</a></li><li>Migrating to null safety — <a href="https://dart.dev/null-safety/migration-guide">https://dart.dev/null-safety/migration-guide</a></li><li>Wikipedia | Tony Hoare — <a href="https://en.wikipedia.org/wiki/Tony_Hoare">https://en.wikipedia.org/wiki/Tony_Hoare</a></li><li>Announcing Flutter 2 — <a href="https://developers.googleblog.com/2021/03/announcing-flutter-2.html">https://developers.googleblog.com/2021/03/announcing-flutter-2.html</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c97b4b628211" width="1" height="1" alt=""><hr><p><a href="https://medium.com/popcodemobile/sound-null-safety-no-flutter-c97b4b628211">Sound Null Safety no Flutter</a> was originally published in <a href="https://medium.com/popcodemobile">Popcodemobile</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Por que um MVP sem acessibilidade não é “viável” e quais ferramentas do Flutter vão te ajudar]]></title>
            <link>https://medium.com/popcodemobile/por-que-um-mvp-sem-acessibilidade-n%C3%A3o-%C3%A9-vi%C3%A1vel-e-quais-ferramentas-do-flutter-v%C3%A3o-te-ajudar-41e3a1e781f6?source=rss----265e4e4ea9f4---4</link>
            <guid isPermaLink="false">https://medium.com/p/41e3a1e781f6</guid>
            <category><![CDATA[development]]></category>
            <category><![CDATA[accessibility]]></category>
            <category><![CDATA[dart]]></category>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Isadora Lima]]></dc:creator>
            <pubDate>Fri, 09 Apr 2021 17:36:22 GMT</pubDate>
            <atom:updated>2021-04-09T17:36:21.939Z</atom:updated>
            <content:encoded><![CDATA[<h3>Por que um MVP sem acessibilidade não é “viável” e quais ferramentas do Flutter ajudam a ter um app acessível</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DUR9IAWMao_oOKlgWc0ApA.jpeg" /></figure><p><strong>Por que acessibilidade?</strong></p><p>De acordo com o Censo de 2010, mais de 45 milhões de brasileiros declararam possuir alguma deficiência, isso significa que 1 a cada 4 brasileiros possuem deficiências que podem tornar seu aplicativo não acessível para eles. Além disso, é importante ressaltar que há deficiências que são temporárias ou situacionais além de somente deficiências permanentes. O que isso significa?</p><p>Um aplicativo que foi criado pensando em pessoas com deficiência visual atende não somente a pessoa cega mas atende também a pessoa com catarata e até um motorista no trânsito que precise usar seu app. Um aplicativo que foi criado pensando em uma pessoa que possui apenas um braço atende também alguém que está com um braço temporariamente machucado e a pessoas que estão segurando recém nascidos. Segue uma tabela com alguns exemplos vindos do Microsoft Design Toolkit.</p><figure><img alt="Tipos de deficiências temporárias, situacionais e permanentes." src="https://cdn-images-1.medium.com/max/478/1*dUjMpqTAneHt_vXw0G2ZKA.jpeg" /><figcaption>Tipos de deficiências temporárias, situacionais e permanentes.</figcaption></figure><p>Lançar um <strong>M</strong>inimal <strong>V</strong>iable <strong>P</strong>roduct que não atende todas as necessidades de acessibilidade é deixar de atender uma parcela significativa da população e do seu público-alvo, o que deixa de tornar o produto realmente Viable.</p><p><strong>As ferramentas do Flutter que podem ajudar a deixar o seu produto acessível e consequentemente viável:</strong></p><p>Existem dois componentes do Flutter que dão suporte à acessibilidade dentro do seu aplicativo, ambos são fáceis de usar e muitas vezes funcionam “já de fábrica”.</p><p><strong>Tamanho de textos</strong></p><p>Dos widgets de Text existe o textScaleFactor que é multiplicado pelo tamanho da fonte definida para renderizar no sistema. O que isso significa? Se você quer que seu texto seja 150% do tamanho da fonte, seu textScaleFactor seria de 1.5. Setar valores para textScaleFactor manualmente irá sobrescrever os valores do sistema quando a acessibilidade estiver ativada. O próprio Flutter irá automaticamente colocar o valor de MediaQueryData.textScaleFactor, que é o valor de escala do sistema, e é atualizado baseado nas configurações de acessibilidade quando houver um contexto válido. Se não houver um contexto disponível o valor vai ser sempre 1.0.</p><figure><img alt="Imagem dos componentes do Widget Text nativo do Flutter" src="https://cdn-images-1.medium.com/max/254/1*2XNNyst2hwv4HfA38YQMKQ.png" /><figcaption>Widget Text nativo do Flutter</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/289/1*97JTsMgOA3lkqp--BCbuYg.gif" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/289/1*cSKPu8hJN83l0MlV25roVA.gif" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/289/1*Fspc-7KXchZN_W61NxhHag.gif" /><figcaption>Tipos de escalonamento do texto: manualmente com o clique do botão, automaticamente com as definições do sistema e fator de escala definido manualmente não cresce baseado nas definições do sistema.</figcaption></figure><p>Apesar do Flutter automaticamente já escalar seus textos, é importante sempre checar seu aplicativo usando essas configurações para garantir que textos não fiquem cortados, o que é ainda pior do que eles não escalarem com a acessibilidade.</p><p><strong>Leitores de Tela</strong></p><p>Leitores de tela são essenciais para pessoas com qualquer tipo de visão diminuída. Tanto a Apple quanto o Google possuem funcionalidades em seus sistemas operacionais que leem a tela do celular para facilitar o uso de softwares por essas pessoas.</p><p>Quando ativamos essa funcionalidade e abrimos um app em Flutter, muitos dos widgets nativos se comportam da forma esperada. O que isso significa? O leitor de tela irá ler a função do widget e o texto (caso tenha), por exemplo: um botão com texto “Clique aqui” vai ser lido como “Clique aqui, botão”.</p><p>Porém, caso seja necessário criar widgets diferentes que não possuam uma descrição padrão que condiz com a sua função é sempre possível usar o widget Semantics.</p><p>O Semantics permite que você descreva não só o widget em questão, mas também o que todas as ações relacionadas a esse widget podem fazer. Ou seja, caso o onLongPress do widget abra um submenu e no onTap ele abra outra tela, essas ações podem ser descritas com o Semantics para tornar todas as funções do seu app mais acessíveis.</p><p>Existem ainda outros widgets que usam Semantics para facilitar casos de uso diferentes, como o MergeSemantics, que marca uma subárvore de widgets como um único node para os quesitos de acessibilidade e ExcludeSemantics, que exclui uma subárvore de widgets da árvore de semantics.</p><p>O Semantics também pode ser usado para melhor descrever widgets, como por exemplo, para detalhar o conteúdo de uma imagem. No exemplo abaixo o widget vai ser lido como “Imagem do logo do Flutter”, contextualizando para o usuário com algum tipo de dificuldade visual.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/355/1*4Y1hcEceFnOq69v1caseaw.png" /><figcaption>Semantics sendo usado para descrever um widget de imagem</figcaption></figure><p><strong>Conclusão</strong></p><p>O Flutter possui ferramentas bastante completas para tratar todos os casos de uso de acessibilidade do seu app. Algumas coisas já vem “prontas”, mas isso não significa que não é preciso fazer testes e ajustar esses componentes para cada caso de uso.</p><p>Um aplicativo que não está devidamente preparado para todas as pessoas que podem usá-lo, não está realmente pronto para ser usado.</p><p><strong>Fontes</strong></p><p><a href="https://www.ibge.gov.br/estatisticas/sociais/populacao/9662-censo-demografico-2010.html?edicao=9749&amp;t=destaques">https://www.ibge.gov.br/estatisticas/sociais/populacao/9662-censo-demografico-2010.html?edicao=9749&amp;t=destaques</a></p><p><a href="https://www.microsoft.com/design/inclusive/">https://www.microsoft.com/design/inclusive/</a></p><p><a href="https://medium.com/flutter-community/a-deep-dive-into-flutters-accessibility-widgets-eb0ef9455bc">https://medium.com/flutter-community/a-deep-dive-into-flutters-accessibility-widgets-eb0ef9455bc</a></p><p><a href="https://www.youtube.com/watch?v=NvtMt_DtFrQ">https://www.youtube.com/watch?v=NvtMt_DtFrQ</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=41e3a1e781f6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/popcodemobile/por-que-um-mvp-sem-acessibilidade-n%C3%A3o-%C3%A9-vi%C3%A1vel-e-quais-ferramentas-do-flutter-v%C3%A3o-te-ajudar-41e3a1e781f6">Por que um MVP sem acessibilidade não é “viável” e quais ferramentas do Flutter vão te ajudar</a> was originally published in <a href="https://medium.com/popcodemobile">Popcodemobile</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Injeção de dependências no Flutter]]></title>
            <link>https://medium.com/popcodemobile/inje%C3%A7%C3%A3o-de-depend%C3%AAncias-no-flutter-152704d4064d?source=rss----265e4e4ea9f4---4</link>
            <guid isPermaLink="false">https://medium.com/p/152704d4064d</guid>
            <category><![CDATA[padrão-de-projeto]]></category>
            <category><![CDATA[dependency-injection]]></category>
            <category><![CDATA[injeção-de-dependência]]></category>
            <category><![CDATA[service-locator]]></category>
            <category><![CDATA[flutter]]></category>
            <dc:creator><![CDATA[João Pedro Quintino]]></dc:creator>
            <pubDate>Thu, 08 Apr 2021 10:51:58 GMT</pubDate>
            <atom:updated>2021-04-08T10:51:58.714Z</atom:updated>
            <content:encoded><![CDATA[<h3>Injeção de Dependências no Flutter</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MMAfCgfRPZ9uhu72TyAkzg.jpeg" /></figure><p>A injeção de dependências é um padrão de projeto que tem como objetivo manter um baixo acoplamento entre módulos de um sistema. Mas, como identifico esse acoplamento no código e como sei que preciso de injeção de dependências? Além disso, como posso implementar a injeção de dependências no Flutter? É isso que tratarei neste artigo.</p><h4><strong>Acoplamento entre módulos</strong></h4><p>Diz-se que duas classes estão com alto acoplamento quando uma das classes “conhece” muito da outra. Ex.:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ea231582949a0f7835844a05792e3d73/href">https://medium.com/media/ea231582949a0f7835844a05792e3d73/href</a></iframe><p>No exemplo acima, a classe BuscaNomeUseCase conhece o construtor concreto BuscaNomesRepository , por isso, as duas classes estão com alto acoplamento, além de uma baixa coesão, pois o método call do BuscaNomeUseCase sabe obter uma lista de nomes e sabe criar um repositório, o que fere o <a href="https://medium.com/@angelomribeiro/princ%C3%ADpio-da-responsabilidade-%C3%BAnica-6d633087fa4e">princípio da responsabilidade única</a>.</p><h4><strong>Por que um alto acoplamento é ruim?</strong></h4><p>Do jeito que está o código acima, não é possível implementar testes unitários com Mocks, pois o objeto BuscaNomeUseCase cria o repositório, tornando inviável que seja criado um repositório em Mock que retorne valores de teste para o objeto.</p><p>Em linhas gerais, um baixo acoplamento traz mais facilidade de manutenção e implementação de novas funcionalidades, além de permitir a utilização de mocks para realizar testes unitários.</p><h4><strong>Como reduzir o acoplamento?</strong></h4><p>Uma maneira bastante eficiente de reduzir o acoplamento é implementando a injeção de dependências. Para isso, é imprescindível que seja utilizadas interfaces, a fim de registrá-las como um contrato entre os módulos que precisarão interagir entre si.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/dcbb22de8eb3d443551baa4ec646384d/href">https://medium.com/media/dcbb22de8eb3d443551baa4ec646384d/href</a></iframe><p>No exemplo acima, foi definida uma interface para o repositório de busca, de modo que todo repositório que implementar esta interface, disponibilize uma função de busca que recebe uma String e retorne uma lista.</p><p>Dessa forma, basta que o BuscaNomeUseCase receba um repositório de busca, através da interface. Assim, ele não precisará saber qual é o repositório concreto que está sendo passado. Ex.:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/079edee36913c0b4ff670acc38070c5f/href">https://medium.com/media/079edee36913c0b4ff670acc38070c5f/href</a></iframe><p>Assim, a classe BuscaNomeUseCase não precisa conhecer o repositório concreto e, muito menos, construí-lo.</p><p>Essa abordagem faz com que seja possível implementar testes unitários com mocks, bastando passar o mock do repositório no construtor do use case.</p><p>Mas ainda há um problema: Imagine que a classe que vai instanciar o BuscaNomeUseCase precisará agora passar também o repositório no construtor. Bem, não é interessante que uma classe que utilize um use case (comumente uma View) saiba, também, criar um use case e um repositório. Injetar as dependências manualmente pelo construtor somente transfere a responsabilidade para a camada acima, fazendo com que a última camada precise instanciar uma classe com uma grande quantidade de parâmetros.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f5966e680ce9916de54d441bfc787600/href">https://medium.com/media/f5966e680ce9916de54d441bfc787600/href</a></iframe><p>Para resolver esse problema, utiliza-se um <em>Injection Container,</em> que é responsável por instanciar as classes e todas as suas dependências.</p><p>Para implementar um <em>Injection Container</em> no Flutter, utilizam-se service locators (localizadores de serviço), como <a href="https://pub.dev/packages/get_it">get_it</a> e <a href="https://pub.dev/packages/kiwi">kiwi</a>. Porém, é necessário registrar as dependências de forma manual. Para registrar as dependências de forma automática, utilizam-se geradores de código para cada package. Para o get_it temos o <a href="https://pub.dev/packages/injectable">injectable</a> e para o kiwi temos o <a href="https://pub.dev/packages/kiwi_generator">kiwi_generator</a>. Ambos permitem usar anotações nas classes para indicar que ela deve ser registrada como uma dependência. Neste artigo, tratarei apenas do get_it, mas a implementação com o kiwi é muito semelhante.</p><h4><strong>Utilizando o get_it para realizar a injeção de dependências</strong></h4><p>Após adicionar o get_it às dependências do seu projeto, é hora de criar o seu <em>injection container</em> e registrar as dependências.</p><p>O get_it fornece um Singleton através de GetIt.instance (ou, de uma forma mais minimalista, GetIt.I). Para registrar os serviços, basta chamar as funções de acordo com a maneira desejada de registro, sendo possível registrar de três maneiras diferentes:</p><ul><li><strong>Factory</strong>: Nessa maneira, você deve passar uma função factory que retornará sempre uma nova instância da dependência. Ex:</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f652ae06adf01909b1961971e58d63ca/href">https://medium.com/media/f652ae06adf01909b1961971e58d63ca/href</a></iframe><ul><li><strong>Singleton</strong>: Nessa maneira, você deve passar uma instância ou classe derivada de uma dependência. Nessa modalidade, sempre será retornada a mesma instância. Como as instâncias do Singleton precisam ser feitas no momento em que são registradas, isso pode acabar consumindo tempo. Ex:</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4c17010740552c7d27270fc619bc774e/href">https://medium.com/media/4c17010740552c7d27270fc619bc774e/href</a></iframe><ul><li><strong>Lazy Singleton</strong>: Nessa maneira, você deve passar uma função factory que retorna uma instância de uma implementação da dependência, de modo semelhante ao Factory. A diferença é que apenas na primeira vez que essa dependência for chamada, ela criará uma instância, nas próximas vezes será retornada a mesma instância já criada, de forma semelhante ao Singleton. Esta opção é preferida sobre o Singleton, pois a nova instância só será criada na primeira vez que for chamada, evitando consumir muito tempo durante o início do app. Ex:</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d174fdb911c2fc93d034f53aa8f3dfe2/href">https://medium.com/media/d174fdb911c2fc93d034f53aa8f3dfe2/href</a></iframe><p>É possível ainda, passar parâmetros para as funções de registro de factories utilizando a função registerFactoryParam, onde podem ser passados dois parâmetros. Com exceção dos parâmetros, esta função funciona igual à registerFactory.</p><p>Para todas as funções de registro de dependências citadas acima, existe uma equivalente assíncrona, que pode ser usada quando a inicialização da dependência é assíncrona (no caso dos Singleton e Lazy Singleton) ou, se, no caso da Factory, ela precisar chamar uma função assíncrona. São elas registerFactoryAsync, registerFactoryParamAsync, registerLazySingletonAsync, registerSingletonAsync. A diferença destas é que elas retornam Future&lt;T&gt; ao invés de T.</p><p>Abaixo está um exemplo utilizando as classes BuscaNomeUseCase, BuscaNomesRepository e IBuscaRepository do exemplo anterior, adicionando um componente de lógica de apresentação BuscaNomeCubit que depende de BuscaNomeUseCase.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/dd24e74f50c92066728fd5a97b772877/href">https://medium.com/media/dd24e74f50c92066728fd5a97b772877/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f2f73b4c5281e879e41673f5ca0adfe8/href">https://medium.com/media/f2f73b4c5281e879e41673f5ca0adfe8/href</a></iframe><p>Depois de criada a função registrarDependencias, basta chamá-la no início do app:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/840d9099878afcb75dd04d7466a00b20/href">https://medium.com/media/840d9099878afcb75dd04d7466a00b20/href</a></iframe><p>Para cancelar o registro de um serviço, basta chamar a função unregister, conforme o exemplo abaixo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/90278eb6bf17aeb09338f37ca44cbcee/href">https://medium.com/media/90278eb6bf17aeb09338f37ca44cbcee/href</a></iframe><p>Com o GetIt, só é possível registrar mais de uma instancia sob o mesmo tipo, se as instancias forem nomeadas, isso é feito passando o parâmetro instanceName e, dessa forma, esta instancia só pode ser acessada passando tipo e nome.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7ca23a58dcc29665d3f871b01da9cad6/href">https://medium.com/media/7ca23a58dcc29665d3f871b01da9cad6/href</a></iframe><p>Ao chamar um serviço, serão instanciadas automaticamente todas as suas dependências. Para realizar a chamada, basta utilizar o Singleton fornecido pelo GetIt, utilizando a função get() ou chamando diretamente a instância como uma função.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1c1550a2c0f040c821fa79497da94f54/href">https://medium.com/media/1c1550a2c0f040c821fa79497da94f54/href</a></iframe><p>Para cancelar o registro de instâncias nomeadas, basta passar o nome no unregister:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1be0e01872a5fad4064b27f5833d8d8c/href">https://medium.com/media/1be0e01872a5fad4064b27f5833d8d8c/href</a></iframe><h4>Automatizando o registro das dependências</h4><p>À medida que o código cresce, vão sendo criadas cada vez mais dependências e, consequentemente, o trabalho manual de registrar as dependências, aumenta. Para solucionar este problema, foi criado o injectable, que é um gerador de código para o get_it. Deixando de lado os prós e contras desta abordagem, este é um package bastante conveniente para os adeptos da geração de código. Com ele, basta anotar as classes que deverão ser registradas e tudo acontece como num passe de mágica, bastando apenas uma pequena configuração.</p><p>Para configurar o injectable, basta anotar a função que registrará as dependências como @injectableInit e chamar a função gerada $initGetIt(), passando a instância do GetIt, conforme exemplo a seguir.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f601234d50a71d2ecde3f3e0f55c0c14/href">https://medium.com/media/f601234d50a71d2ecde3f3e0f55c0c14/href</a></iframe><p>Depois disso, basta chamar a função no início do app normalmente e anotar as classes/objetos que deverão ser registrados, conforme exemplos abaixo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fc299e06eadd24a7f8949c4230aa7e84/href">https://medium.com/media/fc299e06eadd24a7f8949c4230aa7e84/href</a></iframe><p>Depois de anotadas as classes, basta rodar o comando</p><p>flutter packages pub run build_runner build</p><p>para gerar a função de registro das dependências automaticamente.</p><p>Você pode ir ainda além e eliminar a necessidade de anotações nas classes, se o seu projeto seguir rigorosamente alguma convenção de nomes (naming convention) na criação de arquivos ou classes. Nesse caso, basta criar um arquivo build.yaml na raiz do projeto (no mesmo nível do pubspec.yaml) e especificar os arquivos a serem registrados. Por exemplo, você pode avisar ao gerador para registrar automaticamente classes que terminem com DataSource, Repository, Cubit ou UseCase usando um simples padrão de expressão regular class_name_pattern: &quot;DataSource$|Repository$|Cubit$|UseCase&quot; ou, da mesma forma, registrar automaticamente pelo nome do arquivo.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d0372cec21d7721eae91f0e052f55474/href">https://medium.com/media/d0372cec21d7721eae91f0e052f55474/href</a></iframe><h4><strong>Referências</strong></h4><p>Inversion of Control Containers and the Dependency Injection pattern — <a href="https://martinfowler.com/articles/injection.html">https://martinfowler.com/articles/injection.html</a></p><p>Flutter TDD Clean Architecture Course [13] — Dependency Injection — <a href="https://resocoder.com/2019/10/21/flutter-tdd-clean-architecture-course-13-dependency-injection-user-interface/">https://resocoder.com/2019/10/21/flutter-tdd-clean-architecture-course-13-dependency-injection-user-interface/</a></p><p>Injectable — Flutter &amp; Dart Equivalent to Dagger &amp; Angular Dependency Injection — <a href="https://resocoder.com/2020/02/04/injectable-flutter-dart-equivalent-to-dagger-angular-dependency-injection/">https://resocoder.com/2020/02/04/injectable-flutter-dart-equivalent-to-dagger-angular-dependency-injection/</a></p><p>Princípio da Responsabilidade Única — <a href="https://medium.com/@angelomribeiro/princ%C3%ADpio-da-responsabilidade-%C3%BAnica-6d633087fa4e">https://medium.com/@angelomribeiro/princípio-da-responsabilidade-única-6d633087fa4e</a></p><p>Inversão de Controle: Service Locator e Injeção de Dependência — <a href="https://imasters.com.br/software/inversao-de-controle-service-locator-e-injecao-de-dependencia">https://imasters.com.br/software/inversao-de-controle-service-locator-e-injecao-de-dependencia</a></p><p>Injeção de Dependência — <a href="https://medium.com/@eduardolanfredi/inje%C3%A7%C3%A3o-de-depend%C3%AAncia-ff0372a1672">https://medium.com/@eduardolanfredi/injeção-de-dependência-ff0372a1672</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=152704d4064d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/popcodemobile/inje%C3%A7%C3%A3o-de-depend%C3%AAncias-no-flutter-152704d4064d">Injeção de dependências no Flutter</a> was originally published in <a href="https://medium.com/popcodemobile">Popcodemobile</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>