Artigo

Mairon Passos Ferreira; Elaine Barbosa de Figueiredo

DOI: 10.22167/2675-6528-202601583

Artigo derivado de Trabalho de Conclusão de Curso (TCC), com conteúdo baseado no trabalho original do aluno e adaptado ao formato editorial da Revista E&S com apoio da ferramenta ResumeAI, solução de inteligência artificial desenvolvida pelo Instituto Pecege para síntese e organização textual.

Resumo

A crescente complexidade das aplicações web modernas impulsionou a adoção de arquiteturas de micro-frontends, que, embora promovam modularidade e independência, introduziram desafios no gerenciamento e compartilhamento de estado. Objetivou-se analisar e comparar diferentes estratégias de gerenciamento de dados em micro-frontends, avaliando seus impactos na consistência, desempenho, acoplamento e manutenibilidade. Para isso, desenvolveu-se uma prova de conceito com Angular e Module Federation, implementando abordagens centralizadas, descentralizadas e orientadas a eventos, além de utilizar bibliotecas compartilhadas e a Broadcast Channel API. A metodologia aplicada foi experimental e quali-quantitativa, com medições controladas de latência e sincronização. Os resultados indicaram que mecanismos nativos, como a Broadcast Channel, exibiram menor latência em sincronizações leves. O gerenciamento centralizado mostrou-se mais eficaz para a consistência de dados globais, enquanto estratégias orientadas a eventos ofereceram maior flexibilidade e menor acoplamento, apesar de um custo de comunicação ligeiramente superior. Concluiu-se que não existe uma solução única ideal, e a escolha da estratégia deve considerar o contexto e os requisitos arquiteturais específicos.

Palavras-chave: Arquitetura de Software; Arquitetura Orientada a Eventos; Desempenho; Module Federation; Sistemas Distribuídos.

1. Introdução

A forma como os produtos digitais são construídos mudou drasticamente nas últimas décadas, impulsionada pela crescente demanda por aplicações web robustas e dinâmicas. No panorama atual da engenharia de software, a velocidade das equipes de desenvolvimento e a qualidade da experiência do usuário são os fundamentos para o sucesso de qualquer solução digital. Contudo, o crescimento acelerado de sistemas monolíticos tradicionais, caracterizados por uma estrutura única e coesa, tem imposto limitações significativas a essa evolução. Como observa Newman (2021), o acúmulo de código em uma arquitetura monolítica acaba por restringir a velocidade de inovação e, crucialmente, a autonomia das equipes de desenvolvimento.

Em resposta a esse engessamento e à necessidade de maior agilidade e escalabilidade, o conceito de micro-frontends (MFEs) consolidou-se como uma estratégia arquitetural promissora. Ao fragmentar grandes aplicações web em componentes menores e independentes, as organizações ganham a capacidade de escalar suas soluções e equipes de forma isolada. Essa abordagem permite que diferentes partes do sistema evoluam sem que uma impeça o progresso da outra, promovendo modularidade e flexibilidade tecnológica, conforme destacado por Peltonen et al. (2021).

Todavia, embora a decomposição e a modularidade inerentes aos micro-frontends ofereçam vantagens significativas em termos de escalabilidade, flexibilidade tecnológica e autonomia das equipes, essa abordagem não é isenta de desafios complexos. Um dos obstáculos mais relevantes reside no gerenciamento e compartilhamento de estado entre os módulos, conforme apontado por Antunes et al. (2024). Manter a fluidez de uma página web exige que os dados circulem com precisão entre seus diversos componentes, e esse processo de controle e sincronização, conhecido como gerenciamento de estado, é essencial para garantir que a experiência do usuário não seja interrompida por informações desencontradas. Na literatura técnica, este ponto aparece com frequência como um dos gargalos mais complexos para quem decide migrar para arquiteturas de MFEs (Pavlenko et al., 2020).

