Ruta para aprender a programar: guía de estudio

Acabas de conseguir tu primer trabajo en una startup, saliste de un bootcamp con un proyecto en React y ahora te piden mantener una API en Java, o eres freelancer y un cliente te pasó una app en Flutter que nunca habías abierto. La pregunta es siempre la misma: "¿por dónde empiezo y en qué orden?". Esta página es la respuesta que damos: qué lenguaje aprender primero según el trabajo que de verdad vas a hacer, cómo estudiar para que lo básico se quede, y qué cursos de este sitio leer en qué orden, de principiante a avanzado.

Cada semana publicamos más cursos en español. Los enlaces marcados "(en inglés)" llevan, por ahora, a la versión en inglés.

Escribimos software desde 2001, y esta es la pregunta que más nos hacen las personas que se suman a un equipo, más que cualquier bug concreto.

Para quién es esta guía y cómo usarla

Esta guía está pensada para tres tipos de lectores:

• Personas en su primer empleo que saben escribir unas cuantas líneas de código pero nunca han puesto nada en producción, y a las que les dijeron "ponte al día" con el lenguaje del equipo.
• Personas que cambian de stack, por ejemplo alguien de desarrollo web que pasa a un equipo de Flutter, o una desarrolladora Java que heredó una herramienta en VB.NET.
• Mentores que quieren un solo enlace para mandar en lugar de escribir el mismo consejo otra vez.

Cómo usarla: lee una vez la siguiente sección sobre hábitos de estudio. Luego usa la tabla de decisión para elegir un solo lenguaje, abre la lista de cursos de ese lenguaje y avanza en orden. Cada curso indica su nivel al principio (principiante, intermedio o avanzado) y termina con un enlace al siguiente.

La mayoría de los cursos tienen secciones de mediciones: tiempos, uso de memoria, tablas de benchmarks. En la primera pasada puedes saltártelas. Existen porque una regla práctica que mediste tú mismo es una regla en la que vas a confiar, pero no es lo que necesitas en tu primera semana. Vuelve a ellas cuando tu trabajo te haga preguntar "¿esto es lo bastante rápido?".

Cómo estudiar lo básico (y cómo están escritos estos cursos)

Cada curso de este sitio se escribió ejecutando el código y pegando la salida real, errores incluidos. Eso solo te sirve si estudias de la misma manera. Estos siete hábitos son los que, en nuestra experiencia, separan a quien es productivo al mes de quien a los tres meses sigue copiando fragmentos.

1. Escribe el código tú mismo y ejecútalo. No copies y pegues. Escribir te obliga a notar el punto y coma, los dos puntos después de if en Python, el ? después de un tipo en Dart. Tus primeros errores de tipeo producen tus primeros mensajes de error, y eso es justo lo que necesitas practicar: leerlos.
2. Lee el mensaje de error antes de buscar en Google. Los errores del compilador ayudan más de lo que parece. El error de Swift te dice la línea y muchas veces la solución; el incompatible types de Java nombra los dos tipos; el BC30512 de VB.NET dice exactamente qué conversión implícita bloqueó Option Strict. Lee el mensaje completo, busca el número de línea y mira esa línea. Solo después busca.
3. Cambia una cosa y predice la salida antes de ejecutar. Cuando un ejemplo funcione, cambia un valor: deja la lista vacía, pasa null, usa un número mayor a dos mil millones. Anota lo que esperas y luego ejecuta. Si te equivocas, encontraste algo que no entendías, que es justamente el objetivo.
4. Haz los ejercicios antes de leer las respuestas. Los cursos de Dart, Swift y PHP terminan con ejercicios. Dale a cada uno al menos quince minutos antes de abrir la respuesta. En los cursos sin ejercicios, el paso 3 es tu ejercicio.
5. Mide en lugar de creer en mitos. La programación está llena de reglas que alguna vez fueron ciertas. En nuestro curso de concurrencia en Python, agregar hilos a un trabajo limitado por CPU no lo hizo más rápido; en la serie de ML, el descenso de gradiente necesitó 140,538 épocas con variables sin escalar y 2 con variables escaladas. No tienes que medirlo todo, pero cuando una afirmación importa, ponla a prueba.
6. Usa asistentes de IA para entender errores, no para saltarte la escritura. Pegar un error que ya leíste y preguntar "¿por qué pasa esto?" es un buen uso. Pedirle que haga el ejercicio por ti se salta justo la parte que te enseña. Si te sugiere una corrección, asegúrate de poder explicar por qué funciona antes de quedarte con ella.
7. Que sea concreto y corto. Treinta minutos ejecutando código valen más que dos horas viendo videos. Cada sesión de estudio debería terminar con algo que ejecutaste, no con algo sobre lo que leíste.

