DEVELOPER

Bajo la categoría de 'Developer', agrupo todos aquellos temas esenciales del desarrollo de software en general y contenidos transversales que van más allá de la programación pura.

En este espacio comparto desde ideas, sugerencias y recursos clave para la búsqueda de empleo en el sector, hasta mi propio glosario personal de términos técnicos explicados a mi manera. En resumen: todo lo que define el día a día en el escenario general de un Dev.

+

Roadmap de fundamentos de programación

Casi todos los roadmaps que circulan son listas de tecnologías. El problema de esas listas es que envejecen mal: la herramienta de moda de hace tres años hoy está archivada, y quien la estudió siente que perdió el tiempo.

Este roadmap está armado al revés. Primero los fundamentos, que cambian muy poco, y después las herramientas, que son intercambiables. Un desarrollador que entiende HTTP, estructuras de datos y diseño de software aprende un framework nuevo en dos semanas. Al revés no funciona.

Está organizado en once fases. No hace falta dominar una al 100 % para pasar a la siguiente: la idea es dar varias vueltas al mismo mapa, cada vez más profundo.

Cómo usar este roadmap:

Elige un solo lenguaje para las fases 1 a 3. Python, JavaScript/TypeScript, Java o C# son buenas apuestas. Cambiar de lenguaje cada mes es la forma más eficiente de no aprender ninguno.
Construye algo en cada fase. El conocimiento que no pasa por un proyecto se evapora.
Publica lo que construyes. Un repositorio con commits reales vale más que un certificado.

1

Pensar como programador:

Antes de la sintaxis está el razonamiento. Esta fase es la que más gente se salta y la que más caro se cobra después.

Temas:

Lógica de programación: algoritmos y pseudocódigo.
Diagramas de flujo (útiles para entender el control de flujo; no para documentar sistemas).
Descomposición de problemas: partir un problema grande en pasos verificables.
Depuración como método: leer el error, formular una hipótesis, probarla.
Línea de comandos desde el primer día: navegación, permisos, tuberías, variables de entorno.
Control de versiones desde el primer día: qué es un commit, una rama, un merge.

Fuentes:

Proyecto sugerido: una utilidad de consola (conversor, calculadora de cuotas, organizador de archivos) con su repositorio en Git e historial de commits legible.

2

Conceptos básicos:

Variables y tipos de datos: enteros, flotantes, cadenas, booleanos.
Tipado estático vs. dinámico, fuerte vs. débil. Por qué existe TypeScript.
Operadores aritméticos, relacionales y lógicos.
Estructuras de control: if/else, switch/pattern matching.
Bucles: for, while, do-while, iteradores.
Funciones: parámetros, valores de retorno, alcance (scope), closures.
Recursión y su costo.
Manejo de errores y excepciones. Qué capturar y qué dejar propagar.
Manejo de memoria a grandes rasgos: pila vs. montículo, referencias, garbage collector.

Programación orientada a objetos:

Clases y objetos, atributos y métodos.
Encapsulamiento, herencia, polimorfismo, abstracción.
Interfaces y clases abstractas.
Composición sobre herencia: la jerarquía profunda de clases es hoy un antipatrón más que un objetivo.

Programación funcional (ya no es «avanzado»)

Funciones puras, inmutabilidad, efectos secundarios.
map, filter, reduce y funciones de orden superior.
Por qué casi todos los lenguajes modernos mezclan ambos paradigmas.

Concurrencia y asincronía

Procesos, hilos, sincronización, condiciones de carrera, deadlocks.
Modelo asíncrono: callbacks, promesas, async/await, bucles de eventos.

Fuentes:

3

Estructuras de datos y algoritmos

Sigue siendo lo que separa a quien programa de quien resuelve. También es lo que miden las entrevistas técnicas.

Estructuras

Arreglos y listas dinámicas.
Listas enlazadas (simples, dobles, circulares).
Interfaces y clases abstractas.Pilas y colas; colas de prioridad y heaps.
Tablas hash — la estructura más usada del mundo real.
Árboles: binarios, de búsqueda, AVL, rojo-negro, tries.
Grafos y sus representaciones.
Conjuntos y mapas de la librería estándar de tu lenguaje (en el trabajo diario, esto es el 90 %).

Algoritmos

Búsqueda lineal y binaria.
Ordenamiento: burbuja, selección, inserción, quicksort, mergesort (entender por qué en producción se usa el sort de la librería estándar).
Recorridos de grafos: BFS, DFS, Dijkstra.
Programación dinámica y memoización, a nivel introductorio.
Análisis de complejidad (Big O) en tiempo y espacio.

Fuentes:

4

Datos: modelado y persistencia

Conceptos que no caducan

Modelado de datos y diagramas entidad-relación.
Normalización y cuándo desnormalizar a propósito.
Transacciones y propiedades ACID; niveles de aislamiento.
Índices: qué son, cuándo ayudan y cuándo estorban.
Claves primarias, foráneas e integridad referencial.

SQL

