DEV Community: Mateus Bougleux

[Boost]

Mateus Bougleux — Sat, 15 Feb 2025 06:43:32 +0000

Minimal VSCode: How I Crafted a Clean, Keyboard-Driven Coding Setup

Mateus Bougleux — Fri, 31 Jan 2025 03:49:36 +0000

Hey everyone! Let’s talk about productivity hacks. Today, I’m sharing how I transformed my vscode into a minimalist powerhouse—stripping away distractions, optimizing workflows, and embracing keyboard shortcuts so much that my mouse now collects dust (rsrsrs)

Github-Repo

Why Minimalism Matters

Let’s face it: we spend hours staring at our editors. Why not make that time as pleasant and efficient as possible? My goal was simple: remove the noise. Status bar? Hidden. Tab clutter? Eliminated. The result? A Zen-like interface that feels like coding in a distraction-free zone.

Fonts: Where Readability Meets Personality

Fonts aren’t just about aesthetics—they’re about reducing eye strain and staying in the flow. After testing dozens, here’s my top trio:

MonoLisa (current obsession): Crisp, modern, and oddly satisfying.
JetBrains Mono (old reliable): Balanced and battle-tested.
DankMono (wildcard): For those who like a touch of flair.

Apc Customize UI++

Want to turn VSCode into a minimalist dream? Meet Apc Customize UI++. This extension is a game-changer. With it, you can:

✅ Hide UI elements
✅ Tweak margins and spacing
✅ Create a truly yours editor

Dark Mode FTW (Mostly)

Color themes set the mood. Here’s my lineup:

One Dark Pro

My ride-or-die theme. Smooth, easy on the eyes, and perfect for late-night sessions. I’ve tried alternatives, but nothing dethrones this one.
GitHub Theme

For light mode lovers: clean and familiar. The dark version is decent, but One Dark Pro still wins my heart.

Shortcuts & Layouts

This is where the magic happens. My setup revolves around minimizing mouse dependency. Here’s how:

⌨️ Shortcut Philosophy

Everything at your fingertips: Toggle terminal, navigate files, and Copilot with keystrokes.
Proximity is key: I map shortcuts close to the home row to avoid finger gymnastics.

The 75% Keyboard Sweet Spot

After testing 60%, TKL, and full-size boards, I settled on a 75% layout. Why?

It keeps Home, End, Pg Up/Dn accessible—critical for code navigation.
Compact but not cramped (my hands aren’t tiny, but stretching a finger works!).

Smaller layouts forced me into awkward combos (looking at you, 60% 😒). Your mileage may vary, but find what lets you code without friction.

Screenshots

Less Really Is More

This setup isn’t just about looks—it’s about flow. Fewer distractions mean deeper focus. Yes, adapting to shortcuts takes time, but the payoff is worth it.

Your turn! What’s your editor setup like? Any killer extensions or themes I should try? Let’s geek out in the comments! 👇

Optimizing Performance in PHP Applications

Mateus Bougleux — Thu, 30 Jan 2025 03:25:01 +0000

When we are programming, regardless of the language, there are concepts and techniques we can adopt to improve both the readability and understanding of the code, as well as the performance of the application.

The biggest lesson here is: don't try to reinvent the wheel. As I always say: study and research. Most likely, someone has already faced the same problem as you and found an efficient solution. Leveraging the knowledge accumulated by the community not only saves time but also helps avoid common pitfalls and errors.

Queries and Databases

On this topic, which is very important in applications, I have already written a bit, and it's worth a read.

Optimizing Data Persistence and Reading in MySQL and Application

Performance Optimization Techniques

In addition to queries and databases, there are other fundamental areas to optimize applications. Let's highlight some:

Cache
The use of cache is essential to reduce the load on the database by temporarily storing data that is frequently accessed. The community widely uses Redis for this purpose.

Redis is an in-memory NoSQL database, highly performant but volatile, as memory is not persistent. It is ideal for cases such as:

Real-time consumption data
User sessions
Shopping carts

Laravel abstracts the use of Redis very well, both for caching and for other purposes. However, use it with caution! Perform many tests and learn about failover techniques to handle possible unavailability. For example, if your real-time dashboard depends on Redis, what will you do if it becomes inoperative? Planning alternatives is crucial.

Code Optimizations

Some important points when talking about code optimization:

