Artigos para desenvolvedores

Codificação

Base64: para que serve a codificação e como funciona

Como o Base64 transforma dados binários em texto ASCII e quando isso é realmente necessário.

Base32: em que difere do Base64 e quando é mais prático

O alfabeto do Base32, que não diferencia maiúsculas de minúsculas, e os casos em que é mais prático que o Base64.

URL Encode/Decode: o percent-encoding em links

Como caracteres especiais em endereços e parâmetros se tornam sequências %XX.

HTML Entities: como exibir caracteres especiais com segurança

Por que os caracteres < > & precisam ser escapados e como isso evita que a marcação quebre.

JWT: a estrutura do token e o que significa "decodificar" um JWT

O header, o payload e a signature de um JWT, e por que decodificar não é o mesmo que verificar a assinatura.

Unicode Escape: o que significam as sequências \uXXXX

De onde vêm sequências como \u0041 em JSON e strings JS, e o que significam.

ROT13 e a cifra de César: substituição simples de caracteres

Por que um deslocamento de 13 letras torna o ROT13 autoinverso, e por que ainda se usa hoje.

Punycode: como os domínios internacionalizados funcionam no DNS

Como um domínio com caracteres não latinos se torna uma forma ASCII com o prefixo xn--.

Código Morse: como o texto se transforma em pontos e traços

O princípio de codificar letras em pontos e traços, e onde o Morse ainda é usado hoje.

Data URI: quando incorporar imagens diretamente no código

Como um Data URI incorpora o conteúdo de um arquivo diretamente em HTML ou CSS, e quando vale a pena.

Gzip + Base64: comprimir dados para transmitir como texto

Por que dados binários comprimidos também são codificados em Base64 antes de irem para um campo de texto.

XML Entities: escapar caracteres em documentos XML

As cinco entidades XML obrigatórias sem as quais o documento quebra ao ser analisado.

JSON

JSON Formatter: formatar, minificar e validar

Formatar para legibilidade, minificar para tamanho, validar para correção — três tarefas diferentes com JSON.

JSONPath: buscar dados em JSON sem analisar manualmente

Como o JSONPath permite extrair os valores necessários de um JSON grande com uma única expressão, sem percorrê-lo manualmente.

JSON Diff: em que a comparação estrutural difere da textual

Por que a ordem das chaves não deveria afetar a comparação de dois documentos JSON.

JSON Schema: como descrever e validar a estrutura de um JSON

Como o JSON Schema permite verificar automaticamente se os dados atendem a um contrato esperado.

JSON Flatten: transformar uma estrutura aninhada em uma lista plana

Como um JSON profundamente aninhado se transforma numa lista plana de chaves como user.address.city.

JSON Sort Keys: por que ordenar as chaves de um objeto

Por que a ordem das chaves em JSON não é especificada, mas ordená-las continua útil na prática.

JSON Repair: por que o JSON quebra e como consertá-lo

Causas comuns de JSON "quebrado" e o que um reparo automático consegue ou não corrigir.

Mock JSON Generator: para que servem dados fictícios

Como dados fictícios permitem começar a construir uma interface antes de o backend estar pronto.

JSON ↔ YAML/CSV/XML/TOML: quando e por que converter

Que dados se perdem ao converter JSON em CSV e por que YAML e TOML são populares para arquivos de configuração.

Texto

Case Converter: por que existem estilos de nomenclatura diferentes

Por que um mesmo projeto escreve variáveis em camelCase mas arquivos em kebab-case, e de onde vêm essas regras.

Text Diff: como os algoritmos encontram a diferença entre dois textos

Como um algoritmo de diff encontra o conjunto mínimo de mudanças entre duas versões de um texto.

Expressões regulares: sintaxe básica e padrões comuns

Como ler uma expressão regular e em que a correspondência gananciosa difere da preguiçosa.

Ordenar e remover linhas duplicadas: para que serve

Por que uma ordenação numérica que coloca "10" antes de "9" é um erro, e como evitá-lo.

String Escape: por que o mesmo texto precisa ser escapado de forma diferente