A grande questão reside no fato de que, embora a independência dos módulos traga liberdade para as equipes, ela dificulta a orquestração desses dados de forma consistente. Sem um critério rigoroso de integração e sincronização, a descentralização pode gerar sistemas difíceis de manter e módulos que sofrem com falhas de sincronia (Lazzari e Farias, 2021). Essa problemática evidencia uma lacuna prática e teórica sobre como conciliar a integridade das informações com a robustez da arquitetura, buscando entender como diferentes estratégias de gerenciamento de estado podem coexistir sem degradar a performance geral do sistema.

Diante dessas limitações e da crescente demanda por aplicações web robustas e eficientes, capazes de conciliar modularidade e experiência do usuário sem comprometer a integridade dos dados, surge a necessidade de compreender como diferentes abordagens podem minimizar esses problemas. A motivação para este estudo baseia-se na busca por soluções que otimizem o gerenciamento de estado em MFEs, explorando estratégias como as centralizadas, descentralizadas e orientadas a eventos, além de mecanismos de suporte como bibliotecas compartilhadas e a Broadcast Channel API. A compreensão de seus impactos é fundamental para a tomada de decisões arquiteturais informadas.

Com foco nesse problema, o objetivo deste trabalho é avaliar empiricamente as principais abordagens de gerenciamento de estado em arquiteturas de micro-frontends. A intenção é medir, na prática, como elas afetam a consistência e o desempenho por meio de um ambiente controlado. Para tal, o estudo propõe-se a implementar abordagens centralizadas, descentralizadas e orientadas a eventos, medir quantitativamente o desempenho e a eficiência de sincronização, e comparar qualitativamente os resultados para identificar os trade-offs de cada modelo arquitetural.

2. Material e Métodos

A pesquisa adotou uma abordagem aplicada (Gil, 2008) e de natureza experimental, isolando o objeto de estudo para controlar variáveis e observar seus efeitos (Gil, 2002). Caracterizou-se como quali-quantitativa (Sampieri et al., 2006), integrando dados numéricos de latência com a análise de impactos arquiteturais e manutenibilidade. O estudo foi conduzido por meio de um benchmarking controlado, desenhado para avaliar as estratégias de gerenciamento de estado em arquiteturas de micro-frontends (MFEs), buscando testar o comportamento de diferentes métodos de sincronização em ecossistemas modulares.

O objeto empírico foi uma prova de conceito de aplicação de e-commerce, simulando um petshop, desenvolvida para testar as estratégias de gerenciamento de estado em MFEs. A aplicação consistiu em um Shell (Host) e quatro MFEs independentes, dedicados ao Catálogo de Produtos, Carrinho de Compras, Lista de Desejos e Preferências do Usuário. As estratégias avaliadas foram centralizadas, descentralizadas e orientadas a eventos, além de mecanismos de suporte como bibliotecas compartilhadas e a Broadcast Channel API, conforme os pilares definidos para o ambiente experimental.

O ambiente experimental foi construído utilizando Angular (versão 21.1.0) como framework principal para todos os módulos. A arquitetura de micro-frontends foi implementada com Webpack Module Federation (Webpack 5) e a biblioteca @angular-architects/module-federation (versão 20.0.0) (Steyer, 2024). A linguagem de programação empregada foi TypeScript (versão 5.9.2). Para gerenciamento de estado reativo e comunicação, utilizou-se a biblioteca Reactive Extensions for JavaScript [RxJS] (versão 7.8.0), juntamente com as APIs nativas do navegador CustomEvents e Broadcast Channel.

O ambiente de desenvolvimento incluiu Node.js em versão Long-Term Support [LTS], Node Package Manager (npm) versão 11.6.2, Angular CLI versão 21.1.1, Webpack 5.x como empacotador de módulos e Vitest versão 4.0.8 como framework de testes. A seleção dessas tecnologias permitiu concentrar a análise metodológica nas estratégias de gerenciamento de estado, sem introduzir pontos adicionais relacionados à orquestração dos MFEs.

