Tu zona de trabajo: estudia, abre materiales, practica y pregunta cuando te atasques.
El menú de la izquierda es el índice de cursos. Este panel resume cómo usar la plataforma: leer teoría, ver archivos sin descargarlos, bajar guías, copiar código, practicar online y apoyarte en el Mentor IA para entender mejor cada paso.
Impacto de la plataforma
Aprendizaje real con práctica guiada y asistencia de IA
0+
Alumnos formados
0+
Horas impartidas
0+
Ejercicios prácticos
0+
Ejercicios con IA
0%
Satisfacción
Curso Web de Iniciación
De cero a publicar tu primera web en Netlify
HTML
Estructura y etiquetasCSS
Estilos y diseñoJavaScript
InteractividadBootstrap
ComponentesInstala Live Server
Abre VS Code → Extensiones (Ctrl+Shift+X) → Busca "Live Server" → Instalar.
Extensión gratuitaAbre tu archivo .html
Descarga un .html del curso → Abre con VS Code → Clic derecho → Open with Live Server.
Se abre en el navegadorCómo usar los materiales del curso
- Descarga el archivo
.htmlde la unidad que quieras practicar. - Abre VS Code y arrastra el archivo o usa Archivo → Abrir.
- Clic derecho en el código → Open with Live Server.
- Edita el código y guarda (Ctrl+S). La página se actualiza sola.
- Experimenta: cambia colores, textos, añade cosas. ¡Así se aprende!
Checklist antes de empezar
- VS Code instalado
- Extensión Live Server instalada
- Sabes abrir un .html con Live Server
- ¡Listo para la Unidad 1!
Trabajaremos directamente en el código con una clase .html comentada
(estilo Better Comments) y una plantilla rellenable para que el alumno
construya su
primera página paso a paso. La guía .md resume teoría y propone ejercicios cortos.
- 📌 Estructura básica:
Todo documento HTML empieza con
<!DOCTYPE html>, seguido de la etiqueta raíz<html lang="es">. Dentro, el<head>contiene metadatos (ej.<meta charset="UTF-8">,<meta name="viewport">para móviles) y el<title>. El contenido visible se coloca en<body>. - 🧭 Secciones semánticas:
Para que el navegador y lectores de pantalla entiendan la página, usamos etiquetas con
significado:
<header>(cabecera),<nav>(menú),<main>(contenido principal),<section>(bloques temáticos),<article>(artículos o posts) y<footer>(pie de página). - 📝 Contenido:
HTML organiza la información con títulos
h1–h6, párrafos<p>, enlaces<a>, listas<ul>/<ol>con<li>, e imágenes<img>(siempre con atributoalt). - 🔗 Navegación interna:
Puedes crear enlaces que lleven a distintas partes de la misma página usando anclas:
<a href="#id">. Esto sirve para construir un menú simple que “salta” a cada sección. - ♿ Accesibilidad básica:
Es importante mantener una jerarquía clara de títulos (un solo
<h1>y luegoh2/h3en orden), poner texto alternativo a las imágenes y usar atributos comoaria-labeloaria-labelledbycuando sea necesario para que todos los usuarios puedan navegar sin problemas.
⏳ Cargando código...
Trabajaremos directamente en el código con una clase .html comentada
(Better Comments) y una plantilla rellenable para practicar. La guía
.md resume teoría y propone ejercicios rápidos.
- 🎛️ Estilos globales: Lo primero al empezar con CSS es definir la base de la página: una fuente clara, un color de fondo y un color de texto. También se aplican pequeños “reseteos” para que todos los navegadores muestren el diseño igual.
- 🎨 Colores:
Con las propiedades
colorybackground-colordecides la paleta de tu web. Un buen contraste entre texto y fondo hace que la lectura sea más cómoda y accesible. - 🔤 Tipografía:
CSS te permite elegir la
font-family(fuente), controlar el tamaño del texto, hacerlo más grueso o más fino, y usar unidades comopxorempara mantener consistencia en diferentes pantallas. - 📦 Modelo de caja:
Cada elemento HTML se comporta como una “caja” que puedes personalizar con
margin(espacio externo),padding(espacio interno),border(bordes) ybox-shadow(sombras). Entender esto es clave para controlar bien el diseño. - 🧭 Navegación y utilidades: Aprenderás a dar estilo a menús simples y a crear pequeñas clases de utilidad para alinear, centrar o espaciar elementos sin repetir mucho código.
- 🧪 Mini-proyecto: Pondrás en práctica todo lo anterior aplicando CSS a tu portfolio de UT1: darle colores, tipografías y una estructura visual coherente para que se convierta en una página atractiva.
⏳ Cargando código...
Trabajaremos con una clase .html y una plantilla rellenable
para
aplicar
Bootstrap al portfolio de UT1/UT2. La guía .md resume teoría y propone ejercicios
cortos.
- 🔧 ¿Qué es Bootstrap? Es un kit de herramientas que te permite dar estilo y maquetar páginas web sin tener que escribir CSS desde cero. Lo cargas con un enlace (CDN) y ya puedes usarlo.
- 📦 Diseño rápido y ordenado Bootstrap trae un sistema de contenedores, tipografías limpias y utilidades de espaciado que ayudan a que tu página se vea profesional desde el primer minuto.
- 🧱 Grid de 12 columnas Su “rejilla” hace que tu página sea responsiva automáticamente: el contenido se adapta a móvil, tablet o PC sin esfuerzo, solo usando clases ya preparadas.
- 🟦 Componentes listos para usar Menús de navegación, botones, formularios, tablas, alertas, tarjetas y hasta carruseles de imágenes. Todo con un estilo consistente y bonito, listo para personalizar.
- 🗂️ Cards para proyectos Son bloques visuales que combinan imagen + texto + botón. Perfectas para mostrar tus trabajos, productos o ideas sin tener que inventar el diseño.
- 🚀 ¿Por qué usarlo en tu portfolio? Porque con muy poco código consigues que tu página se vea como una web moderna y profesional. Lo que en CSS manual te llevaría horas, aquí lo tienes en minutos.
⏳ Cargando código...
Trabajaremos con una clase .html comentada y una plantilla
rellenable para
integrar JS en el portfolio de UT1/UT2/UT3. La guía .md resume teoría y propone
ejercicios rápidos.
- 🧠 ¿Qué es JavaScript? El lenguaje que hace tu web interactiva: responder a clics, escribir en la página, mostrar/ocultar cosas y actualizar datos sin recargar.
- 🔌 ¿Dónde va el JS?
Dentro de
<script>en el HTML o en un archivo externo.jsenlazado. Ideal: separar el JS en su propio archivo para mantener el código limpio. - 🎛️ Eventos
Acciones del usuario como click, input o submit.
Con
addEventListener“escuchas” esas acciones y ejecutas una función. - 🧩 DOM
El árbol de elementos de tu página. Con
document.querySelectorseleccionas un elemento y contextContent,classListosetAttributelo modificas. - 📨 Formularios
Valida datos, evita envíos vacíos con
event.preventDefault()y muestra feedback visual (mensajes de éxito o error). - 🚀 Mini-proyecto Añadir interacción al portfolio: botón que cambia textos, contador de clics, vista previa de un campo de texto y validación simple del formulario de contacto.
⏳ Cargando código...
Trabajaremos con una clase .html y una plantilla rellenable
listas
para usar.
La guía .md explica cada bloque (tema claro/oscuro, filtro de proyectos, galería
con
modal,
validación de formulario y pequeños retoques de UI).
- 🌗 Tema claro/oscuro
Usa variables CSS y el atributo
data-themeen<body>. La preferencia del usuario se guarda enlocalStoragepara recordar el modo. - 🧱 Maquetación Bootstrap Navbar fija, hero con CTA, grid responsive de “Proyectos” y utilidades de espaciado/colores coherentes.
- 🔎 Filtro de proyectos
Búsqueda en vivo por palabra clave leyendo
data-tags, título y descripción de cada card. - 🖼️ Galería Imágenes que abren un modal a pantalla grande. Sin JS extra: basta con el bundle de Bootstrap.
- ✉️ Formulario Validación con Bootstrap + JS: mensajes claros de éxito/error y reset automático al enviar.
- 🚀 Remate con IA
Pulir microcopys, atributos
altyaria-*, contrastes y CTA. Además, detectar mejoras rápidas de UX, SEO y rendimiento.
⏳ Cargando código...
✅ Pasos (modo rápido)
- Crea una carpeta en tu PC (por ejemplo
mi-web). - Dentro debe existir un archivo llamado
index.html(es el “inicio” de tu web). - Prueba en local: abre
index.htmlo usa Live Server en VS Code. - Entra en Netlify Drop y arrastra la carpeta (o el
index.html). - Netlify te da una URL: abre el enlace, revisa y compártelo.
index.html, rutas rotas a imágenes/CSS (carpetas distintas),
o enlaces con espacios sin codificar.
Enlaces útiles
Más adelante, para un despliegue “pro” (que se actualice solo al cambiar tu código), conecta tu proyecto a GitHub. Para empezar, Drop es perfecto.
DevTools (F12)
- Elements: inspeccionar y editar HTML/CSS en vivo.
- Console: ver errores de JavaScript y probar código.
- Network: analizar peticiones.
- Responsive: probar en móvil/tablet.
Git Básico
git init— Iniciar repositorio.git add .— Preparar cambios.git commit -m "msg"— Guardar versión.git push— Subir a GitHub.
git push.
Plataforma Web Interactiva
Teoría guiada, editor visual y vista previa responsive en una experiencia única.Tu aula web completa en una sola pestaña
Desde aquí entras al entorno donde el alumno estudia la teoría, escribe código, prueba cambios al instante y avanza por unidades sin salir de la misma experiencia.
Estructura, etiquetas y primeras páginas.
Diseño visual, layout y estilos modernos.
Componentes listos y maquetación rápida.
Interactividad, DOM y comportamiento real.
Cada bloque muestra el contenido teórico junto al ejercicio real para que el alumno aprenda con contexto.
El editor forma parte de la experiencia web completa, pensado para practicar con comodidad y continuidad.
Puedes comprobar el resultado en tiempo real y probar el modo móvil sin salir de la experiencia principal.
Entradas rápidas por bloque
Cada acceso abre la plataforma justo en el bloque elegido.
Configuración del entorno y primeras páginas con estructura semántica y etiquetas base.
Ir a inicio y HTMLSelectores, colores, tipografía, cajas y primeras decisiones de maquetación visual.
Ir a CSSSistema de rejilla, componentes reutilizables y aceleración del trabajo responsive.
Ir a BootstrapEventos, DOM y comportamiento dinámico para que la web deje de ser estática.
Ir a JavaScriptIntegración final del portfolio y uso práctico de IA para acelerar iteraciones con criterio.
Ir al proyecto finalHerramientas del navegador, Git y despliegue para subir tu web y trabajar como en un flujo real.
Ir a publicar y depurarCurso Java: guía y descargas
Herramientas necesarias para el curso
Java es un lenguaje muy usado en DAW/DAM y en empresas. En este curso vas a aprender desde lo básico (variables, condicionales, bucles) hasta POO y proyecto final.
Paso 1 · Instalar Java (JDK)
Instala JDK 17 o superior. Recomendado: Temurin (Adoptium), que se instala con asistente (siguiente, siguiente...).
Descargar Temurin JDKPaso 2 · Editor recomendado
Usa Visual Studio Code para abrir los archivos del curso y trabajar cómodo.
Descargar VS CodeExtensiones recomendadas (VS Code)
- Java Extension Pack: compilar, ejecutar y depurar Java.
- Better Comments: mejora la lectura de comentarios.
.java son el código fuente. Las guías .md explican teoría y tareas.
Puedes abrir ambos en VS Code sin problemas.
En esta primera unidad verás los fundamentos de Java para empezar con buen pie: cómo declarar variables, cuáles son los tipos de datos más usados y cómo operar con ellos mediante operadores aritméticos, de comparación y lógicos. Todo con ejemplos sencillos y buenas prácticas para evitar errores típicos.
-
📌 Tipos primitivos y para qué se usan:
int(enteros),double(decimales),boolean(verdadero/falso) ychar(carácter). -
🧮 Operadores aritméticos:
+-*/%. Comparación:==!=<<=>>=. Lógicos:&&(y),||(o),!(no). -
📝 Buenas prácticas:
nombres en camelCase (
precioTotal), evita abreviaturas confusas, inicializa variables, usafinalpara constantes y comenta lo imprescindible. - ✅ Objetivo: al terminar, podrás declarar variables, combinarlas en expresiones y decidir el tipo correcto para cada dato.
En esta unidad aprenderás a tomar decisiones en tus programas controlando el flujo de ejecución.
Verás cómo usar if, else y switch para actuar en función
de ciertas condiciones, y cómo combinar varias usando operadores lógicos como
&& y ||.
-
🔀 Condiciones simples y múltiples con
if,if/elseyelse ifpara controlar casos diferentes. -
📋 Decisiones por casos usando
switchycasepara elegir entre múltiples opciones. -
🧠 Operadores lógicos:
&&(y),||(o),!(no) para combinar o invertir condiciones. -
💡 Buenas prácticas: evita anidar demasiados
if, usa sangrías claras y consideraswitchpara casos múltiples. - ✅ Objetivo: al final podrás crear programas que respondan de forma diferente según la información o las acciones del usuario.
En esta unidad aprenderás a repetir instrucciones de forma automática usando bucles. Veremos
cómo aplicar
for, while y do while en diferentes situaciones reales,
con ejercicios prácticos
como contadores, validaciones y menús.
- 🔁 Bucle
for: ideal para repeticiones controladas - 🔄 Bucle
while: se ejecuta mientras se cumple una condición - 🔂 Bucle
do while: siempre se ejecuta al menos una vez - ✅ Ejercicios con bucles anidados y control de flujo
En esta unidad aprenderás a reutilizar código mediante funciones. Verás cómo declarar métodos, pasarles parámetros y devolver resultados. También aprenderás a modularizar programas y mejorar su mantenimiento.
- 🔧 Declaración de funciones con parámetros
- ↩️ Métodos que devuelven valores
- 🧩 Modularización y reutilización del código
- 💡 Ejemplos con funciones prácticas y organizadas
Esta unidad abarca todos los pilares de la programación orientada a objetos en Java. Aprenderás a construir clases con sus atributos y métodos, crear objetos a partir de ellas, y reutilizar código mediante herencia. También explorarás cómo sobrescribir métodos y usar interfaces para diseñar estructuras flexibles y escalables.
- 🏗️ Definición de clases, atributos y métodos
- 🔁 Instanciación de objetos con
newy acceso a métodos - 🧬 Herencia con
extendsy uso desuper - 🧠 Polimorfismo y sobreescritura de métodos (
@Override) - 🔌 Uso de interfaces para definir comportamientos comunes
- 📘 Guía disponible: solo para Clases y Objetos
En esta unidad aprenderás a detectar, controlar y gestionar errores en tiempo de ejecución.
Usarás bloques
try, catch, finally y también podrás lanzar tus propias
excepciones con throw.
- ⚠️ Gestión de errores con
try/catch/finally - 🎯 Excepciones predefinidas y personalizadas
- 🚫 Uso de
throwythrows - 📘 Guía explicativa con teoría y ejercicios
En esta unidad aprenderás a trabajar con textos en Java: cómo manipular cadenas, extraer
información, reemplazar partes
de un texto y aplicar métodos útiles de la clase String como length,
substring, split, etc.
- ✂️ Cortar y unir textos (
substring,concat) - 🔎 Búsquedas con
contains,indexOfyreplace - 🔠 Conversión entre mayúsculas y minúsculas
- 📘 Guía práctica con teoría y ejercicios resueltos
En esta unidad trabajarás con estructuras de datos básicas como arrays unidimensionales y
bidimensionales, y aprenderás a manipular texto con cadenas.
Es ideal para afianzar el uso de bucles con estructuras de datos y operaciones comunes sobre
arrays y String.
- 📌 Declaración e inicialización de arrays
- 🔁 Recorrido con bucles
foryforeach - 🧩 Operaciones básicas con strings: cortar, unir, buscar
- 📘 Incluye ejercicios combinando arrays y cadenas de texto
En esta unidad aprenderás a utilizar herramientas potentes de análisis y transformación de
texto. Dominarás funciones avanzadas de String
y comenzarás a trabajar con expresiones regulares (regex) para búsquedas,
validaciones y reemplazos complejos.
- 🧠 Métodos avanzados de
String:matches,split,replaceAll - 🧪 Introducción a expresiones regulares
- ✅ Ejemplos de validación de correos, DNI, contraseñas
- 📘 Guía con teoría, patrones y ejercicios prácticos
Esta unidad combina operaciones matemáticas útiles y el tratamiento de fechas y horas en Java.
Aprenderás a utilizar Math para cálculos y LocalDate /
LocalTime para gestionar el tiempo.
- 🧮 Métodos comunes de
Math:sqrt,pow,random,abs... - 📆 Gestión de fechas con
LocalDate - ⏰ Trabajo con
LocalTimeyDuration - 📘 Guía con ejercicios prácticos y ejemplos explicados
Esta unidad profundiza en el uso de expresiones regulares para validar y analizar textos de forma eficiente. Aprenderás a crear patrones para detectar formatos como correos, DNI, contraseñas, fechas y más.
- 🔤 Sintaxis básica de regex:
[a-z],\\d,+,*,{n}... - ✅ Validaciones reales (correo, DNI, nombre, fecha...)
- 🔎 Métodos clave:
matches,replaceAll,split - 📘 Guía con ejemplos resueltos y ejercicios paso a paso
En esta unidad aprenderás a trabajar con archivos en Java, tanto para leer información como para
escribirla.
Utilizarás clases como File, FileReader, BufferedReader,
PrintWriter, etc.
- 📂 Lectura de archivos línea a línea
- 📝 Escritura y creación de archivos de texto
- 🚫 Manejo de excepciones en operaciones con ficheros
- 📘 Incluye guía con ejemplos prácticos y tareas
Esta unidad profundiza en el uso de las colecciones de Java como List,
Set y Map.
Aprenderás a utilizar implementaciones como ArrayList, HashSet y
HashMap para almacenar y manipular datos dinámicos.
- 📋 Listas dinámicas con
ArrayList - 📦 Conjuntos sin duplicados con
HashSet - 🔑 Asociación clave-valor con
HashMap - 📘 Ejercicios prácticos para organizar datos y acceder eficientemente a ellos
En esta unidad aprenderás a declarar constantes de forma segura y estructurada con
enum, así como a definir
constantes simbólicas mediante static final. Estos conceptos son fundamentales para
evitar errores y mejorar la legibilidad del código.
- 🔢 Declaración y uso de enumeraciones con
enum - 🔒 Creación de constantes con
static final - 📚 Casos de uso reales: días de la semana, estados, menús
- 📘 Guía clara con teoría, ejemplos y ejercicios prácticos
En esta unidad aprenderás a dividir tus proyectos Java en archivos organizados y reutilizables mediante el uso de paquetes. También verás cómo importar clases desde otros archivos y trabajar con estructuras modulares en aplicaciones grandes.
- 📦 Creación de paquetes personalizados (
package) - 🔁 Importación de clases con
import - 🧩 Organización lógica del código para proyectos medianos y grandes
- 📘 Guía completa con teoría, buenas prácticas y ejercicios
En esta última unidad aplicarás todos los conocimientos adquiridos a lo largo del curso desarrollando un proyecto completo en Java: un gestor de alumnos con menús, almacenamiento de datos, estructuras condicionales, bucles, colecciones y manejo de errores.
- 🎯 Menú principal con opciones para insertar, mostrar y eliminar datos
- 🧩 Uso de clases, listas, estructuras condicionales y bucles
- 💾 Simulación de persistencia y control de errores
- 📘 Guía detallada con los pasos del proyecto y sugerencias de mejora
Plataforma Java Interactiva
Acceso directo al recorrido completo de Java, organizado por bloques y listo para practicar.Todo el curso de Java, ordenado para estudiar y practicar mejor
Desde esta entrada accedes al entorno donde el alumno puede seguir el temario, revisar el código real, consultar la guía y moverse por bloques con una navegación mucho más cómoda.
Cada unidad enlaza con el material real del curso para trabajar con ejemplos, clases y guías tal como están preparadas.
La teoría acompaña al código para estudiar cada tema con contexto y moverte por el temario sin perder el hilo.
La práctica se hace en la plataforma dedicada, con más comodidad y sin incrustar otro compilador dentro de esta página.
Entradas rápidas por bloque
Cada acceso te lleva al punto de la plataforma donde arranca ese bloque del curso.
Introducción, variables, control de flujo, bucles, funciones y primeras clases para construir una base sólida.
Ir a fundamentosClases, objetos, encapsulación y transición hacia una forma de programar más estructurada.
Ir a POO y objetosExcepciones, validación y tratamiento de errores para que el código no falle de forma caótica.
Ir a excepciones y depuraciónTrabajo con texto, arrays, regex, colecciones y estructuras frecuentes en ejercicios reales.
Ir a estructuras y textoLectura y escritura de ficheros, enums, modularidad y paquetes para estructurar proyectos más serios.
Ir a ficheros y paquetesHerencia, polimorfismo, prácticas avanzadas, JUnit y evolución natural hacia diseño más profesional.
Ir a avanzado y testingConsumo de APIs REST, arquitectura por capas y entrada al backend moderno con Spring Boot.
Ir a APIs y backendProyecto final de consola, JDBC con SQLite y bloques de arquitectura para cerrar el recorrido completo.
Ir a proyecto y arquitectura4 niveles progresivos que entrenan el patrón que se repite en casi todos los exámenes de 1º DAM. El contexto cambia (alumnos, libros, productos…) pero la estructura es siempre la misma.
Una clase · constructor · getters · métodos simples. Para alumnos que todavía afinan la base de clases y objetos.
Producto Básico
nombre, precio y stock. Comprobación de estado y cambios sencillos sobre el objeto.
Alumno Básico
nombre, edad y nota media. Métodos estaAprobado() y modificación de nota. Mismo patrón, distinto contexto.
Libro Básico
título, páginas y estado de préstamo. Métodos prestar() y devolver() sin parámetros.
Clase + array de objetos + contar · buscar · calcular. El salto que más cuesta en 1º DAM.
Alumno con Array
Array de alumnos: mostrar todos, contar aprobados, calcular media, encontrar el mejor.
Libro con Array
Array de libros: listar, buscar por título, contar disponibles, calcular páginas totales.
Producto con Array
Array de productos: listar stock, buscar por nombre, producto más caro, calcular valor total.
Como nivel 2 + modificación de estado sobre objetos encontrados. El patrón exacto del examen real.
Libro Biblioteca
Buscar libro y prestarlo o devolverlo. Distinguir consulta vs modificación de estado.
Producto Tienda
Buscar producto y vender unidades. Control de stock, boolean de éxito y actualización de estado.
Varias clases · HashSet · HashMap · clase gestora · operaciones encadenadas. Preparación de examen largo.
Red Social
HashMap<Usuario, List<Foto>> y HashSet. Etiquetado, likes y eliminación por condición.
Ordenadores
HashSet de periféricos y clase gestora. Agregación, evitar duplicados y actualización de estado.
Reservas Hotel
HashSet y HashMap<Cliente, Reservas>. Cancelación, liberación de estado e ingresos totales.
Curso Java Swing: interfaz, eventos y proyecto final
Este bloque recoge el curso completo de Java Swing para 2º DAM: desde ventanas, layouts y componentes basicos hasta concurrencia, internacionalizacion, persistencia y una aplicacion final conectada a MySQL.
La estructura sigue la misma idea que PHP: guia general, temario por UT, descargas directas, visor de codigo, resumen de guia y una zona practica pensada para estudiar, copiar, adaptar y ejecutar en tu IDE.
Ruta formativa del curso
Anexo MySQL + JDBC + NetBeans
Material complementario para llevar Swing a un CRUD real con base de datos.
Como practicar este curso
Swing necesita IDE local para ver la ventana real. La zona practica te sirve para leer, copiar y preparar el codigo.
- Usa el visor para revisar la UT y abrir la guia completa.
- Copia el codigo al laboratorio externo o llevalo directamente a tu IDE local.
- Ejecuta la version completa en VS Code o NetBeans cuando la UT dependa de GUI real.
Cada unidad resume el objetivo, el foco tecnico y el archivo que debes abrir. Desde aqui puedes descargar, abrir y saltar directamente al laboratorio de estudio de cada UT.
Interfaz, eventos y proyecto final en un entorno más claro
Desde aquí entras a la plataforma donde el alumno sigue el temario de Swing por unidades, revisa el código real, consulta la guía y se mueve por bloques con una estructura mucho más cómoda.
Ventanas, paneles y layouts bien organizados.
Listeners y respuesta real de la GUI.
Tablas, listas, árboles y MVC para apps serias.
Agenda completa con persistencia y despliegue.
Cada UT abre la explicación y el material real del curso para estudiar Swing con contexto técnico y didáctico.
El alumno trabaja con los `.java` y `.md` reales del curso, preparados para abrirlos después en su IDE.
Swing se entiende mejor ejecutando la interfaz en VS Code o NetBeans, y la plataforma te deja todo listo para eso.
Entradas rápidas por bloque
Cada acceso abre la plataforma Swing en el bloque adecuado.
Repaso inicial, primeros JFrame, paneles, componentes y layouts para empezar con buena base.
Ir a repaso y baseEventos del usuario, menús, toolbars y validación para que la interfaz responda bien.
Ir a eventos y estadoListas, tablas, árboles y organización MVC para pasar de ejemplos a aplicaciones mantenibles.
Ir a datos y MVCGraphics2D, pintura personalizada, Look & Feel e internacionalización para una UI más avanzada.
Ir a personalizaciónSwingWorker, persistencia ligera, empaquetado y preparación final de la aplicación.
Ir a concurrencia y entregaAgenda inteligente con persistencia, organización por capas y cierre completo del curso Swing.
Ir al proyecto finalCurso PHP: guia y descargas
PHP te permite crear aplicaciones web dinamicas con backend real: formularios, sesiones, base de datos, autenticacion y APIs. En este curso sigues un camino progresivo desde fundamentos hasta proyecto final.
Cada UT incluye una explicacion breve, codigo .php, guia .md y acceso directo a practica para
estudiar, reutilizar ejemplos y probar cambios sin salir de la plataforma.
Que te llevas en esta ruta
Mismo formato del curso Java: despliegas la UT, lees una explicacion corta y tienes todos los botones listos para abrir codigo, guia y practica sin perder el hilo del curso.
Tu espacio de estudio y práctica PHP en un solo entorno
Desde esta entrada accedes a la plataforma donde el alumno puede seguir el temario por unidades, revisar el código real, leer la guía asociada y practicar con una navegación más cómoda.
Variables, flujo, funciones y arrays.
Formularios, superglobales y sesiones.
PDO, CRUD y endpoints REST.
Seguridad, testing y proyecto final.
Cada unidad abre el código y la explicación real del curso para estudiar el backend con contexto.
El alumno trabaja sobre los archivos `.php` y `.md` del curso tal como están preparados en el repositorio.
La práctica se hace desde la plataforma PHP completa, con más continuidad y mejor navegación por bloques.
Entradas rápidas por bloque
Cada acceso abre la plataforma PHP en el punto adecuado del temario.
Hola mundo, sintaxis, variables, control de flujo, bucles y funciones.
Ir a fundamentosEstructuras de datos, cadenas, formularios y superglobales para empezar a construir backend real.
Ir a formularios y datosPersistencia en archivos, orientación a objetos y código mejor estructurado.
Ir a ficheros y POONamespaces, Composer y MVC sencillo para avanzar hacia una organización más profesional.
Ir a arquitecturaSeguridad básica, PHPUnit y cierre del curso con proyecto final completo.
Ir a calidad y proyectoCurso completo de Python · Aprende desde cero
¿Por qué aprender Python?
Python es un lenguaje moderno y muy demandado, perfecto para empezar por su sintaxis clara. Se usa en IA, web, automatización y datos.
Herramientas necesarias
-
Python 3.10 o superiorDescargar desde la web oficial
-
Visual Studio Code (recomendado)Descargar VS Code
-
Extensiones recomendadasPython, Better Comments
- Comprender qué es una variable y nombrarla con claridad para que el código sea legible.
- Elegir el tipo adecuado (números, texto, verdadero/falso) y convertir entre tipos sin errores.
- Recoger datos sencillos del usuario y mostrar resultados claros y bien formateados.
- Construir expresiones y pequeñas decisiones para resolver problemas cotidianos.
- Organizar datos básicos con colecciones simples cuando sea conveniente.
- Variables y nombres: qué son,
snake_case, reasignación y buenas prácticas. - Tipos básicos:
int,float,str,booly conversiones (int(),float(),str(),bool()). - Entrada y salida:
input(), errores de conversión y f-strings (f"{total:.2f}"). - Operadores: aritméticos (+ − * / // % **), comparación (== != < > ≤ ≥), lógicos (
and,or,not) y asignación compuesta (+=,-=...). - Colecciones mínimas: listas (crear, indexar, añadir) y diccionarios (claves/valores, actualizar).
- Inspección/depuración:
type(),len()y cómo evitar ValueError/NameError.
- Traducir preguntas del mundo real en condiciones lógicas (sí/no).
- Diseñar ramificaciones simples y legibles, evitando anidaciones innecesarias.
- Validar entradas y contemplar casos límite (vacíos, fuera de rango).
- Escribir decisiones expresivas que muestren la intención del código.
- Planificar el flujo: qué hacer cuando se cumple y qué si no.
- Estructura condicional:
if,elif,else, bloques e indentación correcta. - Comparaciones:
==,!=,<,>y comparación encadenada (0 <= x < 10). - Lógica booleana:
and,or,not, precedencia y if anidados. - Truthy / Falsy: valores falsy (
0,"",[],None) ybool(). - Ternario: decisiones compactas en una línea (
"OK" if cond else "NO"). - match / case (3.10+): múltiples ramas legibles con comodín
case _.
- Elegir el bucle adecuado (for para recorrer, while para condición).
- Diseñar bucles seguros con salida bien definida evitando infinitos.
- Aplicar patrones: contador, acumulador, búsqueda y filtrado.
- Transformar datos en resúmenes o informes legibles.
- Usar cortes o saltos cuando simplifiquen la lógica.
- For básico: recorrer listas/strings y construir resultados paso a paso.
- range(inicio, fin, paso): generar secuencias y hacer sumatorios/contadores.
- enumerate(): obtener índice + valor con numeración limpia.
- while controlado: condición clara, contador/bandera y evitar bucles infinitos.
- Control del flujo:
break,continuey else en bucles. - Bucles anidados: tablas de multiplicar y cuadrículas simples.
- Comprensiones de listas: generar listas en una línea con filtro.
- Detectar tareas repetidas y convertirlas en funciones con nombres significativos.
- Pensar en entradas → proceso → salida (diseño de la firma).
- Dividir problemas grandes en pasos pequeños y comprobables.
- Reutilizar código y reducir errores al cambiar en un solo lugar.
- Funciones sin parámetros: bloque que ejecuta una tarea concreta y se reutiliza.
- Parámetros posicionales: pasar datos a la función y usarlos dentro.
- return: devolver resultados para guardarlos y reutilizarlos.
- Valores por defecto y keyword args: llamadas claras con
nombre=valor. - Scope básico: variables locales vs. externas; evitar
global. - Buenas prácticas: funciones "puras", nombres con verbos y una sola responsabilidad.
- Elegir la estructura adecuada según el problema (lista vs. diccionario).
- Pensar en "datos → recorrido → resultado" para informes claros.
- Planificar bucles anidados con cortes y validaciones.
- Aplicar ordenaciones y transformaciones para conclusiones útiles.
- Listas básicas: crear, acceder, slicing y métodos útiles.
- Diccionarios:
get(),keys(),values(),items(). - Recorrer diccionarios: iterar claves/valores para salidas legibles.
- Estructuras anidadas: lista de dicts, dict de listas y bucles combinados.
- Ordenación:
sorted(key=...),min,max,sum. - Comprensiones: crear listas o dicts en una línea con filtros.
- Integración: mini "dashboard" con totales y resumen.
- Pensar en estado + comportamiento: qué datos guarda y qué sabe hacer.
- Definir interfaces sencillas y ocultar detalles con encapsulación.
- Modelar relaciones: composición y herencia cuando aporte claridad.
- Representar objetos de forma útil para personas y depuración.
- Clases y objetos: atributos, métodos y uso de
self. - Inicialización: constructor
__init__para crear estado válido. - Atributos de clase vs instancia:
@classmethod/@staticmethod. - Dunder methods:
__str__,__repr__,__eq__,__len__. - @property: getters/setters con validación para mantener invariantes.
- Herencia y super(): reutilizar y especializar comportamiento.
- Composición: objetos que contienen otros objetos (tiene-un).
Resumen de la unidad
Construir programas robustos que no se caigan ante errores, muestren mensajes claros y cierren recursos de forma segura.
try/exceptbásico: capturar y tratar errores esperados- Múltiples
excepty jerarquía de excepciones elseyfinally: flujos de éxito y limpiezaraisey validación con mensajes descriptivos- Excepciones personalizadas para tu dominio
- Reintento seguro con intentos limitados
Resumen de la unidad
Aprender a organizar y reutilizar código mediante módulos propios y librerías externas de Python.
importyfrom ... import- Crear módulos propios y paquetes
- Módulos estándar:
os,sys,math,random - Instalar librerías con
pip - Gestionar dependencias con
requirements.txt
Resumen de la unidad
Dominar la lectura y escritura de archivos en Python: texto, CSV, JSON y binarios.
open(),read(),write()- Context manager
withpara archivos - Modos de apertura:
r,w,a,b - Trabajar con CSV y JSON
- Manejo de rutas con
os.pathypathlib
Resumen de la unidad
Crear scripts de automatización para tareas del sistema operativo y administración.
- Módulo
osyshutilpara ficheros - Ejecutar comandos con
subprocess - Variables de entorno y argumentos CLI
- Programación de tareas y scripts batch
- Monitorización de procesos del sistema
Resumen de la unidad
Conectar Python con bases de datos SQLite para almacenar y consultar información persistente.
- Módulo
sqlite3de Python - Crear tablas y ejecutar queries SQL
- CRUD: Create, Read, Update, Delete
- Parámetros seguros (evitar SQL Injection)
- Transacciones y manejo de errores
Resumen de la unidad
Escribir tests automáticos y depurar código de forma eficiente para garantizar calidad.
- Módulo
unittestypytest - Escribir tests unitarios y de integración
- Debugger
pdby breakpoints - Logging y trazas de errores
- TDD: Test Driven Development básico
Resumen de la unidad
Dominar Flask, el microframework web más popular de Python. Desde lo básico hasta proyectos completos con estructura profesional.
- Rutas, métodos HTTP y request/response
- Templates con Jinja2 y herencia
- Formularios, validación y CSRF
- Sesiones, cookies y autenticación
- APIs REST con JSON
- Estructura de proyecto profesional (Blueprints)
Material Teórico
Tutorial completo con explicaciones paso a paso y ejemplos de código comentado.
Proyectos Prácticos Completos
Proyecto Básico
Aplicación Flask sencilla con toda la lógica en un solo archivo. Ideal para empezar.
app.py- Código completotemplates/- 4 plantillas HTMLREADME.md- Documentación
Proyecto Avanzado
Estructura profesional con Blueprints, MVC y configuración separada.
app.py- Punto de entradaconfig.py- Configuraciónmodels.py- Modelos de datosroutes/- Blueprintstemplates/- Vistas
Resumen de la unidad
Dominar Django, el framework web "batteries included" de Python. Aprenderás desde la configuración inicial hasta desplegar un proyecto completo.
- Arquitectura MTV (Model-Template-View)
- ORM de Django y migraciones
- Panel de administración automático
- Sistema de usuarios y permisos
- URLs, vistas basadas en clases y templates
- Middleware y configuración avanzada
Material Teórico
Tutorial completo de Django con explicaciones detalladas y ejemplos prácticos.
Proyecto Django Completo
django_pf - Proyecto Funcional
Proyecto Django completo con estructura profesional, listo para ejecutar y modificar.
manage.py- Script gestióndjpf/- Configuraciónsettings.pyurls.py
core/- App principalviews.pytemplates/middleware.py
Documentación Extra
Guías complementarias para profundizar en Django.
Bloques reales presentes en la carpeta del curso
Estos materiales existen en el temario actual y quedan accesibles desde aquí para no perder partes del recorrido que sí están disponibles en la carpeta y en la plataforma completa.
Setup y buenas prácticas
Entorno, instalación y hábitos base para arrancar bien el curso.
Cadenas y operadores
Trabajo específico con texto, concatenación, formateo y operadores básicos.
Programación funcional
Funciones puras, orden superior, `lambda`, `map`, `filter` y composición de lógica.
BBDD con SQLAlchemy
Modelo ORM y acceso a datos con un enfoque más alto que SQLite puro.
Flask parte 2
Sesiones, seguridad y pasos intermedios para pasar del microproyecto a algo más serio.
Consumo de APIs HTTP
Peticiones HTTP, respuestas JSON y trabajo con servicios externos.
Gradle desde cero
Bloque opcional que sirve como ampliación y puente con automatización y herramientas.
Práctica integradora
Aplicar Flask, consumo HTTP y validación de peticiones en una mini API realista con mentalidad cliente-servidor.
- Definir endpoints y devolver JSON coherente
- Validar payloads antes de modificar estado
- Usar códigos HTTP como 200, 201, 400, 401, 404 y 409
- Distinguir lógica de servidor y consumo desde cliente
- Preparar la transición a proyectos Flask más completos
Todo el recorrido de Python en una experiencia más clara
Esta entrada te lleva al entorno donde se unen teoría, ejemplos reales, navegación por bloques y práctica guiada para avanzar con más continuidad.
Cada módulo enseña el archivo Python real del curso para estudiar exactamente el material que forma parte del temario.
La explicación y las notas van al lado del código para estudiar con contexto, no como materiales sueltos.
La práctica se hace en una pestaña aparte para trabajar con más comodidad y sin meter otro editor dentro de esta página.
Entradas rápidas por bloque
Cada acceso te lleva al punto del curso donde empieza ese bloque.
Variables, operadores, condicionales, bucles, funciones y colecciones para construir una base sólida.
Ir a fundamentosClases, objetos, excepciones, módulos y ficheros para empezar a escribir Python más organizado.
Ir a POO y estructuraAutomatización, bases de datos y flujo de trabajo con datos para pasar del script simple a tareas útiles.
Ir a automatización y datosBuenas prácticas, pruebas y revisión de calidad para que el código no solo funcione, sino que sea mantenible.
Ir a testing y calidadFlask y Django como entrada al desarrollo web con rutas, vistas, plantillas y estructura de proyecto.
Ir a web con PythonLlamadas HTTP, consumo de APIs y cierre del recorrido práctico con integración de servicios externos.
Ir a APIsTeoría de Git · Guía completa
¿Qué es Git?
Git es un programa que sirve para guardar la historia de tu proyecto. Piensa en él como una “máquina del tiempo del código”: cada vez que avanzas, puedes sacar una foto de tu trabajo (commit) y volver atrás si algo sale mal.
Carpeta de tu proyecto + una subcarpeta oculta
.git con el historial.
Una foto de tus cambios con un mensaje que los describe.
Una línea de trabajo paralela donde pruebas cosas sin romper la principal (
main).
¿Para qué sirve?
- Seguridad: puedes volver a versiones anteriores cuando algo falla.
- Orden: trabajas en diferentes ramas sin mezclar cambios.
- Trabajo en equipo: varias personas pueden colaborar sin pisarse el código.
- Historial: sabes quién hizo qué y cuándo.
¿Dónde descargarlo?
Descarga oficial en: git-scm.com/downloads
Tras instalarlo, tendrás disponible el comando git en tu terminal
(PowerShell en Windows, Terminal en macOS/Linux).
📁 Working Directory
Tus archivos “sin guardar en Git”.
- Estado: untracked / modified
- Avanza con: git add
- Revisa: git status
🧺 Staging Area
“Cesta” de cambios listos para confirmar.
- Confirma: git commit -m "mensaje"
- Quita del staging: git restore --staged …
📚 Repository (local)
Historial de commits en tu PC.
- Ver: git log --oneline --graph
- Subir: git push
- Recuperar: git reflog
☁️ Remote (GitHub/GitLab)
Copia compartida en la nube.
- Bajar: git pull --ff-only
- Traer refs: git fetch
- Enlazar: git push -u origin main
- add: Working → Staging (git add .)
- commit: Staging → Repo local (git commit -m)
- push: Local → Remote (git push)
- pull: Remote → Local (git pull --ff-only)
- fetch: Remote → refs (git fetch)
- Branch: línea de trabajo (
main,feature/x) - HEAD: tu “puntero” actual
- Upstream: la rama remota asociada (git push -u)
- Entiendo las 4 cajas: Working, Staging, Local, Remote.
- Sé los pasos básicos: add → commit → push / pull.
- Trabajaré en
mainy usaré ramas para features.
Idea: tras instalar Git, define tu identidad y un editor para los mensajes de commit/merge.
# Ver versión instalada git --version # Configurar identidad global git config --global user.name "Tu Nombre" git config --global user.email "tucorreo@ejemplo.com" # Editor recomendado (VS Code) git config --global core.editor "code --wait" # Rama principal por defecto git config --global init.defaultBranch main
git config --global --list.
Idea: git init crea un repo vacío; git clone copia uno
existente.
# 1) Crear repo nuevo en una carpeta mkdir git-ejercicio && cd git-ejercicio git init echo "Hola Git" > README.md git add README.md git commit -m "feat: primer commit" # 2) Clonar un repo existente (ejemplo) cd .. git clone https://github.com/usuario/proyecto.git cd proyecto
git-ejercicio con tu
primer
commit y (si clonas) otra carpeta con el repo remoto.
Idea: Working Directory → Staging Area → Repository (commit).
# Ver estado actual git status # Añadir un archivo concreto git add archivo.txt # Añadir todo lo modificado git add . # Crear un commit git commit -m "feat: mensaje descriptivo y corto" # Ver historial (formato útil) git log --oneline --graph --decorate --all
README.md, confirma un par de commits y visualiza
el árbol
con git log --oneline --graph.
Idea: desarrolla una feature en su propia rama y luego intégrala en
main.
# Listar ramas git branch # Crear y cambiar a una rama (comando moderno) git switch -c feature/nueva-funcionalidad # ...haz commits aquí... # Volver a main git switch main # Fusionar la rama en main git merge feature/nueva-funcionalidad # Eliminar la rama ya fusionada git branch -d feature/nueva-funcionalidad
feature/saludo, edita README.md,
confirma,
vuelve a main y haz merge.
Idea: vincula un remoto (origin), sube tus commits y trae cambios
con seguridad.
# Enlazar remoto llamado "origin" (ejemplo SSH recomendado) git remote add origin git@github.com:usuario/proyecto.git # Subir commits a main y establecer upstream (solo la 1ª vez) git push -u origin main # Actualizar tu main desde el remoto sin crear merges accidentales git pull --ff-only # Descargar referencias sin fusionar (útil antes de rebase) git fetch
git push -u origin main, ya puedes usar simplemente
git push/git pull.
Idea: descarta cambios, revierte commits y usa el “salvavidas”
reflog.
# Descartar cambios en un archivo (working directory) git restore ruta/archivo # Quitar del área de preparado (staging) git restore --staged ruta/archivo # Volver todo al último commit (⚠️ pierdes cambios sin confirmar) git reset --hard HEAD # Crear un commit que "deshace" otro ya publicado git revert <hash-commit> # Recuperación total si te equivocas (historial de movimientos) git reflog # ...elige un hash anterior y vuelve allí: git reset --hard <hash-bueno>
reset --hard borra cambios no confirmados. Usa antes
git reflog si dudas.
Idea: inspecciona qué cambió, cuándo y por quién; compara commits.
# Diferencias en tu working directory git diff # Registro compacto y gráfico de todas las ramas git log --oneline --graph --decorate --all # Ver diferencias entre dos commits git diff <commit1> <commit2> # Alias útil (opcional) para ver historia bonita git config --global alias.lg "log --oneline --graph --decorate --all" # Luego usa: git lg
git diff <hash1> <hash2> para ver qué cambió entre ellos.
🧪 Práctica Git: Dominando el control de versiones
Documento completo con mapa mental, flujo visual, comandos con filtro interactivo, simulador de escenarios paso a paso, laboratorio de terminal con misiones, errores frecuentes y test autocorregible de 12 preguntas. Ábrelo a pantalla completa para estudiar con comodidad.
Haz clic en cada paso para ver el comando. Sigue el orden de arriba a abajo en tu terminal.
git remote set-url origin https://github.com/TUUSUARIO/tu-repo.git
git clone https://github.com/TUUSUARIO/Hello-World.git cd Hello-World git remote -v
git switch -c feature/mi-cambio git branch --show-current
echo "Mi cambio" >> notas.txt git add notas.txt git commit -m "feat: agrego notas" git log --oneline -n 3
git switch main git merge feature/mi-cambio git branch -d feature/mi-cambio
<<<<<<<, y luego git add . && git commitgit push -u origin main
# Crea .gitignore en la raíz del proyecto y pega: node_modules/ dist/ *.log .vscode/ .idea/
Escribe comandos Git como si fuera una terminal real. Pulsa Enter o usa las sugerencias rápidas.
Todos los archivos Markdown del curso, listos para descargar o previsualizar en el navegador.
Repositorio base: https://github.com/octocat/Hello-World
Qué vas a hacer
Traer a tu equipo una copia completa del proyecto (código e historial). Si vas a practicar libremente, clona tu fork para poder subir cambios.
- Necesitas la URL HTTPS del repo (o SSH si tienes clave configurada).
- Comprueba el remoto:
git remote -v(debería verseorigin). - Ruta de trabajo: entra a la carpeta del proyecto tras clonar.
git clone https://github.com/TUUSUARIO/Hello-World.git cd Hello-World git remote -v
git remote set-url origin https://github.com/TUUSUARIO/tu-repo.git
Qué vas a hacer
Abrir una línea de trabajo paralela para no tocar
main. Así podrás experimentar y después integrar.
- Nombres útiles:
feature/…,fix/…,hotfix/…. - Comprueba la rama activa:
git branch --show-current.
git checkout -b feature/cambios-propios git branch --show-current
Qué vas a hacer
Crear/editar archivos, pasarlos a staging y registrar un commit con mensaje claro.
git addmueve cambios al área de preparación;git commitlos guarda en el historial local.- Mensajes útiles:
feat:,fix:,docs:,refactor:. - Deshacer staging:
git restore --staged archivo. Ver estado:git status.
echo "Hola mundo desde mi rama" >> miarchivo.txt git add miarchivo.txt git commit -m "feat: agrega archivo de prueba" git log --oneline -n 3
Qué vas a hacer
Integrar tu rama en la principal. Si aparecen conflictos, edítalos, prueba y confirma el merge.
- Abortar merge si te equivocas:
git merge --abort. - Recuperación avanzada:
git reflog(historial de referencias).
git checkout main git merge feature/cambios-propios
Qué vas a hacer
Enviar tus commits al remoto. La primera vez defines el
upstream con -u.
- Pull” = traer; Push = subir; Sync = ambos.
- Solo avanzas si tu
mainlocal está al día (git pull --ff-onlyrecomendado).
git push origin main # Primera vez: git push -u origin main
Qué vas a hacer
Crear una PR desde tu rama hacia main para revisión.
En GitHub, usa Squash & merge para un historial limpio.
- Incluye título descriptivo y checklist de lo que cambiaste.
# (Opcional) Con GitHub CLI instalada: # gh pr create --base main --head feature/cambios-propios \ # --title "Mi PR" --body "Descripción breve"
Qué vas a hacer
Apuntar tu remoto origin a tu fork para poder subir
sin errores de permisos.
git remote set-url origin https://github.com/TUUSUARIO/tu-repo.git git push -u origin main
Qué vas a hacer
Excluir dependencias y archivos del IDE para que el repositorio sea ligero y limpio.
- Si ya subiste algo que debería ignorarse:
git rm -r --cached carpeta→ commit.
# Crea .gitignore y pega: # Node node_modules/ dist/ *.log # IDEs .vscode/ .idea/ *.iml
¿Qué es esta guía?
Un ejercicio completo en Markdown para simular un examen real de Git: crear repositorios, configurar identidad, commits, ramas, merge, resolución de conflictos y remoto. Ábrela en tu editor favorito o léela en el navegador con el visor integrado.
Cómo usarla paso a paso
- Descarga el archivo
.mdo ábrelo en el navegador con el botón de arriba. - Crea una carpeta de trabajo vacía en tu equipo.
- Abre una terminal en esa carpeta (o la integrada de tu IDE preferido).
- Sigue los pasos de la guía en orden, ejecutando los comandos indicados.
- Para repetir el examen, crea otra carpeta limpia y vuelve a empezar.
Requisitos: Git instalado. Para practicar remoto, inicia sesión en GitHub.
Practica Git de forma visual (sin instalar nada)
Abre un simulador interactivo en español para entender y practicar ramas, commits y merges. Verás el grafo de commits en tiempo real y resolverás retos cortos.
Bases de Datos · Cursos y plataformas
Aquí no vas a encontrarte un bloque suelto de teoría sin contexto, sino una ruta clara de cursos de bases de datos. Cada acordeón resume qué enseña, para quién encaja y te lleva directamente a la plataforma interactiva o a la guía del curso correspondiente.
La idea es sencilla: eliges el curso que mejor encaja con el nivel del alumno, lees un resumen claro y entras a su plataforma específica sin duplicar contenido ni perder tiempo buscando materiales.
Ruta recomendada
Cada curso vive como una pieza independiente: explicación buena, acceso directo y sin mezclar materiales de niveles distintos.
El objetivo aquí no es repetir toda la teoría dentro de la zona privada, sino lanzar bien cada plataforma interactiva con contexto útil.
Puedes enseñar desde cero, reforzar modelado o pasar a JDBC sin rehacer la navegación ni obligar al alumno a buscar qué viene después.
Este es el mejor punto de entrada para alumnos que todavía no entienden bien qué es una tabla, cómo se lee un resultado o por qué una consulta devuelve unas filas y no otras. Está pensado para empezar de verdad desde cero, con una base pequeña, ejercicios muy guiados y un laboratorio que no abruma.
El curso usa SQLite para eliminar instalaciones complicadas y centra al alumno en lo importante:
SELECT, WHERE, ORDER BY, JOIN y primeros resúmenes con GROUP BY.
- Quita el miedo inicial a SQL.
- Trabaja con consultas pequeñas y muy controladas.
- Da una entrada perfecta para alumnos que se bloquean con demasiada teoría.
Este curso ya no es solo una introducción mínima: es una ruta completa para aprender SQL con más recorrido, usando una base de datos de tienda de videojuegos retro mucho más atractiva visualmente y con ejercicios mejor conectados entre sí.
Aquí el alumno trabaja consultas, DML, DDL, joins, agrupaciones y un proyecto final, todo dentro de una plataforma que además incluye un examen interactivo. Es una opción muy buena cuando quieres un curso más redondo pero sin salir del ecosistema SQLite.
- Después de un primer contacto con SQL.
- Cuando quieres un curso más narrativo y visual.
- Si buscas una plataforma más potente sin complicar el entorno.
Este curso cubre una parte que suele faltar mucho: por qué una base de datos se diseña así. En vez de lanzarte directamente a escribir consultas, enseña entidades, atributos, claves, cardinalidad y normalización para que el alumno entienda de dónde salen las tablas y relaciones.
Es un bloque muy útil para 1 DAM y 1 DAW, especialmente cuando el alumno sabe hacer alguna consulta pero todavía no sabe justificar un diseño relacional ni detectar por qué un modelo está mal planteado.
- Da contexto técnico a SQL.
- Refuerza la parte de diseño y normalización.
- Encaja muy bien antes o en paralelo al curso troncal de SQL.
Este es el curso que mejor funciona como eje principal de SQL si quieres una estructura más académica y completa. Está organizado por unidades, cubre desde entorno y consultas básicas hasta joins, subconsultas, DDL, esquema, permisos y proyecto final.
A diferencia de los cursos más ligeros, aquí la ruta es más formal y está pensada para trabajo serio de aula en DAM/DAW, manteniendo todavía una plataforma propia que ordena teoría, ejercicios y apoyo.
- Orden didáctico muy claro por unidades.
- Más serio para seguimiento de curso completo.
- Muy útil como base principal del bloque SQL.
Este curso no es “otro SQL más”: es el paso donde el alumno deja de usar la base de datos solo desde el editor
y empieza a conectarla desde Java con JDBC, usando CRUD real, PreparedStatement, ResultSet, relaciones, transacciones y arquitectura DAO.
Es el puente perfecto entre lo aprendido en programación y lo aprendido en bases de datos. Si el alumno ya sabe algo de Java y SQL por separado, aquí entiende por fin cómo se unen en un proyecto real.
- Cuando el alumno ya domina lo básico de Java y SQL.
- Para Acceso a Datos o refuerzo de DAM.
- Cuando quieres enseñar una integración profesional, no solo consultas sueltas.
Parámetros del Reto
Esperando configuración
Describe tu ejercicio arriba y generaremos un enunciado detallado listo para programar.