Loops: Not always replacing for with foreach will improve performance. Although the code may become more readable, it is essential to test using tools like Xdebug or simple functions like microtime() to validate the real impact. Pay attention to data manipulation inside the loop and avoid memory waste.
Native Operations: Using native PHP functions, such as array_map, is generally safer and more efficient than creating custom solutions. Remember: "No need to reinvent the wheel."
Minimize Loop Operations: Avoid creating unnecessary nested loops. A nested foreach can be as harmful as a SELECT *. Instead, consider alternative solutions, such as rewriting the logic or using more efficient queries to reduce complexity.
PSR (PHP Standards Recommendations): Adhering to PSR practices improves code readability and maintainability. Today, IDEs offer extensions that automate the application of these standards when saving changes. This not only helps in code quality but also makes life easier for those who will maintain it in the future.
Queues: The use of queues is becoming increasingly common. The idea is simple: if the processing of a task can be done later, remove it from the immediate execution of the method.
Example:
When a user makes a purchase on an e-commerce site, is it necessary to send the confirmation email instantly? Often, no. In this case, you can send the email to a queue, which will be processed in batches, saving resources and ensuring scalability.

Sub-Processes: It's not a silver bullet, but depending on the situation, it can be implemented and is worth it.
Example:
Imagine an application responsible for processing hundreds of invoices simultaneously, calculating taxes for each one. If all these operations are performed sequentially, you may face slow performance alerts, even with computational resources to spare (CPU and RAM).
In this case, subprocesses can be a solution. Divide the processing into small parts and execute them in parallel. For example, each subprocess can be responsible for calculating taxes for a group of invoices. This allows your application to make better use of available resources, speed up processing, and avoid bottlenecks.

Requires and Includes: Prefer the use of autoload to manage class and file loading. This not only improves performance but also avoids issues with large and unnecessary classes (the famous "megazords"). For example, loading a class with 7,000 lines just to use a method that performs a SELECT is extremely inefficient. In these situations, it is important to consider refactoring.

About the megazord, it's worth a chat about Refactoring.

Server Optimizations

The first thing you need to know is that PHP is a very lightweight language. Under normal conditions, with a machine suitable for the number of requests and with the proper code optimizations, everything tends to work well.

"But Mateus, what is a machine corresponding to the number of requests?"
I have participated in the implementation and optimization of complex applications that received more than 6 million requests per day using, on average, two machines with 2 vCPUs and 2 GB of RAM each.

Now, talking about tools:

PHP-FPM
It is a FastCGI process manager for PHP, an alternative to the Apache PHP module. PHP-FPM is faster, more flexible, and widely used in production.
OpCache
A caching system for PHP scripts. It stores pre-compiled PHP code in memory, allowing PHP to execute faster, reducing execution time and resource consumption.
Keep Versions Updated
It is crucial to keep packages, tools, frameworks, and the PHP language as up-to-date as possible. I understand that, often, the effort to migrate from an older version, such as PHP 7.4, to a newer one, such as PHP 8.x, may seem high. However, the benefits in terms of performance, security, and support are worth the effort.

Important Considerations:
Pay special attention to the configuration of threads and child processes. Setting values too high for these configurations or allowing the use of large files can overload the machine, leading to failures and unavailability. Always adjust these configurations according to the machine's capacity and the application's actual requirements.

Monitoring

One of the most important items when talking about optimizations is understanding what needs to be optimized. For this, a good APM (Application Performance Monitoring) tool can provide valuable insights, in addition to allowing preventive actions before problems become critical.

There are several approaches to monitoring, from manually searching PHP logs to automated solutions. Among the automated tools, the following stand out:

New Relic
DataDog

These tools are known as "plug and play": just install the agent, restart the service, and configure the dashboards to create metrics and alerts.

On the other hand, there are more manual options that, although requiring more effort and knowledge from the team, may be worth it depending on the context:

Prometheus + Grafana
Elastic Stack

The challenge in using these manual tools lies in the complexity they add, especially in robust applications without a dedicated support team. These solutions require a lot of configuration, rigorous testing, and care to avoid negatively impacting performance. Additionally, they need layers and layers of failover—just one redundancy machine is often not enough.

Despite this, implementing and testing these tools can be a great challenge for a weekend!