A arquitetura da prova de conceito foi projetada para demonstrar a orquestração entre módulos e a gestão de estados transversais, conforme ilustrado na Figura 1. O Shell (Host) foi responsável pela orquestração entre cada módulo e pela gestão de estados transversais, enquanto os MFEs mantiveram sua autonomia, compartilhando apenas informações essenciais. Essa organização reduziu o acoplamento direto e favoreceu a escalabilidade da aplicação, alinhando-se aos princípios de Fowler e Lewis (2014).

Figura 1 – Arquitetura de gerenciamento de estado em MFEs em um ambiente experimental

Fonte: Dados originais da pesquisa

A Figura 1 detalha a estrutura dos micro-frontends, evidenciando a separação clara entre estados globais e locais. O Shell atua não apenas como ponto de integração, mas como elemento de controle, enquanto os mecanismos de comunicação baseados em eventos e bibliotecas compartilhadas funcionam como intermediários para a sincronização entre módulos. Essa representação visual apoia a compreensão de como as diferentes estratégias de gerenciamento de estado foram integradas e testadas no ambiente simulado.

A coleta de dados foi realizada em um ambiente controlado, configurado com Angular 19.2.18 (Shell) e 21.1.0 (MFEs), Module Federation 20.0.0, navegador Chrome 136 (64-bit) e sistema operacional Windows 11. A API `performance.now()` foi utilizada para medição. Para cada operação avaliada, executaram-se 100 iterações, totalizando 1.600 medições (16 operações × 100 iterações), seguindo recomendações para micro benchmarks (Georges et al., 2007). Uma fase de aquecimento (warm-up) descartou as 10 primeiras iterações, e um intervalo de 5ms foi inserido entre as operações para evitar saturação do *event loop*.

A análise dos dados envolveu a avaliação quantitativa de latência e eficiência de sincronização, bem como uma análise qualitativa dos impactos arquiteturais, acoplamento e manutenibilidade. Indicadores como tempo de resposta, uso de recursos, taxa de sincronização e complexidade de integração foram observados. Para validar as diferenças de latência, aplicou-se o teste estatístico ANOVA de fator único. Métricas de acoplamento aferente (Ca) e eferente (Ce) (Martin, 2017), complexidade ciclomática (McCabe, 1976) e complexidade cognitiva (Campbell, 2023) foram utilizadas para avaliar a complexidade.

A pesquisa não envolveu seres humanos nem dados sensíveis, sendo conduzida em um ambiente simulado para fins acadêmicos. Contudo, o estudo possui limitações metodológicas, pois os testes de benchmark foram executados em ambiente local (localhost). Essa configuração eliminou a latência real de rede, variações de largura de banda e o impacto de infraestruturas distribuídas, como CDNs e balanceadores de carga, comuns em cenários de produção. Adicionalmente, os volumes de dados (payloads) utilizados nas operações avaliadas apresentavam baixa complexidade estrutural e tamanho reduzido.

3. Resultados e Discussão

Os testes de benchmark foram executados com cem iterações para cada operação, precedidas por dez iterações de aquecimento, com o objetivo de mitigar efeitos de inicialização e obter medições mais estáveis. Os resultados detalhados por operação consideraram métricas de tendência central, como média e mediana, e de dispersão, incluindo desvio padrão, mínimo e máximo, além de percentis P95 e P99. Essa abordagem permitiu analisar tanto o comportamento médio quanto cenários de pior caso, conforme as recomendações de Jain (1991), garantindo uma avaliação robusta do desempenho das estratégias de gerenciamento de estado em micro-frontends.

A análise dos dados revelou que todas as estratégias de gerenciamento de estado apresentaram latências extremamente baixas, com valores médios inferiores a um milissegundo. Este achado demonstra que o custo de comunicação entre os micro-frontends, no contexto avaliado, é desprezível do ponto de vista da experiência do usuário. Contudo, foram observadas variações sutis entre as estratégias, especialmente em operações que envolvem sincronização entre módulos, como a alteração de tema (toggle-theme) e a adição ao carrinho (cart-add), as quais exibiram maior dispersão e valores máximos ligeiramente superiores.

