Arquitectura de Software (Software Architecture) — Programa del curso
Docente: Gerson Garrido
1. Descripción
La arquitectura de un sistema es el conjunto de decisiones que cuesta cambiar: en qué partes se divide, cómo se comunican esas partes, dónde viven los datos y qué pasa cuando algo falla. Esas decisiones casi nunca las determina lo que el sistema hace. Las determina qué tan bien debe hacerlo: cuántas personas lo usan a la vez, cuánto puede tardar, cuánto tiempo puede estar caído, qué tan seguido cambia y quién lo va a mantener. A eso se le llama atributos de calidad, y el curso empieza por ahí.
En arquitectura no hay respuestas correctas sin contexto. Los microservicios no son mejores que un monolito, ni una cache es siempre buena idea: cada decisión mejora un atributo y empeora otro. Por eso el curso no enseña un catálogo de soluciones, sino a decidir: escribir lo que se necesita de forma que se pueda medir, comparar alternativas, elegir una, dejar escrito por qué y comprobar con una medición que la decisión sirvió. El curso se organiza en cuatro partes:
- Fundamentos y atributos de calidad — qué es la arquitectura, qué requisitos la determinan, cómo se escribe y se mide un atributo de calidad, y cómo se parte un sistema en módulos.
- Estilos, tácticas y decisiones — estilos monolíticos y distribuidos, tácticas para cada atributo, y cómo se documenta y se evalúa una decisión (ADR, C4, arc42, ATAM).
- Datos y sistemas distribuidos — replicación, sharding, cache, transacciones entre servicios, mensajería y consistencia, vistos como decisiones con costos.
- Fallas, operación y evolución — resiliencia y observabilidad, fitness functions, deuda de arquitectura, cómo se parte un monolito y la arquitectura de sistemas con modelos de lenguaje.
El sistema del curso es Tinkuy, una plataforma de venta de entradas para conciertos y partidos que escribimos para el curso, en TypeScript con Node.js 26, PostgreSQL, Redis y NATS. Empieza como un monolito pequeño que funciona. Durante el semestre le llegan requisitos de calidad que ese diseño no aguanta: se abre la venta de un concierto y la carga se multiplica, dos personas compran el mismo asiento, la pasarela de pagos se cae. Cada requisito obliga a rediseñar una parte, y ese rediseño es el proyecto del curso.
Los términos técnicos van en inglés cuando así se dicen y así aparecen en los libros y en la documentación (trade-off, sharding, circuit breaker, broker); los que de verdad se usan en español (atributo de calidad, disponibilidad, replicación, cola) van en español, con el inglés entre paréntesis la primera vez. El glosario reúne los principales. Las lecturas y la documentación de las herramientas están en inglés.
2. Carga horaria
| Componente | Horas/semana | Formato |
|---|---|---|
| Teoría | 4 h | Dos sesiones de 2 h (Sesión A y Sesión B) |
| Laboratorio | 2 h | Una sesión práctica guiada |
3. Resultados de aprendizaje
Al finalizar el curso, el estudiante será capaz de:
- Explicar qué es la arquitectura de un sistema, distinguir sus estructuras (módulos, componentes y conectores, asignación) e identificar los requisitos que la determinan.
- Escribir atributos de calidad como escenarios medibles, priorizarlos en un utility tree y medirlos en un sistema que corre (latencia por percentiles, throughput, disponibilidad).
- Dividir un sistema en módulos con límites explícitos, razonar sobre su acoplamiento y su cohesión, y hacer que las reglas de dependencia se comprueben de forma automática.
- Comparar estilos de arquitectura monolíticos y distribuidos, y elegir tácticas para modificabilidad, rendimiento, disponibilidad y seguridad, diciendo qué se gana y qué se paga con cada una.
- Documentar una arquitectura con vistas (C4, arc42) y registrar sus decisiones como ADR, y evaluarla frente a sus escenarios con un método como ATAM.
- Diseñar el manejo de los datos de un sistema distribuido: replicación, sharding, cache, transacciones, sagas y mensajería, y explicar qué garantías de consistencia ofrece cada diseño.
- Diseñar para las fallas (timeouts, retries, circuit breakers, load shedding), observar un sistema en operación con SLOs, y comprobar el diseño inyectando fallas.
- Hacer evolucionar una arquitectura: protegerla con fitness functions, reconocer la deuda de arquitectura, extraer un servicio de un monolito y relacionar la estructura del sistema con la de los equipos.
4. Bibliografía
Textos principales:
Len Bass, Paul Clements y Rick Kazman. Software Architecture in Practice, 4.ª edición. Addison-Wesley, 2021. https://www.sei.cmu.edu/library/software-architecture-in-practice-fourth-edition/
Es el texto clásico de la disciplina y el de la primera mitad del curso: un capítulo por atributo de calidad, con sus escenarios y sus tácticas, y luego diseño, evaluación y documentación. Cada semana cita sus capítulos.
Martin Kleppmann y Chris Riccomini. Designing Data-Intensive Applications, 2.ª edición. O’Reilly, 2026. https://dataintensive.net/
Es el texto de la segunda mitad: replicación, sharding, transacciones, consistencia y procesamiento de streams, siempre como trade-offs. La segunda edición cambia la numeración de los capítulos; las guías citan esa edición.
Ninguno de los dos es gratuito. Por eso cada semana incluye también lecturas libres con las que se puede seguir el curso, y los apuntes cubren todo lo que entra en los exámenes.
Complementos:
- Mark Richards y Neal Ford. Fundamentals of Software Architecture, 2.ª edición. O’Reilly, 2025. Un capítulo por estilo, incluido el modular monolith; para las semanas 3 a 5, 7 y 15 (no es gratuito): https://fundamentalsofsoftwarearchitecture.com/
- Neal Ford, Mark Richards, Pramod Sadalage y Zhamak Dehghani. Software Architecture: The Hard Parts. O’Reilly, 2021. Cómo partir un sistema y cómo volver a unir sus datos y sus flujos; para las semanas 12 y 15.
- Michael Nygard. Release It!, 2.ª edición. Pragmatic Bookshelf, 2018. Patrones y antipatrones de estabilidad; para la semana 14: https://pragprog.com/titles/mnee2/release-it-second-edition/
- Neal Ford, Rebecca Parsons, Patrick Kua y Pramod Sadalage. Building Evolutionary Architectures, 2.ª edición. O’Reilly, 2022. Fitness functions; para la semana 15: https://evolutionaryarchitecture.com/
- Betsy Beyer y otros. Site Reliability Engineering. O’Reilly, 2016. Libre en línea: https://sre.google/sre-book/table-of-contents/
Lecturas libres que el curso usa todas las semanas:
- El modelo C4 (https://c4model.com/), arc42 (https://arc42.org/) y los ADR (https://adr.github.io/).
- Kazman, Klein y Clements. ATAM: Method for Architecture Evaluation. Reporte del SEI, con PDF libre: https://www.sei.cmu.edu/library/atam-method-for-architecture-evaluation/
- Cloud Design Patterns, del Azure Architecture Center: https://learn.microsoft.com/en-us/azure/architecture/patterns/
- Unmesh Joshi. Patterns of Distributed Systems: https://martinfowler.com/articles/patterns-of-distributed-systems/
- Martin Kleppmann. Apuntes y videos del curso de sistemas distribuidos de Cambridge: https://www.cl.cam.ac.uk/teaching/2627/ConcDisSys/
- The Architecture of Open Source Applications: https://aosabook.org/en/
- Los artículos clásicos de Parnas, Conway, Foote y Yoder, y los de Dynamo y Kafka, enlazados en las guías de las semanas que los usan.
Cursos de referencia. El programa toma ideas de cursos que se dictan actualmente; sus materiales se enlazan, no se copian:
- Carnegie Mellon, 17-423 Software System Design: un bloque por atributo de calidad y un proyecto que los equipos rediseñan cuando llega un requisito nuevo: https://cmu-swdesign.github.io/
- Carnegie Mellon, 17-633 Architectures for Software Systems: estilos, tácticas, evaluación y documentación, con el libro de Bass, Clements y Kazman.
- TU Delft, Software Architecture: el análisis de la arquitectura de sistemas open source reales: https://se.ewi.tudelft.nl/delftswa/
- University of Cambridge, Concurrent and Distributed Systems: la base de la tercera parte: https://www.cl.cam.ac.uk/teaching/2627/ConcDisSys/
- University of Waterloo, CS 446 Software Design and Architectures: https://pengyunie.github.io/cs446-1261/
La comparación completa y las decisiones que salieron de ella están en
resources/references.md. Todo este material se
enlaza, no se copia: los ejemplos, ejercicios, figuras, el sistema Tinkuy
y los enunciados del curso son propios.
5. Calendario
Este es el calendario oficial del curso. Cada semana enlaza a su guía con lecturas, objetivos y actividades de laboratorio. Las sesiones marcadas con ✂️ se pueden comprimir o pasar a lectura autónoma si se pierden clases por feriados.
| Sem. | Sesión A (2 h) | Sesión B (2 h) | Laboratorio (2 h) | Entregas |
|---|---|---|---|---|
| 1 | Presentación del curso · Qué es la arquitectura: estructuras y decisiones que cuesta cambiar | Qué determina una arquitectura: requisitos significativos, restricciones y stakeholders | Entorno; recorrer Tinkuy y dibujar lo que hay | P0 publicado |
| 2 | Atributos de calidad y escenarios de seis partes | Medir y priorizar: percentiles, disponibilidad, utility tree y trade-offs | Escribir escenarios para Tinkuy y medirlos con k6 | |
| 3 | Modularidad: ocultamiento de información, cohesión y acoplamiento | Dependencias: ciclos, inversión de dependencias, ports y adapters | Reglas de dependencia con dependency-cruiser; romper un ciclo | P0 entrega · P1 publicado |
| 4 | Estilos monolíticos: capas y modular monolith | Pipeline y microkernel · ✂️ big ball of mud | Un medio de pago como plug-in | |
| 5 | Estilos distribuidos: service-based y microservicios; las falacias de la computación distribuida | Event-driven: broker y mediator · Cómo se elige un estilo | El mismo caso en dos estilos, comparado con escenarios | P1 entrega · P2 publicado |
| 6 | Tácticas de modificabilidad y de rendimiento | Tácticas de disponibilidad y de seguridad | Pool de conexiones y cache: medir antes y después | |
| 7 | Decidir y documentar: ADR, vistas, C4 y arc42 | Diseñar y evaluar: diseño guiado por atributos y ATAM · ✂️ risk storming | Un ATAM reducido sobre Tinkuy | |
| 8 | Repaso | Examen parcial | — | P2 entrega · P3 publicado |
| 9 | Trade-offs en los sistemas de datos: transaccional y analítico, un nodo y muchos | Modelos de datos, formatos y evolución de esquemas y contratos | Cambiar un contrato sin romper a quien lo usa | |
| 10 | Replicación con un líder: síncrona y asíncrona, retraso y failover | Varios líderes y sin líder: conflictos y quórums · ✂️ Dynamo | Una réplica de PostgreSQL: retraso, read-your-writes y failover | |
| 11 | Sharding: por rango, por hash, rebalanceo y hot spots | Cache y escalabilidad: cache-aside, invalidación, estampida, servicios sin estado | Cache-aside con Redis en Tinkuy y una estampida | P3 entrega · P4 publicado |
| 12 | Transacciones y niveles de aislamiento: cómo se vende dos veces un asiento | Transacciones entre servicios: two-phase commit, sagas, idempotencia y outbox | No vender el mismo asiento dos veces, de tres maneras | |
| 13 | Mensajería: colas y logs, garantías de entrega y orden | Event sourcing y CQRS · Consistencia y consenso para quien diseña | Outbox y consumidor idempotente con NATS JetStream | |
| 14 | Resiliencia: timeouts, retries, circuit breaker, bulkhead y load shedding | Observabilidad: logs, métricas, trazas y SLOs | Una pasarela de pagos lenta y caída, con Toxiproxy | P4 entrega · P5 publicado |
| 15 | Evolución: fitness functions, deuda de arquitectura, strangler fig y ley de Conway | Arquitectura de sistemas con modelos de lenguaje: RAG, agentes, guardrails, costo y latencia | Fitness functions para Tinkuy | |
| 16 | Casos: la arquitectura de sistemas reales · ✂️ el rol de quien hace arquitectura | Presentaciones finales | Defensa oral del proyecto | P5 entrega |
| — | Examen final en el período de exámenes |
Sobre el examen final: el calendario asume que la universidad tiene un período de exámenes después de la semana 16. Si no lo tiene, el final se toma en la Sesión A de la semana 16 y los temas ✂️ pasan a lectura autónoma.
6. Proyecto
El proyecto es un solo sistema, Tinkuy, que se rediseña seis veces. Cada
entrega trae un requisito de calidad nuevo, escrito como escenario con su
medida, que el diseño anterior no cumple. El equipo decide cómo cambiar la
arquitectura, lo implementa, lo documenta (un ADR por decisión y los diagramas
C4 actualizados) y comprueba el escenario con las pruebas públicas: reglas de
dependencia, pruebas de carga con umbrales e inyección de fallas. Cada entrega
debe seguir pasando las pruebas de las anteriores. El detalle y las reglas de
entrega están en projects/README.md.
| # | Entrega | Lo que agrega | Publicado | Entrega |
|---|---|---|---|---|
| P0 | Reconocimiento | Leer el monolito inicial: diagramas C4 de contexto y de contenedores, tres escenarios de calidad medidos con k6 y una regla de dependencia que ya no se viola (individual) | Sem. 1 | Sem. 3 |
| P1 | Módulos con límites | Modular monolith con límites que se comprueban en cada build, y un medio de pago nuevo agregado como plug-in sin tocar el núcleo | Sem. 3 | Sem. 5 |
| P2 | La apertura de ventas | La venta de un concierto bajo carga: latencia p95 dentro del umbral y ninguna entrada vendida dos veces, con las tácticas elegidas justificadas en ADRs | Sem. 5 | Sem. 8 |
| P3 | Lecturas que escalan | Una réplica de lectura y una cache: el catálogo responde aunque el principal esté ocupado, y quien compra ve su compra de inmediato | Sem. 8 | Sem. 11 |
| P4 | Pagos como servicio | Los pagos salen del monolito a un servicio propio: saga de compra, outbox, mensajes con NATS y consumidores idempotentes | Sem. 11 | Sem. 14 |
| P5 | Cuando algo falla | La pasarela de pagos lenta o caída no tumba la venta: timeouts, circuit breaker y load shedding comprobados con Toxiproxy, SLOs, fitness functions y el documento de arquitectura final, con defensa oral | Sem. 14 | Sem. 16 |
7. Uso de herramientas e inteligencia artificial
[confirmar] La tabla siguiente es la propuesta por defecto; cada fila la decide el docente antes de publicar el curso.
| Herramienta | Proyecto y laboratorios | Exámenes |
|---|---|---|
Diagnósticos del compilador y del intérprete (tsc, los errores de Node.js) y herramientas que revisan el programa (depcruise) |
[confirmar] | [confirmar] |
| Documentación oficial (Node.js, PostgreSQL, Redis, NATS, las herramientas del curso) y búsqueda en la web | [confirmar] | [confirmar] |
| Autocompletado del editor que completa nombres y líneas, sin generar soluciones enteras | [confirmar] | [confirmar] |
| Corrector ortográfico, traductor y herramientas de accesibilidad | [confirmar] | [confirmar] |
| Formateadores (el formateador del editor) | [confirmar] | [confirmar] |
| IA generativa para explicar conceptos, errores o código, sin que escriba lo entregado | [confirmar] | [confirmar] |
| IA generativa que escribe código, pruebas, ADRs o diagramas | [confirmar] | [confirmar] |
Cómo se declara. [confirmar] Qué se escribe y dónde cuando se usa una herramienta permitida que debe declararse.
Explicación oral. A cualquier estudiante se le puede pedir que explique de forma oral cualquier parte de lo que entregó su equipo: qué decisión se tomó, qué alternativas se descartaron y cómo se comprobó. La defensa oral de la semana 16 es una de esas ocasiones, pero no la única.
8. Políticas
- Equipos: P0 es individual. P1–P5: [confirmar] (parejas o equipos, y si se mantienen todo el semestre).
- Integridad académica: se puede discutir ideas con otros equipos, pero el código, los ADRs, los diagramas y las mediciones entregados deben ser del equipo. Copiar el trabajo de otro equipo o de un proyecto publicado cuenta como plagio. Las mediciones se entregan tal como salieron: retocar un número para pasar un umbral es una falta igual de grave.
- Herramientas e IA: ver la sección 7.
9. Entorno de trabajo
Todo el trabajo práctico se hace dentro de un contenedor Docker que trae
Node.js 26 (que ejecuta TypeScript directamente), PostgreSQL 18, Redis, NATS
con JetStream, k6 para las pruebas de carga, Toxiproxy para inyectar fallas de
red, y tsc y dependency-cruiser. Todos los servicios corren dentro del mismo
contenedor, así que no hace falta instalar ni configurar nada más, y funciona
igual en Linux, Windows (WSL2) y macOS (incluido Apple Silicon). Instrucciones
en labs/README.md.