In most cases, tools like New Relic offer a great starting point, providing significant capacity to prevent catastrophes. However, it is important to be aware of the cost, which can become significant depending on usage.

Maximizando a aplicação — PHP

Mateus Bougleux — Thu, 30 Jan 2025 03:10:53 +0000

Quando estamos programando, independentemente da linguagem, existem conceitos e técnicas que podemos adotar para melhorar tanto a legibilidade e o entendimento do código quanto o desempenho da aplicação.

O maior aprendizado aqui é: não tente reinventar a roda. Como eu sempre digo: estude e pesquise. Muito provavelmente, alguém já enfrentou o mesmo problema que você e encontrou uma solução eficiente. Aproveitar o conhecimento acumulado pela comunidade não apenas economiza tempo, mas também ajuda a evitar armadilhas e erros comuns.

Queries e Banco de Dados

Sobre esse assunto, que é muito importante nas aplicações, eu já escrevi um pouco, vale a pena dar uma lida.

Otimizando Persistência e Leitura de dados no MySQL e Aplicação

Técnicas de Otimização de Performance

Além de queries e banco de dados, existem outras áreas fundamentais para otimizar aplicações. Vamos destacar algumas:

Cache
O uso de cache é essencial para reduzir a carga no banco de dados, armazenando temporariamente dados que são acessados frequentemente. A comunidade utiliza amplamente o Redis para esse propósito.

O Redis é um banco de dados NoSQL em memória, altamente performático, mas volátil, já que a memória não é persistente. Ele é ideal para casos como:

Dados de consumo em tempo real
Sessões de usuários
Carrinhos de compra

O Laravel abstrai muito bem o uso do Redis, tanto para cache quanto para outras finalidades. No entanto, use-o com cautela! Realize muitos testes e aprenda sobre técnicas de failover para lidar com possíveis indisponibilidades. Por exemplo, se seu dashboard em tempo real depende do Redis, o que você fará se ele ficar inoperante? Planejar alternativas é crucial.

Otimizações de código

Alguns pontos importante quando falamos sobre otimização de escrita de código:

Loops: Nem sempre substituir for por foreach vai melhorar o desempenho. Embora o código possa ficar mais legível, é essencial testar usando ferramentas como o *Xdebug * ou funções simples como microtime() para validar o impacto real. Preste atenção na manipulação de dados dentro do loop e evite desperdício de memória.
Operações Nativas: Utilizar funções nativas do PHP, como array_map, geralmente é mais seguro e eficiente do que criar soluções personalizadas. Lembre-se: "Não precisa reinventar a roda".
Minimize operações em Loop: Evite criar loops dentro de loops desnecessariamente. Um foreach aninhado pode ser tão prejudicial quanto um SELECT *. Em vez disso, considere soluções alternativas, como reescrever a lógica ou usar queries mais eficientes para reduzir a complexidade.
PSR (PHP Standards Recommendations): Aderir às práticas da PSR melhora a legibilidade e a manutenção do código. Hoje, IDEs oferecem extensões que automatizam a aplicação desses padrões ao salvar alterações. Isso não apenas ajuda na qualidade do código, mas também facilita a vida de quem dará manutenção no futuro
Filas: O uso de filas (queues) é cada vez mais comum. A ideia é simples: se o processamento de uma tarefa pode ser feito posteriormente, remova-a da execução imediata do método.
Exemplo:
Quando um usuário faz uma compra no e-commerce, é necessário enviar o e-mail de confirmação instantaneamente? Muitas vezes, não. Nesse caso, você pode enviar o e-mail para uma fila, que será processada em lotes, economizando recursos e garantindo escalabilidade.

Sub-Processos: Não é bala de prata, mas dependendo da situação pode ser implementado e vale a pena.
Exemplo:
Imagine uma aplicação responsável por processar centenas de notas fiscais simultaneamente, calculando impostos para cada uma. Se todas essas operações forem realizadas em sequência, você poderá enfrentar alertas de lentidão, mesmo com recursos computacionais sobrando (CPU e RAM).
Nesse caso, subprocessos podem ser uma solução. Divida o processamento em pequenas partes e execute-as em paralelo. Por exemplo, cada subprocesso pode ser responsável por calcular impostos para um grupo de notas fiscais. Isso permite que sua aplicação aproveite melhor os recursos disponíveis, acelere o processamento e evite gargalos.