Para facilitar a comparação entre as abordagens, os resultados consolidados indicaram que a estratégia baseada em biblioteca compartilhada (Shared Library) apresentou o menor valor médio de latência, com 0,07 milissegundos. Em seguida, a Broadcast Channel registrou 0,10 milissegundos, a abordagem orientada a eventos 0,13 milissegundos e, por fim, o gerenciamento centralizado com 0,15 milissegundos. Essas diferenças, embora estatisticamente significativas, são de magnitude muito pequena para serem percebidas pelo usuário final, conforme será discutido adiante.

As variações de desempenho encontradas têm suas raízes na natureza técnica de cada escolha arquitetural. Quando se utilizam bibliotecas compartilhadas, o acesso aos dados ocorre quase instantaneamente na memória, eliminando camadas de abstração que poderiam introduzir atrasos. Este comportamento valida a premissa de Fowler e Lewis (2014) de que o caminho direto entre objetos é, por essência, mais veloz. Em contrapartida, o barramento de eventos, por exigir a publicação e o consumo de mensagens, introduz um custo adicional em latência, justificando os milissegundos extras observados nas medições.

Essa dinâmica expõe o equilíbrio inerente entre desempenho e desacoplamento em arquiteturas de software. A escolha por bibliotecas compartilhadas, embora mais rápida, implica em dependências mais fortes entre os módulos, o que pode, em última instância, restringir a evolução independente do sistema. Por outro lado, a adoção de estratégias orientadas a eventos, mesmo com uma latência marginalmente maior, confere a liberdade arquitetural que Newman (2021) defende como crucial para o crescimento sustentável de micro-frontends.

Um achado relevante diz respeito ao impacto real do Module Federation. Os dados empíricos refutam a preocupação de que arquiteturas distribuídas possam introduzir um overhead proibitivo para a aplicação. Com uma latência média de aproximadamente 0,11 milissegundos, a comunicação entre os módulos se assemelha a chamadas locais, o que corrobora a tese de Geers (2020) sobre a viabilidade dessas soluções em produtos modernos de alta escala. Isso sugere que o avanço das ferramentas de desenvolvimento tem mitigado os desafios de desempenho em arquiteturas distribuídas.

A percepção de que a busca por uma solução única e definitiva para o gerenciamento de estado é um equívoco foi reforçada pelos resultados. A abordagem mais eficaz parece ser o uso de estratégias híbridas, adaptando a ferramenta à natureza do dado e às necessidades específicas de cada parte do sistema. A literatura, e este estudo, sugerem que o sucesso reside em saber dosar performance, consistência e desacoplamento de acordo com o contexto arquitetural (Newman, 2021).

Para validar a precisão das diferenças de latência observadas e garantir o rigor metodológico, aplicou-se o teste estatístico ANOVA de fator único (Analysis of Variance) sobre o conjunto total das 1.600 medições. O resultado indicou um valor-p de 0,002, substancialmente inferior ao nível de significância padrão (p < 0,05). Este resultado rejeita a hipótese nula, comprovando que a variação de desempenho entre as estratégias, com vantagem técnica para as bibliotecas compartilhadas, é estatisticamente verdadeira e não um evento aleatório.

É crucial, contudo, distinguir entre significância estatística e relevância prática. Embora o teste confirme a superioridade matemática do acesso direto em memória, a magnitude real dessa diferença, na casa dos centésimos de milissegundo, é irrelevante do ponto de vista da percepção humana e da experiência do usuário. A evidência estatística reforça a tese central deste estudo: dado que o custo de desempenho é, na prática, insignificante, a escolha arquitetural deve priorizar a redução da complexidade e do acoplamento, evitando sacrificar a qualidade e a manutenibilidade do código por micro-otimizações de eficiência. Divergências com Estudos Anteriores

