El bug no se reproducía en ningún portátil. Tres personas abrimos el simulador del IDE, recorrimos el flujo completo dos veces y todo salió limpio. En un Android de dos años, el mismo build se quedó colgado un instante en la primera pantalla y después pidió un permiso que el simulador había concedido en silencio semanas antes. Mismo commit, mismo paquete. Lo único que cambiaba era dónde corría.
La cosa es esta: el emulador no miente a propósito. Es un proceso de escritorio, con CPU de escritorio, permisos que ya aprobaste y una única versión del anfitrión, siempre al día. Un miniprograma real vive dentro de la app de otro, en un teléfono que nunca has tenido en la mano, con una versión del anfitrión que no controlas. Rendimiento, diálogos de permisos y versión del anfitrión son los tres agujeros en los que tropezamos una y otra vez, y son sistemáticos, no accidentes.
Dónde se nota de verdad la diferencia
Empieza por el rendimiento. Tu portátil tiene ventilador, está enchufado y su CPU no baja de rendimiento en una demo de dos minutos. Un gama media con tres años sí lo hace, y justo cuando el minijuego lleva un rato corriendo y el cuerpo ya está templado. Hemos visto una pantalla mantener los fotogramas estables en el simulador y empezar a perderlos en cuanto el dispositivo se calentaba. El código no cambió; cambió el silicio.
Los permisos son más traicioneros. En el simulador concedes cámara o ubicación el primer día y te olvidas de que eso existe. Los usuarios reales deniegan, bloquean el aviso para siempre, revocan cosas desde el sistema y te devuelven un estado que tu código nunca ha visto. El fallo casi nunca es un cuelgue: es un mapa en blanco, una subida que no hace nada, un botón muerto porque una rama daba por hecho el consentimiento.
Y está el anfitrión. Cada uno publica su librería base, y la gente no actualiza según tu calendario. Una API que se comporta de una forma en el runtime actual puede comportarse distinto, o no existir, en una versión de hace dos años. Si solo pruebas contra la última, estás probando contra un build que buena parte de tu audiencia jamás instaló.
| Diferencia | En el simulador | En un dispositivo real | Cómo detectarlo antes |
|---|---|---|---|
| Presupuesto de fotogramas | CPU de escritorio, sin estrangulamiento | El gama media baja al calentarse | Perfilar en el móvil más barato que soportes, tras diez minutos de uso |
| Avisos de permisos | Concedidos una vez y olvidados | Denegación, bloqueo permanente, revocación del sistema | Instalación limpia con todos los permisos revocados antes de cada pasada |
| Librería base del anfitrión | Siempre la más reciente | Usuarios anclados a versiones de hace años | Fijar una versión mínima y dejar un dispositivo en ella |
| Red | Wi-Fi de oficina, sin pérdida de paquetes | Señal floja, portales cautivos, cortes a media petición | Limitar a un perfil lento y cortar la conexión durante la carga |
| Almacenamiento | Se limpia cuando te apetece | Límites de cuota y borrados que no provocaste | Llenar la caché y medir el arranque en frío |
| Entrada | Clics de ratón precisos | Dedos grandes, deslizamientos al borde, muescas de pantalla | Pasarle el móvil a alguien que no haya visto el diseño |
Lo que cuesta una matriz de dispositivos de verdad
No vamos a fingir que la respuesta sea «prueba en dispositivos reales» y ya. Una matriz con cinco anfitriones, tres versiones de sistema y un puñado de móviles baratos es cara de comprar y pesada de mantener: cargados, actualizados y con sesión abierta en cuentas reales. Las granjas de dispositivos en la nube ayudan, pero no son lo mismo que un teléfono con conexión irregular en la mano de alguien, y la factura sube con cada combinación que añades.
La automatización también tiene techo. Puedes guionizar toques y capturas, pero no el interruptor de permisos del sistema, ni una app anfitriona que se actualiza de madrugada, ni una notificación que aterriza a mitad del flujo. Nuestra suite automática cubre bien el camino feliz y mal los estados raros, justo al revés de donde viven los bugs de los miniprogramas. Aprendimos a leer un pipeline en verde como una señal de que lo obvio va bien, no de que esto funciona.
Y hay problemas que no existen hasta que llega tráfico real. Un despliegue gradual del anfitrión, una rareza de red regional, un modelo que no compramos: eso aparece por releases por fases y tickets de soporte, no en un laboratorio. Incomoda, porque significa que no puedes comprar certeza con más hardware. Solo puedes acortar la distancia entre publicar algo y darte cuenta de que se rompió.
Publica poco y luego observa
Así que dejamos de intentar que el simulador fuera honesto y empezamos a tratarlo como lo que es: un sitio rápido para comprobar lógica, no un sitio para firmar el visto bueno. La firma ocurre en una matriz pequeña que de verdad mantenemos: un móvil antiguo por anfitrión, uno clavado a la versión mínima de la librería base y otro que dejamos a propósito caliente y lleno de trastos. Todo lo demás sale como release por fases a un trozo de usuarios reales, con las rutas de permiso denegado y arranque en frío instrumentadas antes de ampliar el despliegue.
Ese orden importa más que las herramientas. Caza los bugs de lógica donde iterar es barato, los de dispositivo en unos pocos móviles reales, y acepta que la última categoría solo se ve en producción. A los equipos que les va mal no son los que tienen un laboratorio modesto, sino los que creyeron que un simulador limpio significaba que ya habían terminado.
Fuentes
- Documentación del framework de Mini Programs de WeChat — dónde se describen el simulador, la depuración en dispositivo y las versiones de la librería base.
- Documentación para desarrolladores de Mini Programs de Alipay — otro IDE con su propio flujo de vista previa: ahí empiezan las diferencias.
- Documentación de Chrome DevTools — inspección remota y paneles de rendimiento que conviene copiar para medir en el móvil.
- Documentación de Taro — cómo un solo código compila en builds por anfitrión y ramas condicionales.