Universidad de Chile – Departamento de Ciencias de la Computación

• CC3002 – Código Complementario
  • Metodologías de Diseño y Programación
  • 📚 Contenido
  • 🧩 Descripción general
    • Objetivo del curso
    • Progresión (resumen)
    • Stack técnico (implementado aquí)
    • Estructura del repositorio
  • ⚙️ Requisitos
    • ¿Sin Git? Método ZIP
    • Con Git (recomendado)
  • 🔄 Actualizar tu copia
  • ▶️ Ejecutar ejemplos (@main)
  • 🧪 Testing rápido
  • 🗂️ Índice de módulos
  • 📌 Notas pedagógicas importantes
  • ❓ FAQ rápida
  • 🪪 Licencia
    • GitHub (Descripción y Topics sugeridos)

Aprender a diseñar y programar usando OOP clásica en Scala 3, construyendo desde tipos y clases simples hasta patrones de diseño y técnicas básicas de FP.

1. Tipado estático y primeras clases.
2. Encapsulación, herencia y polimorfismo.
3. Pruebas automatizadas (MUnit/JUnit).
4. Abstracciones (traits / clases abstractas).
5. Patrones de diseño fundamentales (Observer, State, Factory, Singleton, Visitor, etc.).
6. Manejo de errores con excepciones.
7. Genéricos (parametrización de tipos) y reutilización.
8. Introducción a FP: inmutabilidad gradual, composición, for-comprehensions, Option/Future simplificados.

• Scala 3.7.3 sobre SBT 1.11.x (build multi-módulo).
• JDK 17+ (probado con Azul JDK 25).
• Pruebas: MUnit (todos los módulos) y JUnit 5 (módulo 03-testing).
• Formateo: Scalafmt, indentación significativa (sin llaves extensivas).

• Cada carpeta numerada (01-..., 02-..., etc.) es un subproyecto independiente.
• El proyecto raíz compila y prueba todos simultáneamente.
• No incluye las diapositivas oficiales; sólo código de apoyo y ejercicios.
• Clases faltantes (12, 16) viven en: dcc-cc3002/clases-2025-2.

No necesitas instalar todo antes de leer el código. Para ejecutar ejemplos locales:

• Java (JDK): versión 17 o superior.
• SBT: 1.11.x.
• IDE recomendado: IntelliJ IDEA + plugin Scala (o VS Code con Metals).

Verifica tus versiones (Terminal):

java -version
sbt --version

Si alguno falla, instala:

• JDK: https://adoptium.net o Azul.
• SBT: https://www.scala-sbt.org/download.html

1. Haz clic en el botón verde Code en GitHub.
2. Selecciona Download ZIP.
3. Descomprime y abre la carpeta en IntelliJ / VS Code.
4. Abre una terminal dentro de la carpeta y ejecuta: sbt compile.

git clone https://github.com/r8vnhill/clases-memes.git
cd clases-memes
git switch <year>/<semester>   # Ej: 2025/2 (Primavera 2025)

Usa la rama correspondiente al semestre (por ej., 2025/2 = Primavera 2025). Si estás en otra rama podrías ver contenido desactualizado.

Para traer cambios nuevos del semestre:

git fetch origin
git switch <year>/<semester>        # Ej: git switch 2025/2
git pull --ff-only origin <year>/<semester>

--ff-only evita merges accidentales y mantiene el historial limpio.

Si hiciste cambios locales y aparece un mensaje de conflicto:

1. Guarda tus archivos aparte.
2. Restablece: git reset --hard origin/<year>/<semester> (⚠️ borra cambios no guardados).
3. Vuelve a copiar tus modificaciones si las necesitas.

Para confirmar el nombre de la rama del semestre, lista ramas remotas:

git branch -r --list "origin/*/*"

Pasos generales:

sbt compile                       # Compila todo
sbt "project forComprehensions" run   # Ejecuta el runner por defecto del módulo

Listar todos los entry points detectados:

sbt "project forComprehensions" "show discoveredMainClasses"

Ejecutar uno específico:

sbt "project forComprehensions" "runMain cl.uchile.dcc.forcomprehensions.basics.basicsRunner"

Si no aparece ningún @main, revisa que hayas compilado (sbt compile) y estés en la rama correcta.

sbt test                      # Todos los módulos
sbt "project testing" test    # Solo módulo de pruebas
sbt "project testing" "testOnly *Calculator*"  # Patrón

MUnit se usa para la mayoría de ejemplos; JUnit 5 solo aparece en 03-testing para comparar estilos.

Clases 12 y 16: ver repositorio externo ya enlazado.

Genéricos: aparecen de forma gradual (parámetros de tipo) a partir de módulos medios para mostrar reutilización segura sin duplicar código.

Intro FP: módulos 18–20 introducen patrones funcionales básicos sin abandonar el enfoque OOP (composición, manejo de efectos simples, for-comprehensions).

1. OOP clásica primero: evitamos al inicio características avanzadas de Scala (pattern matching extensivo, enum, implicits/given, for-comprehensions complejos) para no saturar.
2. Código en inglés, comentarios en español: esto simula entornos reales manteniendo claridad didáctica.
3. Genéricos: se introducen para mostrar cómo parametrizar tipos sin sacrificar legibilidad.
4. FP progresiva: partimos de colecciones y funciones simples; luego for-comprehensions como azúcar sobre map/flatMap/withFilter.
5. Patrones de diseño: se implementan versiones simplificadas con foco en entender el rol de cada patrón antes de optimizar.
6. Ejemplos intencionalmente pequeños: favorecen lectura rápida sobre eficiencia.

Programa histórico: transcripción 2021 (puede estar desactualizado en algunos nombres de clases).

No se reconoce sbt: Asegura que instalaste SBT y reinicia la terminal. En Windows verifica que el ejecutable esté en PATH.

No veo mains al ejecutar show discoveredMainClasses: Compila primero (sbt compile) y confirma rama 2025/2.

Error de versión Java: Usa JDK 17+. Si tienes JDK 8 aparecerán errores de sintaxis Scala 3.

IntelliJ no indexa: Abre el proyecto raíz, espera la importación SBT y sincroniza. Si falla, borra .idea y reimporta.

Conflictos al actualizar la rama: Usa git pull --ff-only. Si ya hiciste commits locales no deseados, guarda tus archivos y resetea (git reset --hard origin/2025/2).

Este material se distribuye bajo CC BY 4.0. Texto completo: creativecommons.org/licenses/by/4.0.

Uso estrictamente educativo: algunas implementaciones se simplifican para destacar conceptos sobre rendimiento o robustez extrema.

¿Comentarios o mejoras? Abre un issue o discútelo en clase.