Nivel inicial23 min de lectura · Publicado el

MVC (Modelo Vista Controlador) y sus derivados: MVP y MVVM

MVC con el aforo de un bar: el portero (controlador) llama a entra(), el libro (modelo) guarda la regla del máximo de 2 y el cartel Aforo: 2/2 es la vista. MVC: la regla, en el modelorubentejera.com CONTROLADORentra()máx.2MODELOAforo: 2/2VISTA
El portero (controlador) recibe a cada cliente y se lo pasa al libro con entra(). El libro (modelo) guarda la regla, un máximo de 2, y avisa al cartel (vista), que muestra Aforo: 2/2.

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 Aforo avisa 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:

  1. El navegador pide una dirección, por ejemplo POST /entrar al pulsar un botón.
  2. El enrutador elige qué acción del controlador la atiende, según el método y la ruta.
  3. El controlador da una orden al modelo: «ha entrado alguien».
  4. El modelo aplica las reglas: si el bar está lleno, no deja entrar a nadie más.
  5. El controlador elige la vista y le pasa los datos del modelo.
  6. 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 if rá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, MVP, MVVM y MVI con el mismo ejemplo. En MVC, la vista escucha al modelo y el controlador lo cambia sin tocar la vista. En MVP, el presentador habla con el modelo y le dice a la vista qué pintar; la vista no conoce el modelo. En MVVM, la vista se enlaza al ViewModel, que conoce el modelo pero no la vista. En MVI, intent produce una acción, model calcula el estado nuevo y view lo pinta, un flujo de datos en un solo sentido.
En MVC, MVP y MVVM, cada flecha va de quien conoce a quien es conocido; en MVI, las flechas discontinuas son el flujo de datos. Fíjate en la vista, en magenta: en MVC llega hasta el modelo; en MVP y MVVM ya no lo ve, y en MVI solo recibe el estado.

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 if para 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, Aforo guarda 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:

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).