SELECT, INSERT, UPDATE, DELETE.
JOIN en todas sus formas, GROUP BY, HAVING, ORDER BY.
Subconsultas, CTE (WITH) y funciones de ventana — hoy son básicas, no avanzadas.
Motores: PostgreSQL, MySQL/MariaDB, SQL Server, Oracle, SQLite. PostgreSQL se ha consolidado como la opción por defecto para proyectos nuevos; si vas a aprender uno solo, que sea ese.

NoSQL

Documentales (MongoDB), clave-valor (Redis, DynamoDB), columnares (Cassandra), grafos (Neo4j), vectoriales (pgvector, Qdrant) para búsqueda semántica y aplicaciones con IA.
Teorema CAP y consistencia eventual.
Criterio honesto: empieza en relacional y justifica cualquier desvío.

NoSQL

Documentales (MongoDB), clave-valor (Redis, DynamoDB), columnares (Cassandra), grafos (Neo4j), vectoriales (pgvector, Qdrant) para búsqueda semántica y aplicaciones con IA.
Teorema CAP y consistencia eventual.
Criterio honesto: empieza en relacional y justifica cualquier desvío.

Fuentes:

5

La web por dentro

Cimientos (antes de cualquier framework)

HTTP/HTTPS: métodos, códigos de estado, cabeceras, cookies, caché, CORS.
DNS, TCP/IP, UDP, modelo OSI, TLS.
Cómo funciona un navegador: DOM, CSSOM, render, event loop.
MDN: HTTP 🇪🇸 · Roadmap de diseño de APIs.

Frontend

HTML emántico y accesibilidad (WCAG, roles ARIA, navegación por teclado). La accesibilidad dejó de ser opcional: en muchos mercados es requisito legal.
CSS: Flexbox, Grid, diseño responsivo, variables nativas, container queries, capas (@layer). Los preprocesadores tipo Sass ya no son obligatorios: buena parte de lo que aportaban hoy es CSS nativo.
JavaScript moderno: manipulación del DOM, fetch, módulos ES, ES2020+.
TypeScript: en la práctica es el estándar profesional del frontend.
Frameworks: React, Angular, Vue, además de Svelte y Solid. Aprende uno a fondo.
Herramientas de build: Vite es hoy el estándar de facto; Webpack sigue vivo en proyectos heredados y aparecen alternativas rápidas como Rspack, Turbopack y Rolldown. ⚠️ Create React App quedó oficialmente descontinuado en 2025: para proyectos nuevos, la propia documentación de React recomienda un framework o un build tool moderno.
Renderizado: CSR, SSR, SSG e islas. Next.js, Nuxt, Astro, Angular SSR.
web.dev para rendimiento y buenas prácticas (Core Web Vitals).

Backend

Arquitecturas de API: REST, GraphQL, gRPC, WebSockets, eventos.
Autenticación y autorización: sesiones, JWT, OAuth 2.0, OpenID Connect, passkeys.
Validación de entradas, paginación, versionado, manejo de errores, idempotencia.
Servidores y proxys: Nginx, Caddy, Apache.
Frameworks: Spring Boot, ASP.NET Core, Django, FastAPI, Express/NestJS, Laravel, Go (net/http).
Runtimes de JavaScript: Node.js sigue siendo el estándar; Deno y Bun ya son opciones reales.

Móvil

Nativo: Kotlin (Android), Swift (iOS).
Multiplataforma: Flutter, React Native, Kotlin Multiplatform, .NET MAUI. ⚠️ Xamarin dejó de tener soporte el 1 de mayo de 2024; su sucesor es .NET MAUI. Objective-C solo tiene sentido para mantener código existente.

Fuentes:

6

Calidad: pruebas y código limpio

Tipos de prueba

Unitarias, de integración, de extremo a extremo (E2E).
De rendimiento, de carga, de seguridad, de usabilidad.
Pirámide de pruebas: muchas unitarias, algunas de integración, pocas E2E. Explicación de Martin Fowler.

Metodologías

TDD (red → green → refactor) y BDD.
Pruebas como documentación ejecutable.

Herramientas vigentes

JS/TS: Vitest y Jest para unitarias; Playwright para E2E (desplazó a Selenium y compite de frente con Cypress).
Python: pytest. Java: JUnit 5. .NET: xUnit/NUnit.

Código limpio

Nombres que explican la intención; funciones cortas con una sola responsabilidad.
Comentarios que explican el por qué, no el qué.
Refactorización continua y detección de code smells: catálogo de Refactoring Guru 🇪🇸.
Revisión de código: guía de ingeniería de Google sobre code review.
Convenciones de commits: Conventional Commits 🇪🇸.
Documentación: README útil, ADR (registros de decisiones de arquitectura), OpenAPI para APIs.

Fuentes:

7

Diseño y arquitectura

Principios

SOLID: SRP, OCP, LSP, ISP, DIP explicados en español 🇪🇸.
DRY, KISS, YAGNI, ley de Demeter.
Acoplamiento y cohesión — el par de conceptos que subyace a todo lo demás.

Patrones de diseño