Por que a mesma aspa é escapada de forma diferente numa string JS, em JSON e num comando shell.

CRLF contra LF: por que os caracteres de fim de linha ainda importam

Por que um arquivo escrito no Windows pode aparecer como "totalmente alterado" no git em Linux.

Contar caracteres e palavras: por que nem sempre é trivial

Por que um emoji ou uma letra acentuada podem contar como vários caracteres de uma vez.

Lorem Ipsum: de onde vem o texto de preenchimento e para que serve

Por que os designers usam deliberadamente texto "sem sentido" em vez de conteúdo real em mockups.

Slugify: como transformar qualquer texto numa URL

Como um título como "Olá, Mundo!" se transforma numa string compatível com URL como ola-mundo.

Markdown: por que uma sintaxe de texto simples venceu editores ricos

Por que desenvolvedores preferem escrever documentação em Markdown em vez de num editor de texto rico.

Espaços e caracteres invisíveis: a causa oculta de bugs estranhos

Por que duas strings aparentemente idênticas podem não coincidir por causa de um caractere invisível.

Text Reverse: por que "inverter um texto" é mais difícil do que parece

Por que uma inversão ingênua de string pode transformar um emoji em bytes inutilizáveis.

Análise de frequência de texto: para que serve contar repetições de palavras

Como a frequência das letras num texto cifrado ajuda a quebrar as cifras de substituição mais simples.

Hashes/Cripto

Hash Generator: em que MD5, SHA-1 e SHA-256 diferem entre si

Por que o MD5 ainda é usado para verificar a integridade de arquivos, mas não para senhas.

Checksum Verifier: como verificar que um arquivo não está corrompido

Por que um checksum coincidente confirma a integridade de um arquivo, mas não quem o criou.

HMAC: em que um hash com chave difere de um hash comum

Por que um SHA-256 comum não protege contra a adulteração de uma mensagem, mas o HMAC sim.

Bcrypt: por que as senhas são hasheadas devagar, não rápido

Por que um SHA-256 rápido é uma má escolha para senhas, e um bcrypt lento é a certa.

UUID: como são gerados identificadores que quase nunca se repetem

Por que um UUID v4 pode ser gerado de forma independente em milhões de máquinas sem risco de colisão.

Gerador de senhas: o que realmente torna uma senha forte

Por que uma senha longa feita de palavras de dicionário é mais forte que uma curta com símbolos e números.

AES: como funciona a criptografia simétrica

Por que a mesma chave cifra e decifra os dados no AES, e como isso difere da criptografia assimétrica.

Argon2: por que esse algoritmo venceu a competição de hashing de senhas

Como o Argon2 se defende melhor contra ataques com GPU do que algoritmos de hashing de senhas mais antigos.

Scrypt: por que o algoritmo precisa de tanta memória

Por que o scrypt exige deliberadamente muita memória para dificultar a quebra em dispositivos ASIC.

TOTP: como funcionam os códigos de uso único em apps autenticadores

Por que o código do Google Authenticator funciona sem internet e se sincroniza com o servidor apenas pela hora.

PBKDF2: o padrão mais antigo de alongamento de chave

Por que o número de iterações recomendado para o PBKDF2 cresce a cada ano.

X.509: o que há dentro de um certificado SSL

O que exatamente o navegador verifica no certificado de um site antes de mostrar o cadeado verde.

PGP: como funciona a criptografia de chave pública e privada

Por que se pode compartilhar livremente uma chave pública PGP, mas nunca a privada.

Tempo/Números

Tempo Unix: por que os computadores contam o tempo desde 1970

Por que 1º de janeiro de 1970 se tornou o ponto de referência do tempo para a maioria dos sistemas de computador.

Expressões cron: como decifrar um agendamento de tarefas

Como decifrar uma expressão como */15 * * * * e saber exatamente quando a tarefa será executada.

Sistemas numéricos: para que servem o binário, o octal e o hexadecimal

Por que a cor #FF5733 no CSS é escrita com dígitos hexadecimais em vez de decimais.