Ao confrontar os achados experimentais desta pesquisa com a literatura consolidada sobre o tema, observam-se divergências notáveis, especialmente em relação à performance. O estudo conduzido por Zhang et al. (2019) relatou latências consideravelmente altas, ultrapassando a marca dos cem milissegundos nas trocas de mensagens entre os micro-frontends, um valor que se aproxima do limiar de percepção do usuário final. Em contraste, as medições coletadas neste trabalho revelaram um cenário drasticamente distinto, evidenciando tempos de resposta na escala de sub-milissegundos para todas as abordagens de gerenciamento testadas.

Essa discrepância substancial nos números reflete o salto evolutivo das ferramentas de desenvolvimento e as escolhas do contexto tecnológico. Enquanto estudos anteriores utilizavam técnicas como iframes e Web Components, com comunicação baseada em postMessage e necessidade de serialização de dados, a abordagem deste trabalho empregou o Module Federation, que permite comunicação direta em memória dentro do mesmo processo. Essa mudança reduz significativamente a sobrecarga de comunicação, eliminando custos associados à serialização e ao isolamento entre contextos.

A evolução das ferramentas e técnicas de integração no front-end tem um impacto direto no desempenho das arquiteturas de micro-frontends, sugerindo que conclusões obtidas em contextos tecnológicos anteriores devem ser reinterpretadas à luz dessas novas abordagens. De maneira semelhante, os achados apresentam convergência parcial com Ocariza et al. (2013), que classificou o uso de Custom Events como significativamente mais lento em comparação a chamadas diretas. Embora a direção do resultado seja confirmada, a magnitude dessa diferença (0,13ms para eventos versus 0,07ms para acesso direto) mostrou-se irrelevante do ponto de vista prático.

Considerando o limiar de percepção humana de aproximadamente dezesseis milissegundos (Nielsen, 1993), ambas as abordagens operam em uma escala temporal imperceptível ao usuário final. Essa otimização nos motores de processamento JavaScript dos navegadores modernos garante que as equipes de desenvolvimento tenham uma liberdade arquitetural muito maior. Desse modo, priorizar abordagens orientadas a eventos para garantir um forte desacoplamento já não impõe as severas penalidades de desempenho observadas em sistemas do passado. Revisão do Trade-off

Na engenharia de software, existe uma máxima clássica que sugere uma escolha inevitável: ou se prioriza o desempenho, ou se busca o desacoplamento, sendo que soluções mais velozes geralmente criam acoplamentos mais fortes entre os componentes (Bass et al., 2013). No entanto, este trabalho revela que esse trade-off perde força quando se observa micro-frontends construídos com Module Federation. A teoria, nesse caso, parece mais rigorosa do que a realidade prática dos navegadores atuais, que demonstram uma capacidade de processamento otimizada.

Os números evidenciam essa clareza: a diferença entre o modelo mais acoplado, representado pela biblioteca compartilhada com 0,07 milissegundos, e o mais desacoplado, via eventos com 0,13 milissegundos, é de meros 0,06 milissegundos. Para o contexto de uma página web moderna, esse valor é praticamente invisível, pois não chega nem perto de afetar o tempo de resposta percebido pelo usuário nem o tempo de renderização de um frame. Essa insignificância prática do custo de desempenho muda o foco da discussão arquitetural.

Se a performance não é mais o principal obstáculo, a escolha de como gerenciar o estado deve ser guiada por outros valores. Ganham peso a facilidade de manutenção, o nível de acoplamento e a simplicidade para testar e evoluir o código. Em última análise, os resultados mostram que o desenvolvedor tem liberdade para priorizar a saúde da arquitetura, visto que, na prática, o custo de desempenho entre as abordagens analisadas revelou-se irrelevante para a experiência do usuário. Acoplamento e Complexidade Arquitetural

