O bug não aparecia em nenhum notebook. Três de nós abrimos o simulador da IDE, percorremos o fluxo inteiro duas vezes e deu tudo certo. Num Android de dois anos, o mesmo build engasgou na primeira tela e depois pediu uma permissão que o simulador já tinha liberado em silêncio semanas antes. Mesmo commit, mesmo pacote. A única coisa que mudou foi onde ele rodou.
A questão é essa: o emulador não mente de propósito. É um processo de desktop, com CPU de desktop, permissões que você já aprovou e uma única versão do anfitrião, sempre atualizada. Um miniprograma real vive dentro do app de outra pessoa, num aparelho que você nunca segurou, numa versão do anfitrião que você não controla. Desempenho, diálogos de permissão e versão do anfitrião são os três buracos em que tropeçamos sempre, e são sistemáticos, não acidentes.
Onde a diferença aparece de verdade
Comece pelo desempenho. Seu notebook tem ventoinha, está na tomada e a CPU não cai de rendimento numa demo de dois minutos. Um intermediário de três anos cai, sim, e justo quando o minigame já roda faz um tempo e o aparelho esquentou. Já vimos uma tela manter os quadros estáveis no simulador e começar a perder quadros assim que o celular esquentava. O código não mudou; mudou o silício.
Permissões são mais traiçoeiras. No simulador você libera câmera ou localização no primeiro dia e esquece que aquilo existe. Usuários reais negam, bloqueiam o aviso para sempre, revogam tudo pelo sistema e te entregam um estado que seu código nunca viu. A falha quase nunca é um crash: é um mapa em branco, um upload que não faz nada, um botão morto porque um ramo assumiu consentimento.
E tem o anfitrião. Cada um publica sua biblioteca base, e as pessoas não atualizam no seu calendário. Uma API que se comporta de um jeito no runtime atual pode se comportar diferente, ou simplesmente não existir, numa versão de dois anos atrás. Se você só testa contra a mais recente, está testando contra um build que boa parte do público nunca instalou.
| Diferença | No simulador | No aparelho real | Como pegar antes |
|---|---|---|---|
| Orçamento de quadros | CPU de desktop, sem estrangulamento | O intermediário cai quando esquenta | Perfilar no celular mais barato que você suporta, depois de dez minutos de uso |
| Avisos de permissão | Liberados uma vez e esquecidos | Negação, bloqueio permanente, revogação do sistema | Instalação limpa com todas as permissões revogadas antes de cada passada |
| Biblioteca base do anfitrião | Sempre a mais recente | Usuários presos em versões de anos atrás | Fixar uma versão mínima e deixar um aparelho nela |
| Rede | Wi-Fi do escritório, sem perda de pacotes | Sinal fraco, portais cativos, quedas no meio da requisição | Limitar a um perfil lento e cortar a conexão durante o carregamento |
| Armazenamento | Limpa quando você quer | Limites de cota e limpezas que você não provocou | Encher o cache e medir a partida a frio |
| Entrada | Cliques de mouse precisos | Dedos grandes, deslizes na borda, entalhes da tela | Passar o celular para alguém que nunca viu o design |
O que custa uma matriz de aparelhos de verdade
Não vamos fingir que a resposta é «teste em aparelhos reais» e pronto. Uma matriz com cinco anfitriões, três versões de sistema e um punhado de celulares baratos é cara de comprar e chata de manter: carregados, atualizados e logados em contas reais. As fazendas de dispositivos na nuvem ajudam, mas não são a mesma coisa que um telefone com conexão instável na mão de alguém, e a conta sobe a cada combinação que você adiciona.
Automação também tem teto. Dá para roteirizar toques e capturas, mas não a chave de permissão do sistema, nem um app anfitrião que se atualiza de madrugada, nem uma notificação que chega no meio do fluxo. Nossa suíte automática cobre bem o caminho feliz e mal os estados esquisitos — exatamente o contrário de onde vivem os bugs de miniprograma. Aprendemos a ler um pipeline verde como sinal de que o óbvio vai bem, não de que aquilo funciona.
E tem problema que só existe quando chega tráfego real. Um rollout gradual do anfitrião, uma esquisitice de rede regional, um modelo que não compramos: isso aparece em releases por fatias e tickets de suporte, não no laboratório. Incomoda, porque significa que você não compra certeza com mais hardware. Só encurta a distância entre publicar algo e perceber que quebrou.
Publique pouco e depois observe
Então paramos de tentar tornar o simulador honesto e passamos a tratá-lo como o que ele é: um lugar rápido para checar lógica, não um lugar para dar o aval. O aval acontece numa matriz pequena que a gente realmente mantém: um aparelho antigo por anfitrião, um fixado na versão mínima da biblioteca base e outro que deixamos de propósito quente e entulhado. Todo o resto sai como release por fatias para um pedaço dos usuários reais, com as rotas de permissão negada e partida a frio instrumentadas antes de ampliar o rollout.
Essa ordem importa mais que a ferramenta. Pegue os bugs de lógica onde iterar é barato, os de aparelho em uns poucos celulares reais, e aceite que a última categoria só aparece em produção. Os times que se dão mal não são os que têm um laboratório modesto, e sim os que acharam que um simulador limpo queria dizer que tinham terminado.
Fontes
- Documentação do framework de Mini Programs do WeChat — onde o simulador, a depuração em aparelho e as versões da biblioteca base são descritos.
- Documentação para desenvolvedores de Mini Programs do Alipay — outra IDE com seu próprio fluxo de preview: é aí que as diferenças começam.
- Documentação do Chrome DevTools — inspeção remota e painéis de desempenho que vale copiar para medir no celular.
- Documentação do Taro — como um único código vira builds por anfitrião e ramificações condicionais.