Tags populares：
Virtualização segurança DNS verificação formal análise de alcance IA erros do compilador conflito de macro extensão web framework de desenvolvimento Gráficos de Bitmap Todos os tags

Loops de Retorno Elegantes: Evitando Redundância e Suspensões Inesperadas

2025-08-27

O autor explora como escrever um loop de retorno elegante que limita claramente o número de tentativas, evita suspensões desnecessárias após a última tentativa, relata o erro original se a tentativa falhar e evita a duplicação de código. Várias abordagens são comparadas, decidindo-se por um loop `try while` com um limite superior para garantir a terminação, resolvendo problemas de limites e potenciais loops infinitos em soluções anteriores. Embora a solução final não seja perfeita, representa uma melhoria significativa na brevidade e robustez em relação às tentativas anteriores.

Leia mais
(matklad.github.io)
Desenvolvimento

Maneira inteligente de lidar com enums parciais em Zig

2025-08-09

Zig oferece uma solução elegante para lidar com correspondência parcial em enums, evitando código redundante e pânico em tempo de execução. O artigo detalha uma técnica inteligente usando `inline` e `comptime unreachable` para permitir que o compilador verifique ramificações `else` desnecessárias em tempo de compilação, melhorando a robustez e legibilidade do código. Isso é particularmente útil ao lidar com várias variantes de enum, simplificando significativamente a lógica do código.

Leia mais
(matklad.github.io)
Desenvolvimento Verificações em tempo de compilação

A utilidade mal compreendida de `font-size-adjust`

2025-07-26

Este artigo contesta o equívoco comum em torno da propriedade CSS `font-size-adjust`. O autor argumenta que `font-size` especifica o tamanho da caixa em torno de um glifo, não o glifo em si, levando a inconsistências entre diferentes fontes. Em vez de se concentrar apenas na substituição de fontes, `font-size-adjust` pode ser usado para garantir um tamanho mais consistente em várias fontes em uma página. O autor recomenda defini-lo como `ex-height 0.53` em um reset CSS para melhor consistência tipográfica.

Leia mais
(matklad.github.io)
Desenvolvimento

Leitor RSS minimalista: Construindo um feed de blog personalizado com Deno

2025-06-26

Cansado de leitores RSS pesados? O autor adotou uma abordagem diferente, construindo um leitor RSS personalizado usando Deno e um simples arquivo de texto. Ele exibe apenas os títulos e links das três postagens mais recentes, sem armazenamento de texto completo local ou marcadores de leitura/não lidos, e é atualizado automaticamente diariamente por meio do GitHub Actions. O código é conciso, fácil de entender e estender, o sonho de um minimalista.

Leia mais
(matklad.github.io)
Desenvolvimento

Compilações Rápidas em Rust: Segredos para um CI Inferior a 10 Minutos

2025-06-20

É uma reclamação comum que o Rust compila lentamente, mas o autor argumenta que a maioria dos projetos Rust compila muito mais lentamente do que deveria. Usando o rust-analyzer (200 mil linhas de código mais um milhão de linhas de dependências) como exemplo, eles alcançaram um pipeline de CI de 8 minutos no GitHub Actions. O artigo detalha estratégias para otimizar os tempos de compilação, incluindo o aproveitamento do cache de CI, divisão de tarefas de CI, desativação da compilação incremental e informações de depuração, redução de dependências, utilização de `cargo build -Z timings` para análise de desempenho e arquitetura cuidadosa do código para evitar a instanciação excessiva de genéricos em limites de crate. O autor destaca o impacto do tempo de compilação na produtividade do desenvolvedor e recomenda otimizar regularmente os tempos de compilação para manter os tempos de CI para grandes projetos Rust em uma faixa razoável, por exemplo, cerca de 10 minutos.

Leia mais
(matklad.github.io)
Desenvolvimento Otimização de Compilação

O Problema de Coordenação de Código Aberto: Lições do Desktop Linux e LSP

2025-06-20

O autor usa sua experiência com NixOS e um aplicativo KDE como ponto de partida para discutir os desafios de coordenar software de código aberto no ambiente de desktop Linux. Ele destaca a falta de um padrão de API unificado na área de trabalho do Linux, levando a um ecossistema de software fragmentado, descrito como uma "máquina de movimento perpétuo à la Escher". Isso é contrastado com o lançamento do Protocolo de Servidor de Linguagem (LSP) pela Microsoft há uma década. Embora a implementação tenha sido medíocre, sua mera existência resolveu o problema de coordenação para recursos de IDE, impulsionando o progresso da indústria. O autor argumenta que a falta de coordenação da comunidade de código aberto levou à oportunidade perdida de criar um protocolo de IDE unificado antes do LSP. O sucesso do Linux, no entanto, é atribuído ao padrão de API predefinido fornecido pelo POSIX, reduzindo as dificuldades de coordenação. Este artigo leva à reflexão sobre os mecanismos de coordenação da comunidade de código aberto e os modelos de desenvolvimento de ecossistemas de software. Categoria: Tecnologia

Leia mais
(matklad.github.io)
Tecnologia

Duas Regras Práticas para Código Eficiente

2025-05-17

Este artigo apresenta duas dicas práticas para melhorar a eficiência do código: mover as condições `if` para cima e os loops `for` para baixo. Mover as condições `if` para a função de chamada reduz a ramificação, simplifica o fluxo de controle e melhora a legibilidade. Mover os loops `for` para onde os dados em lote são processados aproveita as vantagens do processamento em lote, melhora o desempenho e potencialmente desbloqueia a vetorização. Essas duas dicas se complementam, melhorando efetivamente a eficiência do código, especialmente ao lidar com grandes quantidades de dados.

Leia mais
(matklad.github.io)
Desenvolvimento