Os resultados qualitativos indicam que o acoplamento e a complexidade não são apenas métricas que podem ser ignoradas, mas sim pilares fundamentais para a sustentabilidade em arquiteturas de micro-frontends. Em cenários que envolvem múltiplas equipes, a capacidade de um módulo evoluir sem “quebrar” o restante do sistema é crucial. Essa autonomia, um requisito central para qualquer projeto distribuído, depende diretamente da forma como os dados transitam entre as partes, e o acoplamento, definido por Stevens et al. (1974) como o nível de interdependência entre módulos, assume um papel decisivo.

Durante o experimento, notou-se que cada estratégia de gerenciamento de estado desenha um perfil de dependência único na arquitetura. As métricas de acoplamento aferente (Ca) e eferente (Ce), propostas por Martin (2017), foram extraídas de forma estática por meio da análise da árvore de dependências dos módulos na arquitetura Angular. O índice elevado de Ca nas bibliotecas compartilhadas (Ca = 4) é notável, pois os quatro módulos da aplicação consomem essas estruturas simultaneamente, exigindo que sejam tratadas com o rigor de uma API pública, com versionamento impecável e mudanças milimetricamente calculadas (Geers, 2020).

A abordagem orientada a eventos demonstrou baixo acoplamento aferente e eferente, uma vez que emissores e consumidores de eventos não possuem conhecimento direto entre si, comunicando-se apenas por meio de contratos bem definidos. Essa característica alinha-se com a Lei de Demeter (Holland e Lieberherr, 1989), que preconiza a redução do conhecimento entre módulos como forma de diminuir o acoplamento. Em contraste, a estratégia baseada em bibliotecas compartilhadas, embora mais eficiente em desempenho, viola parcialmente esse princípio ao permitir acesso direto a estruturas internas, criando dependências implícitas que podem dificultar a evolução do sistema.

Esses achados evidenciam um trade-off claro entre desempenho e independência estrutural: soluções com maior eficiência técnica tendem a gerar um acoplamento mais elevado. No que se refere à complexidade, a análise buscou ir além de avaliações qualitativas, adotando escores numéricos extraídos por ferramentas de análise estática de código. Considerou-se a complexidade ciclomática (McCabe, 1976), que avalia a quantidade de caminhos independentes no código, e a complexidade cognitiva (Campbell, 2023), que mensura o esforço estrutural necessário para um desenvolvedor compreender o fluxo de controle.

A estratégia descentralizada apresentou os menores escores em ambas as dimensões de complexidade (ciclomática = 2; cognitiva = 3), sendo significativamente mais simples de implementar e manter. Por outro lado, abordagens como o uso de Broadcast Channel exibiram escores de complexidade acentuados (ciclomática = 12; cognitiva = 18), justificados pela natureza assíncrona da comunicação e pela necessidade de lidar estruturalmente com cenários de falha e ressincronização entre abas.

A estratégia orientada a eventos demonstrou um comportamento intermediário, com maior complexidade de implementação devido à configuração de listeners e definição de contratos, mas com complexidade moderada de uso (ciclomática = 7; cognitiva = 10). Esse resultado indica que, embora mais sofisticada, essa abordagem pode oferecer um bom equilíbrio entre flexibilidade e manutenibilidade. De forma geral, os resultados sugerem que a escolha da estratégia de gerenciamento de estado deve considerar não apenas aspectos de desempenho, mas principalmente o impacto no acoplamento e na complexidade do sistema.

Em arquiteturas de micro-frontends, especialmente em contextos organizacionais distribuídos, estratégias que favorecem baixo acoplamento e menor complexidade cognitiva tendem a proporcionar maior sustentabilidade e facilidade de evolução ao longo do tempo. A autonomia de deploy, por exemplo, é um fator crítico que é diretamente influenciado por essas características, permitindo que equipes independentes desenvolvam e implantem seus módulos sem interdependências excessivas. Limitações e Trabalhos Futuros

