1. Contenidos
1.1 Herramientas de desarrollo en entorno servidor
Desarrollar una aplicación web en entorno servidor no consiste únicamente en escribir código. Durante el ciclo de desarrollo utilizamos distintas herramientas para editar, ejecutar, probar, depurar, gestionar dependencias, controlar versiones y desplegar la aplicación.
Las herramientas más habituales pueden agruparse por su función:
| Tipo de herramienta |
Función |
Ejemplos |
| Editor / IDE |
Escribir, navegar, refactorizar y depurar código. |
Visual Studio Code, PhpStorm, IntelliJ IDEA, Visual Studio |
| Terminal |
Ejecutar comandos, servidores, scripts y herramientas del proyecto. |
Bash, PowerShell, terminal integrada del IDE |
| Control de versiones |
Registrar cambios y facilitar el trabajo colaborativo. |
Git |
| Gestor de dependencias |
Instalar y actualizar librerías utilizadas por el proyecto. |
Composer, npm, pip, Maven, Gradle, NuGet |
| Servidor / entorno local |
Ejecutar la aplicación durante el desarrollo. |
PHP Development Server, Apache, Nginx, Docker |
| Cliente HTTP |
Enviar peticiones y comprobar respuestas de una aplicación o API. |
curl, Postman, herramientas similares |
| Herramientas de base de datos |
Consultar, modificar y administrar bases de datos. |
SQLite CLI, DBeaver, phpMyAdmin, clientes específicos |
| Pruebas |
Comprobar automáticamente que el software se comporta como se espera. |
PHPUnit, JUnit, pytest, herramientas propias del framework |
Idea clave: una herramienta no forma necesariamente parte de la aplicación final. Por ejemplo, Git o un IDE ayudan a desarrollar el proyecto, pero no son componentes que el usuario necesite para utilizar la aplicación.
1.2 Gestores de dependencias
Las aplicaciones actuales suelen utilizar código desarrollado por terceros. En lugar de copiar manualmente estas librerías dentro del proyecto, utilizamos un gestor de dependencias.
Un gestor de dependencias permite:
- Declarar qué paquetes necesita una aplicación.
- Descargar automáticamente esos paquetes.
- Resolver las dependencias entre unas librerías y otras.
- Controlar las versiones compatibles.
- Actualizar las dependencias de forma organizada.
- Reproducir el mismo entorno de dependencias en distintos equipos.
Ejemplo: Composer en PHP
Composer es un gestor de dependencias para PHP. Las dependencias principales del proyecto se declaran normalmente en el fichero composer.json.
{
"require": {
"monolog/monolog": "^3.0"
}
}
Posteriormente pueden instalarse desde la terminal:
composer install
Composer crea además un mecanismo de autoload que permite cargar automáticamente las clases instaladas.
<?php
require __DIR__ . '/vendor/autoload.php';
Gestores habituales según el ecosistema
| Ecosistema |
Gestor habitual |
Fichero de configuración habitual |
| PHP | Composer | composer.json |
| JavaScript / Node.js | npm | package.json |
| Python | pip y otras herramientas del ecosistema | requirements.txt o pyproject.toml |
| Java | Maven / Gradle | pom.xml / ficheros Gradle |
| .NET | NuGet | Fichero de proyecto |
Importante: incorporar una dependencia ahorra trabajo, pero también introduce código externo que deberá mantenerse y actualizarse. Antes de añadir una librería conviene comprobar que aporta suficiente valor al proyecto.
1.3 ¿Qué es un framework?
Un framework es un conjunto organizado de componentes, convenciones y herramientas que proporciona una estructura de partida para desarrollar aplicaciones.
Cuando programamos sin framework debemos decidir y construir manualmente muchos aspectos comunes:
- Cómo asociamos una URL con una operación.
- Cómo organizamos los ficheros.
- Cómo validamos los datos.
- Cómo accedemos a la base de datos.
- Cómo gestionamos usuarios y sesiones.
- Cómo generamos las vistas.
- Cómo gestionamos errores.
- Cómo configuramos y probamos la aplicación.
Un framework proporciona soluciones, convenciones o puntos de extensión para muchas de estas tareas.
Funciones habituales de un framework web
| Funcionalidad |
Ejemplo de necesidad |
| Enrutamiento | Relacionar /productos/25 con el código que muestra el producto 25. |
| Controladores / handlers | Organizar el código que responde a cada operación. |
| Plantillas | Separar los datos de la estructura HTML. |
| Validación | Comprobar los datos recibidos desde formularios o APIs. |
| Acceso a datos / ORM | Trabajar con registros de una base de datos mediante objetos o abstracciones. |
| Autenticación | Gestionar usuarios e inicio de sesión. |
| Middleware | Ejecutar operaciones comunes antes o después de una petición. |
| Configuración | Gestionar parámetros distintos para desarrollo y producción. |
| Pruebas | Facilitar la creación de tests automatizados. |
| CLI | Crear componentes, ejecutar migraciones o iniciar el servidor desde terminal. |
1.4 Framework, librería y runtime
Estos conceptos están relacionados, pero no son equivalentes.
| Concepto |
Función |
Ejemplo |
| Runtime |
Proporciona el entorno necesario para ejecutar el programa. |
PHP, Node.js, JVM, .NET Runtime |
| Librería |
Proporciona funciones o componentes concretos que nuestro código utiliza cuando los necesita. |
Una librería para generar PDF o registrar logs |
| Framework |
Proporciona una estructura global y define una forma de organizar la aplicación. |
Laravel, Symfony, Django, Spring Boot, ASP.NET Core |
Una aplicación puede utilizar simultáneamente los tres niveles:
PHP ← Runtime
│
▼
Laravel ← Framework
│
├── componente de correo
├── librería de logs
└── otras dependencias ← Librerías
1.5 Principales frameworks de programación en servidor
Existen frameworks para prácticamente todos los lenguajes utilizados en desarrollo web. No existe un framework universalmente mejor: cada uno responde a un ecosistema, una filosofía y unas necesidades determinadas.
Laravel
Laravel es un framework de aplicaciones web para PHP. Proporciona una estructura completa para desarrollar aplicaciones y ofrece funcionalidades relacionadas con enrutamiento, acceso a datos, validación, colas, tareas programadas, pruebas y otros servicios habituales.
- Lenguaje: PHP.
- Enfoque: framework de propósito general con numerosas funcionalidades integradas.
- Adecuado para: aplicaciones web, paneles, servicios y APIs desarrollados en el ecosistema PHP.
Symfony
Symfony es un framework PHP basado en componentes reutilizables. Puede utilizarse como framework completo o aprovechar determinados componentes dentro de otros proyectos.
- Lenguaje: PHP.
- Enfoque: modular y basado en componentes.
- Adecuado para: aplicaciones PHP que requieren una estructura sólida y un alto nivel de configuración.
Spring Boot
Spring Boot facilita la creación de aplicaciones basadas en Spring que pueden ejecutarse como aplicaciones autónomas. Reduce gran parte de la configuración inicial necesaria y se integra con el amplio ecosistema Spring.
- Lenguaje principal: Java.
- Enfoque: aplicaciones autónomas basadas en Spring con configuración simplificada.
- Adecuado para: servicios, APIs y aplicaciones empresariales dentro del ecosistema Java.
Django
Django es un framework web escrito en Python orientado a facilitar el desarrollo de aplicaciones basadas en datos. Incluye herramientas para modelos, vistas, plantillas, formularios, administración y otros elementos habituales.
- Lenguaje: Python.
- Enfoque: framework completo con numerosas funcionalidades integradas.
- Adecuado para: aplicaciones web en las que Python sea una elección apropiada para el equipo o el proyecto.
Flask
Flask es un framework ligero para Python. Proporciona un núcleo reducido y permite incorporar extensiones según las necesidades del proyecto.
- Lenguaje: Python.
- Enfoque: minimalista y extensible.
- Adecuado para: aplicaciones pequeñas, servicios o proyectos en los que se prefiera seleccionar los componentes de forma explícita.
Express
Express es un framework web minimalista y flexible para Node.js. Se centra especialmente en el enrutamiento, el middleware y el manejo de peticiones y respuestas.
- Lenguaje: JavaScript o TypeScript sobre Node.js.
- Enfoque: núcleo reducido y basado en middleware.
- Adecuado para: APIs y servicios web donde se quiera trabajar dentro del ecosistema JavaScript/Node.js.
ASP.NET Core
ASP.NET Core es un framework web multiplataforma del ecosistema .NET para construir aplicaciones y servicios web.
- Lenguaje habitual: C#.
- Enfoque: framework completo integrado con la plataforma .NET.
- Adecuado para: aplicaciones web y APIs dentro del ecosistema .NET.
Comparación general
| Framework |
Ecosistema |
Orientación general |
| Laravel | PHP | Framework completo y productivo |
| Symfony | PHP | Framework modular y basado en componentes |
| Spring Boot | Java | Aplicaciones y servicios basados en Spring |
| Django | Python | Framework completo orientado a aplicaciones basadas en datos |
| Flask | Python | Framework ligero y extensible |
| Express | Node.js | Framework minimalista basado en rutas y middleware |
| ASP.NET Core | .NET / C# | Framework web completo del ecosistema .NET |
1.6 Programar sin framework y con framework
Un framework no permite hacer algo que sea necesariamente imposible sin él. Su principal aportación es proporcionar estructura, convenciones y componentes reutilizables para resolver problemas frecuentes.
Sin framework
En una aplicación PHP muy sencilla podríamos decidir manualmente qué código ejecutar según la URL:
<?php
$ruta = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
if ($ruta === '/') {
require 'inicio.php';
} elseif ($ruta === '/productos') {
require 'productos.php';
} else {
http_response_code(404);
require '404.php';
}
Con un framework
Un framework suele ofrecer una abstracción específica para definir rutas. Un ejemplo conceptual sería:
Route::get('/', [InicioController::class, 'index']);
Route::get(
'/productos',
[ProductoController::class, 'index']
);
El framework se ocupa de proporcionar el mecanismo de enrutamiento y establece una convención para organizar el código.
Ventajas de utilizar un framework
- Reduce la necesidad de resolver repetidamente problemas comunes.
- Proporciona una estructura reconocible al proyecto.
- Facilita el mantenimiento y el trabajo en equipo.
- Integra herramientas de seguridad, validación, pruebas o acceso a datos.
- Permite aprovechar documentación, ecosistema y componentes existentes.
Posibles limitaciones
- Requiere aprender sus convenciones y herramientas.
- Introduce dependencias adicionales.
- Puede resultar excesivo para programas muy pequeños.
- Las decisiones arquitectónicas quedan parcialmente condicionadas por el framework.
- El proyecto deberá mantenerse compatible con la evolución de sus dependencias.
Idea clave: utilizar un framework no sustituye el conocimiento de HTTP, programación, bases de datos o seguridad. El framework proporciona abstracciones sobre esos conceptos, pero el desarrollador debe comprender qué problema está resolviendo.
1.7 Selección de tecnologías y arquitectura
Elegir una tecnología porque es popular o porque el equipo ya la conoce puede ser un punto de partida, pero una decisión técnica debe relacionarse con los requisitos reales del proyecto.
El proceso puede realizarse en este orden:
- Comprender el problema.
- Identificar requisitos funcionales y no funcionales.
- Determinar los componentes necesarios.
- Proponer tecnologías compatibles.
- Comparar ventajas y limitaciones.
- Seleccionar una solución y justificarla.
Requisitos funcionales
Describen qué debe hacer la aplicación.
- Registrar usuarios.
- Gestionar productos.
- Procesar pedidos.
- Generar informes.
- Ofrecer una API.
Requisitos no funcionales
Describen cómo debe comportarse el sistema o qué restricciones debe cumplir.
- Número esperado de usuarios.
- Necesidades de rendimiento.
- Seguridad.
- Disponibilidad.
- Facilidad de mantenimiento.
- Capacidad de crecimiento.
- Coste de infraestructura.
- Experiencia disponible en el equipo.
1.8 Criterios para seleccionar un lenguaje y un framework
No existe una fórmula automática para seleccionar una tecnología, pero podemos evaluar varias dimensiones.
| Criterio |
Preguntas que debemos formular |
| Adecuación funcional |
¿Permite resolver de forma natural las funcionalidades principales? |
| Conocimiento del equipo |
¿El equipo domina la tecnología? ¿Cuánto tiempo necesita para aprenderla? |
| Mantenibilidad |
¿Favorece una estructura comprensible y fácil de evolucionar? |
| Ecosistema |
¿Dispone de librerías, herramientas y documentación suficientes? |
| Madurez y soporte |
¿La tecnología tiene mantenimiento activo y una comunidad o entidad responsable? |
| Seguridad |
¿Proporciona mecanismos que facilitan desarrollar de forma segura? |
| Rendimiento |
¿Sus características son adecuadas para la carga prevista? |
| Escalabilidad |
¿Podemos ampliar el sistema si aumenta su utilización? |
| Despliegue |
¿La infraestructura disponible permite ejecutarla y mantenerla con facilidad? |
| Coste |
¿Qué costes de infraestructura, licencias, formación y mantenimiento implica? |
Importante: una elección técnica es buena cuando está bien ajustada al problema y sus restricciones. Dos equipos pueden proponer soluciones diferentes para el mismo proyecto y ambas ser válidas si están correctamente justificadas.
1.9 Matriz de decisión
Cuando existen varias alternativas razonables puede utilizarse una matriz de decisión. Consiste en seleccionar criterios, asignar una puntuación a cada alternativa y utilizar la comparación como apoyo a la decisión.
Por ejemplo, un equipo puede comparar tres alternativas utilizando una escala de 1 a 5:
| Criterio |
Alternativa A |
Alternativa B |
Alternativa C |
| Experiencia del equipo | 5 | 3 | 2 |
| Adecuación al proyecto | 4 | 5 | 4 |
| Ecosistema | 4 | 4 | 5 |
| Facilidad de despliegue | 5 | 3 | 3 |
| Mantenibilidad | 4 | 5 | 4 |
La puntuación no debe sustituir al razonamiento. Su función es hacer visibles los criterios utilizados y facilitar la comparación.
1.10 Herramientas y arquitectura como conjunto
La decisión final no consiste únicamente en seleccionar un lenguaje o un framework. Una propuesta tecnológica incluye varios elementos que deben ser compatibles entre sí.
PROYECTO
|
+-- Lenguaje
|
+-- Framework
|
+-- Base de datos
|
+-- Servidor / runtime
|
+-- Gestor de dependencias
|
+-- Herramientas de desarrollo
|
+-- Control de versiones
|
+-- Estrategia de pruebas
|
+-- Despliegue
Por ejemplo, una posible propuesta podría ser:
Lenguaje: PHP
Framework: Laravel
Gestor dependencias: Composer
Base de datos: PostgreSQL
Servidor web: Nginx
Control de versiones: Git
IDE/editor: VS Code / PhpStorm
Pruebas: herramientas del ecosistema PHP
Esta lista no constituye por sí sola una buena arquitectura. El equipo debe explicar por qué cada decisión es adecuada para los requisitos del proyecto.
2. Ejercicios
2.1 Mini-sprint de selección tecnológica y arquitectura
Trabajaréis en equipos como si fuerais el grupo técnico responsable de comenzar un nuevo proyecto. Cada equipo recibirá uno de los casos propuestos por el profesor.
El objetivo no es encontrar una única respuesta correcta, sino construir una propuesta técnica coherente y justificada.
Fase 1. Analizar el proyecto
Leed el caso e identificad:
- Las funcionalidades principales.
- Los tipos de usuarios.
- Los datos que deberá almacenar la aplicación.
- Los requisitos de seguridad más evidentes.
- Las necesidades de rendimiento o concurrencia.
- Las posibilidades de crecimiento futuro.
Fase 2. Elegir la solución tecnológica
El equipo debe seleccionar, como mínimo:
| Elemento |
Decisión del equipo |
| Lenguaje de servidor | |
| Framework | |
| Servidor web / forma de ejecución | |
| Base de datos | |
| Gestor de dependencias | |
| Editor o IDE | |
| Control de versiones | |
| Herramientas adicionales | |
Fase 3. Justificar las decisiones
Para cada decisión importante debéis utilizar el siguiente esquema:
DECISIÓN:
Elegimos ___________________________
PORQUE:
____________________________________
____________________________________
VENTAJAS PARA ESTE PROYECTO:
1. __________________________________
2. __________________________________
3. __________________________________
LIMITACIÓN O RIESGO:
____________________________________
Como mínimo deberán justificarse:
- El lenguaje.
- El framework.
- La base de datos.
- La arquitectura general.
Fase 4. Diagrama de arquitectura
Dibujad un diagrama que represente los componentes principales del sistema y la comunicación entre ellos.
El diagrama debe identificar, cuando corresponda:
- Cliente / navegador.
- Servidor web.
- Aplicación o framework.
- Runtime.
- Base de datos.
- Servicios externos.
- Principales comunicaciones.
Fase 5. Alternativa descartada
Elegid una tecnología alternativa que también pudiera utilizarse y explicad:
- Qué alternativa habéis considerado.
- Qué ventajas tendría.
- Por qué finalmente habéis elegido otra opción.
Objetivo: justificar una alternativa descartada obliga a comparar tecnologías y evita que la decisión se reduzca a elegir automáticamente la herramienta que ya conocemos.
Fase 6. Presentación de la propuesta
Cada equipo dispondrá de un máximo de 3 minutos para presentar su propuesta al resto de la clase.
La presentación debe explicar:
- Qué problema debe resolver el sistema.
- Qué arquitectura proponéis.
- Qué lenguaje y framework habéis elegido.
- Las razones principales de vuestra elección.
- Una limitación o riesgo de vuestra propuesta.
Fase 7. Coevaluación
Mientras un equipo presenta, el resto de equipos evaluará la propuesta utilizando la rúbrica facilitada por el profesor.
La evaluación debe valorar principalmente:
- La adecuación de la solución al problema.
- La calidad de la justificación.
- La coherencia de la arquitectura.
- La identificación de ventajas y limitaciones.
- La claridad de la comunicación.
Recuerda: no se debe penalizar una propuesta únicamente por utilizar una tecnología diferente a la elegida por vuestro equipo. Lo que se evalúa es si la elección está razonada y responde correctamente a los requisitos.