Fundamentos del lenguaje
Variables, tipos, condicionales y bucles explicados con ejemplos que se repiten en casi cualquier lenguaje. La idea es reconocer el patrón antes de memorizar la sintaxis.
Cada ruta agrupa módulos que se apoyan unos en otros: primero se entiende el lenguaje, después se construye, y al final se trabaja como lo haría un equipo. Elige según tu punto de partida y el tipo de proyecto que quieras sostener en el tiempo.
Pensada para quien nunca escribió una línea. Se trabajan variables, tipos de datos, condicionales y bucles con ejercicios cortos que se corrigen en clase. Al terminar, puedes leer y modificar programas sencillos sin depender de copiar y pegar.
Ver esta rutaPara quienes ya manejan lo básico y quieren armar algo funcional. Cubre estructura de un proyecto, separación entre interfaz y lógica del servidor, manejo de dependencias y preparación del entorno de publicación. Incluye revisión de errores frecuentes al desplegar por primera vez.
Ver esta rutaEnfocada en el día a día de un equipo técnico: control de versiones, ramas, resolución de conflictos, linters y organización de tareas en un repositorio. Útil si vas a integrarte a un proyecto compartido o si trabajas solo y quieres ordenar tu propio flujo.
Ver esta rutaPara quienes ya estudiaron por su cuenta y sienten huecos. Se revisan temas puntuales, se corrigen malos hábitos y se practica con casos reales de depuración. El ritmo lo marcas tú, con acompañamiento para resolver dudas concretas.
Consultar disponibilidadCada persona llega con un punto de partida distinto: alguien que nunca escribió una línea de código, alguien que quiere ordenar lo que aprendió por su cuenta, o alguien que necesita cambiar de rumbo profesional. La ruta se arma en pasos concretos y se ajusta según el ritmo de cada uno.
Antes de asignar cualquier módulo, se conversa sobre la experiencia previa, el tiempo disponible por semana y el objetivo real. No todos buscan lo mismo: algunos quieren entender lógica, otros apuntan a construir una aplicación concreta. Esa charla inicial define qué conviene estudiar primero y qué se puede dejar para más adelante.
Se revisan nociones básicas con ejercicios cortos: variables, condicionales, estructuras de datos simples. La idea no es evaluar con nota, sino ubicar en qué punto conviene entrar. Si alguien ya maneja bucles y funciones, se salta directo a temas de organización de código; si no, se refuerza la base sin apuro.
La formación se organiza en bloques que se apoyan uno sobre otro. Cada módulo combina explicación, práctica guiada y un ejercicio propio donde el estudiante aplica lo aprendido sin copiar. Los temas cubren desde fundamentos del lenguaje hasta desarrollo de aplicaciones, herramientas de trabajo y conceptos esenciales de informática.
Durante el recorrido hay espacio para consultar bloqueos puntuales: un error que no se entiende, una decisión de diseño que confunde, una herramienta que no arranca. Las respuestas apuntan a que el estudiante aprenda a resolver por su cuenta la próxima vez, no a que dependa de una solución dada.
Al cerrar un tramo de módulos, se propone un trabajo donde se junten varias piezas: interfaz, lógica, manejo de datos y control de versiones. No es un examen, es una forma de ver qué quedó firme y qué conviene repasar. El resultado sirve como referencia concreta del avance, no como promesa de empleo ni de resultados garantizados.
Con el proyecto revisado, se define qué viene después: profundizar en un área específica, sumar herramientas nuevas o encarar un desarrollo propio con más autonomía. La ruta no termina en un punto fijo, se rearma según lo que la persona quiera hacer con lo aprendido.
Dudas que suelen aparecer antes de empezar un módulo, durante las prácticas o al organizar el propio ritmo de estudio. Respuestas concretas, sin rodeos.
No. El punto de partida está pensado para quien nunca escribió una línea de código. Se trabaja con ejemplos cortos, se explica qué hace cada instrucción y se avanza solo cuando los conceptos básicos quedan claros. Si ya tenés alguna noción, podés saltar las primeras unidades y entrar directo a estructuras de control o funciones.
El recorrido sugerido empieza por fundamentos de programación, sigue con desarrollo de aplicaciones y termina en herramientas de trabajo colaborativo. Ese orden no es obligatorio, pero respeta una lógica: cada bloque usa lo aprendido en el anterior. Si tu objetivo es puntual, como entender control de versiones, podés ir directo a ese módulo sin arrastrar el resto.
Depende del ritmo de cada persona y de cuántas horas semanales le dedique. Los módulos están divididos en unidades breves, con ejemplos y ejercicios, para que se puedan hacer en sesiones de una o dos horas. Lo importante no es la velocidad sino sostener la práctica: conviene repetir los ejercicios hasta que las decisiones de código salgan sin consultar apuntes.
Los conceptos se presentan de forma que se puedan trasladar entre lenguajes: variables, tipos, condicionales, bucles, funciones y manejo de errores aparecen en casi todos. Los ejemplos usan sintaxis habitual en el desarrollo web y de aplicaciones, y cuando una diferencia entre lenguajes importa, se aclara. La idea es que puedas leer código nuevo sin depender de un único entorno.
Un editor de código con resaltado de sintaxis, un sistema de control de versiones para guardar el avance y un entorno local para probar lo que se escribe. También se trabaja con la terminal en lo básico: mover archivos, ejecutar comandos y leer mensajes de error. No hace falta instalar nada exótico; el objetivo es que el entorno sea reproducible en cualquier equipo.
Sirven como base técnica ordenada, no como garantía de empleo. Lo que ofrecen es una ruta clara para entender cómo se construye software, cómo se organiza un proyecto y qué prácticas se esperan en un equipo. A partir de ahí, la continuidad depende de la práctica sostenida y de los proyectos personales que cada persona decida armar por su cuenta.
Los módulos no se acumulan por acumular. Cada uno resuelve una parte concreta del trabajo técnico: entender un lenguaje, montar una aplicación, moverla entre entornos y sostenerla cuando algo falla. Abajo está el mapa de capacidades que se trabajan a lo largo del recorrido.
Variables, tipos, condicionales y bucles explicados con ejemplos que se repiten en casi cualquier lenguaje. La idea es reconocer el patrón antes de memorizar la sintaxis.
Del prototipo a algo que funciona: estructura de carpetas, lógica del servidor, formularios, estados y validaciones. Se trabaja con proyectos pequeños pero completos.
Control de versiones, ramas, resolución de conflictos y entornos locales reproducibles. Es la parte que casi nadie enseña al principio y que después se nota.
Configuración de variables de entorno, revisión de registros y pruebas básicas antes de exponer un proyecto. Publicar no es el final, es el inicio de otra etapa.
Interpretar mensajes del compilador o del navegador, aislar el problema y avanzar paso a paso en lugar de probar al azar. Una habilidad que ahorra horas.
Sistemas de archivos, terminal, redes básicas y nociones de seguridad. El contexto que hace que las decisiones técnicas tengan sentido.
Cada bloque se puede retomar por separado, pero el orden sugerido construye sobre lo anterior. Si alguna parte ya se domina, se puede avanzar sin repetir.