Qué lenguaje aprender primero, según tu objetivo

Elige el lenguaje por el trabajo que vas a hacer, no por los rankings de popularidad. Si tu equipo ya tiene un código base, su lenguaje gana cualquier discusión.

Si nadie te dijo qué lenguaje usa el equipo, pregunta. Es una mejor primera pregunta que cualquiera que podamos responder aquí.

Todas las series en orden, de principiante a avanzado

Las series de seis partes siguen el mismo patrón: los cursos 1 y 2 son de nivel principiante, el 3 y el 4 intermedio, el 5 y el 6 avanzado. En la primera pasada, detente después del curso 4.

Python

Java

PHP

Si escribes PHP expuesto a internet, considera los cursos 4 y 5 obligatorios, no avanzados.

Dart (para Flutter)

Si trabajas con Flutter, lee el curso 5 pronto: casi toda app se conecta a la red, y una interfaz congelada suele ser un error de async.

Swift

VB.NET

C

El curso de C# no son seis cursos largos sino muchos artículos cortos, uno por tema. Léelos en este orden.

Principiante: instalación y núcleo del lenguaje

1. Configurar C# en 2026: SDK de .NET 10, dotnet CLI y editores (en inglés)
2. Variables y tipos en C# con .NET 10: decimal vs double (en inglés)
3. Operadores en C# con .NET 10: overflow, ??, % y desplazamientos (en inglés)
4. if vs switch en C#: patterns, CS8509 y velocidad (en inglés)
5. Bucles en C# con .NET 10: cómo funciona foreach por dentro (en inglés)
6. break, continue y goto en C#: salir de bucles anidados (en inglés)
7. Arrays en C# con .NET 10: jagged vs 2D, Span y costo de redimensionar (en inglés)
8. Métodos en C# con .NET 10: ref, out, params y sobrecargas (en inglés)
9. Manejo de excepciones en C#, probado de nuevo en .NET 10 (en inglés)

Intermedio: clases y colecciones

10. Clases en C# con .NET 10: primary constructors, required, init (en inglés)
11. Modificadores de acceso y this en C#: prueba con dos ensamblados (en inglés)
12. Constructores y finalizadores en C#: orden, GC y Dispose (en inglés)
13. Propiedades en C#: get/set, auto-propiedades e init (en inglés)
14. Propiedades en C# a fondo: la palabra clave field y required (en inglés)
15. Herencia en C#: override vs new y trampas del constructor (en inglés)
16. Interfaces en C#: métodos por defecto y static abstract (en inglés)
17. Structs en C#: copias, copias defensivas y costo del boxing (en inglés)
18. Métodos de extensión, partial y clases anidadas en C# (en inglés)
19. ArrayList y Hashtable en C#: costo del boxing y migración (en inglés)
20. List<T> por dentro: crecimiento de capacidad y AsSpan (en inglés)
21. Cómo elegir colecciones en C#: Dictionary, HashSet, Frozen (en inglés)
22. Archivos en C# con .NET 10: async, BOM y trampas de rutas (en inglés)

Avanzado: funciones como valores, LINQ, genéricos y eventos

23. Tipos y métodos anónimos en C# en 2026 (en inglés)
24. Expresiones lambda en C#, ejecutadas de nuevo en .NET 10 (en inglés)
25. Delegados Func y Action en C#: trampas y costo de llamada (en inglés)
26. Fundamentos de LINQ en C#, ejecutados en .NET 10 (en inglés)
27. LINQ en C#: sintaxis de consulta vs de métodos (en inglés)
28. GroupBy y Join en LINQ: claves, ToLookup y CountBy (en inglés)
29. Genéricos en C# con .NET 10: restricciones, varianza y boxing (en inglés)
30. Delegados y eventos en C#, probados de nuevo en .NET 10 (en inglés)
31. Callbacks con delegados en C#: progreso, cancelación y cadenas (en inglés)
32. Eventos en C# más allá de lo básico: accessors, async y weak (en inglés)
33. Reflexión y atributos en C#: costo de Invoke y avisos de AOT (en inglés)

