MVC (Modelo Vista Controlador) y sus derivados: MVP y MVVM
El Modelo Vista Controlador (MVC) existe para evitar un problema frecuente. Empiezas una pantalla con un botón y un texto. Seis meses después, el mismo fichero lee de la base de datos, valida, calcula y pinta. Cambiar un color da miedo, y probar una regla exige abrir la aplicación y hacer clic.
MVC y sus derivados (MVP, MVVM y MVI) atacan ese problema. Todos se basan en la misma idea: separar lo que el programa sabe de cómo lo enseña.
Qué es MVC (Modelo Vista Controlador)
El Modelo Vista Controlador (MVC), o patrón MVC, es un patrón de arquitectura de software que divide la parte de la aplicación que habla con el usuario en tres componentes:
- Modelo: los datos y las reglas del problema. Sabe, por ejemplo, que en el bar del ejemplo no caben más de 2 personas. No sabe nada de pantallas.
- Vista: lo que ve el usuario. Lee el modelo y lo representa.
- Controlador: recibe lo que hace el usuario (teclas, clics) y lo traduce en órdenes para el modelo.
Piensa en el aforo de un bar. El libro de aforo del encargado es el modelo: cuántas personas hay, cuál es el máximo y si cabe alguien más. El cartel de la puerta («Aforo: 2/2») es la vista. El portero es el controlador: recibe a cada cliente y le pide al libro que apunte la entrada. Puedes cambiar el cartel por una pantalla sin tocar la regla del máximo, y cambiar de portero sin reescribir el libro.
De dónde viene
MVC lo formuló Trygve Reenskaug en 1978 y 1979, durante su estancia en el grupo de Smalltalk de Xerox PARC. Martin Fowler, en su artículo GUI Architectures (2006), resume así el reparto: el modelo es el elemento del dominio y no sabe nada de la interfaz; el controlador recibe lo que hace el usuario, y la vista solo muestra el estado del modelo. Reenskaug, en su página sobre MVC, resume el propósito esencial: salvar la distancia entre el modelo mental del usuario y el modelo digital que hay en el ordenador.
La primera versión de sus notas, de mayo de 1979, se llamaba Thing-Model-View-Editor. Según el propio Reenskaug, los nombres definitivos salieron de largas discusiones con Adele Goldberg.
En ese mismo artículo, Fowler dice que MVC es probablemente el patrón más citado del desarrollo de interfaces y también el peor citado. Por eso «MVC» significa cosas algo distintas según a quién preguntes.
El MVC de los frameworks web
Si llegas a MVC desde Ruby on Rails, Spring MVC, ASP.NET MVC o Laravel, verás el mismo reparto con otra forma. La guía oficial de Rails 8.1, por ejemplo, organiza el código en modelos, vistas y controladores. La diferencia con el MVC original es que en la web la vista no se queda escuchando al modelo: el controlador recibe una petición HTTP, pide datos al modelo y entrega una vista ya generada. Es una adaptación del mismo principio, no la versión de Smalltalk. Lo ves paso a paso en la sección siguiente, con código y peticiones reales.
¿MVC es un patrón de diseño o de arquitectura?
Encontrarás las dos etiquetas, y las dos tienen parte de razón. Esta explicación es nuestra, no una definición de un autor concreto.
- Como patrón de diseño, MVC es una forma de repartir responsabilidades entre unas pocas clases de una pantalla. Ese reparto se apoya en patrones más pequeños, como el Observer con el que el modelo
Aforoavisa a la vista de que ha cambiado en la versión de terminal de más abajo. - Como patrón de arquitectura, MVC organiza toda la parte de la aplicación que habla con el usuario. Es lo que hacen los frameworks web: deciden en qué carpetas va cada pieza y cómo viaja una petición de una a otra.
La diferencia es de escala. Un patrón de diseño ordena unas pocas clases; un patrón de arquitectura ordena una parte grande del sistema. Por eso, más que discutir la etiqueta, conviene saber qué ordena MVC y qué deja fuera: como se ve al final del artículo, no dice nada de los casos de uso, la base de datos ni los servicios externos.
Cómo funciona MVC en una aplicación web
En una web, cada clic o cada envío de formulario es una petición HTTP que llega al servidor. El recorrido es siempre parecido:
- El navegador pide una dirección, por ejemplo
POST /entraral pulsar un botón. - El enrutador elige qué acción del controlador la atiende, según el método y la ruta.
- El controlador da una orden al modelo: «ha entrado alguien».
- El modelo aplica las reglas: si el bar está lleno, no deja entrar a nadie más.
- El controlador elige la vista y le pasa los datos del modelo.
- La vista genera la respuesta (una página HTML o un JSON) y vuelve al navegador.
En el bar: el cliente llega a la puerta (la petición), el portero lo apunta en el libro (controlador y modelo) y el cartel muestra el aforo actualizado (la vista). El portero no decide cuántos caben: eso lo dice el libro.
Ejemplo de MVC: el aforo del bar en la web
El ejemplo es un contador de aforo con un máximo de 2 personas, en JavaScript para Node.js. Primero, el modelo, en aforo.js. Fíjate en que no importa nada de la vista ni de HTTP:
// aforo.js — Modelo: las reglas del negocio.
export class Aforo {
#personas = 0;
#oyentes = [];
constructor(maximo) {
this.maximo = maximo;
}
get personas() { return this.#personas; }
get completo() { return this.#personas >= this.maximo; }
entra() {
if (this.completo) return;
this.#personas++;
this.#avisar();
}
sale() {
if (this.#personas === 0) return;
this.#personas--;
this.#avisar();
}
// Patrón Observer: quien quiera enterarse de los cambios se apunta aquí.
alCambiar(oyente) { this.#oyentes.push(oyente); }
#avisar() { this.#oyentes.forEach((oyente) => oyente()); }
}
El servidor usa ese modelo. La vista devuelve HTML y el controlador recibe peticiones HTTP. No necesita ningún framework: solo el módulo node:http de Node.js.
// web.js — MVC en la web con el mismo modelo, sin frameworks.
import { createServer } from 'node:http';
import { Aforo } from './aforo.js';
const aforo = new Aforo(2); // Modelo: la regla del máximo vive aquí.
// Vista: recibe los datos y devuelve HTML. No decide nada.
function vistaAforo({ personas, maximo, completo }) {
const boton = completo
? '<p>Completo</p>'
: '<form method="post" action="/entrar"><button>Entrar</button></form>';
return `<h1>Aforo: ${personas}/${maximo}</h1>${boton}`;
}
// Controlador: cada ruta traduce una petición en una orden al modelo
// y elige qué responder.
const rutas = {
'GET /': (res) => html(res, vistaAforo(aforo)),
'POST /entrar': (res) => { aforo.entra(); volverAlInicio(res); },
'POST /salir': (res) => { aforo.sale(); volverAlInicio(res); },
};
function html(res, cuerpo) {
res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' }).end(cuerpo);
}
function volverAlInicio(res) {
res.writeHead(303, { Location: '/' }).end(); // 303: «ve a ver el resultado»
}
createServer((req, res) => {
const accion = rutas[`${req.method} ${req.url}`];
if (accion) return accion(res);
res.writeHead(404).end('No encontrado');
}).listen(3000, () => console.log('Escuchando en http://localhost:3000'));
Arráncalo en una terminal:
node web.js
Escuchando en http://localhost:3000
Y, desde otra, haz de navegador con curl. Primero pide la página; después pulsa «Entrar» tres veces:
curl -s -w '\n' localhost:3000/
curl -s -o /dev/null -w '%{http_code}\n' -X POST localhost:3000/entrar
curl -s -o /dev/null -w '%{http_code}\n' -X POST localhost:3000/entrar
curl -s -o /dev/null -w '%{http_code}\n' -X POST localhost:3000/entrar
curl -s -w '\n' localhost:3000/
<h1>Aforo: 0/2</h1><form method="post" action="/entrar"><button>Entrar</button></form>
303
303
303
<h1>Aforo: 2/2</h1><p>Completo</p>
El tercer POST llega al controlador igual que los otros dos, pero el aforo se queda en 2/2: la regla vive en el modelo, y el controlador no tiene que saberla. Cada POST responde con un 303, que le dice al navegador «ve a ver el resultado a /». Así, si el usuario recarga la página, no vuelve a enviar el formulario.
MVC en los frameworks más usados
Los frameworks web hacen por ti el enrutador y el servidor, y te piden que repartas el código en las tres piezas. Cada uno lo adapta a su manera:
| Framework | Lenguaje | Cómo reparte MVC |
|---|---|---|
| Ruby on Rails 8.1 | Ruby | Modelos con Active Record, vistas en plantillas ERB y controladores que atienden cada petición |
| Spring MVC (Spring Framework 7.0) | Java y Kotlin | Un servlet central, el DispatcherServlet, recibe todas las peticiones y las reparte a los controladores |
| ASP.NET Core MVC | C# | Controladores, vistas con Razor y modelos; la documentación pide sacar la lógica de negocio del controlador y llevarla al modelo de dominio |
| Django 6.1 | Python | Se describe como MTV (modelo, plantilla y vista): lo que Django llama «vista» decide qué datos se muestran, la «plantilla» decide cómo se ven, y el papel de controlador lo hace el propio framework |
| Android (Jetpack) | Kotlin | La guía oficial no propone MVC: recomienda una capa de interfaz con state holders como ViewModel y un flujo de datos en un solo sentido, más cerca de MVVM |
Si trabajas con Rails, puedes ver las tres piezas en el blog: cómo crear modelos, cómo editar las vistas y cómo generar un recurso completo con scaffold. Y la regla del aforo, en Rails, sería una validación del modelo, no un if en el controlador.
Ventajas e inconvenientes de MVC
Ventajas
- Cambias la pantalla sin tocar las reglas. La interfaz cambia mucho más a menudo que el negocio.
- Pruebas las reglas sin interfaz. El modelo no depende de la vista ni del controlador, como verás en los tests de más abajo.
- Cada pieza tiene un solo trabajo, así que es más fácil encontrar dónde está un fallo.
- Varias interfaces, un modelo. La web de este ejemplo y las versiones de terminal de más abajo usan el mismo
Aforo. - Estructura conocida. Si llegas a un proyecto de Rails o Spring, ya sabes dónde buscar cada cosa.
Inconvenientes
- Más piezas para algo pequeño. Un script de veinte líneas no necesita tres ficheros.
- El controlador tiende a engordar si no se vigila, porque es el sitio más cómodo para «poner un
ifrápido». - La sigla significa cosas distintas según el framework, como recuerda Fowler.
- No organiza el resto de la aplicación. Casos de uso, base de datos y servicios externos quedan fuera, como se ve al final.
Las dos primeras ventajas las recoge también la documentación de ASP.NET Core MVC: la lógica de la interfaz suele cambiar más que la de negocio, y como el modelo no depende de la vista ni del controlador, se puede construir y probar por separado. El resto del balance es nuestro.
Un mismo ejemplo en MVC, MVP, MVVM y MVI
Para comparar las variantes, usamos el mismo modelo Aforo de la web, sin cambiar ni una línea, pero ahora en la terminal. Los clics se simulan.
MVC: la vista escucha al modelo
// mvc.js
import { Aforo } from './aforo.js';
// Vista: observa el modelo y lo pinta cada vez que cambia.
export function crearVista(aforo, pintar) {
const render = () =>
pintar(`Aforo: ${aforo.personas}/${aforo.maximo}${aforo.completo ? ' (completo)' : ''}`);
aforo.alCambiar(render);
render();
}
// Controlador: traduce lo que hace el usuario en órdenes al modelo.
export function crearControlador(aforo) {
return {
tecla(t) {
if (t === '+') aforo.entra();
if (t === '-') aforo.sale();
},
};
}
if (import.meta.main) {
const aforo = new Aforo(2);
crearVista(aforo, console.log);
const controlador = crearControlador(aforo);
['+', '+', '+', '-'].forEach((t) => controlador.tecla(t));
}
$ node mvc.js
Aforo: 0/2
Aforo: 1/2
Aforo: 2/2 (completo)
Aforo: 1/2
El controlador nunca toca la vista. Cambia el modelo, y el modelo avisa a quien le esté escuchando. El tercer + no hace nada porque la regla del máximo está en el modelo.
MVP (Modelo Vista Presentador): la vista no conoce el modelo
En MVP, la vista es pasiva: avisa de los clics y pinta lo que le digan. El presentador está en medio: recibe los eventos, habla con el modelo y decide qué mostrar. En el bar, el portero ahora también escribe el cartel a mano.
Según Fowler, MVP apareció en IBM y, sobre todo, en Taligent en los años noventa, y lo popularizaron los desarrolladores de Dolphin Smalltalk.
// mvp.js
import { Aforo } from './aforo.js';
// Presentador: recibe los eventos de la vista, habla con el modelo
// y le dice a la vista qué mostrar. La vista no conoce el modelo.
export class Presentador {
constructor(aforo, vista) {
this.aforo = aforo;
this.vista = vista;
vista.alPulsarEntrar(() => aforo.entra());
vista.alPulsarSalir(() => aforo.sale());
aforo.alCambiar(() => this.#actualizar());
this.#actualizar();
}
#actualizar() {
const { personas, maximo, completo } = this.aforo;
this.vista.mostrarTexto(`Aforo: ${personas}/${maximo}`);
this.vista.activarBotonEntrar(!completo);
}
}
// Vista pasiva: solo pinta lo que le dicen y avisa de los clics.
export function crearVistaConsola() {
const manejadores = {};
return {
alPulsarEntrar(fn) { manejadores.entrar = fn; },
alPulsarSalir(fn) { manejadores.salir = fn; },
mostrarTexto(texto) { console.log(texto); },
activarBotonEntrar(activo) { if (!activo) console.log('[Entrar] desactivado'); },
pulsar(boton) { manejadores[boton](); }, // simula un clic
};
}
if (import.meta.main) {
const vista = crearVistaConsola();
new Presentador(new Aforo(2), vista);
['entrar', 'entrar', 'salir'].forEach((b) => vista.pulsar(b));
}
$ node mvp.js
Aforo: 0/2
Aforo: 1/2
Aforo: 2/2
[Entrar] desactivado
Aforo: 1/2
La ventaja aparece en los tests: como la vista es una interfaz con cuatro métodos, puedes darle al presentador una vista falsa y comprobar qué le pide pintar, sin abrir ninguna ventana.
Diferencias entre MVC y MVP
MVC
- La vista lee el modelo y se repinta cuando este avisa
- El controlador solo recibe la entrada del usuario
- La vista conoce el modelo; el modelo solo avisa a quien le escucha
MVP
- La vista no conoce el modelo
- El presentador recibe los eventos y dice a la vista qué mostrar
- La vista es tan simple que casi no hace falta probarla
MVVM (Modelo Vista VistaModelo): la vista se enlaza sola
En MVVM, el ViewModel («modelo de la vista») guarda el estado de la pantalla ya preparado para pintarse (el texto, si el botón está activo) y ofrece comandos (entrar, salir). La vista se enlaza a esas propiedades y se actualiza sola cuando cambian. En el bar, el cartel ya no lee el libro: un empleado le prepara el texto y la pantalla se actualiza sola.
La documentación de Microsoft lo resume así: la vista conoce al ViewModel y el ViewModel conoce al modelo, pero el ViewModel no sabe nada de la vista. El nombre lo presentó John Gossman, de Microsoft, en 2005, como una variante de MVC para WPF. Fowler había descrito antes una idea muy parecida con el nombre de Presentation Model (2004).
// mvvm.js
import { Aforo } from './aforo.js';
// ViewModel: expone estado listo para pintar y comandos.
// No conoce la vista: solo avisa de que algo cambió.
export class AforoViewModel {
#oyentes = [];
constructor(aforo) {
this.aforo = aforo;
aforo.alCambiar(() => this.#oyentes.forEach((oyente) => oyente()));
}
get etiqueta() { return `Aforo: ${this.aforo.personas}/${this.aforo.maximo}`; }
get puedeEntrar() { return !this.aforo.completo; }
entrar() { this.aforo.entra(); } // comandos
salir() { this.aforo.sale(); }
alCambiar(oyente) { this.#oyentes.push(oyente); }
}
// "Data binding" casero: enlaza una propiedad del ViewModel con la pantalla.
// En WPF, .NET MAUI o Jetpack Compose esto lo hace el framework.
export function enlazar(vm, propiedad, pintar) {
const actualizar = () => pintar(vm[propiedad]);
vm.alCambiar(actualizar);
actualizar();
}
if (import.meta.main) {
const vm = new AforoViewModel(new Aforo(2));
enlazar(vm, 'etiqueta', console.log);
enlazar(vm, 'puedeEntrar', (sí) => { if (!sí) console.log('[Entrar] desactivado'); });
vm.entrar(); vm.entrar(); vm.salir();
}
$ node mvvm.js
Aforo: 0/2
Aforo: 1/2
Aforo: 2/2
[Entrar] desactivado
Aforo: 1/2
En la práctica no escribes la función enlazar: la pone el framework. Por eso MVVM brilla en entornos con enlace de datos, como WPF y .NET MAUI, y por eso en Android Jetpack existe una clase ViewModel que expone el estado a la interfaz.
Bonus: MVI (Modelo Vista Intención)
MVI viene del mundo reactivo; la documentación de Cycle.js lo describe como partir el programa en tres funciones: intent (escuchar al usuario), model (procesar) y view (responder al usuario). El estado es un valor que no se modifica: cada acción produce un estado nuevo, y todo circula en un solo sentido.
// mvi.js
// Intent: traduce lo que hace el usuario en una acción con nombre.
export const intent = (tecla) => ({ '+': 'ENTRAR', '-': 'SALIR' })[tecla];
// Model: función pura que calcula el estado siguiente.
export function model(estado, accion) {
const { personas, maximo } = estado;
if (accion === 'ENTRAR' && personas < maximo) return { ...estado, personas: personas + 1 };
if (accion === 'SALIR' && personas > 0) return { ...estado, personas: personas - 1 };
return estado;
}
// View: función pura del estado al texto en pantalla.
export const view = ({ personas, maximo }) =>
`Aforo: ${personas}/${maximo}${personas >= maximo ? ' (completo)' : ''}`;
if (import.meta.main) {
let estado = { personas: 0, maximo: 2 };
console.log(view(estado));
for (const tecla of ['+', '+', '+', '-']) {
estado = model(estado, intent(tecla));
console.log(view(estado));
}
}
$ node mvi.js
Aforo: 0/2
Aforo: 1/2
Aforo: 2/2 (completo)
Aforo: 2/2 (completo)
Aforo: 1/2
Aquí el tercer + devuelve el mismo estado y la vista lo vuelve a pintar igual: no hay nada que observar, solo funciones que se encadenan.
Las cuatro, probadas sin pantalla
La prueba de que la separación funciona es que cada variante se puede testear sin interfaz. Estos tests usan el ejecutor de pruebas que trae Node (node --test):
// aforo.test.js
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { Aforo } from './aforo.js';
import { crearVista, crearControlador } from './mvc.js';
import { Presentador } from './mvp.js';
import { AforoViewModel } from './mvvm.js';
import { intent, model, view } from './mvi.js';
test('MVC: el controlador cambia el modelo y la vista se repinta sola', () => {
const aforo = new Aforo(1);
const pantalla = [];
crearVista(aforo, (t) => pantalla.push(t));
crearControlador(aforo).tecla('+');
assert.equal(pantalla.at(-1), 'Aforo: 1/1 (completo)');
});
test('MVP: el presentador desactiva Entrar con una vista falsa', () => {
const llamadas = {};
const vistaFalsa = {
alPulsarEntrar: (fn) => (llamadas.entrar = fn),
alPulsarSalir: () => {},
mostrarTexto: (t) => (llamadas.texto = t),
activarBotonEntrar: (a) => (llamadas.activo = a),
};
new Presentador(new Aforo(1), vistaFalsa);
llamadas.entrar();
assert.equal(llamadas.texto, 'Aforo: 1/1');
assert.equal(llamadas.activo, false);
});
test('MVVM: el ViewModel se prueba sin ninguna vista', () => {
const vm = new AforoViewModel(new Aforo(1));
vm.entrar();
assert.equal(vm.etiqueta, 'Aforo: 1/1');
assert.equal(vm.puedeEntrar, false);
});
test('MVI: el modelo es una función pura', () => {
const lleno = { personas: 1, maximo: 1 };
assert.equal(model(lleno, intent('+')), lleno);
assert.equal(view(model(lleno, intent('-'))), 'Aforo: 0/1');
});
$ node --test
✔ MVC: el controlador cambia el modelo y la vista se repinta sola
✔ MVP: el presentador desactiva Entrar con una vista falsa
✔ MVVM: el ViewModel se prueba sin ninguna vista
✔ MVI: el modelo es una función pura
ℹ tests 4
ℹ pass 4
Tabla comparativa: MVC, MVP, MVVM y MVI
| MVC | MVP | MVVM | MVI | |
|---|---|---|---|---|
| Quién recibe al usuario | Controlador | La vista, que avisa al presentador | La vista, que llama a comandos del ViewModel | Intent, que lo convierte en acciones |
| Cómo se actualiza la pantalla | La vista escucha al modelo | El presentador llama a la vista | Enlace de datos (data binding) | La vista se recalcula a partir del estado |
| ¿La vista conoce el modelo? | Sí | No | No (solo el ViewModel) | Solo el estado |
| Qué pruebas sin pantalla | Modelo | Modelo y presentador (con vista falsa) | Modelo y ViewModel | Modelo, intent y vista (son funciones) |
| Dónde lo verás | Frameworks web (Rails, Spring MVC, ASP.NET MVC) | Apps sin enlace de datos | WPF, .NET MAUI, Android Jetpack | Cycle.js, arquitecturas con flujo en un solo sentido |
Cuándo elegir cada uno
- MVC, si trabajas con un framework web que ya lo trae. No pelees con la estructura de Rails o Spring: aprovéchala y mantén los controladores finos.
- MVP, si tu plataforma no tiene enlace de datos y quieres probar la lógica de la pantalla con una vista falsa.
- MVVM, si tu plataforma sí tiene enlace de datos (WPF, .NET MAUI, Android con Jetpack). Es la opción más natural y la que menos código de pegamento deja.
- MVI, si la pantalla tiene mucho estado que cambia a la vez y quieres que cada cambio sea predecible y fácil de reproducir.
Más importante que la sigla es la regla común: las reglas del negocio no viven en la pantalla. Si una regla solo se puede probar haciendo clic, está en el sitio equivocado.
Errores típicos al aplicar MVC
- Las reglas en el controlador. Es un error frecuente. El controlador debería ser fino: recibir, delegar y responder. Si decide cuántos caben, acabas con un God Object, una clase que lo sabe y lo hace todo.
- Lógica en la vista. Un
ifpara mostrar u ocultar un botón es lógica de presentación y está bien ahí. Un cálculo de precios dentro de una plantilla, no. - Un modelo que solo guarda datos. Si el modelo es una bolsa de getters y setters y las reglas viven en otras clases, Martin Fowler lo llama modelo anémico. En el ejemplo,
Aforoguarda el número de personas y sabe si está completo. Tienes la diferencia entre objetos y estructuras de datos en Objetos y estructuras de datos en Código Limpio. - Confiar en lo que llega del usuario. El controlador es la puerta de entrada y debe filtrar los datos de la petición antes de pasarlos al modelo. En Rails, eso son los strong params.
MVC y la arquitectura hexagonal o limpia
MVC, MVP y MVVM ordenan la parte que habla con el usuario. No dicen nada de cómo organizar el resto: casos de uso, base de datos, servicios externos.
Ahí entran la arquitectura hexagonal y la arquitectura limpia. Alistair Cockburn, en su artículo sobre arquitectura hexagonal (2005), pone la interfaz gráfica como ejemplo de adaptador: una pieza que traduce lo que hace una persona a la API de la aplicación. Robert C. Martin, en The Clean Architecture (2012), coloca los presentadores, las vistas y los controladores en la capa de adaptadores, por fuera de los casos de uso.
Dicho de forma sencilla (esto ya es una interpretación, no algo que escriban ellos): MVC, MVP o MVVM deciden cómo está montado el enchufe, y la arquitectura hexagonal decide que la casa funcione con cualquier enchufe. En nuestro ejemplo, la clase Aforo es la que no cambia aunque pases de la terminal a una web o a una app móvil.
El mismo criterio sirve con un agente de IA: si le pides una pantalla y le dices qué patrón seguir y qué no puede importar cada pieza (por ejemplo, «el ViewModel no conoce la vista»), tienes un límite claro que un test puede comprobar. Es la idea de la IA Limpia: aprovechar la velocidad sin perder la estructura.
Siguiente paso
Abre una pantalla de tu proyecto y busca una regla de negocio (un límite, un cálculo, una validación). Si está dentro de la vista o del controlador, muévela al modelo y escríbele un test. Si quieres afinar el criterio de qué va en cada clase, sigue con Clases en Código Limpio y el principio de responsabilidad única.
Fuentes
Comprobado el 7 y el 8 de noviembre de 2026:
- Trygve Reenskaug, MVC: Xerox PARC 1978-79 y su nota Models-Views-Controllers (10 de diciembre de 1979). La web original de la Universidad de Oslo ya no responde; se ha leído la copia de Internet Archive.
- Martin Fowler, GUI Architectures (2006) y Presentation Model (2004).
- John Gossman, Introduction to Model/View/ViewModel pattern for building WPF apps (2005, archivo de Microsoft).
- Microsoft Learn, Model-View-ViewModel (libro Enterprise Application Patterns Using .NET MAUI, revisado en septiembre de 2024).
- Android Developers, ViewModel overview.
- Cycle.js, Model-View-Intent.
- Guías de Rails 8.1, Getting Started: Model-View-Controller Basics.
- Spring Framework 7.0, DispatcherServlet: el patrón front controller de Spring MVC.
- Microsoft Learn, Overview of ASP.NET Core MVC (ASP.NET Core 10, actualizado en agosto de 2026): responsabilidades de modelo, vista y controlador, y la recomendación de sacar la lógica de negocio del controlador.
- Documentación de Django 6.1, FAQ: General: por qué Django se describe como MTV.
- Android Developers, Guide to app architecture: capa de interfaz con state holders y flujo de datos en un solo sentido.
- Martin Fowler, Anemic Domain Model (2003).
- Node.js 24, HTTP (
createServer,writeHead). - Alistair Cockburn, Hexagonal Architecture (2005) y Robert C. Martin, The Clean Architecture (2012).
Todo el código se ha ejecutado con Node.js 24.21.0 en Linux (node mvc.js, node mvp.js, node mvvm.js, node mvi.js, node --test y node web.js con curl 8.18.0, con "type": "module" en package.json). import.meta.main requiere Node.js 24.2.0 o 22.18.0 en adelante y, en Node.js 24, está marcado como «Stability: 1.0 - Early development», es decir, en desarrollo inicial (documentación de Node.js 24).