🏗️ Arquitectura de Kursor

Descubre el diseño modular y extensible que hace de Kursor una plataforma única

📋 Contenido

Visión General

🎯 Principios de Diseño

Kursor está construido siguiendo principios de arquitectura limpia y diseño modular:

  • Separación de Responsabilidades: Cada capa tiene una función específica
  • Inversión de Dependencias: Las capas internas no dependen de las externas
  • Extensibilidad: Fácil adición de nuevos tipos de preguntas
  • Mantenibilidad: Código organizado y bien estructurado
  • Testabilidad: Componentes aislados y fáciles de probar
  • Escalabilidad: Arquitectura preparada para crecimiento
  • Flexibilidad: Múltiples estrategias de aprendizaje
  • Portabilidad: Funciona en múltiples plataformas
📊 Arquitectura en Capas
🎨 Capa de Presentación (UI)
⚙️ Capa de Servicios
🏛️ Capa de Dominio
💾 Capa de Persistencia
🧩 Módulos Extensibles

Capas de Arquitectura

🎨 UI
Capa de Presentación

Interfaz gráfica desarrollada con JavaFX que proporciona una experiencia de usuario moderna e intuitiva.

Componentes principales:
  • KursorApplication.java - Aplicación principal
  • CursoSessionManager.java - Gestión de sesiones
  • CursoDialog.java - Diálogos modales
  • EstadisticasDialog.java - Visualización de estadísticas
⚙️ Servicios
Capa de Servicios

Orquesta la lógica de negocio y coordina las operaciones entre las diferentes capas.

Servicios principales:
  • CursoPreviewService.java - Vista previa de cursos
  • CursoManager.java - Gestión de cursos
  • ModuleManager.java - Gestión de módulos
  • PreguntaFactory.java - Creación de preguntas
🏛️ Dominio
Capa de Dominio

Contiene las entidades principales y la lógica de negocio del sistema de aprendizaje.

Entidades principales:
  • Curso.java - Entidad principal del curso
  • Bloque.java - Agrupación de preguntas
  • Pregunta.java - Pregunta base
  • Sesion.java - Sesión de aprendizaje
💾 Persistencia
Capa de Persistencia

Gestiona el almacenamiento y recuperación de datos utilizando JPA/Hibernate con SQLite.

Componentes principales:
  • SQLiteDialect.java - Dialecto para SQLite
  • persistence.xml - Configuración JPA
  • Entidades JPA para persistencia
  • Repositorios de datos

Patrones de Diseño

Patrón Factory

Utilizado para crear diferentes tipos de preguntas de manera uniforme, permitiendo la extensibilidad del sistema.

public class PreguntaFactory {
    public static Pregunta crearPregunta(String tipo, Map<String, Object> datos) {
        // Lógica para crear preguntas según el tipo
    }
}
Patrón Strategy

Implementado para las estrategias de aprendizaje, permitiendo cambiar el comportamiento de la presentación de preguntas.

  • EstrategiaSecuencial.java
  • EstrategiaAleatoria.java
  • EstrategiaRepeticionEspaciada.java
Patrón Builder

Utilizado para construir objetos complejos como cursos de manera fluida y legible.

  • CursoBuilder.java - Construcción de cursos
  • API fluida para configuración
  • Validación durante la construcción
Beneficios de los Patrones
  • Mantenibilidad: Código más organizado y fácil de entender
  • Extensibilidad: Fácil adición de nuevas funcionalidades
  • Testabilidad: Componentes aislados y fáciles de probar
  • Reutilizabilidad: Patrones probados y documentados

Sistema Modular

🧩 Arquitectura de Módulos

Kursor utiliza un sistema modular basado en el patrón Service Provider Interface (SPI) de Java, permitiendo la extensión dinámica de tipos de preguntas.

Módulos Disponibles:
  • Flashcard Module: Tarjetas de memoria
  • Multiple Choice Module: Preguntas de opción múltiple
  • Fill Blanks Module: Completar huecos
  • True/False Module: Preguntas booleanas
Estructura de Módulo:
  • Module.java - Interfaz principal
  • Pregunta.java - Implementación específica
  • services/ - Registro SPI
  • pom.xml - Dependencias