Temas solo de Windows (léelos cuando tu trabajo los necesite): El registro de Windows en C# con .NET 10: CA1416 y RegistryView (en inglés) · WinForms ShowDialog vs Show: modal y no modal (en inglés) · Botones Aceptar/Cancelar en WinForms: AcceptButton y DialogResult (en inglés) · WinForms de instancia única con Mutex (en inglés)

HTTP y fundamentos web (para quien toque un servidor o una API)

Toda app habla HTTP. Estos cursos leen la salida real de curl -v contra servidores de prueba locales: códigos de estado, redirecciones, cookies, caché, TLS y compresión. Lee del 1 al 3 antes de tu primera tarea con una API.

JavaScript (ejecutado en JavaScriptCore)

Solo el núcleo del lenguaje: tipos, funciones, objetos, clases, promesas y rendimiento, todo ejecutado en el shell jsc que viene con macOS. El DOM del navegador y Node.js se explican, pero se marcan como "no ejecutado aquí".

C (cómo funciona la máquina de verdad)

Opcional para la mayoría de los trabajos, pero es el camino más rápido para entender la memoria, los punteros y por qué los otros lenguajes se comportan como se comportan. Compilado con clang, con AddressSanitizer atrapando los bugs.

C++ (después de C, o directo desde otro lenguaje)

Para videojuegos, sistemas embebidos, código de alto rendimiento y programación competitiva. Compilado con Apple clang 21 y libc++, con sanitizers atrapando los bugs y cada afirmación de velocidad medida.

Algoritmos y estructuras de datos (para todos)

Los ejemplos son principalmente en C y C++, con algo de C#, pero las ideas sirven para cualquier lenguaje. Léelos cuando ya te sientas cómodo con bucles y funciones en tu propio lenguaje.

• Principiante, búsqueda y ordenamiento: Búsqueda lineal vs binaria vs HashSet, medidas (en inglés) → Búsqueda binaria en C (en inglés) → Bubble, insertion y quick sort en C, medidos (en inglés)
• Principiante a intermedio, estructuras lineales: Lista enlazada simple en C++ (en inglés) → Lista doblemente enlazada en C++ (en inglés) → Lista enlazada circular en C++ y el problema de Josefo (en inglés) → Pila (stack) en C++: overflow, ASan y benchmarks (en inglés) → Cola enlazada en C++: fugas y dequeue vacío (en inglés) → Cola circular en C++: llena vs vacía, módulo vs máscara (en inglés)
• Intermedio, árboles y heaps: Recorrido de árboles en C++: cuándo desborda la recursión (en inglés) → Árbol binario de búsqueda en C (en inglés) → Heap binario: heapify en O(n), heapsort y PriorityQueue (en inglés)
• Avanzado, grafos y estrategia: DFS en C++ y C#: límites de recursión, ciclos y orden topológico (en inglés) → BFS en C++: caminos más cortos y el bug de la marca de visitado (en inglés) → Algoritmos voraces en C: cuándo falla el cambio de monedas frente a DP (en inglés)

Expresiones regulares (para todos)

Todo desarrollador termina escribiendo una regex para buscar en logs, validar entradas o limpiar datos rápido. Los ejemplos se ejecutan en .NET, Python, PHP y motores tipo JavaScript.

• Principiante: ¿Qué es una regex? Usos, límites y una prueba de velocidad en .NET (en inglés) → Coincidencias simples con regex: mayúsculas, cultura y escape (en inglés) → Metacaracteres de regex y la trampa del salto de línea con $ (en inglés) → Clases de caracteres: [abc], rangos y \p{L}, probados (en inglés)
• Intermedio: Cuantificadores de regex: greedy, lazy y possessive, medidos (en inglés) → Grupos en regex: numeración, grupos con nombre y balanceo en .NET (en inglés) → Referencias inversas en .NET, Python, PHP y JS (en inglés)
• Avanzado: Regex para caracteres repetidos: (.)\1+ en 4 motores (en inglés) → Lookaround en 5 motores: Python, PHP, .NET y JS (en inglés)