Além da Seleção Escalar: Processamento em Lote de Fluxos de Eventos para Eficiência

2025-05-15

O autor descreve a ineficiência do antipadrão de seleção escalar no design de serviços com estado, exemplificado por um servidor LSP. Processar eventos um de cada vez leva a atrasos e desperdício de recursos. A solução proposta é processar fluxos de eventos em lote. Uma função `batch_stream` mescla eventos recebidos em lotes, melhorando significativamente a eficiência. Sob baixa carga, ele se comporta como processamento de evento único, mas sob alta carga, reduz drasticamente a sobrecarga, aumentando o desempenho.

Leia mais
(matklad.github.io)
Desenvolvimento evento-driven

Comptime do Zig: Metaprogramação poderosa, mas contida

2025-04-20

O recurso comptime do Zig é conhecido por suas capacidades: genéricos, compilação condicional e muito mais. No entanto, ele é deliberadamente restritivo, não permitindo geração de código dinâmica, extensões de sintaxe personalizadas, informações de tipo em tempo de execução (RTTI) e E/S. Este artigo explora o raciocínio por trás dessas limitações, mostrando como o Zig consegue metaprogramação eficiente e fácil de entender por meio de avaliação parcial e especialização de tipo. Um exemplo de função de impressão personalizada demonstra como o Zig realiza reflexão em tempo de execução com segurança de tipo sem RTTI. O artigo conclui elogiando a elegância única do Zig na metaprogramação; embora menos poderoso que alternativas, é notavelmente eficiente e fácil de usar na prática.

Leia mais
(matklad.github.io)
Desenvolvimento metaprogramação comptime

Depurador como REPL: Run to Cursor e Quick Evaluate Expression do IntelliJ IDEA

2025-03-28

Cansado de depuradores tradicionais, especialmente das limitações do gdb e lldb com código nativo, o autor descobriu um fluxo de trabalho poderoso no IntelliJ IDEA. Combinando "Run to Cursor" e "Quick Evaluate Expression", o depurador se transforma em um REPL. "Run to Cursor" executa o programa até a posição do cursor, enquanto "Quick Evaluate Expression" permite avaliar expressões (mesmo código recém-digitado!) dentro do frame de pilha atual. Essa abordagem substitui a execução passo a passo por uma interação mais experimental e bidimensional dentro do editor, utilizando preenchimento de código e oferecendo uma experiência de depuração significativamente mais eficiente.

Leia mais
(matklad.github.io)
Desenvolvimento

Use opções longas em scripts

2025-03-22

Muitas utilidades de linha de comando oferecem opções curtas (-f) e opções longas (--force). Embora as opções curtas sejam convenientes para uso interativo, as opções longas são muito superiores em scripts. Sua melhor legibilidade e natureza autoexplicativa melhoram a manutenibilidade e a compreensão. Por exemplo, no Git, `git switch --create release-{today} origin/main` é significativamente mais claro do que `git switch -c my-new-branch`, especialmente em scripts complexos.

Leia mais
(matklad.github.io)
Desenvolvimento opções longas

Rust Hardcore: Um Ray Tracer sem Alocação Dinâmica de Memória

2025-01-30

Esta publicação detalha um estudo de caso sobre a escrita de um aplicativo Rust usando apenas uma API mínima, artificialmente restrita (sem alocação dinâmica de memória). O autor critica o RAII (Resource Acquisition Is Initialization) por levar a um gerenciamento de recursos desorganizado e propõe um "modo hardcore": dividir o programa em um binário `std` e uma biblioteca `#![no_std] no_alloc`, permitindo apenas que o binário solicite recursos diretamente do SO. Usando um ray tracer de brinquedo como exemplo, o autor explica meticulosamente o tratamento de buffers de pixels, paralelização, o alocador de memória e a análise de cena neste "modo hardcore", atingindo, em última análise, um ray tracer sem alocação dinâmica de memória.

Leia mais
(matklad.github.io)
Desenvolvimento

Invariantes: Uma Ferramenta Poderosa para Escrever Código Correto

2025-01-12

Este artigo explora o conceito de 'invariantes' na programação e suas aplicações. Começando com um pequeno exemplo — escrever uma variação de busca binária que calcula o ponto de inserção —, o autor demonstra como definir e manter invariantes leva a código correto. Invariantes, explica o artigo, são propriedades que se mantêm verdadeiras durante toda a evolução dinâmica de um sistema, simplificando o raciocínio ao evitar as complexidades de considerar vários caminhos de execução. Exemplos de projetos como Cargo, rust-analyzer e TigerBeetle ilustram os benefícios do uso de invariantes em sistemas grandes, como melhor manutenção e desempenho. O autor conclui resumindo a importância dos invariantes na programação em pequena e grande escala, destacando seu valor na escrita de código correto e eficiente.

Leia mais
(matklad.github.io)
Desenvolvimento técnicas de programação

Ideia revolucionária: Aplicando os princípios do Magit ao sistema de controle de versão jj

2024-12-13

O autor propõe uma abordagem inovadora: aplicar a interface de controle de versão Magit do Emacs (que usa arquivos de texto como sua interface de usuário) ao nascente ecossistema de controle de versão jj. O artigo destaca que a interface de usuário baseada em texto do Magit oferece eficiência e portabilidade. Aproveitando o protocolo LSP, uma experiência semelhante ao Magit pode ser implementada em vários editores, evitando o desenvolvimento redundante. O autor prevê a geração de arquivos de texto específicos (como .jj/status.jj) e o uso de recursos do LSP, como tokens semânticos, faixas de dobramento e ir para a definição, para alcançar operações de controle de versão semelhantes ao Magit. O objetivo final é criar uma interface de usuário eficiente e multiplataforma para o controle de versão jj.

Leia mais
(matklad.github.io)
Desenvolvimento