Ejemplo de Interfaz de Módulo:
public interface PreguntaModule {
    String getTipo();
    Pregunta crearPregunta(Map<String, Object> datos);
    boolean validarPregunta(Pregunta pregunta);
    ComponenteUI crearComponenteUI(Pregunta pregunta);
}
Ventajas del Sistema Modular
  • Extensibilidad: Nuevos tipos de preguntas sin modificar el núcleo
  • Mantenimiento: Módulos independientes y aislados
  • Distribución: Módulos pueden distribuirse por separado
  • Testing: Pruebas unitarias por módulo

Modelo de Dominio

🏛️ Entidades Principales del Sistema

El modelo de dominio de Kursor representa las entidades principales del sistema de aprendizaje interactivo:

📚 Entidades de Contenido
  • Curso - Entidad raíz que contiene todo el contenido educativo
  • Bloque - Agrupación de preguntas por tipo y tema
  • Pregunta - Entidad base abstracta para todos los tipos
🎯 Entidades de Aprendizaje
  • Sesión - Representa una sesión de aprendizaje activa
  • Respuesta - Respuestas del usuario a las preguntas
  • PreguntaSesion - Estado de una pregunta en una sesión
Ejemplo de Estructura YAML Completa:
id: curso_ejemplo
titulo: "Curso de Ejemplo Completo"
descripcion: "Un curso que demuestra todas las capacidades"
bloques:
  - id: bloque_flashcards
    titulo: "Flashcards de Vocabulario"
    descripcion: "Aprende vocabulario básico"
    tipo: "flashcard"
    preguntas:
      - pregunta: "¿Qué significa 'Hello'?"
        respuesta: "Hola"
        metadatos:
          categoria: "saludos"
          dificultad: "facil"
      
  - id: bloque_multiple
    titulo: "Preguntas de Opción Múltiple"
    descripcion: "Elige la respuesta correcta"
    tipo: "multiplechoice"
    preguntas:
      - pregunta: "¿Cuál es la capital de España?"
        opciones:
          - "Madrid"
          - "Barcelona"
          - "Valencia"
          - "Sevilla"
        respuesta_correcta: 0
        explicacion: "Madrid es la capital de España desde 1561"
      
  - id: bloque_huecos
    titulo: "Completar Huecos"
    descripcion: "Rellena los espacios en blanco"
    tipo: "fillblanks"
    preguntas:
      - texto: "La capital de España es ___."
        huecos:
          - respuesta: "Madrid"
            alternativas: ["Madrid", "madrid"]
      
  - id: bloque_truefalse
    titulo: "Verdadero o Falso"
    descripcion: "Determina si es verdadero o falso"
    tipo: "truefalse"
    preguntas:
      - pregunta: "Madrid es la capital de España."
        respuesta: true
        explicacion: "Madrid es efectivamente la capital de España"
Jerarquía de Tipos de Pregunta
Pregunta (Clase Abstracta)
  • ├── Flashcard
    • • pregunta: String
    • • respuesta: String
    • • metadatos: Map<String, Object>
  • ├── PreguntaTest (Opción Múltiple)
    • • pregunta: String
    • • opciones: List<String>
    • • respuestaCorrecta: int
    • • explicacion: String
  • ├── PreguntaCompletarHuecos
    • • texto: String
    • • huecos: List<Hueco>
    • • validacion: ValidacionHuecos
  • └── PreguntaTrueFalse
    • • pregunta: String
    • • respuesta: boolean
    • • explicacion: String
Estrategias de Aprendizaje
EstrategiaAprendizaje (Interfaz)
  • ├── EstrategiaSecuencial
    • • ordenaPreguntas(List<Pregunta>)
    • • Mantiene orden original
    • • Ideal para progresión lógica
  • ├── EstrategiaAleatoria
    • • ordenaPreguntas(List<Pregunta>)
    • • Mezcla aleatoriamente
    • • Evita memorización por orden
  • ├── EstrategiaRepeticionEspaciada
    • • Algoritmo SuperMemo 2
    • • Factor de facilidad adaptativo
    • • Optimiza retención a largo plazo
  • └── EstrategiaRepetirIncorrectas
    • • Dos fases: original + incorrectas
    • • Enfoque en áreas de dificultad
    • • Mejora progresiva
Relaciones entre Entidades
📚 Relaciones de Contenido
  • Curso → Bloques (1:N) - Un curso contiene múltiples bloques
  • Bloque → Preguntas (1:N) - Un bloque contiene múltiples preguntas
  • Pregunta → Tipos Específicos (1:1) - Herencia polimórfica