Línea de comandos (para todos, empieza aquí)

Estas tres series son para todos, sin importar el lenguaje que elegiste. La mayoría de las personas nuevas se topan con la terminal y Git el primer día y con SQL durante el primer mes, normalmente antes de sentirse cómodas en su lenguaje principal. Todo se ejecutó en SQLite 3.51, Git 2.54 y zsh/bash de macOS; cuando las herramientas de Linux (GNU) se comportan distinto, los cursos lo indican.

Git (para todos)

SQL (para todos)

Machine learning desde cero (después de Python)

Cinco cursos que usan solo la biblioteca estándar de Python, para que veas qué hace el "entrenamiento" antes de que una biblioteca lo esconda. Termina primero los cursos 1 a 4 de Python.

1. Regresión lineal desde cero: GD, SGD y escalado (en inglés) (intermedio)
2. k-means en Python puro: mínimos locales y k-means++ (en inglés) (intermedio)
3. Naive Bayes en Python puro sobre 86 artículos reales del blog (en inglés) (intermedio)
4. Del perceptrón a la red neuronal en Python puro, medido (en inglés) (avanzado)
5. TF-IDF y BM25 desde cero: buscando en nuestro propio blog (en inglés) (avanzado, el puente hacia RAG)

Un plan para tus primeras cuatro semanas

Este plan asume cerca de una hora al día, además de tu onboarding normal. Cubre un lenguaje más los fundamentos compartidos. No incluye los cursos avanzados, a propósito.

Antes de la semana 1, o en paralelo: los cursos 1–2 de línea de comandos y 1–2 de Git. La mayoría de las preguntas del tipo "no corre" de la primera semana terminan siendo una ruta, un espacio en el nombre de un archivo o un cambio sin commit, no el lenguaje.

Para C#, reemplaza "cursos 1 y 2" por los artículos 1 a 9 de la lista de principiante y "cursos 3 y 4" por los artículos 10 a 22, y cuenta con que las semanas 1 y 2 te tomen tres semanas. Es normal: los artículos son cortos, pero son más.

Los cursos avanzados (5 y 6: async, concurrencia, rendimiento, memoria) vienen después, cuando una tarea real los pida. Leerlos en la semana 2 casi siempre solo genera confusión.

Cuando te atores

• Achica el programa. Borra código hasta que el problema desaparezca y luego vuelve a poner lo último que quitaste. Un ejemplo de diez líneas que falla es más fácil de entender y de preguntar.
• Imprime más de lo que crees necesario. Imprime el valor y su tipo (type(x) en Python, x.runtimeType en Dart, x.GetType() en C#). La mitad de los bugs de principiante son un valor que no es del tipo que suponías.
• Revisa la versión. python3 --version, java -version, dart --version, php -v, swift --version, dotnet --version. Un ejemplo escrito para una versión nueva puede fallar en una vieja con un error confuso.
• Pregunta bien. Lleva el código, el texto completo del error y lo que ya intentaste. Un mentor puede responder eso en dos minutos; "no funciona" toma veinte.
• Para a los 30 minutos y pregunta. Pasar toda una tarde atascado enseña menos que desatascarte en media hora y usar el resto para practicar.

Una nota honesta sobre nuestro entorno

Los cursos se ejecutaron en una Mac con Apple Silicon (M1 Pro) con versiones específicas: Python 3.9 y 3.11, OpenJDK 26, PHP 8.5, Dart SDK 3.11, Swift 6.4, .NET 10 y Apple clang 21, SQLite 3.51, Git 2.54, y zsh 5.9 / bash 3.2 en macOS. Cada curso indica las versiones exactas que usó. En Windows o Linux, o con otras versiones, las rutas de archivos, los tiempos y algunos mensajes de error van a ser distintos. Los artículos de WinForms se compilaron para Windows pero no se ejecutaron en la Mac, y lo dicen. Los tiempos vienen de una sola computadora y sirven para mostrar qué enfoque gana y por cuánto, más o menos, no son números exactos que debas esperar.

Si algo de un curso no coincide con lo que ves, revisa primero la versión. Si sigue siendo distinto, es útil saberlo, y probablemente es señal de que algo cambió.