Embora os resultados deste estudo demonstrem a viabilidade e a baixa latência das diferentes abordagens de gerenciamento de estado, é fundamental reconhecer as limitações inerentes ao ambiente experimental desenhado. Os testes de benchmark foram executados em um ambiente de desenvolvimento local (localhost), o que elimina a latência real de rede, as variações de largura de banda e o impacto de infraestruturas distribuídas, como servidores de entrega de conteúdo (CDNs) e balanceadores de carga, que são frequentemente presentes em cenários reais de produção.

Além disso, os volumes de dados (payloads) trafegados nas operações avaliadas, a exemplo dos itens de carrinho e preferências de tema, possuíam baixa complexidade estrutural e tamanho reduzido. Em aplicações distribuídas de grande escala, onde objetos de estado podem ser consideravelmente maiores e aninhados, estratégias baseadas em barramento de eventos ou na Broadcast Channel API podem sofrer um overhead de desempenho superior devido aos altos custos computacionais associados à serialização e desserialização de dados na memória do navegador.

Por conseguinte, a generalização destes resultados para sistemas em produção deve ser feita com cautela. Recomenda-se, como oportunidade de aprimoramento contínuo, que trabalhos futuros repliquem este modelo introduzindo simulações de degradação de rede (network throttling) e o tráfego de payloads mais densos para validar a resiliência das estratégias em condições de estresse, oferecendo uma visão mais completa de seu comportamento em ambientes reais.

Em síntese, a pesquisa demonstrou que, embora todas as estratégias de gerenciamento de estado em micro-frontends apresentem latências imperceptíveis ao usuário em um ambiente controlado, a escolha ideal transcende o desempenho bruto. A decisão deve ser orientada por um equilíbrio entre consistência, flexibilidade e, principalmente, a redução do acoplamento e da complexidade arquitetural, garantindo a manutenibilidade e a autonomia das equipes em longo prazo, conforme os requisitos específicos de cada domínio funcional.

4. Conclusão

O presente estudo analisou e comparou diferentes estratégias de gerenciamento de dados em arquiteturas de micro-frontends, avaliando seus impactos na consistência, desempenho, acoplamento e manutenibilidade. Verificou-se que todas as abordagens testadas, incluindo centralizadas, descentralizadas, orientadas a eventos, bibliotecas compartilhadas e a Broadcast Channel API, apresentaram latências de comunicação na escala de sub-milissegundos, imperceptíveis ao usuário final. Embora diferenças estatisticamente significativas tenham sido identificadas, com as bibliotecas compartilhadas exibindo a menor latência, a relevância prática dessas variações mostrou-se desprezível. Observou-se que o Module Federation mitigou o overhead de desempenho em arquiteturas distribuídas, refutando preocupações anteriores. O gerenciamento centralizado revelou-se eficaz para a consistência de dados globais, enquanto estratégias orientadas a eventos e descentralizadas ofereceram maior flexibilidade e menor acoplamento, com a Broadcast Channel API destacando-se pela baixa latência em sincronizações leves. A complexidade arquitetural e o acoplamento emergiram como fatores cruciais na escolha da estratégia, mais relevantes que a performance bruta.

A principal contribuição deste trabalho reside na demonstração empírica de que, no contexto de micro-frontends construídos com Module Federation, o tradicional trade-off entre desempenho e desacoplamento perde sua força. Isso confere aos desenvolvedores maior liberdade para priorizar a manutenibilidade, a redução da complexidade e o baixo acoplamento, sem sacrificar a experiência do usuário. Contudo, o estudo possui limitações, pois os testes foram realizados em ambiente local com payloads de dados reduzidos, o que pode não refletir integralmente cenários de produção com latência de rede e volumes de dados maiores. Sugere-se que estudos futuros repliquem este modelo, incorporando simulações de degradação de rede e payloads mais densos para validar a resiliência das estratégias em condições de estresse, aprimorando a generalização dos achados. Concluiu-se que a escolha da estratégia ideal deve ser contextual e equilibrar consistência, flexibilidade e, sobretudo, a sustentabilidade arquitetural.

Referências Bibliográficas