Requires e includes: Prefira o uso de autoload para gerenciar carregamento de classes e arquivos. Isso não só melhora o desempenho como evita problemas com classes grandes e desnecessárias (os famosos “megazords”). Por exemplo, carregar uma classe com 7.000 linhas apenas para usar um método que faz um SELECT é extremamente ineficiente. Nessas situações, é importante considerar uma refatoração.

Sobre o megazord, vale a pena um papo sobre Refatoração.

Otimizações de servidor

A primeira coisa que você precisa saber é que o PHP é uma linguagem muito leve. Em condições normais de temperatura e pressão, com uma máquina adequada à quantidade de requisições e com as devidas otimizações no código, tudo tende a funcionar bem.

“Mas Mateus, o que é uma máquina correspondente à quantidade de requisições?”
Já participei da implementação e otimização de aplicações complexas que recebiam mais de 6 milhões de requisições por dia utilizando, em média, duas máquinas com 2 vCPUs e 2 GB de RAM cada.

Agora, falando sobre ferramentas:

PHP-FPM
É um gerenciador de processos FastCGI para PHP, uma alternativa ao módulo PHP do Apache. O PHP-FPM é mais rápido, flexível e amplamente utilizado em produção.
OpCache
Um sistema de cache para os scripts PHP. Ele armazena o código PHP pré-compilado na memória, permitindo que o PHP execute com maior rapidez, reduzindo o tempo de execução e o consumo de recursos.
Manter as versões atualizadas
É fundamental manter os pacotes, ferramentas, frameworks e a linguagem PHP o mais atualizados possível. Entendo que, muitas vezes, o esforço para migrar de uma versão mais antiga, como o PHP 7.4, para uma mais recente, como o PHP 8.x, pode parecer alto. Porém, os benefícios em termos de desempenho, segurança e suporte valem o esforço.

Cuidados importantes:
Tenha atenção especial à configuração de threads e child processes (processos filhos). Definir valores muito altos para essas configurações ou permitir o uso de arquivos grandes pode sobrecarregar a máquina, levando a falhas e indisponibilidades. Sempre ajuste essas configurações de acordo com a capacidade da máquina e os requisitos reais da aplicação.

Monitoramento

Um dos itens mais importantes quando falamos sobre otimizações é entender o que precisa ser otimizado. Para isso, uma boa ferramenta de monitoramento no nível de APM (Application Performance Monitoring) pode fornecer informações valiosas, além de permitir ações preventivas antes que os problemas se tornem críticos.

Existem várias abordagens para monitoramento, desde a busca manual em logs do PHP até soluções automatizadas. Entre as ferramentas automatizadas, destacam-se:

New Relic
DataDog

Essas ferramentas são conhecidas como “plug and play”: basta instalar o agente, reiniciar o serviço e configurar os painéis para criar métricas e alertas.

Por outro lado, existem opções mais manuais que, embora exijam maior esforço e conhecimento da equipe, podem valer a pena dependendo do contexto:

Prometheus + Grafana
Elastic Stack

O desafio em utilizar essas ferramentas manuais está na complexidade que elas adicionam, especialmente em aplicações robustas sem um time dedicado para sustentação. Essas soluções demandam muita configuração, testes rigorosos e cuidado para evitar que os agentes impactem negativamente o desempenho. Além disso, elas precisam de camadas e camadas de failover — apenas uma máquina de redundância muitas vezes não é suficiente.

Apesar disso, implementar e testar essas ferramentas pode ser um ótimo desafio para um final de semana!

Na maioria dos casos, ferramentas como o New Relic oferecem um ótimo ponto de partida, proporcionando grande capacidade para prevenir catástrofes. No entanto, é importante ficar atento ao custo, que pode se tornar significativo dependendo do uso.

Docker: A Week or a Few Hours

Mateus Bougleux — Thu, 30 Jan 2025 02:58:29 +0000

Starting a new project always comes with a mix of excitement and hesitation. Will the code run? Will the environment cooperate? And most importantly: how long will it take until everything is up and running?

That’s exactly how I found myself facing a new repository, surrounded by an equally new team. Before I even wrote a single line of code, I was given a warning:

— It took me a week to get this project running on my machine. It works in production, though. I’ve never changed anything there.