Creacionales: Singleton, Factory Method, Abstract Factory, Builder, Prototype.
Estructurales: Adapter, Decorator, Facade, Proxy, Bridge, Composite, Flyweight.
De comportamiento: Observer, Strategy, Command, Iterator, State, Template Method, Chain of Responsibility, Mediator, Memento, Visitor.

Patrones arquitectónicos

MVC, MVVM, cliente-servidor, arquitectura en capas.
Arquitectura hexagonal / puertos y adaptadores, Clean Architecture.
Monolito vs. microservicios (y monolito modular, que hoy es la recomendación por defecto para equipos pequeños).
Arquitecturas orientadas a eventos, CQRS, event sourcing.
DDD: lenguaje ubicuo, contextos delimitados, agregados.

Fuentes:

8

Entrega y operación (DevOps)

Contenedores: Docker, imágenes, capas, multi-stage builds, Docker Compose.
Orquestación: Kubernetes 🇪🇸 — necesario solo cuando la escala lo justifica.
CI/CD: pipelines, entornos, despliegue azul-verde y canario, feature flags. Herramientas: GitHub Actions 🇪🇸, GitLab CI/CD, Jenkins, CircleCI. ⚠️ Travis CI perdió relevancia en proyectos abiertos; hoy el punto de partida razonable es GitHub Actions.
Infraestructura como código: Terraform/OpenTofu, Ansible, Pulumi.
Nube: AWS, Google Cloud, Azure. Conceptos: IaaS, PaaS, SaaS, serverless, edge. Plataformas tipo Vercel, Netlify, Render o Railway resuelven el 80 % de los proyectos pequeños sin tocar infraestructura.
Observabilidad: logs estructurados, métricas y trazas (OpenTelemetry). Prometheus, Grafana, Loki, ELK/OpenSearch, Sentry.
Fiabilidad: SLI, SLO, presupuesto de error, post-mortems sin culpables

Fuentes:

9

Seguridad

Esta es la sección que más cambió respecto a cualquier roadmap anterior a 2025.

OWASP Top 10:2025 — publicado tras cuatro años sin actualización, con dos categorías nuevas:

A01 Broken Access Control (absorbe SSRF)
A02 Security Misconfiguration
A03 Software Supply Chain Failures (nueva; amplía «componentes vulnerables y desactualizados»)
A04 Cryptographic Failures
A05 Injection (aquí viven SQLi y XSS)
A06 Insecure Design
A07 Authentication Failures
A08 Software or Data Integrity Failures
A09 Security Logging & Alerting Failures
A10 Mishandling of Exceptional Conditions (nueva; errores mal manejados, sistemas que fallan «abiertos»)

Prácticas mínimas

Validación y saneamiento de entradas; consultas parametrizadas.
Gestión de secretos (nada de credenciales en el repositorio) y rotación.
Hash de contraseñas con algoritmos actuales (Argon2, bcrypt), MFA, passkeys.
Seguridad de la cadena de suministro: fijar versiones, SBOM, firmas, escaneo de dependencias (Dependabot, Trivy, Snyk).

Fuentes:

10

Cómo se trabaja en equipo

Ágil: Manifiesto Ágil 🇪🇸, Scrum (guía oficial), Kanban, XP.
Tradicional: cascada y en qué contextos todavía se usa (regulados, contratos cerrados).
Gestión: Jira, Trello, Linear, Asana, GitHub Projects.
Flujo de trabajo con Git: trunk-based development, GitHub Flow, GitFlow (y por qué GitFlow está en retirada).
Habilidades no técnicas: estimar, decir que no, escribir bien un ticket, comunicar un bloqueo temprano. Pesan más que el 80 % de la lista técnica de arriba.

Fuentes:

11

Desarrollo asistido por IA (la sección nueva)

Ningún roadmap escrito antes de 2024 tiene esto, y hoy es parte del trabajo diario. Según la encuesta de desarrolladores de Stack Overflow, el 84 % usa o planea usar herramientas de IA, y el 51 % de los profesionales las usa a diario; al mismo tiempo, la confianza en su salida está en mínimos: más gente desconfía de la exactitud (46 %) que confía (33 %).

La lectura correcta de esos dos datos juntos: la IA acelera a quien ya tiene fundamentos y multiplica los errores de quien no los tiene. Por eso esta fase va al final y no al principio.

Qué aprender

Herramientas: asistentes en el editor (GitHub Copilot, Cursor, Windsurf) y agentes de terminal/repositorio (Claude Code, Codex, Gemini CLI, Jules).
Escribir buenos prompts y, sobre todo, buen contexto: archivos de instrucciones del proyecto, ejemplos, criterios de aceptación.
Revisar como si el código lo hubiera escrito un junior desconocido: leerlo completo, probarlo, cuestionar dependencias inventadas.
Riesgos concretos: alucinación de paquetes, licencias, filtración de secretos, deuda técnica acelerada.
Nociones de LLM útiles para construir producto: embeddings, RAG, ventana de contexto, MCP, agentes.

Fuentes: