Principios del Software: diseñando sistemas robustos sin morir en el intento

En ingeniería de software existen reglas no escritas que todo desarrollador termina aprendiendo a golpes… o leyendo un buen blog 😎 Estas directrices nos ayudan a construir sistemas mantenibles, escalables, robustos y con menos bugs que líneas de código mal indentadas.

Hoy veremos los principios más importantes, categorizados y con ejemplos prácticos para que te vayas con ideas claras y aplicables desde ya.

🧱 Principios fundamentales de ingeniería de software

1. Modularidad

Dividir el software en piezas independientes para que puedas trabajar sin romperlo todo.

✅ Ventajas:

• Puedes probar módulos por separado

• Puedes trabajar en equipo (sin conflictos Git infernales)

• Facilita el mantenimiento

💡 Ejemplo (Node.js/React): Imagina que tienes un dashboard y decides separar:

/components ├── ChartCard.jsx ├── MetricsSummary.jsx ├── UserTable.jsx

Cada componente maneja algo independiente. Si UserTable explota, tu Chart sigue chill.

2. Abstracción

Ocultar la complejidad detrás de interfaces simples (como cuando importas y no te interesa qué brujería hay detrás).

💡 Ejemplo (JavaScript):

1// ❌ Sin abstracción
2fetch('https://api.example.com/users')
3  .then(res => res.json())
4  .then(data => console.log(data));
5
6// ✅ Con abstracción
7import { getUsers } from './api/users';
8
9getUsers().then(users => console.log(users));

Con esto:

• getUsers() es simple

• El fetch queda escondido en un módulo separado

• No tienes que leer URLs en tu lógica principal

3. Encapsulación

Agrupar datos y funciones dentro de una entidad y restringir el acceso interno para evitar caídas tipo dominó.

💡 Ejemplo (POO en JavaScript):

1class Counter {
2  #count = 0; // privado
3
4  increment() {
5    this.#count++;
6  }
7
8  get value() {
9    return this.#count;
10  }
11}
12
13const c = new Counter();
14c.increment();
15console.log(c.value); // 1
16console.log(c.#count); // ❌ Error, está encapsulado

4. Separación de intereses

Cada parte del sistema debe encargarse de una tarea y no más.

💡 Ejemplo:

• El Backend maneja lógica y datos

• El Frontend renderiza UI

• Los estilos (CSS) no van dentro de la lógica

• Las validaciones no van dentro de la UI

Si mezclas todo: terminas con espagueti code y el italiano se ofende 🍝

🧠 Principios SOLID — la Biblia no oficial de la POO

S – Responsabilidad Única (SRP)

Cada clase/componente/módulo debe hacer una sola cosa.

💡 React ejemplo:

1// ❌ Este componente hace todo (UI + fetch + lógica)
2function UserList() { ... }
3
4// ✅ Mejor modular
5function UserListUI({ users }) { ... }
6function useUsers() { ... } // hook que obtiene datos

O – Abierto/Cerrado (OCP)

Debes poder extender sin tocar el código original.

💡 Ejemplo:

1// ✅ Usamos estrategia o patrón para extender
2class Logger {
3  log(message) { console.log(message) }
4}
5
6class FileLogger extends Logger {
7  log(message) { saveToFile(message) } // Extendemos sin modificar Logger
8}

L – Sustitución de Liskov (LSP)

No debes romper nada al cambiar una clase por su hija.

💡 Ejemplo válido:

1function printLogger(logger) {
2  logger.log("Hola mundo");
3}
4
5printLogger(new Logger());      ✅
6printLogger(new FileLogger());  ✅ tampoco rompe

I – Segregación de interfaces (ISP)

Es mejor tener interfaces pequeñas que una gigante que nadie usa completa.

💡 Ejemplo:

1// ❌
2interface Animal { correr(); nadar(); volar(); }
3
4// ✅
5interface Runner { correr(); }
6interface Swimmer { nadar(); }
7interface Flyer { volar(); }

D – Inversión de dependencias (DIP)

No dependas de lo específico, depende de lo abstracto.

💡 JavaScript ejemplo:

1// ❌ Muy acoplado
2import MySQL from './db/mysql';
3
4// ✅ Usamos abstracción
5import DB from './db';
6
7DB.connect();

🧰 Otros principios notables

DRY — Don’t Repeat Yourself

Si escribes lo mismo 2 veces, ya estás perdiendo.

💡 Ejemplo:

1// ❌ Duplicación
2const totalA = priceA * 1.19;
3const totalB = priceB * 1.19;
4
5// ✅ Extracto
6const calcIVA = price => price * 1.19;
7
8const totalA = calcIVA(priceA);
9const totalB = calcIVA(priceB);

KISS — Keep It Simple

No compliques lo que puede ser simple.

Si puedes hacerlo entendible por tu yo del pasado, lo estás haciendo bien.

YAGNI — No lo vas a necesitar

¿Crear un sistema de plugins para una app que ni siquiera tiene usuarios? Tranquilo Iron Man, no lo necesitas todavía 🤖

Anticipación al cambio

Todo cambia:

• requisitos

• tecnologías

• hasta tu framework favorito 😭 (F por AngularJS)

Diseña pensando en adaptabilidad, pero sin sobreingeniería.

💡 Ejemplo práctico:

• Configuración por variables de entorno (.env)

• Servicios desacoplados

• Componentes reutilizables

• Arquitecturas tipo microservicios cuando lo amerita

🏁 Conclusiones

¿Qué puedes hacer HOY para aplicarlos?

✅ Lista rápida:

1. Extrae funciones repetidas (DRY)

2. Separa lógica y UI (SRP + SoC)

3. Usa módulos/servicios (Modularidad)

4. Oculta lo complejo detrás de funciones (Abstracción)

5. Evita “por si acaso” features (YAGNI)

6. Piensa en extensiones, no modificaciones (OCP)

7. Usa hooks y composición en React para separar preocupaciones

Si te gustó este post, sígueme en Instagram donde subo tips de programación, arquitectura y memes 💻🔥 Y si quieres más contenido profundo, visita mi blog: 👉 andercdev.com/blog

Nos vemos en el próximo post 👋😎