🎯 Relaciones de Aprendizaje
  • Sesión → Curso (N:1) - Múltiples sesiones por curso
  • Sesión → PreguntaSesiones (1:N) - Estado de cada pregunta
  • PreguntaSesion → Respuesta (1:1) - Respuesta del usuario
  • Sesión → Estrategia (1:1) - Estrategia aplicada
Modelo de Persistencia
Entidades JPA
  • ├── EstadisticasUsuario
    • • id: Long
    • • usuarioId: String
    • • sesionesCompletadas: int
    • • preguntasRespondidas: int
    • • porcentajeExito: double
  • ├── EstadoSesion
    • • id: Long
    • • cursoId: String
    • • fechaInicio: LocalDateTime
    • • fechaFin: LocalDateTime
    • • estrategia: String
  • ├── RespuestaPregunta
    • • id: Long
    • • sesionId: Long
    • • preguntaId: String
    • • respuesta: String
    • • correcta: boolean
    • • tiempoRespuesta: int
  • └── EstadoEstrategia
    • • id: Long
    • • usuarioId: String
    • • estrategia: String
    • • configuracion: String (JSON)
Patrones de Diseño Aplicados
Patrones Implementados
  • ├── Strategy Pattern
    • • Estrategias de aprendizaje
    • • Intercambio dinámico
    • • Extensibilidad
  • ├── Factory Pattern
    • • PreguntaFactory
    • • Creación de preguntas
    • • Encapsulación de lógica
  • ├── Builder Pattern
    • • CursoBuilder
    • • Construcción fluida
    • • Validación durante construcción
  • ├── Observer Pattern
    • • Notificaciones de progreso
    • • Actualización de UI
    • • Desacoplamiento
  • └── Plugin Pattern
    • • Módulos extensibles
    • • ServiceLoader
    • • Carga dinámica
Características del Modelo de Dominio
  • Rico en Comportamiento: Las entidades no son solo datos, sino que encapsulan lógica de negocio
  • Extensible: Nuevos tipos de preguntas se pueden añadir sin modificar el núcleo
  • Persistente: Integración completa con JPA/Hibernate para persistencia
  • Validado: Validaciones a nivel de dominio y persistencia
  • Testeable: Diseño que facilita las pruebas unitarias

Persistencia

Sistema Implementado al 85%

La persistencia de Kursor está prácticamente completa con JPA + SQLite, solo falta el EstrategiaStateManager.

💾 Estrategia de Persistencia

Sistema robusto con JPA/Hibernate + SQLite completamente implementado y probado.

✅ Implementado:
  • 5 Entidades JPA: Sesion, EstadoEstrategia, RespuestaPregunta, EstadisticasUsuario, EstadoSesion
  • 4 Repositorios: Con operaciones CRUD completas
  • Configuración automática: PersistenceConfig.java
  • 15 Pruebas: Suite completa de tests de integración
🎯 Características:
  • Gestión de sesiones: Estado completo de aprendizaje
  • Estado de estrategias: Serialización JSON automática
  • Historial detallado: Todas las respuestas registradas
  • Estadísticas: Métricas y análisis de progreso
Ver Detalles Completos EstrategiaStateManager Pendiente

Extensibilidad

🔧 Crear Nuevos Módulos

Kursor está diseñado para ser altamente extensible. Aquí te mostramos cómo crear un nuevo módulo:

1. Implementar la Interfaz:
public class MiNuevoModule implements PreguntaModule {
    @Override
    public String getTipo() {
        return "mi_nuevo_tipo";
    }
    
    @Override
    public Pregunta crearPregunta(Map<String, Object> datos) {
        // Implementar lógica de creación
        return new MiNuevaPregunta(datos);
    }
}
2. Registrar el Módulo:
# META-INF/services/com.kursor.modules.PreguntaModule
com.kursor.mimodulo.MiNuevoModule
Consideraciones
  • Asegúrate de que el módulo sea compatible con la versión de Kursor
  • Implementa validaciones adecuadas
  • Proporciona documentación clara
  • Incluye tests unitarios
Recursos para Desarrolladores

🚀 ¿Listo para Contribuir?

Únete al desarrollo de Kursor y ayuda a mejorar la plataforma

Ver en GitHub Reportar Issues Discusiones