Nothing like a little motivation before getting started, right? I took a deep breath and did what any rational person would do: I opened the README.md. Not much information. Okay, plan B: check language versions, dependencies, tools. Incompatible versions, conflicting packages, a festival of minor roadblocks. Three-quarters of the day spent, and still, the application wouldn't run.

Then it hit me: with everything I had already changed and installed, how could I be sure I was on the right track? What if, instead of fighting the environment, I simply dockerized it?

That’s the real power of containers: predictability. I can break everything as many times as I want and always have a clean environment to start over. A few hours later, the application was running. Not perfectly, but it worked. A bit more effort, and I had something presentable, a first step toward building a solid and reliable environment.

Docker is a tool for standardization, automation, and easier deployments. But it’s also a great ally in experimentation and learning. It allows us to fail without fear, to test, to optimize. And at the end of the day, it doesn’t matter whether it took seven days or just a few hours—what matters is that now, the project runs.

Geoespacial no Laravel: Otimizações para Mapas Interativos e Grandes Volumes de Dados

Mateus Bougleux — Wed, 29 Jan 2025 14:48:17 +0000

Com mais de 7 milhões de registros e a necessidade de transformar dados em insights acionáveis, como podemos utilizar tecnologias geoespaciais para criar mapas interativos eficientes? Neste artigo, exploramos como Laravel e MySQL podem enfrentar esse desafio de maneira escalável e eficaz.

O Desafio Inicial

O projeto surgiu com a seguinte demanda: “Temos mais de 7 milhões de registros em uma tabela no MySQL e queremos gerar valor com esses dados.”

A primeira coisa que muitas pessoas pensam é: “Qual linguagem usar para construir a aplicação?” Contudo, frequentemente esquecemos o artefato mais crucial nesse tipo de situação: o banco de dados. Será que ele aguenta a demanda? Preciso migrar? Mudar a estrutura? Será que o MySQL é capaz de lidar com essa carga?

Minha resposta inicial foi: “Provavelmente, o MySQL consegue resolver isso.” Mas antes de mergulhar no desafio do polígono (que é uma história à parte), precisamos entender como o MySQL lidará com os filtros. Quais são os filtros necessários? Quais atributos realmente importam?

A tabela em questão tinha dezenas de atributos, mas poucos eram relevantes para a solução (como de costume). Validamos as possibilidades de preenchimento nos filtros e criamos algumas restrições para afinar as buscas.
Como estamos falando sobre mapa, presumimos que a base da busca vai ser a cidade ou algo mais específico, nesse caso eram os bairros. Sabendo disso, a partir da seleção do estado e da cidade por parte do usuário, podemos buscar todos os bairros da cidade, permitindo o uso de um select2 onde o usuário pudesse escolher a partir de uma estrutura controlada.

Assim, com o bairro preenchido, poderíamos disponibilizar outros filtros, como nomes, categorias, avaliações e outras possíveis características. Isso tornaria as buscas ainda mais precisas, oferecendo aos usuários a capacidade de encontrar exatamente o que procuram, sem comprometer a performance do sistema.

Com essa abordagem, conseguimos criar filtros dinâmicos e bem definidos, permitindo a escrita de queries mais completas e otimizadas. Além disso, com a aplicação de alguns índices adequados, garantimos especificidade nas buscas. Até aqui, o filtro estava resolvido.

Agora, o desafio do polígono. Mas antes disso, vamos falar sobre a aplicação que dá suporte a tudo isso.

A Aplicação

Sabendo da quantidade massiva de registros, mas que apenas uma fração seria renderizada simultaneamente no mapa, a aplicação foi planejada com foco na eficiência. Para isso, escolhi uma stack robusta e flexível que pra mim é (como eu normalmente digo) “Toque me voi”: Laravel e React.

Laravel
O back-end, desenvolvido com Laravel 11, utilizei o Breeze para estruturar rapidamente a base do projeto e permitir foco nas funcionalidades críticas. Além da arquitetura MVC padrão, adicionei camadas de Service e Repository para organizar responsabilidades e facilitar a manutenção do código.

React
No front-end, a aplicação foi totalmente modularizada com React. Componentes bem definidos e o uso de partials garantiram a reutilização de elementos e um fluxo claro de comunicação entre as partes do sistema. Essa organização permitiu que o front-end se comunicasse eficientemente com o back-end através de requisições Axios, garantindo simplicidade e eficiência.

Vale Saber

Embora o projeto fosse inicialmente interno e de baixa demanda, a arquitetura foi projetada para possibilitar escalabilidade futura, como o uso de serviços independentes na AWS com por exemplo, Fargate para a API e CloudFront para o front-end.

Essa arquitetura é possível porque toda a interação acontece via API, e o serviço não mantém estado no lado do servidor, o que facilita a separação de responsabilidades.

Testes

A estabilidade do sistema foi garantida com uma suíte de testes robusta, implementada em Pest, cobrindo 22 endpoints com cerca de 500 testes. Adotar uma abordagem orientada a testes trouxe confiança nos deploys e eficiência na manutenção, mostrando o valor indispensável dessa prática no desenvolvimento de software escalável e confiável.

O core da aplicação

A parte central da aplicação gira em torno do mapa. Para gerenciar essa funcionalidade, utilizei o Leaflet, uma biblioteca leve e poderosa para manipulação de mapas, complementada por alguns pacotes que trouxeram mais eficiência e recursos.

Clusterização de Markers
Uma das principais otimizações foi feita com o pacote react-leaflet-markercluster, que permite agrupar os markers em clusters dinâmicos. Como a aplicação lida com um grande número de pontos no mapa, tentar renderizar todos de uma só vez resultaria em uma degradação significativa de desempenho. Com a clusterização, conseguimos:

Reduzir a sobrecarga de renderização, agrupando markers próximos.
Melhorar a experiência do usuário, exibindo os pontos de forma mais limpa e organizada.
Manter a performance estável, mesmo com milhares de registros.

Desenho de Polígonos
Outro elemento crucial foi o react-leaflet-draw, utilizado para permitir que os usuários desenhem polígonos diretamente no mapa. Esse recurso possibilitou:

Capturar as coordenadas dos vértices do polígono desenhado.
Usar essas coordenadas para construir uma query no banco de dados, filtrando os registros com base na interseção dos pontos.

Integração e Usabilidade

Os filtros adicionais, como seleção de estado, cidade e bairro, foram incorporados diretamente no fluxo do mapa. Isso garantiu uma experiência intuitiva, onde o usuário pode refinar sua busca antes ou depois de desenhar o polígono.

Além disso:

Camadas personalizadas foram configuradas no Leaflet para diferenciar tipos de registros, categorias e outros atributos relevantes.
O mapa foi otimizado para lidar com lazy loading de pontos, carregando apenas os dados visíveis na área em foco, o que ajuda a reduzir a sobrecarga no cliente e no servidor.

A Tabela e Índices

A tabela utilizada é semelhante a uma tabela de usuários comum, mas com foco no endereço e uma coluna específica para armazenar os pares de coordenadas. Essas coordenadas são armazenadas em uma coluna do tipo POINT, que representa um ponto no espaço em um sistema de coordenadas geográficas ou cartesianas. Além disso, foi adicionado um índice geoespacial para otimizar as consultas.

Como Funciona o Índice Geoespacial

O índice geoespacial é uma estrutura especializada para acelerar consultas relacionadas a dados espaciais, como pontos, linhas e polígonos. No caso do MySQL, o índice espacial é implementado usando R-Tree (Regional Tree) em tabelas do tipo MyISAM ou InnoDB para colunas do tipo POINT, LINESTRING ou POLYGON.

Otimização com o Índice Geoespacial

Armazenamento Estruturado
O índice organiza os dados espaciais de forma hierárquica, dividindo-os em regiões menores que representam partes do espaço. Isso permite localizar rapidamente quais áreas são relevantes para uma consulta específica.
Consultas com Funções Espaciais
As funções espaciais do MySQL, como ST_Contains, ST_Within e ST_Intersects, utilizam o índice para identificar quais registros se encontram dentro de uma área específica, como um polígono desenhado no mapa.
Exemplo: A função **ST_Contains **verifica se um polígono contém um ponto e utiliza o índice para determinar rapidamente quais pontos estão dentro do polígono.

SELECT id, name, address
FROM users
WHERE ST_Contains(
    ST_GeomFromText('POLYGON((...))'),
    coordinates
);
-- Esse é um exemplo de escrita para buscar registros dentro de um polígono.

Nessa consulta:

ST_GeomFromText cria o polígono baseado nas coordenadas enviadas pela aplicação.
ST_Contains usa o índice geoespacial para verificar quais pontos estão dentro do polígono.

Considerações Finais

Ao concluir o projeto, alguns pontos de aprendizado e observações se destacaram. Estes detalhes podem ser úteis para quem trabalha com projetos similares e busca otimizar tanto o desempenho quanto a arquitetura das aplicações.

1. Migração das Coordenadas

As coordenadas previamente existentes estavam em colunas separadas (latitude e longitude), o que inviabilizava o uso direto do índice geoespacial. Para resolver isso:
Foi necessário criar um script que percorresse os registros e os transformasse em uma nova coluna chamada coordinates, do tipo POINT.
Esse processo garantiu a compatibilidade com o índice espacial e viabilizou a utilização das funções geoespaciais do MySQL.

2. Eficiência no JavaScript
Embora o JavaScript seja versátil, a escolha do método de iteração pode impactar a performance dependendo do contexto. Um exemplo prático:

O uso do array.map é comum por sua sintaxe limpa e funcionalidade, mas pode ser menos performático em comparação com um loop for...in dependendo da situação.
É importante analisar o caso específico e realizar testes de desempenho para determinar qual abordagem é mais eficiente.

3. Soluções Alternativas para Otimização
Sempre busque formas de melhorar a eficiência e a experiência do usuário. No contexto deste projeto, algumas técnicas foram essenciais:

Lazy Loading: Carregar os dados apenas quando eles são necessários, como ao aproximar ou mover o mapa, reduziu significativamente a carga na aplicação e no servidor.
Clusterização: Mostrar grupos de registros em vez de pontos individuais evitou a sobrecarga de renderização e melhorou a experiência de visualização no mapa.

4. Tratamentos e Validações Concretas
Um dos maiores gargalos de performance pode ser causado por retrabalhos desnecessários na busca de dados. Exemplos de boas práticas incluem atualizações localizadas, se um registro precisa ser atualizado (como o status em um relatório), execute o update no banco, e se for retornado sucesso atualize apenas o necessário no front sem buscar todo data set novamente.

Projetos como esse mostram como pequenos detalhes fazem a diferença na performance e escalabilidade de uma aplicação. Investir em otimizações direcionadas, evitar desperdícios de recursos e adotar boas práticas de desenvolvimento garante não apenas um melhor desempenho, mas também uma base sólida para crescer com o projeto.
Último mas não menos importante: Mantenha o foco na entrega.

Docker, Uma Semana ou Algumas Horas

Mateus Bougleux — Wed, 29 Jan 2025 14:35:42 +0000

Começar um projeto novo sempre vem com um misto de empolgação e receio. O código vai rodar? O ambiente vai cooperar? E, principalmente: quanto tempo vai levar até tudo estar funcionando?

Foi assim que me vi diante de um repositório novo, cercado por uma equipe igualmente nova. Antes mesmo de escrever uma linha de código, me deram um aviso:

— Demorei uma semana pra fazer esse projeto rodar na minha máquina. Em produção, já funciona. Nunca alterei nada por lá.

Nada como um pouco de motivação antes de começar, né? Respirei fundo e fiz o que qualquer pessoa racional faria: abri o README.md. Pouca informação. Ok, plano B: checar versões de linguagens, dependências, ferramentas. Versões incompatíveis, pacotes conflitantes, um festival de pequenos empecilhos. Três quartos do dia investidos e nada da aplicação funcionar.

Foi então que me ocorreu: com tudo que já alterei e instalei, como eu posso garantir que estou no caminho certo? E se, em vez de lutar contra o ambiente, eu simplesmente dockerizasse?

A grande sacada dos containers é essa: a previsibilidade. Eu posso quebrar tudo quantas vezes quiser, e sempre terei um ambiente limpo para recomeçar. Depois de algumas horas, a aplicação rodava. Não perfeitamente, mas funcionava. Um pouco mais de esforço e já havia algo digno de ser apresentado, um primeiro passo para estruturar um ambiente sólido e confiável.

Docker é ferramenta para padronizar, automatizar, facilitar deploys. Mas também é um grande aliado na experimentação e aprendizado. Ele nos permite errar sem medo, testar, otimizar. E no fim do dia, não importa se levaram sete dias ou algumas horas — o que importa é que, agora, o projeto roda.