Jetpack Compose y el fin del XML: cómo cambió el juego
Mira, voy a ser directo. Si llevas un rato programando en Android — digamos, desde los tiempos oscuros de Eclipse y los LinearLayout anidados hasta el infinito — sabes perfectamente de qué hablo cuando digo que trabajar con XML era, bueno, un fastidio monumental.
No siempre. Pero casi siempre.
La época del sufrimiento silencioso
Había una rutina que todos conocíamos de memoria, una especie de ritual doloroso que nadie cuestionaba porque "así se hacían las cosas":
Primero diseñabas la interfaz en un archivo XML — rezando para que el ConstraintLayout no te traicionara a última hora. Después inflabas ese layout dentro de una Activity o un Fragment, buscabas cada vista con findViewById() como quien busca las llaves del coche a las siete de la mañana, y finalmente conectabas todo con lógica manual que, sinceramente, se sentía como pegar ladrillos con cinta adhesiva.
¿Funcionaba? Claro que funcionaba.
¿Era elegante? Ni de lejos.
El código se multiplicaba, los bugs visuales aparecían de la nada, y mantener un proyecto mediano ya se convertía en una odisea. Y no me hagas hablar de cuando tocaba actualizar el estado de la interfaz manualmente — vista por vista, campo por campo, como un relojero ajustando engranajes diminutos con los dedos temblorosos.
Entonces llegó Jetpack Compose y todo se sacudió
Google llevaba tiempo cocinando algo. Se notaba. Y cuando finalmente presentaron Compose, muchos lo miramos con escepticismo — yo incluido, para qué negarlo. ¿Otro framework más? ¿Otra promesa de "ahora sí va a ser más fácil"?
Pero esta vez era diferente.
Jetpack Compose introdujo un enfoque declarativo que cambió radicalmente la forma en que pensamos sobre las interfaces en Android. En vez de explicarle al sistema cómo construir cada vista paso a paso — que si infla esto, que si busca aquello, que si conecta lo otro — ahora simplemente le describes qué quieres ver en pantalla según el estado actual.
Así, sin más vueltas:
@Composable
fun Saludo(nombre: String) {
Text(text = "Hola, $nombre")
}
Eso es todo. Sin XML. Sin IDs. Sin inflar nada. Sin ese código repetitivo que te hacía sentir que estabas copiando y pegando tu propia vida.
¿Por qué tanta gente dice que Compose "mató" al XML?
A ver, matarlo matarlo... quizás es un poco dramático. Pero la verdad — y esto lo digo después de haberlo usado en varios proyectos reales — es que las reglas del juego cambiaron por completo.
Menos código, menos dolores de cabeza. Lo que antes necesitaba un archivo XML, una clase en Kotlin o Java, enlaces de vistas y lógica adicional para actualizar la interfaz... ahora se resuelve en un solo archivo. A veces en unas pocas líneas. Y no es magia negra ni nada raro — es simplemente un diseño más inteligente.
La reactividad dejó de ser un parche. Compose trabaja de forma nativa con State. Si algo cambia, la interfaz se entera sola y se actualiza sin que tengas que mover un dedo extra. Esto puede parecer menor, pero cuando has pasado noches depurando por qué un TextView no se actualizaba correctamente, créeme, es una revolución silenciosa.
El mantenimiento ya no da miedo. Bueno, quizás un poquito. Pero mucho menos que antes. El XML separaba diseño y lógica, lo cual sonaba bonito en la teoría, pero en la práctica generaba un baile constante entre archivos que complicaba todo innecesariamente. Compose unifica las cosas de manera más orgánica — los componentes terminan siendo reutilizables, escalables y, sobre todo, más fáciles de leer por otro ser humano que no seas tú a las tres de la madrugada.
Y luego está @Preview. Poder visualizar componentes sin ejecutar toda la aplicación es de esas cosas que, una vez las pruebas, no entiendes cómo vivías sin ellas. Como el aire acondicionado. O el café con hielo en agosto.
Pero espera — ¿entonces XML ya está enterrado?
No tan rápido.
Sería deshonesto decir que XML desapareció del mapa. Todavía respira, aunque con oxígeno prestado. Lo vas a encontrar en aplicaciones antiguas que nadie se atreve a refactorizar, en proyectos corporativos enormes que migran a paso de tortuga, y en equipos donde la adopción de nuevas tecnologías avanza... digamos que con cautela.
También hay casos puntuales donde ciertas vistas tradicionales siguen teniendo sentido. No muchos, pero existen.
Sin embargo — y aquí viene lo importante — si hoy, en pleno 2026, arrancas un proyecto desde cero en Android, la pregunta ya no es "¿debería usar XML?". La pregunta real, la que todo el mundo se hace en voz baja, es:
"¿Hay alguna razón legítima para NO usar Compose?"
Y las razones se están acabando.
¿Merece la pena aprenderlo ahora?
Absolutamente.
Mira, yo entiendo la fatiga tecnológica. Cada dos años aparece algo nuevo que promete cambiarlo todo y a veces uno piensa "paso, ya esperaré a ver si sobrevive". Pero Compose ya sobrevivió. Ya se consolidó. Ya es parte del ecosistema estándar de Android, y no dominarlo es quedarse atrás, así de claro.
Las ventajas son tangibles y concretas:
- Desarrollo notablemente más ágil
- Código limpio que no da vergüenza enseñar
- Integración nativa con Kotlin — porque, seamos honestos, Java en Android ya huele a museo
- Menos boilerplate — ese código basura que escribes por obligación y no por elección
- Una arquitectura moderna que respira mejor
- Mejor experiencia cuando la app necesita crecer
Para cerrar esto
Jetpack Compose no se limitó a sustituir una herramienta por otra. Cambió la manera en que los desarrolladores Android piensan sobre construir interfaces. Es un cambio de mentalidad, no solo de sintaxis.
XML fue el cimiento durante muchos años — y hay que reconocerle eso, porque cumplió su función. Pero Compose llegó para simplificar lo complejo, modernizar lo anticuado y acelerar lo que antes era tediosamente lento.
¿Desapareció el XML por completo? Todavía no.
¿Ganó Compose la partida? Prácticamente, sí.
En el Android de hoy, el futuro ya no se escribe en XML.
Se compone en Kotlin. Y francamente, ya era hora.

0 Response to "Jetpack Compose y el fin del XML: cómo cambió el juego"
Publicar un comentario