<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Alcides Junior on Medium]]></title>
        <description><![CDATA[Stories by Alcides Junior on Medium]]></description>
        <link>https://medium.com/@alcidesjuniorbr?source=rss-ed26dc376903------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*h7v75br82u5o68J4fJr6Sg.jpeg</url>
            <title>Stories by Alcides Junior on Medium</title>
            <link>https://medium.com/@alcidesjuniorbr?source=rss-ed26dc376903------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 02:03:33 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@alcidesjuniorbr/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Por que é importante você como engenheiro escrever um ADR?]]></title>
            <link>https://alcidesjuniorbr.medium.com/por-que-%C3%A9-importante-voc%C3%AA-como-engenheiro-escrever-um-adr-d0e502febd74?source=rss-ed26dc376903------2</link>
            <guid isPermaLink="false">https://medium.com/p/d0e502febd74</guid>
            <category><![CDATA[adr]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[ios-software-engineer]]></category>
            <dc:creator><![CDATA[Alcides Junior]]></dc:creator>
            <pubDate>Wed, 01 Jul 2026 14:24:35 GMT</pubDate>
            <atom:updated>2026-07-01T14:24:42.510Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*hBcPrLvygJSSytu5" /><figcaption>Photo by <a href="https://unsplash.com/@lureofadventure?utm_source=medium&amp;utm_medium=referral">Ali Kazal</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Recentemente precisei implementar uma mudança relativamente pequena em um projeto.</p><p>Do ponto de vista da implementação, não havia nada muito complexo. A solução era direta e boa parte da infraestrutura necessária já existia. Era o tipo de tarefa que, depois do Pull Request aprovado, provavelmente seria esquecida em poucos dias.</p><p>Só que essa mudança tinha uma característica diferente.</p><p>Ela envolvia mais de um time.</p><p>Enquanto implementava, comecei a pensar em uma situação que já vivi várias vezes ao longo da carreira. Alguém, alguns meses depois, abriria aquele código e inevitavelmente faria a mesma pergunta:</p><blockquote><em>“Por que isso foi feito assim?”</em></blockquote><p>Foi aí que decidi escrever um ADR.</p><p>Para quem nunca ouviu falar nesse termo, ADR significa <em>Architecture Decision Record</em>. É um documento simples que registra uma decisão arquitetural: qual problema precisava ser resolvido, quais alternativas foram consideradas, por que uma delas foi escolhida e quais impactos essa decisão traz para o sistema.</p><p>Quando comecei a ler sobre ADRs, achei que eles fossem úteis apenas para grandes mudanças de arquitetura.</p><p>Depois de escrever o meu primeiro, percebi que não é bem assim. O valor não estava na complexidade da implementação. Estava na quantidade de contexto que poderia ser perdida com o tempo.</p><p>Uma coisa que sempre me chamou atenção é que raramente temos dificuldade para entender o que um código faz.</p><p>Abrimos uma classe, seguimos o fluxo e, com um pouco de tempo, entendemos seu comportamento.</p><p>O que costuma ser difícil é entender por que aquele comportamento existe. Por que existe uma validação aparentemente desnecessária? Por que determinado fluxo depende de uma configuração específica?</p><p>Por que uma abordagem mais simples não foi utilizada?</p><p>Essas respostas quase nunca aparecem no código.</p><p>Elas também dificilmente aparecem em um commit ou em um Pull Request. Afinal, essas discussões normalmente acontecem durante refinamentos, conversas entre engenheiros, alinhamentos com outros times ou até em chamadas que ninguém vai lembrar alguns meses depois.</p><p>Foi justamente isso que me motivou a escrever o ADR.</p><p>Eu não queria documentar a implementação.</p><p>Queria documentar o raciocínio.</p><p>Queria que, daqui a alguns meses, alguém conseguisse entender o contexto da decisão sem precisar procurar quem participou daquela entrega.</p><p>Enquanto escrevia, percebi outra coisa interessante.</p><p>Documentar uma decisão também ajuda quem está escrevendo.</p><p>Quando você precisa explicar por que escolheu um caminho e descartou outros, acaba revisitando sua própria linha de raciocínio. Em alguns momentos, isso até faz aparecer perguntas que ainda não tinham sido feitas.</p><p>É um exercício que melhora a qualidade da decisão, não apenas da documentação.</p><p>Outro ponto que achei importante é que mudanças envolvendo mais de um time costumam carregar muito contexto distribuído.</p><p>Cada equipe conhece bem a sua parte do fluxo.</p><p>Mas ninguém conhece tudo.</p><p>Sem um registro, esse conhecimento fica espalhado entre pessoas, mensagens e reuniões. Conforme o tempo passa, reconstruir toda essa história fica cada vez mais difícil.</p><p>Percebi que um ADR funciona como um ponto de encontro dessas informações.</p><p>Ele não substitui a documentação técnica.</p><p>Não substitui o código.</p><p>E muito menos substitui boas conversas entre os times.</p><p>Mas ajuda a preservar algo que normalmente desaparece muito rápido: a motivação por trás da decisão.</p><p>Esse foi meu primeiro ADR.</p><p>Com certeza não será o último.</p><p>Nem toda mudança precisa de um.</p><p>Mas, sempre que uma decisão arquitetural atravessar domínios, envolver diferentes equipes ou tiver potencial para gerar dúvidas no futuro, provavelmente vou reservar alguns minutos para registrá-la.</p><p>Tenho a impressão de que esse tempo será recuperado muitas vezes nos próximos meses.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d0e502febd74" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Backoff em aplicações mobile]]></title>
            <link>https://alcidesjuniorbr.medium.com/backoff-em-aplica%C3%A7%C3%B5es-mobile-175000bafe0b?source=rss-ed26dc376903------2</link>
            <guid isPermaLink="false">https://medium.com/p/175000bafe0b</guid>
            <category><![CDATA[retry-pattern]]></category>
            <category><![CDATA[back-off]]></category>
            <category><![CDATA[resilience]]></category>
            <dc:creator><![CDATA[Alcides Junior]]></dc:creator>
            <pubDate>Wed, 08 Apr 2026 15:33:52 GMT</pubDate>
            <atom:updated>2026-04-08T15:33:52.821Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Qnymn29VPHrx7Vzj" /><figcaption>Photo by <a href="https://unsplash.com/@kuyuneth2543?utm_source=medium&amp;utm_medium=referral">Kuyune</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Imagine que você tem seu app rodando que depende de um serviço de backend. Por algum motivo, o usuário começa a tomar toco e recebe falhas.<br>A primeira coisa que você deve pensar é: bom, já que tem essa possibilidade de, em determinados endpoints, receber erro, vamos implementar o retry e assim, permitir que nossos usuários tentem novamente utilizar o serviço. <br>Em partes, você está certo e até seguindo bons padrões de UX, uma vez que você trata o erro e permite seu usuário se recuperar do erro e tentar novamente, porém, tem mais uma camada do problema: ao permitir que, incansavelmente, seu usuário tente de novo e de novo e de novo, cada falha gera uma retentativa que acaba sobrecarregando os serviços de backend e agora, você está delegando mais um problema para o backend:<br>antes, o sistema que já estava instável, agora está lidando com sobrecarga e o retry que deveria ajudar, acaba se tornando um pesadelo.</p><p>O retry em si não é o problema e existe uma estratégia para resolver esse problema sem piorar a situação e é aí que entra o tal do retry com backoff.</p><h3>O que é backoff?</h3><p>Backoff é uma estratégia de retry onde o tempo de espera entre tentativas aumenta progressivamente que pode ser implementada no mobile-side. Ao invés de tentar novamente após uma falha, o sistema aguarda um período antes de realizar uma nova tentativa.</p><p>Esse tempo de espera pode seguir 3 estratégias:</p><ul><li>crescimento linear</li><li>crescimento exponencial</li><li>crescimento exponencial com jitter</li></ul><p><strong>Mas… por qual motivo backoff é importante?</strong><br>Sem uma estratégia de backoff, retries podem causar mais problemas do que resolver.</p><h4>Evitar sobrecarga no servidor</h4><p>Quando múltiplos clientes falham ao mesmo tempo e tentam novamente imediatamente, ocorre o efeito conhecido como thundering herd<strong>*</strong>. Isso pode derrubar ainda mais o sistema.</p><blockquote><strong>*</strong>refere-se principalmente a um problema de desempenho em computação, onde um grande número de processos desperta simultaneamente para acessar um recurso, sobrecarregando o sistema.</blockquote><h4>Respeitar limites de API</h4><p>Muitas APIs impõem limites de requisição. Retry agressivo pode resultar em bloqueios temporários, aumento do tempo de indisponibilidade e degradação da experiência do usuário.</p><p>O uso de backoff torna o sistema mais tolerante a falhas transitórias, como:</p><ul><li>perda momentânea de conexão</li><li>picos de latência</li><li>instabilidade temporária do backend</li></ul><h4>Tipos de backoff</h4><p><strong>Backoff linear<br></strong>O tempo de espera cresce de forma constante.<br>Exemplo:<br> 1s, 2s, 3s, 4s etc…</p><p>Quando usar:</p><ul><li>cenários simples</li><li>baixo volume de usuários</li><li>quando previsibilidade é importante</li></ul><p>Limitação:<br>Não escala bem sob alta concorrência.</p><p><strong>Backoff exponencial<br></strong>O tempo de espera dobra a cada tentativa.<br>Exemplo:<br> 1s, 2s, 4s, 8s, 16s</p><p>Quando usar:</p><ul><li>APIs sensíveis</li><li>sistemas distribuídos</li><li>cenários com alta concorrência</li></ul><p><strong>Backoff exponencial com jitter<br></strong>Adiciona um fator aleatório ao tempo de espera.<br>Exemplo:<br> 1.3s, 2.1s, 3.8s<br>Por que isso importa:<br>Evita que milhares de clientes façam retry ao mesmo tempo. Essa é a abordagem mais usada em produção e que gosto de considerar para sistemas robustos.</p><p>Lembrando: Backoff é estratégia de resiliência, o que não significa que TODO RETRY deva ter essa estratégia, devemos usar apenas para cenários considerados necessários como por exemplo:</p><ul><li>reconexão de serviços em tempo real(websocket, chats, streaming)</li><li>requisições de rede(fetch de dados, sincronização)</li><li>uploads e downloads</li><li>procesos críticos com tolerância a falha(envio de eventos, analytics e logs)</li></ul><p>Não usar em casos de erros como 400, 401, 403. Esses erros não devem nem ser tratados como retry.</p><p>Um fator importante é que todo retry deve ter um limite, sem essa regra, você acaba criando um problema maior deixando em aberto, então, sempre se atente de definir um limite máximo de retentativas(maxRetry).</p><p><strong>Dica final<br></strong>Backoff não é apenas uma técnica de retry. É uma estratégia fundamental para construir aplicações resilientes, escaláveis e preparadas para falhas reais. Em ambientes mobile, onde a instabilidade de rede é comum, aplicar backoff corretamente pode ser a diferença entre uma experiência confiável e um sistema que falha sob pressão.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=175000bafe0b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SRP não é preciosismo]]></title>
            <link>https://alcidesjuniorbr.medium.com/srp-n%C3%A3o-%C3%A9-preciosismo-12730608f8a7?source=rss-ed26dc376903------2</link>
            <guid isPermaLink="false">https://medium.com/p/12730608f8a7</guid>
            <dc:creator><![CDATA[Alcides Junior]]></dc:creator>
            <pubDate>Mon, 02 Feb 2026 03:01:06 GMT</pubDate>
            <atom:updated>2026-02-02T09:59:36.804Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DQVovkVAaADxO0BXyYn2IQ@2x.jpeg" /><figcaption>Photo by Nik on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>SRP (Single Responsibility Principle) é um daqueles conceitos que muita gente conhece de nome, mas pouca gente aplica com intenção.</p><p>E isso acontece porque SRP costuma ser tratado como:</p><p>• um detalhe de arquitetura<br>• uma discussão estética<br>• mais um tópico de SOLID</p><p>Só que SRP não tem nada a ver com deixar o código bonito. SRP tem a ver com algo bem mais caro e bem mais real que é não deixar o sistema virar um lugar perigoso de mudar!!!</p><h4>O que SRP realmente significa</h4><p>Você provavelmente já ouviu:</p><p>“Uma classe deve ter apenas uma responsabilidade.”</p><p>Mas essa frase sozinha é muito vaga e abre muita margem para dois extremos bem perigosos:</p><p>1. separar demais e criar burocracia<br>2. ignorar o problema até o projeto ficar pesado</p><p>Gosto de pensar que a definição que realmente guia decisões boas é que um módulo deve ter apenas um motivo para mudar. Ou seja: quando algo muda no produto, o impacto no código deveria ser localizado. E o SRP existe pra aumentar a chance disso acontecer.</p><h4>Por que SRP importa tanto…</h4><p>Quase ninguém acorda pensando “vou quebrar SRP hoje”. 🤡</p><p>A quebra acontece “sem querer”:</p><p>• só vou colocar esse mapeamento aqui rapidinho<br>• só vou tratar esse erro aqui<br>• já que tá aqui, eu formato a moeda também<br>• vou disparar tracking aqui mesmo<br>• depois eu arrumo, so criar um débito técnico rsrsrs</p><p>E quando você percebe, uma classe que deveria ser simples virou um concentrado de responsabilidades. Esse tipo de código funciona.<br>O problema é o custo de mudança que ele cria…</p><h4>A falta de SRP não deixa o código feio, deixa o projeto caro</h4><p>O preço aparece assim:<br>• refatoração vira risco<br>• bugs reaparecem em fluxos que “não tinham nada a ver”<br>• testes começam a exigir mocks infinitos<br>• mudanças pequenas geram regressão<br>• o time começa a evitar mexer em partes críticas<br>• o sistema fica lento de evoluir, mesmo com todo mundo “produzindo muito”</p><p>É aí que SRP deixa de ser um conceito e vira sobrevivência.</p><h4>Exemplo em Swift: uma tela de transações sem SRP</h4><p>Trouxe um exemplo de um app meu e é um exemplo bem comum em apps: carregar transações e decidir como renderizar.</p><pre>final class TransactionsViewModel {<br><br>    private let service: TransactionsServiceProtocol<br>    private let analytics: AnalyticsTracking<br>    private let coordinator: FinanceCoordinating<br><br>    init(<br>        service: TransactionsServiceProtocol,<br>        analytics: AnalyticsTracking,<br>        coordinator: FinanceCoordinating<br>    ) {<br>        self.service = service<br>        self.analytics = analytics<br>        self.coordinator = coordinator<br>    }<br><br>    func loadTransactions() async {<br>        analytics.track(event: &quot;transactions_load_started&quot;)<br><br>        do {<br>            let response = try await service.fetchTransactions()<br><br>            let transactions: [Transaction] = response.items.map { item in<br>                Transaction(<br>                    id: item.id,<br>                    title: item.merchantName ?? &quot;Compra&quot;,<br>                    amountText: Self.formatCurrency(item.amountInCents),<br>                    dateText: Self.formatDate(item.date),<br>                    category: item.category ?? &quot;Outros&quot;<br>                )<br>            }<br><br>            if transactions.isEmpty {<br>                coordinator.showEmptyState()<br>            } else {<br>                coordinator.showTransactionsList(transactions)<br>            }<br><br>            analytics.track(event: &quot;transactions_load_success&quot;, params: [<br>                &quot;count&quot;: transactions.count<br>            ])<br><br>        } catch {<br>            analytics.track(event: &quot;transactions_load_failure&quot;)<br><br>            if (error as NSError).code == 401 {<br>                coordinator.showSessionExpired()<br>            } else {<br>                coordinator.showGenericError()<br>            }<br>        }<br>    }<br><br>    private static func formatCurrency(_ cents: Int) -&gt; String {<br>        let value = Double(cents) / 100<br>        return value.formatted(.currency(code: &quot;BRL&quot;))<br>    }<br><br>    private static func formatDate(_ date: Date?) -&gt; String {<br>        guard let date else { return &quot;&quot; }<br>        return date.formatted(date: .numeric, time: .omitted)<br>    }<br>}</pre><p>O código funciona, mas a classe tem muitos motivos para mudar:<br>• contrato do backend mudou<br>• modelo interno mudou<br>• UI mudou<br>• regra de empty state mudou<br>• navegação mudou<br>• regra de erro mudou<br>• tracking mudou<br>• formatação mudou</p><p>Isso é exatamente o tipo de classe que vira:<br>“não mexe nisso que pode quebrar”<br>E quando um sistema chega nesse ponto, ele para de evoluir com segurança.</p><h4>SRP bem aplicado não gera burocracia, ele separa decisões</h4><p>SRP não significa criar mil arquivos.</p><p>Ele significa separar decisões.</p><p>Neste exemplo existem decisões diferentes misturadas:<br>1. buscar dados<br>2. transformar DTO em algo pronto pra UI<br>3. decidir navegação<br>4. tracking<br>A refatoração abaixo separa isso em responsabilidades claras.</p><h4>Refatorando com SRP</h4><p>UseCase: busca transações.<br>O UseCase fica responsável apenas por orquestrar a busca de dados.</p><pre>protocol FetchTransactionsUseCaseProtocol {<br>    func execute() async throws -&gt; [TransactionDTO]<br>}<br><br>final class FetchTransactionsUseCase: FetchTransactionsUseCaseProtocol {<br><br>    private let service: TransactionsServiceProtocol<br><br>    init(service: TransactionsServiceProtocol) {<br>        self.service = service<br>    }<br><br>    func execute() async throws -&gt; [TransactionDTO] {<br>        let response = try await service.fetchTransactions()<br>        return response.items<br>    }<br>}</pre><h4>Tracking como responsabilidade separada: Decorator</h4><p>Uma armadilha comum é colocar analytics/tracking diretamente na ViewModel.</p><p>Isso “funciona”, mas mistura responsabilidades.</p><p>Uma solução elegante é tratar tracking como um detalhe transversal (cross-cutting concern), e aplicá-lo como um Decorator em cima do UseCase.</p><p>Assim:<br>• o UseCase “real” não sabe nada de analytics<br>• o tracking não polui a ViewModel<br>• os motivos de mudança ficam separados</p><pre>final class FetchTransactionsUseCaseAnalyticsDecorator: FetchTransactionsUseCaseProtocol {<br><br>    private let decoratee: FetchTransactionsUseCaseProtocol<br>    private let analytics: AnalyticsTracking<br><br>    init(<br>        decoratee: FetchTransactionsUseCaseProtocol,<br>        analytics: AnalyticsTracking<br>    ) {<br>        self.decoratee = decoratee<br>        self.analytics = analytics<br>    }<br><br>    func execute() async throws -&gt; [TransactionDTO] {<br>        analytics.track(event: &quot;transactions_load_started&quot;)<br><br>        do {<br>            let result = try await decoratee.execute()<br>            analytics.track(event: &quot;transactions_load_success&quot;, params: [<br>                &quot;count&quot;: result.count<br>            ])<br>            return result<br>        } catch {<br>            analytics.track(event: &quot;transactions_load_failure&quot;)<br>            throw error<br>        }<br>    }<br>}</pre><h4>DTO para algo pronto pra UI</h4><p>Em Swift, uma forma idiomática de aplicar SRP aqui é fazer com que o modelo de apresentação saiba se construir a partir do DTO.</p><pre>struct TransactionViewData {<br><br>    let id: String<br>    let title: String<br>    let amountText: String<br>    let dateText: String<br>    let category: String<br><br>    init(dto: TransactionDTO) {<br>        self.id = dto.id<br>        self.title = dto.merchantName ?? &quot;Compra&quot;<br>        self.amountText = Self.formatCurrency(dto.amountInCents)<br>        self.dateText = Self.formatDate(dto.date)<br>        self.category = dto.category ?? &quot;Outros&quot;<br>    }<br><br>    private static func formatCurrency(_ cents: Int) -&gt; String {<br>        let value = Double(cents) / 100<br>        return value.formatted(.currency(code: &quot;BRL&quot;))<br>    }<br><br>    private static func formatDate(_ date: Date?) -&gt; String {<br>        guard let date else { return &quot;&quot; }<br>        return date.formatted(date: .numeric, time: .omitted)<br>    }<br>}</pre><h4>ViewModel orquestra sem virar “classe Deus”</h4><p>Agora o ViewModel tem uma responsabilidade mais limpa:</p><p>• solicitar os dados<br>• transformar em ViewData<br>• coordenar efeitos (empty state / navegação)</p><pre>final class TransactionsViewModel {<br><br>    private let fetchTransactions: FetchTransactionsUseCaseProtocol<br>    private let coordinator: FinanceCoordinating<br><br>    init(<br>        fetchTransactions: FetchTransactionsUseCaseProtocol,<br>        coordinator: FinanceCoordinating<br>    ) {<br>        self.fetchTransactions = fetchTransactions<br>        self.coordinator = coordinator<br>    }<br><br>    func loadTransactions() async {<br>        do {<br>            let dtos = try await fetchTransactions.execute()<br>            let transactions = dtos.map(TransactionViewData.init)<br><br>            if transactions.isEmpty {<br>                coordinator.showEmptyState()<br>            } else {<br>                coordinator.showTransactionsList(transactions)<br>            }<br>        } catch {<br>            coordinator.showGenericError()<br>        }<br>    }<br>}</pre><p>Agora as mudanças têm impacto localizado:</p><p>• mudou API: mexe no UseCase<br>• mudou tracking: mexe no Decorator<br>• mudou formatação/regras de exibição: mexe no TransactionViewData<br>• mudou UI/navegação: mexe no ViewModel/Coordinator</p><p>Consegue sentir a diferença e importância desse princípio?</p><h4>Como enxergar que meu código quebra o SRP?</h4><p>Quando estou analisando uma classe, geralmente eu faço as seguintes perguntas:</p><p>• Se eu mudar UI, isso muda aqui?<br>• Se eu mudar backend, isso muda aqui?<br>• Se eu mudar regra de negócio, isso muda aqui?<br>• Se eu mudar tracking/analytics, isso muda aqui?<br>• Se eu mudar formatação de dados, isso muda aqui?</p><p>Se a resposta for sim pra várias, SRP já foi quebrado. 😑<br>E um sintoma clássico:<br>Você abre a classe e sente que “qualquer mudança vai dar ruim”.</p><p>SRP existe para remover esse medo.</p><p>Ou seja: o SRP não é sobre preciosismo ou sobre quebrar uma classe em mil arquivos, mas sim sobre, de forma consciente, separar as responsabilidades. O impacto disso é colossal no dia-a-dia.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=12730608f8a7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A tal da zona de conforto]]></title>
            <link>https://alcidesjuniorbr.medium.com/a-tal-da-zona-de-conforto-c093ff6a78d8?source=rss-ed26dc376903------2</link>
            <guid isPermaLink="false">https://medium.com/p/c093ff6a78d8</guid>
            <category><![CDATA[zona-de-conforto]]></category>
            <category><![CDATA[crescimento]]></category>
            <category><![CDATA[carreira]]></category>
            <dc:creator><![CDATA[Alcides Junior]]></dc:creator>
            <pubDate>Mon, 05 Jan 2026 20:49:43 GMT</pubDate>
            <atom:updated>2026-01-05T20:49:43.875Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*98BSR2Lhy8cCcAVK" /><figcaption>A tal da zona de conforto</figcaption></figure><p>Falar sobre zona de conforto na área de tecnologia costuma gerar estranhamento. Afinal, estamos em um mercado que muda o tempo todo, exige estudo constante e nunca para. Mesmo assim, a zona de conforto existe. E, muitas vezes, ela se disfarça de produtividade.</p><p>Neste texto, quero falar justamente sobre esse ponto. Não sobre acomodação óbvia, mas sobre aquele momento em que você entrega bem, resolve tudo que aparece e, ainda assim, começa a estagnar sem perceber.</p><p>Antes de tudo, deixa eu me apresentar.</p><p>Meu nome é Alcides Junior. Sou engenheiro de software iOS há mais de cinco anos, com experiência em aplicações de larga escala que impactam milhões de usuários diariamente. Sou técnico em informática com foco em desenvolvimento de software e bacharel em Engenharia de Computação pelo IFCE. Ao longo da minha trajetória, aprendi que nem todo crescimento é visível, e que executar bem nem sempre significa evoluir.</p><h3>O que é a zona de conforto, afinal?</h3><p>Na tecnologia, a zona de conforto raramente está ligada à simplicidade. Ela está ligada à previsibilidade.</p><p>Ela aparece quando você passa a trabalhar quase sempre em tarefas que domina completamente. Não são tarefas fáceis, mas são conhecidas. Você sabe exatamente como começar, como executar e como entregar. O risco é baixo, o resultado é previsível e o esforço mental diminui.</p><p>O problema é que, quando isso se torna regra, você entra no modo executor. Você entrega, resolve, ajuda o time, mas deixa de ser visto como alguém que influencia decisões, propõe caminhos ou assume problemas novos. Aos poucos, sua atuação perde visibilidade e sua carreira começa a andar de lado.</p><h3>Como perceber que você entrou nesse modo?</h3><p>Identificar a zona de conforto exige honestidade consigo mesmo. Um sinal comum é quando alguém te delega tarefas para você com total certeza do resultado, sem espaço para dúvida ou aprendizado novo.</p><p>No contexto iOS, isso pode significar implementar telas semelhantes às que você já construiu dezenas de vezes, cuidar sempre das mesmas camadas da aplicação ou resolver problemas técnicos previsíveis. São entregas importantes, mas que não te colocam em situações novas.</p><p>Quando a maior parte do seu tempo é consumida por esse tipo de atividade, existe uma grande chance de você estar confortável demais, mesmo sem perceber.</p><p>Vale ressaltar que isso não é ruim, pensa que terrível seria se você não conseguisse entregar coisas com qualidade, porém, sempre há espaço para melhorar e é isso que estamos abordando aqui.</p><h3>Por que buscar novos desafios é tão importante?</h3><p>Assumir algo novo quase sempre gera insegurança. Sair do modo executor exige lidar com incerteza, risco e, muitas vezes, com a possibilidade de errar. Isso é desconfortável. E é exatamente por isso que funciona.</p><p>Quando você passa a assumir problemas ainda não mapeados, liderar decisões ou estruturar soluções do zero, algumas coisas mudam rapidamente. Você ganha visibilidade, porque passa a ser lembrado como alguém que resolve problemas difíceis. Você aprende mais, porque desafios reais aceleram o aprendizado. E você constrói experiência concreta, criando um legado que vai além da tarefa entregue.</p><p>Esse tipo de postura muda a forma como você é visto dentro da empresa.</p><h3>Crescimento não vem só da execução</h3><p>No mundo corporativo, executar bem é o mínimo esperado. O diferencial está em ir além disso. Permanecer apenas no modo executor pode ser confortável no curto prazo, mas se torna arriscado ao longo do tempo, especialmente quando se busca crescimento, reconhecimento ou posições de maior responsabilidade.</p><p>O equilíbrio é o caminho mais saudável. Saber executar com excelência, mas também saber quando se expor a desafios novos, mesmo que eles causem desconforto. É nesse espaço que acontece o verdadeiro amadurecimento profissional.</p><p>Carreira não é sobre evitar riscos o tempo todo. É sobre escolher, conscientemente, quais riscos valem a pena assumir.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c093ff6a78d8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Errar faz parte da carreira: aprenda primeiro a domar seus medos]]></title>
            <link>https://alcidesjuniorbr.medium.com/errar-faz-parte-de-virar-s%C3%AAnior-aprenda-primeiro-a-domar-seus-medos-fd3f207e79eb?source=rss-ed26dc376903------2</link>
            <guid isPermaLink="false">https://medium.com/p/fd3f207e79eb</guid>
            <category><![CDATA[carreira]]></category>
            <category><![CDATA[careers]]></category>
            <category><![CDATA[career-advice]]></category>
            <category><![CDATA[desenvolvimento-pessoal]]></category>
            <category><![CDATA[junior-developer]]></category>
            <dc:creator><![CDATA[Alcides Junior]]></dc:creator>
            <pubDate>Mon, 15 Dec 2025 21:42:13 GMT</pubDate>
            <atom:updated>2025-12-15T21:44:45.831Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*234uJZYmuMVzFE0x" /><figcaption>Photo by <a href="https://unsplash.com/@element5digital?utm_source=medium&amp;utm_medium=referral">Element5 Digital</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Quando estamos no início da carreira, existe uma pressão silenciosa(e perigosa) em querer acertar sempre.</p><p>Escolher a melhor arquitetura, código mais limpo, zero comentários em Pull Requests, cometer erros então? nem pensar…</p><p>É, eu já estive exatamente nessa situação aí… e preciso te contar uma coisa: ninguém vira sênior sem errar bastante no caminho. Mas atente-se: não é apenas errar, é aprender com o erro, esse efeito rebote é muito importante ter.</p><p>No começo, é bem comum você achar que é errar é um sinal de falta da capacidade e começa a nascer o que chamamos de síndrome do impostor, mas a questão é que você nem sempre está conseguindo enxergar uma oportunidade de evoluir.</p><h4>A faculdade e eu</h4><p>Bem, eu sou formado em engenharia de computação pelo Instituto Federal de Educação, Ciência e Tecnologia do Ceará &lt;<a href="https://portal.ifce.edu.br/campus/fortaleza/">IFCE</a>&gt;.<br>Na cadeira de computação gráfica, eu me dei bastante mal. Reprovei duas vezes e eu me martirizei bastante a primeira vez, vi todos os meus colegas irem bem, tirarem boas notas e eu me dando super mal.</p><p>Quando reprovei a segunda vez, eu fiz um exercício de entender o que eu não estava entendendo, o que estava me fazendo ir tão mal nessa disciplina e esse exercício me gerou uma lista de coisas. Quando foquei nessa lista, fiz a disciplina novamente e bingo! consegui finalmente passar, mas não só passar, aprender a aprender.</p><p>Trazendo essa experiência para o mercado de trabalho, não é diferente: os erros por si só vão sim te atrapalhar, mas quando você usa como uma ferramenta, o céu é o limite e é aí que você precisa começar a exercitar e não a temer os erros.</p><h4>A decisão perfeita…</h4><p>Como um desenvolvedor Junior, você ainda está formando repertório, você ainda não sabe de tudo e tá tudo bem! as vezes, nem o sênior do seu time tem todas as respostas, isso é super normal!</p><p>O que você precisa entender aqui é:</p><ul><li>Entender o contexto</li><li>Perguntar quando não souber, não existe pergunta boba, existe bobo que não pergunta!</li><li>Tentar tomar pequenas decisões</li><li>Aprender com o resultado</li></ul><p>Existe um mito de que bons desenvolvedores não erram 🙄 mentira, somos humanos! até mesmo quem usa IA erra(alguns erram feio, mas não vamos focar nisso). <br>Bons desenvolvedores erram, mas eles aprendem rápido com seus erros.<br>Se você nunca erra, provavelmente está sempre jogando no seguro e sinto te dizer mas isso limita muito seu crescimento.</p><h4>O que um sênior espera em um Junior e ama ver…</h4><p>Aqui vai uma dica valiosíssima, pega papel e caneta pra anotar:</p><p>Um sênior não espera que um Junior saiba tudo, nem ele mesmo sabe, mas existe algo muito importante em você, que está no começo da sua carreira e um sênior ou empresa vai amar ver em você:</p><ul><li>Ser curioso</li><li>Ter responsabilidade</li><li>Não esconder erros</li><li>Ser humilde e ter disposição para aprender</li></ul><p>Ninguém espera 100% de perfeição em uma pessoa Junior, esperam evolução, sede de aprender, coragem para errar e aprender com os seus erros.</p><p>Mesmo com decisões &quot;ruins&quot;, você ainda pode achar valor, porque isso te ensina o por que algo não funcionou, o que faria diferente na próxima vez e como pensar melhor no futuro.</p><p>Com o tempo, essas pequenas decisões vão formando uma base sólida que na frente, irá permitir decisões maiores e mais rápidas e é assim que senioridade se constrói.</p><h4>Vencer a tentação</h4><p>Perguntar não arranca pedaço, porém, você precisa ponderar e saber a hora certa de perguntar. Quando eu era Junior, eu cometi diversas vezes o erro de sempre que travar, correr para uma pessoa mais senior e tentar obter a resposta para me destravar. Como um todo, isso não é ruim, porém é importante tentar antes de perguntar e outra coisa: é muito importante saber perguntar.</p><p>Existe uma diferença enorme e é aí onde todo Junior erra, eu errei demais mas você não irá cometer mais esse erro porque está lendo meu artigo. <br>Quando você for perguntar algo para alguém não chegue e fale: <strong>&quot;não estou conseguindo fazer tal coisa&quot;</strong>. Isso não vai te ajudar em nada. A forma correta e inclusive vai te ensinar muito e as vezes, até na hora que for perguntar você mesmo terá a resposta que é o seguinte: <strong>&quot;Fulano, eu estou travado em tal coisa, eu fui pela abordagem de tentar fazer de tal forma, até funcionou em partes mas para tal cenário não está funcionando, consegue me ajudar?&quot;</strong></p><p>Consegue perceber a diferença?</p><p>Em um, você apenas reporta o problema. Isso é ruim porque, se você já tiver tentado outras soluções, mas não tiver comentado, vai fazer a pessoa na qual está pedindo ajuda perder tempo ou gastando tempo para entender o problema.<br>No segundo, você apresenta quais caminhos tentou, mas falhou e precisa de ajuda naquele ponto.</p><p>Tente exercitar a clareza, algo que pode muito te ajudar é <a href="https://www.youtube.com/watch?v=mf-wghj-VXM&amp;t=110s">Depuração com Pato de Borracha</a>.</p><h4>Conselho final</h4><p>Se eu pudesse voltar no tempo e falar algo para o meu &quot;eu&quot; Junior, seria: não tenha medo de perguntar muito menos de errar, tenha medo de ficar parado! Estude, teste, pergunte, falhe, tente de novo.</p><p>Obrigado pela leitura e caso tenha te ajudado, me ajuda compartilhando esse artigo com teus amigos e no teu <a href="https://www.linkedin.com/">linkedin</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fd3f207e79eb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Café com a concorrência: Actor e isolamento de estado]]></title>
            <link>https://alcidesjuniorbr.medium.com/caf%C3%A9-com-a-concorr%C3%AAncia-actor-e-isolamento-de-estado-dc2bff7ffff8?source=rss-ed26dc376903------2</link>
            <guid isPermaLink="false">https://medium.com/p/dc2bff7ffff8</guid>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[swift-concurrency]]></category>
            <category><![CDATA[actors]]></category>
            <dc:creator><![CDATA[Alcides Junior]]></dc:creator>
            <pubDate>Thu, 20 Nov 2025 15:27:00 GMT</pubDate>
            <atom:updated>2025-11-20T15:28:02.586Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*27lm2S7v1-isM8pAWMz-tQ@2x.jpeg" /><figcaption>Photo by <a href="http://delphianpark.com/">Demi DeHerrera</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Nesse artigo, iremos nos aprofundar ainda mais sobre o tema concorrência moderna e iremos entender:</p><ul><li>porque race conditions ainda podem ocorrer com async/await</li><li>Como o Swift previne isso com Actor,</li><li>e isolamento de estado</li><li>Exemplo de implementação thread-safe usando actor</li></ul><h4>O problema das race conditions mesmo usando async/await</h4><p>Sabia que mesmo usando async/await, o acesso concorrente a variáveis ainda pode gerar race conditions? Vamos discutir o exemplo abaixo:</p><pre>class Counter {<br>    var value = 0<br><br>    func increment() {<br>        value += 1<br>    }<br>}<br><br>let counter = Counter()<br><br>await withTaskGroup(of: Void.self) { group in<br>    for _ in 1...1000 {<br>        group.addTask {<br>            counter.increment()<br>        }<br>    }<br>}<br>print(counter.value)</pre><p>O que acontece nesse exemplo e que serve para explicar o motivo de mesmo usando async/await ainda estarmos suscetíveis a race conditions é simplesmente porque class em Swift não tem isolamento de estado. No exemplo acima, cada task está alterando o value ao mesmo tempo e o compilador não impede isso quando estamos lidando com class.</p><h4>Como resolvemos isso então?</h4><p>No swift 5.5, a partir do iOS 15, foi introduzido um novo conceito representativo de entidade chamado Actor, agora, além de struct, enum e class, temos o tipo Actor.</p><p>Ele é bem semelhante ao class, porém, com garantias automáticas de exclusão mútua.</p><p>A gente pode pensar no actor como uma espécie de classe com isolamento interno de estado, porque ela tem propriedades e métodos como uma class, pode ter herança de protocolos, inicializadores e até métodos async, porém, o Swift nos garante que somente uma task por vez acessa seu estado interno. Bacana né?</p><p>Vamos ver o exemplo abaixo:</p><pre>actor Counter {<br>    var value = 0<br><br>    func increment() {<br>        value += 1<br>    }<br>}<br><br>let counter = Counter()<br><br>await withTaskGroup(of: Void.self) { group in<br>    for _ in 1...1000 {<br>        group.addTask {<br>            await counter.increment()<br>        }<br>    }<br>}<br><br>let result = await counter.value<br>print(result)</pre><p>Observe que não precisamos usar nenhum NSLock, nenhuma DispatchQueue.sync, o compilador já resolveu tudo pra gente pelo simples fato de utilizar Actor.</p><h4>Como o isolamento funciona internamente?</h4><p>Cada actor mantém a sua fila privada de execução, quando uma task tenta acessar uma propriedade ou método do actor, ela é suspensa até que o executor esteja livre!</p><p>Ou seja:</p><p>O acesso ao estado interno é sequencial e controlado, nenhuma outra task entra até a atual terminar e o compilador exige await sempre que o acesso pode suspender.</p><p>Isso é o que pode ser chamado de isolamento de estado(state isolation).</p><p>No próximo artigo iremos explorar sobre Sendable.</p><p>Te aguardo no próximo café com a concorrência!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dc2bff7ffff8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Café com a concorrência: async/await]]></title>
            <link>https://alcidesjuniorbr.medium.com/caf%C3%A9-com-a-concorr%C3%AAncia-async-await-20f6b9d4c501?source=rss-ed26dc376903------2</link>
            <guid isPermaLink="false">https://medium.com/p/20f6b9d4c501</guid>
            <category><![CDATA[swift-concurrency]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[ios-development]]></category>
            <category><![CDATA[asyncawait]]></category>
            <dc:creator><![CDATA[Alcides Junior]]></dc:creator>
            <pubDate>Wed, 05 Nov 2025 21:04:43 GMT</pubDate>
            <atom:updated>2025-11-05T21:04:43.476Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*juQpClH3LK86eips" /><figcaption>Photo by <a href="https://unsplash.com/@nate_dumlao?utm_source=medium&amp;utm_medium=referral">Nathan Dumlao</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>A partir desse artigo, já começamos a adentrar no que o Swift 5.5 pode nos oferecer em relação a concorrência moderna. Vamos entender o que é o modelo estruturado de concorrência, aprender a usar async e task, como substituir DispatchGroup e closures aninhas e entender os benefícios de segurança e legibilidade.</p><h3>Vamos começar analisando um problema usado no modelo GCD</h3><p>Antes do novo modelo de concorrência no Swift, lidar com callbacks era(e ainda é dependendo do target do seu projeto rsrs) dessa forma:</p><pre>func loadUserData(completion: @escaping (User?) -&gt; Void) {<br>    DispatchQueue.global().async {<br>        let user = fetchFromNetwork()<br>        DispatchQueue.main.async {<br>            completion(user)<br>        }<br>    }<br>}</pre><p>Observe que era algo meio difícil de bater o olho e entender de cara, tínhamos que fazer alguns aninhamentos dentro dos callbacks, também tínhamos erros de sincronização(o que gera hands e até crashes se for algo usando na UI) se esquecêssemos de voltar para a main thread e claro, a dificuldade para compor múltiplas tarefas, como carregar 3 ou mais dados em paralelo, por exemplo.</p><h4>Resolvendo com async/await</h4><p>O async/await foi introduzido no Swift 5.5, lançado junto com o iOS 15.<br>Ele é utilizado para marcar funções assíncronas, onde elas podem pausar e retomar sem bloquear threads.</p><pre>func loadUserData() async -&gt; User? {<br>    await fetchFromNetwork()<br>}<br><br>// para chamar o cógido acima usamos o Task<br>Task {<br>    let user = await loadUserData()<br>    print(user)<br>}</pre><p>O código acima pode até parecer síncrono, mas acredite: ele totalmente assíncrono!!!!!! maneiro, né?</p><h4>Mas… e o papel do tal do Task?</h4><p>O Task cria um escopo assíncrono dentro de uma função síncrona e ele equivale a começar uma thread assíncrona controlada.</p><pre>Task {<br>    let image = await downloadImage()<br>    let processed = await processImage(image)<br>    await saveToCache(processed)<br>    print(&quot;Tudo pronto!&quot;)<br>}</pre><p>Aqui o compilador nos garante que o fluxo respeite o escopo, erros e cancelamentos sejam propagados corretamente e que a memória seja gerenciada de forma segura.</p><h3>Concorrência estruturada</h3><p>Um dos conceitos mais poderosos disso tudo é que toda task pertence a um escopo, ou seja: Nada fica solto no background sem controle(não é 100% verdade e veremos o porquê no próximo artigo). Quando um escopo termina, todas as subtasks são canceladas e a árvore de tasks é hierárquica e previsível.</p><p><strong>exemplo:</strong></p><pre>func loadFeed() async {<br>    async let profile = fetchUserProfile()<br>    async let posts = fetchUserPosts()<br>    async let notifications = fetchNotifications()<br><br>    await (profile, posts, notifications)<br>}</pre><blockquote>Note que aqui, os três métodos rodam em paralelo e o await combina os resultados quando elas terminam. Lembra do nosso <strong>DispatchGroup</strong>? então… aqui ele é substituído pelo await.</blockquote><h4>Breve exemplo de GCD vs Swift Concurrency</h4><p>Veja esse exemplo de várias tarefas usando os conceitos do GCD:</p><pre>let group = DispatchGroup()<br>for url in urls {<br>    group.enter()<br>    DispatchQueue.global().async {<br>        download(url)<br>        process()<br>        save()<br>        group.leave()<br>    }<br>}<br><br>group.notify(queue: .main) {<br>    print(&quot;Tudo finalizado!&quot;)<br>}</pre><blockquote>Note que tivemos que notificar manualmente a main queue!</blockquote><p>Agora, o mesmo exemplo usando Swift Concurrency:</p><pre>func processImages(urls: [URL]) async {<br>    await withTaskGroup(of: Void.self) { group in<br>        for url in urls {<br>            group.addTask {<br>                await download(url)<br>                await process()<br>                await save()<br>            }<br>        }<br>    }<br>    print(&quot;Tudo finalizado!&quot;)<br>}</pre><blockquote>Note que usamos o withTaskGroup, esse carinha faz automaticamente o papel do nosso <strong>DispatchGroup</strong>, mas com cancelamento automático das subtasks em erro, isolamento de escopo e segurança de memória garantida pelo compilador.</blockquote><h4>Beleza mas… e o tratamento de erros e cancelamentos?</h4><p>Massa meu querido leitor! que bom que você tá curioso sobre isso, é muito importante. Então… tarefas podem lançar erros normalmente com <strong>throws</strong> e você pode usar <strong>try</strong> <strong>await</strong> de boas.</p><p><strong>exemplo:</strong></p><pre>func fetchData() async throws -&gt; String {<br>    try await Task.sleep(nanoseconds: 1_000_000_000)<br>    return &quot;Dados recebidos com sucesso!!!&quot;<br>}<br><br>Task {<br>    do {<br>        let result = try await fetchData()<br>        print(result)<br>    } catch {<br>        print(&quot;Falha ao buscar dados: \(error)&quot;)<br>    }<br>}</pre><p>já para cancelamentos:</p><pre>let task = Task {<br>    try await fetchData()<br>}<br>task.cancel()</pre><p>simples né?</p><p>Te aconselho a explorar mais o async/await. Um belo exemplo a se fazer é tentar reescrever requisições http de algum projeto seu usando async/await. Além de ser um desafio bem divertido, vai te mostrar na prática os benefícios de usar concorrência moderna e claro: ter um código menos verboso e mais legível.</p><p>No próximo artigo falaremos sobre Actors, Sendable e muito mais…<br>Te aguardo no nosso próximo café!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=20f6b9d4c501" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Café com a concorrência: Operation e OperationQueue]]></title>
            <link>https://alcidesjuniorbr.medium.com/caf%C3%A9-com-a-concorr%C3%AAncia-operation-e-operationqueue-94e2bec88ca9?source=rss-ed26dc376903------2</link>
            <guid isPermaLink="false">https://medium.com/p/94e2bec88ca9</guid>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[gcd]]></category>
            <category><![CDATA[operationqueue]]></category>
            <dc:creator><![CDATA[Alcides Junior]]></dc:creator>
            <pubDate>Fri, 31 Oct 2025 01:11:56 GMT</pubDate>
            <atom:updated>2025-10-31T01:11:56.251Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*FnbJdbpFhikk4U02" /><figcaption>Photo by <a href="https://unsplash.com/@nate_dumlao?utm_source=medium&amp;utm_medium=referral">Nathan Dumlao</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>No <a href="https://medium.com/@alcidesjuniorbr/caf%C3%A9-com-a-concorr%C3%AAncia-dispatchgroup-e-dispatchsemaphore-071afdbaf3a3">artigo</a> anterior, vimos sobre DispatchGroups e DispatchSemaphores, bem como, vimos também sobre QoS e no nosso café com concorrência de hoje, vamos explorar sobre concorrência orientada a objetos.</p><h3>Mas… o que é o Operation?</h3><p>É uma abstração orientada a objetos sobre o GCD e encapsula uma tarefa concorrente em um objeto, sendo capaz de:</p><ul><li>cancelar execuções usando operation.cancel()</li><li>controlar dependências entre operações</li><li>reaproveitas lógica de execução</li><li>monitorar estado(isReady, isExecuting, isFinished)</li><li>integrar facilmente com arquiteturas</li></ul><h3>E o que é OperationQueue?</h3><p>É uma fila que gerencia várias Operation onde pode ser decido:</p><ul><li>quando executar</li><li>quantas podem rodar ao mesmo tempo</li><li>a ordem</li><li>a prioridade</li></ul><p>Por debaixo dos panos a OperationQueue acaba usando GCD, só que nos dá muito mais controle. Vamos ver mais sobre isso?</p><pre>let queue = OperationQueue()<br>queue.maxConcurrentOperationCount = 2 // máximo de 2 operações simultâneas<br><br>let op1 = BlockOperation {<br>    print(&quot;Iniciando tarefa 1&quot;)<br>    Thread.sleep(forTimeInterval: 1)<br>    print(&quot;Finalizando tarefa 1&quot;)<br>}<br><br>let op2 = BlockOperation {<br>    print(&quot;Iniciando tarefa 2&quot;)<br>    Thread.sleep(forTimeInterval: 2)<br>    print(&quot;Finalizando tarefa 2&quot;)<br>}<br><br>queue.addOperations([op1, op2], waitUntilFinished: false)</pre><p>Observe que, agora, de forma orientada a objeto setamos o máximo de operações simultâneas e executadas na background thread.</p><h4>Dependências entre operações</h4><p>Antes, tínhamos a opção de usar Semaphores e DispatchGroup para controlar dependências, agora, temos mais a seguinte forma de controlar dependências:</p><pre>let queue = OperationQueue()<br>let download = BlockOperation {<br>    print(&quot;Baixando imagem&quot;)<br>    Thread.sleep(forTimeInterval: 2)<br>}<br>let resize = BlockOperation {<br>    print(&quot;Redimensionando imagem&quot;)<br>}<br>resize.addDependency(download) // O resize aqui só começa dps do download<br>queue.addOperations([download, resize], waitUntilFinished: false)</pre><p>Vamos fazer um breve comparativo usando <strong>Semaphore</strong>/<strong>DispatchGroup</strong>?</p><pre>let group = DispatchGroup()<br>let semaphore = DispatchSemaphore(value: 2)<br><br>for url in urls {<br>    group.enter()<br>    semaphore.wait()<br><br>    DispatchQueue.global().async {<br>        downloadImage(url)<br>        semaphore.signal()<br>        group.leave()<br>    }<br>}<br><br>group.notify(queue: .main) {<br>    print(&quot;Tudo pronto!&quot;)<br>}</pre><p>Observe que aqui é algo mais manual, ou seja, nós precisamos controlar os pontos onde teremos que esperar usando <strong><em>enter</em></strong>, <strong><em>leave</em></strong>, <strong><em>wait</em></strong> e <strong><em>signal</em></strong>, diferente do usado com <em>OperationQueue</em>.</p><h4>Cancelamento</h4><p>Diferente do que conhecemos no GCD, com OperationQueue, podemos cancelar uma operação a qualquer momento.</p><pre>let queue = OperationQueue()<br><br>let op = BlockOperation {<br>    for i in 1...5 {<br>        guard !OperationQueue.current!.isCancelled else {<br>            print(&quot;Operação cancelada!&quot;)<br>            return<br>        }<br>        print(&quot;Executando passo \(i)&quot;)<br>        Thread.sleep(forTimeInterval: 1)<br>    }<br>}<br><br>queue.addOperation(op)<br><br>// cancelar antes de terminar<br>DispatchQueue.main.asyncAfter(deadline: .now() + 2) {<br>    op.cancel()<br>}</pre><p>Essa abordagem é excelente ter na manga porque conseguimos evitar desperdício no uso de CPU, mantendo nossas aplicações mais eficientes e “econômicas”.</p><h4>Custom Operation</h4><p>Podemos também criar subclasses de Operation, permitindo criar custom operations como no exemplo abaixo:</p><pre>final class DownloadOperation: Operation {<br>    private let url: URL<br><br>    init(url: URL) {<br>        self.url = url<br>    }<br><br>    override func main() {<br>        if isCancelled { return }<br><br>        print(&quot;Baixando \(url.lastPathComponent)&quot;)<br>        Thread.sleep(forTimeInterval: 2)<br><br>        if isCancelled { return }<br><br>        print(&quot;Finalizou \(url.lastPathComponent)&quot;)<br>    }<br>}<br><br>let queue = OperationQueue()<br>let urls = (1...3).map { URL(string: &quot;https://picsum.photos/\($0 * 100)&quot;)! }<br><br>urls.forEach { url in<br>    let op = DownloadOperation(url: url)<br>    queue.addOperation(op)<br>}</pre><p>Isso nos abre um leque de possibilidades, podemos criar uma DownloadOperation, ImageProcessingOperation, SaveCacheOperation e muito mais coisas. Fora que também garantimos <strong>testabilidade</strong> e <strong>isolamento</strong> de lógica.</p><h4>Prioridades de Operation</h4><p>É importante lembrar que essas prioridades não definem o <strong>QoS</strong>!!! <br>apenas influenciam na ordem de entrada na fila.</p><pre>op.queuePriority = .veryHigh<br><br>// vs<br><br>queue.qualityOfService = .userInitiated</pre><p>Dito isto, temos:</p><ul><li>veryHigh</li><li>high</li><li>normal(default)</li><li>low</li><li>veryLow</li></ul><h3>Cancelamento em cadeia</h3><p>Se uma operação for cancelada, você tem a opção de também cancelar suas dependentes.</p><pre>resize.addDependency(download)<br><br>download.completionBlock = {<br>    if download.isCancelled {<br>        resize.cancel()<br>    }<br>}</pre><p>Se o GCD é o motor, OperationQueue é o volante. A partir daqui, o poder não tá apenas em executar tarefas simultâneas mas em orquestrar o comportamento delas. E é nessa orquestra que a concorrência começa a soar como música.</p><p>No próximo artigo, as coisas começam a esquentar ainda mais! então corre pra pegar tua xícara de café porque vamos falar sobre async/await!</p><p>Te espero numa próxima…</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=94e2bec88ca9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Café com a concorrência: DispatchGroup e DispatchSemaphore]]></title>
            <link>https://alcidesjuniorbr.medium.com/caf%C3%A9-com-a-concorr%C3%AAncia-dispatchgroup-e-dispatchsemaphore-071afdbaf3a3?source=rss-ed26dc376903------2</link>
            <guid isPermaLink="false">https://medium.com/p/071afdbaf3a3</guid>
            <category><![CDATA[dispatchgroup]]></category>
            <category><![CDATA[dispatchsemaphore-swift]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[concurrency]]></category>
            <category><![CDATA[gcd]]></category>
            <dc:creator><![CDATA[Alcides Junior]]></dc:creator>
            <pubDate>Sat, 25 Oct 2025 21:49:13 GMT</pubDate>
            <atom:updated>2025-10-25T21:49:13.167Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*mAIpO779FKFb9xKy" /><figcaption>Photo by <a href="https://unsplash.com/@nate_dumlao?utm_source=medium&amp;utm_medium=referral">Nathan Dumlao</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>No <a href="https://alcidesjuniorbr.medium.com/caf%C3%A9-com-a-concorr%C3%AAncia-fundamentos-de-concorr%C3%AAncia-no-ios-a2b1eb68d6d4"><strong>artigo anterior</strong></a>, falamos um pouco sobre concorrência vs paralelismo DispatchQueue, race conditions.<br>Hoje, iremos explorar um pouco sobre DispatchGroup e DispatchSemaphore.</p><p>Mas antes… vamos falar sobre</p><h3>Quality of Service(QoS)</h3><p>QoS ou Quality of Service definie o nível de prioridade e o tipo de recurso que uma tarefa deve receber ao ser executada.</p><p>Cada DispatchQueue ou OperationQueue(tema do próximo artigo) podem ter um QoS definido e o iOS usa essa informação para tomar algumas decisões como:</p><ul><li>Em qual pool de thread uma tarefa será executada</li><li>Quanto tempo de CPU ela pode consumir</li><li>Quanta energia pode gastar</li><li>Quando ela deve ser agendada em relação as outras tarefas</li></ul><p>Entender sobre como usar corretamente QoS é fundamental para conseguir usufruir 100% do que o GCD nos oferece.</p><p>Aqui, vamos entender como as filas são priorizadas e qual QoS escolher para cada cenário, seja para UI, tarefas em background, sync etc.</p><h3>DispatchGroup</h3><blockquote><em>&quot;Famoso: me avisa quando tudo acabar.&quot;</em></blockquote><p>Ele funciona como um orquestrador, onde ao finalizar várias tarefas assíncronas, ele sincroniza o término dessas tarefas.</p><pre>let group = DispatchGroup()<br>let queue = DispatchQueue.global(qos: .userInitiated)<br><br>for i in 1...3 {<br>    group.enter()<br>    queue.async {<br>        print(&quot;Baixando imagem \(i)...&quot;)<br>        Thread.sleep(forTimeInterval: 1)<br>        print(&quot;Imagem \(i) finalizada!&quot;)<br>        group.leave()<br>    }<br>}<br><br>group.notify(queue: .main) {<br>    print(&quot;Todas as imagens foram baixadas!&quot;)<br>}</pre><h4>Entendendo um pouco melhor</h4><ul><li>group.enter(): indica que uma nova tarefa iniciou</li><li>group.leave(): indica que uma tarefa terminou</li><li>group.notify: é chamado quando todas as tarefas finalizam.</li></ul><h4>Aplicabilidade</h4><p>Imagine um cenário onde você quer executar determinada ação apenas após suas imagens carregarem:</p><pre>let urls = [<br>    URL(string: &quot;https://picsum.photos/300&quot;)!,<br>    URL(string: &quot;https://picsum.photos/400&quot;)!,<br>    URL(string: &quot;https://picsum.photos/500&quot;)!<br>]<br><br>let downloader = ImageDownloader()<br>let group = DispatchGroup()<br><br>urls.forEach { url in<br>    group.enter()<br>    downloader.download(from: url) { image in<br>        print(&quot;Imagem baixada:&quot;, image != nil)<br>        group.leave()<br>    }<br>}<br><br>group.notify(queue: .main) {<br>// o que você precisa fazer quando todas as imagens forem baixadas<br>// você faz aqui dentro<br>    print(&quot;Todas as imagens foram baixadas!&quot;)<br>}</pre><h4>DispatchSemaphore</h4><blockquote>&quot;Controla quantas tarefas rodam por vez.&quot;</blockquote><p>Ainda pensando em performance, imagine um cenário onde uma tela precise carregar uma grid com muitas imagens e isso pode sobrecarregar o app. Nesse cenário, entramos com o conceito de semáforos com o DispatchSemaphore, que nos permite otimizar limitando quantas tarefas podemos executar SIMULTANEAMENTE.</p><pre>let semaphore = DispatchSemaphore(value: 3) // apenas 3 downloads simultâneos<br>let queue = DispatchQueue.global(qos: .userInitiated)<br><br>for i in 1...10 {<br>    queue.async {<br>        semaphore.wait() // bloqueia se já tiver 3 rodando<br>        print(&quot;Baixando imagem \(i)&quot;)<br>        Thread.sleep(forTimeInterval: 2)<br>        print(&quot;Imagem \(i) finalizada&quot;)<br>        semaphore.signal() // libera vaga<br>    }<br>}</pre><p>Ou seja, teremos no máximo 3 downloads simultâneos, quando uma tarefa termina e chama signal, outra entra na fila.</p><p>Em resumo: wait decrementa 1 e signal incrementa 1.</p><h4>DispatchGroup + DispatchSemaphore</h4><pre>let group = DispatchGroup()<br>let semaphore = DispatchSemaphore(value: 3)<br>let queue = DispatchQueue.global(qos: .userInitiated)<br><br>for url in urls {<br>    group.enter()<br>    queue.async {<br>        semaphore.wait()<br>        downloader.download(from: url) { image in<br>            print(&quot;Download concluído:&quot;, image != nil)<br>            semaphore.signal()<br>            group.leave()<br>        }<br>    }<br>}<br><br>group.notify(queue: .main) {<br>    print(&quot;Todos os downloads finalizados!&quot;)<br>}</pre><p>Aqui, o semaphore controla quantas roda por vez, enquanto o group avisa quando todas terminaram.</p><h3>Voltando para QoS: Principais níveis de QoS</h3><ul><li><strong>userInteractive</strong>: tem prioridade altíssima, é usado em UI, animações, gestures e updates em UI, porém, deve ser usado com cuidado pois compete com a main thread</li><li><strong>userInitiated</strong>: tem prioridade alta, é usado em ações iniciadas pelo usuário como um download, abrir um arquivo ou fazer login. Essa QoS é ideal para tarefas rápidas que precisam de resposta imediata</li><li><strong>utility</strong>: tem prioridade média, é usado para sincronizações, carregamentos de dados ou cálculos demorados. Ela balanceia eficiência e performance</li><li><strong>background</strong>: tem prioridade baixa, é utilizada para backups, pré-carregamentos, analytics, logs. Ela poupa energia e roda quando o sistema estiver ocioso</li><li><strong>default</strong>: tem prioridade intermediária, caso não especifique uma QoS, o sistema adotará essa. Geralmente, ela fica entre a <strong>userInitiated</strong> e a <strong>utility</strong></li></ul><h4>Vamos ver como elas atuam na prática?</h4><pre>let queues: [(String, DispatchQoS.QoSClass)] = [<br>    (&quot;Interactive&quot;, .userInteractive),<br>    (&quot;Initiated&quot;, .userInitiated),<br>    (&quot;Utility&quot;, .utility),<br>    (&quot;Background&quot;, .background)<br>]<br><br>for (name, qos) in queues {<br>    DispatchQueue.global(qos: qos).async {<br>        for i in 1...3 {<br>            print(&quot;\(name) tarefa \(i)&quot;)<br>        }<br>    }<br>}</pre><p>Note que o sistema vai obedecer a ordem de prioridade onde as tarefas que contém QoS userInteractive e userInitiated terminarão primeiro enquanto as que tiverem utility e background irão demorar a entrar na fila.</p><p><strong>Dica extremamente importante!<br></strong>Evite usar muito a userInitiated. Um app bem performático é aquele que prioriza apenas o que o usuário percebe, o resto deve rodar silenciosamente em níveis mais baixos de QoS.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=071afdbaf3a3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Café com a concorrência: Fundamentos de Concorrência no iOS]]></title>
            <link>https://alcidesjuniorbr.medium.com/caf%C3%A9-com-a-concorr%C3%AAncia-fundamentos-de-concorr%C3%AAncia-no-ios-a2b1eb68d6d4?source=rss-ed26dc376903------2</link>
            <guid isPermaLink="false">https://medium.com/p/a2b1eb68d6d4</guid>
            <category><![CDATA[serial-queue]]></category>
            <category><![CDATA[café-com-concorrencia]]></category>
            <category><![CDATA[ios-concurrency]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[gcd]]></category>
            <dc:creator><![CDATA[Alcides Junior]]></dc:creator>
            <pubDate>Wed, 22 Oct 2025 00:11:32 GMT</pubDate>
            <atom:updated>2025-10-22T00:11:32.205Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Pq1oCrD0FlNiKHpV" /><figcaption>Photo by <a href="https://unsplash.com/@nate_dumlao?utm_source=medium&amp;utm_medium=referral">Nathan Dumlao</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Essa é uma série de artigos onde vamos falar sobre alguns conceitos de concorrência no swift e aprenderemos seus benefícios, quando e porquê utilizar.<br>Oi! me chamo Alcides Junior, sou engenheiro de software iOS e quero compartilhar com você um pouco desse conhecimento tão importante.</p><h3>Concorrência vs Paralelismo</h3><p>Parecem duas palavras com o mesmo significado, não é mesmo? Mas há sutilezas importantes aqui!</p><h4><strong>Concorrência</strong></h4><p>Dizemos que algo é concorrente quando &quot;disputa&quot; atenção, ou seja: num cenário onde precisamos fazer o download de uma imagem, salvar localmente e atualizar a UI de forma <strong>intercalada </strong>temos um cenário de concorrência de recursos.</p><h4>Paralelismo</h4><p>Dizemos que temos um cenário de paralelismo quando ocorre ao mesmo tempo, porém, em núcleos de processamento diferentes. Por exemplo: quando precisamos processar 4 imagens simultaneamente em 4 núcleos de CPU.</p><p>Se tratando de iOS, a concorrência é o normal, porque o sistema gerencia threads e intercala execução conforme os recursos. Em outras palavras: Pense como uma fila de tarefas a serem executadas, onde a main queue é responsável pela UI e background queue é responsável pelo trabalho &quot;pesado&quot; como baixar imagens, salvar arquivos, processar imagens etc.</p><p>É muito importante entender esses conceitos para evitar diversos problemas como travamentos de UI, crashes e race conditions.</p><h3>DispatchQueue(GCD)</h3><p>O dispatchQueue é o coração da concorrência no Swift. Ele é a base de tudo em concorrência tradicional no iOS, então, antes de avançarmos nos conceitos modernos de concorrência, é importante entender sobre o GCD(Grand Central Dispatch). Esse conceito aborda temas como:</p><ul><li><strong>Serial Queue</strong>: fila que executa uma tarefa por vez e com ordem garantida.</li><li><strong>Concurrent Queue</strong>: executa múltiplas tarefas em paralelo</li><li><strong>Main Queue</strong>: fila principal e associada a thread de UI.</li><li><strong>Global Queue</strong>: fila de background onde a prioridade pode ser definida.</li></ul><p>Abaixo, vamos ver um exemplo utilizando a background e main thread em um exemplo clássico do dia a dia de um desenvolvedor iOS:</p><p>Imagine um cenário onde temos uma tableView e precisamos baixar imagens e carregá-las para o usuário: temos um cenário onde precisamos combinar o &quot;trabalho pesado&quot; que seria baixar a imagem e atualizar a view.</p><pre>DispatchQueue.global(qos: .background).async {<br>    print(&quot;Baixando imagem...&quot;)<br><br>    DispatchQueue.main.async {<br>        print(&quot;Atualizando UI...&quot;)<br>    }<br>}</pre><p>Nesse cenário estamos evitando um problema clássico que é o travamento da UI, porque estamos combinando a background thread juntamentamente com a main thread.</p><h3>Race condition</h3><p>Outro problema clássico no mundo iOS são as race conditions. Esse problema, além de gerar resultados incertos, pode gerar crashes em nossas aplicações. Basicamente, race condition acontece quando tentamos acessar um mesmo recurso ao mesmo tempo.</p><p>Abaixo, trago um exemplo de acesso a uma variável que, em determinados momentos pode ter valores errados.</p><pre>var counter = 0<br><br>DispatchQueue.global().async {<br>    for _ in 0..&lt;1000 { counter += 1 }<br>}<br><br>DispatchQueue.global().async {<br>    for _ in 0..&lt;1000 { counter += 1 }<br>}</pre><p>Aqui o valor hora vai ser 1000, hora vai ser 2000.</p><p>Agora imagine isso num cenário bancário onde, o usuário tenta fazer transações e fica sem saldo… seria um baita problema!</p><p>Outro cenário bem ruim seria a tentativa de acesso a arrays ou dicionários, que poderia gerar crashes justamente por problema de race condition.</p><h4>Como resolveríamos o exemplo acima?</h4><p>Se tratando de race condition, temos algumas técnicas para tentar resolver esse problema, lembrando: com o sistema de concorrência moderno, temos mais outras técnicas, mas aqui nesse artigo vamos nos limitar ao que o GCD nos oferece.</p><ul><li><strong>Serial Queue</strong>: usando uma DispatchQueue(label: &quot;syncQueue&quot;) para garantir a execução de forma síncrona.</li><li><strong>Barrier block</strong>: usando uma DispatchQueue.concurrent + .async(flags: .barrier) garantimos exclusividade temporária.</li><li><strong>Locks/Semaphores</strong>: sincronizamos de forma manual o acesso.</li></ul><p>Vamos usar a primeira técnica, que seria usar Serial Queue:</p><pre>let syncQueue = DispatchQueue(label: &quot;com.meuApp.syncQueue&quot;)<br>var counter = 0<br><br>for _ in 0..&lt;1000 {<br>    syncQueue.async {<br>        counter += 1<br>    }<br>}</pre><p>com essa técnica, garantimos que nosso valor final será sempre 1000.</p><p>No próximo artigo vamos ver um pouco mais sobre DispatchGroup e DispatchSemaphore.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a2b1eb68d6d4" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>