Operações bit a bit: como AND, OR e XOR funcionam no nível dos bits

Em que o AND bit a bit difere do lógico, e para que serve operar sobre bits individuais de um número.

Diferença entre datas: por que contar dias é mais complicado do que parece

Por que subtrair datas de forma ingênua pode dar um resultado incorreto por causa dos anos bissextos.

Cálculo de idade: por que não é uma simples subtração de anos

Por que simplesmente subtrair os anos de nascimento pode dar uma idade um ano maior que a real.

Fusos horários: por que UTC não é a mesma coisa que GMT

Por que UTC nunca muda duas vezes ao ano, enquanto o horário de Londres (GMT/BST) muda.

Calculadora de duração: como somar corretamente horas, minutos e segundos

Por que ao somar minutos e segundos é preciso "transportar" o resto para a próxima casa, assim como na soma decimal.

ISO 8601 Duration: como escrever uma duração em formato padrão

Por que PT1H30M significa «1 hora 30 minutos», e não «1 minuto 30 horas».

Número da semana: por que países diferentes contam as semanas de forma diferente

Por que 1º de janeiro às vezes pertence à semana 52 ou 53 do ano anterior segundo o padrão ISO 8601.

Números romanos: como funciona um sistema sem zero nem posições

Por que IV significa 4 e não 6, e como funciona a regra de subtração nos números romanos.

IEEE 754: por que 0.1 + 0.2 não é igual a 0.3 no código

Por que em quase toda linguagem de programação 0.1 + 0.2 exibe 0.30000000000000004.

Número por extenso: para que transformar dígitos em palavras

Por que documentos bancários escrevem o valor tanto em dígitos quanto por extenso ao mesmo tempo.

Rede/HTTP

Análise de URL: quais partes compõem um endereço web

Por que uma URL tem uma parte depois do símbolo # que o servidor nem chega a receber.

Query String vs. JSON: por que os parâmetros GET são tão limitados

Por que passar um array ou um objeto aninhado pela query string de uma URL não é tão simples quanto com JSON.

User-Agent: por que essa string é tão confusa

Por que Chrome, Safari e Edge contêm ao mesmo tempo as palavras "Mozilla" e "Safari" no User-Agent.

Basic Authentication: como funciona a forma mais simples de proteger um recurso HTTP

Por que o Basic Auth exige obrigatoriamente HTTPS, já que Base64 é codificação, não criptografia.

Cabeçalhos HTTP: o que está escondido em cada requisição e resposta

Por que o cabeçalho Content-Type determina como o navegador interpreta o corpo da resposta do servidor.

Cookies: como um pequeno pedaço de texto mantém o estado de uma sessão

Por que o atributo HttpOnly protege um cookie contra roubo por meio de JavaScript malicioso.

CORS: por que o navegador bloqueia requisições "normais" para outro domínio

Por que um erro de CORS acontece no navegador, não no servidor, e quem realmente bloqueia a requisição.

Cabeçalhos de email: como rastrear o caminho de uma mensagem do remetente até você

Por que é preciso ler os cabeçalhos Received de baixo para cima para rastrear o caminho de uma mensagem.

SEO

Meta tags: quais realmente afetam a busca e as redes sociais

Por que um mecanismo de busca às vezes ignora sua meta description e gera seu próprio snippet a partir do texto da página.

robots.txt: como os bots de busca decidem o que podem rastrear

Por que uma regra Disallow no robots.txt não esconde uma página dos resultados de busca se outra fonte tiver um link para ela.

Sitemap.xml: por que os mecanismos de busca precisam de um mapa do site

Por que estar listado no sitemap.xml não garante que um mecanismo de busca vá indexar a página.

Favicon: por que um único ícone precisa de tantos tamanhos e formatos

Por que um único favicon.ico já não é suficiente para exibir corretamente em todos os dispositivos.

Gerando sitemap.xml: como montar um mapa do site automaticamente

Por que os mecanismos de busca em grande parte ignoram o campo priority no sitemap.xml, mesmo fazendo parte da especificação.