Antunes, F. et al. Investigating Benefits and Limitations of Migrating to a Micro-Frontends Architecture. In: SBES 24, 2024, Curitiba. Anais… Curitiba, PR: 2024. Disponível em: https://doi.org/10.5281/zenodo.10951484.

Bass, L.; Clements, P.; KAZMAN, R. Software architecture in practice. 3. ed. Upper Saddle River: Addison-Wesley, 2013.

Campbell, G. A. Cognitive complexity: a new way of measuring understandability. Geneva: SonarSource, 2023. Disponível em: https://www.sonarsource.com/docs/CognitiveComplexity.pdf. Acesso em: 7 fev. 2026.

Fowler, M.; Lewis, J. Microservices: a definition of this new architectural term. [S. I.]: MartinFowler.com, 2014. Disponível em: https://martinfowler.com/articles/microservices.html. Acesso em: 7 fev. 2026.

Geers, M. Micro frontends in action. Shelter Island: Manning Publications, 2020.

Georges, A.; Buytaert, D.; Eeckhout, L. Statistically rigorous Java performance evaluation. In: ACM SIGPLAN CONFERENCE ON OBJECT-ORIENTED PROGRAMMING SYSTEMS, LANGUAGES, AND APPLICATIONS (OOPSLA), 22., 2007, Montreal. Proceedings […]. New York: ACM, 2007. p. 57-76.

Gil, A. C. Como elaborar projetos de pesquisa. 4. ed. São Paulo: Atlas, 2002.

Gil, A. C. Métodos e técnicas de pesquisa social. 6. ed. São Paulo: Atlas, 2008.

Holland, I.; Lieberherr, K. Assuring good style for object-oriented programs. IEEE Software, Los Alamitos, v. 6, n. 5, p. 38-48, set. 1989.

Jain, R. The art of computer systems performance analysis: techniques for experimental design, measurement, simulation, and modeling. New York: John Wiley & Sons, 1991.

Lazzari, L.; Farias, K. An exploratory study on the effects of event-driven architecture on software modularity. 27 out. 2021.

Martin, R. C. Clean architecture: a craftsman’s guide to software structure and design. Boston: Prentice Hall, 2017.

Mccabe, T. A complexity measure. IEEE Transactions on Software Engineering, Los Alamitos, v. SE-2, n. 4, p. 308-320, dez. 1976.

Newman, S. Building microservices: designing fine-grained systems. 2. ed. Sebastopol: O’Reilly Media, 2021.

Ocariza, F. et al. An empirical study of client-side JavaScript bugs. In: INTERNATIONAL SYMPOSIUM ON EMPIRICAL SOFTWARE ENGINEERING AND MEASUREMENT (ESEM), 2013, Baltimore. Proceedings […]. New York: IEEE, 2013. p. 55–64.

Pavlenko, A. et al. Micro-frontends: application of microservices to web front-ends. Journal of Internet Services and Information Security (JISIS), v. 10, n. 2, p. 49–66, maio 2020.

Peltonen, S.; Mezzalira, L.; Taibi, D. Motivations, benefits, and issues for adopting MFEs: A Multivocal Literature Review. Information and Software Technology, v. 136, p. 106571, 1 ago. 2021.

Sampieri, R. H.; Collado, C. F.; Lucio, P. B. Metodologia de pesquisa. 3. ed. São Paulo: McGraw-Hill, 2006.

Stevens, C. et al. Structured design. IBM Systems Journal, Armonk, v. 13, n. 2, p. 115-139, 1974.

Steyer, M. Micro Frontends and Moduliths with Angular. 2024.

Zhang, H. et al. Research and Application of Micro Frontends. IOP Conference Series: Materials Science and Engineering, v. 490, n. 6, p. 062082, 1 abr. 2019.

Artigo oriundo de Trabalho de Conclusão de Curso da Especialização em Engenharia de Software do MBA USP/Esalq

Para saber mais sobre o curso, clique aqui e acesse a plataforma MBX Academy