Unidad 5

Introducción 📜

En esta unidad vas a explorar los sistemas de partículas. Los sistemas de partículas son conjuntos de partículas que interactúan entre sí y con su entorno. Estos sistemas son fundamentales en el mundo del arte y diseño generativo, ya que permiten crear composiciones complejas y dinámicas a partir de reglas simples.

¿Qué aprenderás en esta unidad? 💡

En esta unidad vas a experimentar con aplicaciones interactivas que tendrán las siguientes características:

Emitirán partículas que se moverán en el espacio.
Las partículas estarán sujetas a fuerzas que las harán cambiar de dirección y velocidad.

Actividad 01

¿En dónde se usan sistemas de partículas?

🎯 Enunciado: te voy a pedir que le des una mirada a este artículo publicado en Medium por la artista Amelia Winger-Bearskin. En el artículo vas a encontrar ejemplos de sistemas de partículas en el arte y la inteligencia artificial. Dale una mirada a los artistas, ejemplos y proyectos que aparecen en el artículo. Tengo que decirte que uno de los artistas que aparece referenciado es Refik Anadol, uno de mis artistas favoritos.

📤 Entrega: selecciona dos proyectos que mencionen en el artículo que te llamen la atención y que te gustaría explorar más. Escribe un breve resumen de cada uno de ellos y comenta por qué te interesan y cómo crees que se pueden conectar con tu perfil profesional o con algún interés personal que tengas.

🚀 Tu solución:

“State of the Union” (2007)

En esta pieza, DuBois utilizó análisis de texto y visualización de datos para examinar los discursos del Estado de la Unión desde 1790 hasta 2006. Los discursos de cada presidente fueron desglosados y visualizados en varios formatos que destacaban patrones en el uso de palabras, las emociones y temas recurrentes a lo largo de los años.

¿Cómo lo hizo?

Análisis de palabras: DuBois diseñó un algoritmo que analizaba la frecuencia de palabras y frases dentro de los discursos, buscando temas dominantes, como la economía, la guerra, la paz, la salud, etc.
Visualización de datos: Los resultados se transformaron en una serie de representaciones visuales que mostraban cómo los presidentes abordaban diferentes temas a lo largo de las décadas. Estas visualizaciones eran impactantes y presentaban una cronología visual del discurso presidencial estadounidense.

Impacto y significado:

Reflejo de la historia política: La obra no solo presentaba datos fríos, sino que también ofrecía una crítica sobre cómo los presidentes utilizan el lenguaje para dar forma a la narrativa política y social. Por ejemplo, se podían ver claramente los momentos en que ciertos temas, como la guerra en Irak o el terrorismo, dominaban las palabras de los discursos.
Transformación de los datos en arte: Al convertir los discursos en un formato visual y auditivo, DuBois invitaba al espectador a reflexionar sobre el poder del lenguaje y los discursos políticos, no solo como instrumentos de poder, sino también como un medio de influencia cultural.

La obra como performance:

DuBois llevó “State of the Union” a la esfera performativa mediante la interactividad. El público podía ver cómo se generaban las visualizaciones de los discursos en tiempo real, lo que añadía una capa de experiencia inmersiva a la obra.

“Mushroom Cloud” de Refik Anadol es una de sus obras más poderosas, que utiliza la inteligencia artificial y la visualización de datos para abordar un tema profundamente conmovedor y sombrío: el impacto de las armas nucleares y la memoria colectiva relacionada con el uso de la bomba atómica.

”Mushroom Cloud” (2021)

En esta obra, Anadol se sumerge en la historia del bombardeo atómico de Hiroshima y Nagasaki durante la Segunda Guerra Mundial, usando la visualización de datos generados por inteligencia artificial para crear una representación de la nube en forma de hongo, un símbolo icónico asociado con las explosiones nucleares.

¿Cómo lo hizo?

Uso de datos históricos: Anadol recopiló datos e imágenes históricas, incluidas fotografías y testimonios de las víctimas, de los bombardeos nucleares en Japón. Estos datos alimentaron un modelo de inteligencia artificial que los procesó y los tradujo en representaciones visuales y sonoras.
Generación de imágenes con IA: La IA se utilizó para crear imágenes impresionantes y abstractas de la famosa nube en forma de hongo, pero con una estética completamente nueva y transformada. En lugar de ser una imagen directa y literal de la nube, Anadol generó patrones, texturas y formas fluidas que evocan la tragedia sin mostrarlas explícitamente.
Simulación y abstracción: Al utilizar la IA para “reinterpretar” los datos históricos, Anadol no se limita a simplemente mostrar una representación visual, sino que crea una experiencia sensorial de la memoria histórica y los efectos de la bomba. Las imágenes que emergen son tanto poéticas como inquietantes, desafiando al espectador a reflexionar sobre los efectos devastadores de las armas nucleares, pero también sobre la memoria colectiva de estos eventos.

Impacto y significado de la obra:

La memoria y la catástrofe: “Mushroom Cloud” no solo refleja el evento en sí, sino que también examina cómo lo recordamos y lo integramos en la conciencia colectiva. La obra de Anadol hace que los espectadores confronten el pasado a través de una lente digital, invitándolos a reflexionar sobre el poder de la tecnología para generar nuevas formas de recordar y de sanar.
Estética del dolor y la transformación: La obra transforma un evento traumático en una experiencia estética, que es a la vez emocionalmente impactante y tecnológicamente avanzada. La intención de Anadol es crear una meditación sobre los efectos duraderos del trauma y el proceso de transformación que ocurre cuando esa historia se procesa a través de los medios de la tecnología contemporánea.

Interactividad y experiencias inmersivas:

Instalación inmersiva: Esta obra, como muchas de las de Anadol, a menudo se presenta en una instalación inmersiva donde las imágenes generadas por la IA se proyectan en grandes pantallas o incluso en 360 grados alrededor del espectador. Esto crea una experiencia envolvente que invita a los asistentes a ser parte del proceso de reflexión sobre la historia y el impacto del uso de la energía nuclear.

Investigación 🔎

En esta fase, repasarás los conceptos de herencia y polimorfismo que aplicarás para crear sistemas de partículas que se comporten y se vean de manera diferente. Adicionalmente, aplicarás fuerzas a las partículas para que se muevan e interactúan con el entorno.

Actividad 02

Revisa y repasa algunos conceptos

🎯 Enunciado: dale una mirada al capítulo sobre sistemas de partículas del texto guía del curso, pero quiero que te concentres en los siguientes conceptos:

✅ 1. Revisa detalladamente el ejemplo 4.2: an Array of Particles.

✅ 2. Analiza el ejemplo 4.4: a System of Systems.

✅ 3. Analiza el ejemplo 4.5: a Particle System with Inheritance and Polymorphism.

✅ 4. Analiza el ejemplo 4.6: a Particle System with Forces.

✅ 5. Analiza el ejemplo 4.7: a Particle System with a Repeller.

🧐🧪✍️ En tu bitácora responde a esta pregunta para cada una de las simulaciones: ¿Cómo se está gestionando la creación y la desaparción de las partículas y cómo se gestiona la memoria en cada una de las simulaciones?

📤 Entrega:

Vas a modificar cada una de las simulaciones anteriores incluyen en cada una, al menos un concepto de las unidades anteriores, pero no repitas concepto, la idea es que repases al menos uno de cada unidad.
Vas a gestionar la creación y la desaparición de las partículas y la memoria. Explica cómo lo hiciste.
Explica qué concepto aplicaste, cómo lo aplicaste y por qué.
Incluye un enlace a tu código en el editor de p5.js.
Incluye el código fuente de cada una de las simulaciones.
Captura de pantallas de cada una de las simulaciones con las imágenes que más te gusten como resultado de la ejecución de cada una de las simulaciones.

🚀 Tu solución:

Ejemplo 4.2

Codigo fuente:

class Particle {
  constructor(x, y) {
    this.position = createVector(x, y);
    this.acceleration = createVector(0, 0);
    this.velocity = createVector(random(-1, 1), random(-1, 0));
    this.lifespan = 255.0;
  }

  run() {
    let gravity = createVector(0, 0.05);
    this.applyForce(gravity);
    this.update();
    this.show();
  }

  applyForce(force) {
    this.acceleration.add(force);
  }

  update() {
    this.velocity.add(this.acceleration);
    this.position.add(this.velocity);
    this.lifespan -= 2;
    this.acceleration.mult(0);
  }

  show() {
    stroke(0, this.lifespan);
    strokeWeight(2);
    fill(127, this.lifespan);
    circle(this.position.x, this.position.y, 8);
  }

  isDead() {
    return this.lifespan < 0.0;
  }
}

let particles = []; // Declaración del arreglo de partículas

function setup() {
  createCanvas(640, 240);
}

function draw() {
  background(255);

  particles.push(new Particle(width / 2, 20));

  for (let i = particles.length - 1; i >= 0; i--) {
    let particle = particles[i];
    particle.run();

    if (particle.isDead()) {
      particles.splice(i, 1);
    }
  }
}

La gestión de creación y desaparición de partículas sigue un flujo controlado dentro del draw():

Creación de partículas:
- En cada fotograma (draw()), se genera una nueva partícula en particles.push(new Particle(width / 2, 20));.
- Esto significa que el número de partículas puede aumentar indefinidamente si no se eliminan.
Desaparición de partículas:
- Cada partícula tiene una propiedad lifespan, que comienza en 255 y disminuye en this.lifespan -= 2; en cada fotograma.
- Cuando lifespan cae por debajo de 0, isDead() devuelve true.
- Se elimina del array de partículas con particles.splice(i, 1);.

Gestión de memoria en la simulación

La memoria se maneja mediante la actualización y eliminación eficiente de partículas:

Evita el crecimiento descontrolado de memoria: Como se eliminan partículas muertas, el arreglo particles no crece indefinidamente.
Cada objeto tiene una vida útil: Al reducir lifespan, las partículas no permanecen en memoria más tiempo del necesario.
Uso de splice() para liberación de memoria: Se eliminan de particles, permitiendo que JavaScript las recoleccione como basura (garbage collection).

Codigo editado:

let particles = [];

class Particle {
  constructor(x, y) {
    this.position = createVector(x, y);
    this.acceleration = createVector(0, 0);
    this.velocity = createVector(random(-2, 2), random(-2, 0));
    this.lifespan = 255.0;
    this.color = color(random(255), random(255), random(255), this.lifespan); // Color aleatorio
    this.size = random(5, 15); // Tamaño aleatorio
  }

  run() {
    let gravity = createVector(0, 0.05);
    this.applyForce(gravity);
    this.update();
    this.show();
  }

  applyForce(force) {
    this.acceleration.add(force);
  }

  update() {
    this.velocity.add(this.acceleration);
    this.position.add(this.velocity);
    this.lifespan -= 2;
    this.acceleration.mult(0);
  }

  show() {
    stroke(0, this.lifespan);
    strokeWeight(2);
    fill(this.color);
    circle(this.position.x, this.position.y, this.size); // Usa tamaño aleatorio
  }

  isDead() {
    return this.lifespan < 0.0;
  }
}

function setup() {
  createCanvas(640, 240);
}

function draw() {
  background(255);
  particles.push(new Particle(width / 2, 20));

  for (let i = particles.length - 1; i >= 0; i--) {
    let particle = particles[i];
    particle.run();
    if (particle.isDead()) {
      particles.splice(i, 1);
    }
  }
}

Ejemplo 4.4

Codigo fuente:

class Particle {
  constructor(x, y) {
    this.position = createVector(x, y);
    this.acceleration = createVector(0, 0);
    this.velocity = createVector(random(-1, 1), random(-1, 0));
    this.lifespan = 255.0;
  }

  run() {
    let gravity = createVector(0, 0.05);
    this.applyForce(gravity);
    this.update();
    this.show();
  }

  applyForce(force) {
    this.acceleration.add(force);
  }

  update() {
    this.velocity.add(this.acceleration);
    this.position.add(this.velocity);
    this.lifespan -= 2;
    this.acceleration.mult(0);
  }

  show() {
    stroke(0, this.lifespan);
    strokeWeight(2);
    fill(127, this.lifespan);
    circle(this.position.x, this.position.y, 8);
  }

  isDead() {
    return this.lifespan < 0.0;
  }
}

class Emitter {
  constructor(x, y) {
    this.origin = createVector(x, y);
    this.particles = [];
  }

  addParticle() {
    this.particles.push(new Particle(this.origin.x, this.origin.y));
  }

  run() {
    for (let i = this.particles.length - 1; i >= 0; i--) {
      this.particles[i].run();
      if (this.particles[i].isDead()) {
        this.particles.splice(i, 1);
      }
    }
  }
}

let emitters = [];

function setup() {
  createCanvas(640, 240);
  createP("Click to add particle systems");
}

function draw() {
  background(255);
  for (let emitter of emitters) {
    emitter.run();
    emitter.addParticle();
  }
}

function mousePressed() {
  emitters.push(new Emitter(mouseX, mouseY));
}

Codigo editado

class Particle {
  constructor(position) {
    this.position = position.copy();
    this.velocity = p5.Vector.random2D().mult(random(1, 3));
    this.acceleration = createVector(0, 0);
    this.lifespan = 255;
  }

  applyForce(force) {
    this.acceleration.add(force);
  }

  update() {
    this.velocity.add(this.acceleration);
    this.position.add(this.velocity);
    this.lifespan -= 2;
    this.acceleration.mult(0);
  }

  show() {
    stroke(0, this.lifespan);
    strokeWeight(2);
    fill(127, this.lifespan);
    circle(this.position.x, this.position.y, 8);
  }

  isDead() {
    return this.lifespan < 0;
  }

  run() {
    this.applyForce(createVector(0, 0.05)); // Simulación de gravedad
    this.update();
    this.show();
  }
}

class Emitter {
  constructor(position) {
    this.origin = position.copy();
    this.particles = [];
  }

  addParticle() {
    this.particles.push(new Particle(this.origin));
  }

  run() {
    for (let i = this.particles.length - 1; i >= 0; i--) {
      this.particles[i].run();
      if (this.particles[i].isDead()) {
        this.particles.splice(i, 1);
      }
    }
  }
}

let emitters = [];

function setup() {
  createCanvas(640, 240);
  createP("Click to add particle systems");
}

function draw() {
  background(255);
  for (let emitter of emitters) {
    emitter.run();
    emitter.addParticle();
  }
}

function mousePressed() {
  emitters.push(new Emitter(createVector(mouseX, mouseY)));
}

Gestión de Creación y Desaparición de Partículas

Creación de Partículas:
- Cada Emitter tiene un método addParticle(), que añade nuevas partículas a su lista (this.particles).
- En cada iteración de draw(), se llama a addParticle(), generando partículas continuamente en la posición del emisor.
Desaparición de Partículas:
- Cada Particle tiene una propiedad lifespan que disminuye en cada actualización (update()).
- Cuando lifespan llega a cero, isDead() devuelve true.
- En el método run() del Emitter, se revisa cada partícula: si está “muerta”, se elimina con splice() del arreglo.

Gestión de Memoria en la Simulación

Almacenamiento de Objetos: Cada partícula es un objeto independiente almacenado en la memoria. A medida que se crean nuevas partículas, se ocupa más espacio en la RAM.
Eliminación de Partículas: Se usa splice(i, 1) para eliminar partículas muertas, lo que reduce la carga en la memoria.
Fragmentación y Optimización: En lugar de usar splice(), podrías usar filter(), que evita la reestructuración del arreglo y puede ser más eficiente:
```
this.particles = this.particles.filter(particle => !particle.isDead());
```
Uso de p5.Vector: Este enfoque optimiza cálculos matemáticos y reduce la carga computacional en comparación con manejar coordenadas manualmente.

Aplicación 🛠

En esta fase, aplicarás los conceptos que aprendiste en las fases anteriores para resolver un problema de diseño en el que puedas aplicar los conceptos de herencia y polimorfismo con partículas.

Actividad 03

Obra de arte generativa algorítmica interactiva en tiempo real

🎯 Enunciado: diseña e implementa una obra de arte generativa algorítmica interactiva en tiempo real en p5.js que cumpla con los siguientes requisitos:

Debes utilizar los conceptos de herencia y polimorfismo que revisaste en la fase de investigación.
Debes utilizar al menos un concepto de cada una de las unidades anteriores: 4 conceptos.
Debes definir cómo vas a gestionar el tiempo de vida de las partículas y la memoria.
La obra debe ser interactiva en tiempo real. Puedes usar teclado, mouse, música, el micrófono, video, sensor o cualquier otro dispositivo de entrada.
Documenta el proceso de creación, incluyendo la idea inicial, bocetos, experimentación con el código y el resultado final.

📤 Entrega:

Enlace a tu obra en el editor de p5.js.
El código.
Qué concepto de cada unidad aplicaste, cómo lo aplicaste y por qué.
Una captura de pantalla con una imagen de tu obra.

🚀 Tu solución:

Idea Inicial

Crear una obra de arte basada en partículas que se comporten como ecos visuales del movimiento del usuario (a través del mouse). Las partículas reaccionan en tiempo real y desaparecen con el tiempo. Además, algunas cambiarán su comportamiento dependiendo de la distancia al cursor (polimorfismo). Esta pieza representa la idea de cómo dejamos rastros en nuestro entorno.

Conceptos Aplicados

Unidad	Concepto	Aplicación	Por qué
1 - Fundamentos	Coordenadas y dibujo	Uso de `ellipse()`, `stroke()`, `fill()` en posiciones dinámicas	Para representar partículas en movimiento
2 - Estructuras	Arrays y objetos	Manejo de partículas en un array	Permite gestionar múltiples elementos en tiempo real
3 - Programación Orientada a Objetos	Herencia y polimorfismo	Clase `Particle` y subclases `SlowParticle`, `FastParticle` con métodos sobrescritos	Añade variedad de comportamiento visual y dinamismo
4 - Interacción	Entrada del mouse	Uso de `mouseX`, `mouseY` para generar partículas	Hace la obra reactiva e interactiva

Gestión del Tiempo de Vida y Memoria

Cada partícula tiene una propiedad lifespan. En cada frame, disminuye. Cuando llega a 0, se elimina del array principal (particles). Esto mantiene la memoria optimizada y simula el paso del tiempo.

Experimentación y Proceso Creativo

Bocetos en papel: líneas curvas que seguían al mouse como estelas.
Primer prototipo: partículas básicas que desaparecían.
Mejora: clases hijas con diferentes velocidades.
Pruebas con interacción: ajuste del número de partículas, distancia del mouse, colores.
Resultado final: partículas con distintos comportamientos y desaparición progresiva.

Código Completo

let particles = [];

function setup() {
  createCanvas(800, 600);
  background(0);
}

function draw() {
  background(0, 20); // efecto de estela
  for (let i = particles.length - 1; i >= 0; i--) {
    particles[i].update();
    particles[i].display();
    if (particles[i].isDead()) {
      particles.splice(i, 1);
    }
  }
}

// Crear partículas al mover el mouse
function mouseMoved() {
  let p;
  if (random(1) > 0.5) {
    p = new FastParticle(mouseX, mouseY);
  } else {
    p = new SlowParticle(mouseX, mouseY);
  }
  particles.push(p);
}

// Clase base
class Particle {
  constructor(x, y) {
    this.x = x;
    this.y = y;
    this.lifespan = 255;
    this.size = random(5, 15);
    this.vx = random(-1, 1);
    this.vy = random(-1, 1);
    this.color = color(random(255), random(255), random(255), this.lifespan);
  }

  update() {
    this.x += this.vx;
    this.y += this.vy;
    this.lifespan -= 2;
    this.color.setAlpha(this.lifespan);
  }

  display() {
    noStroke();
    fill(this.color);
    ellipse(this.x, this.y, this.size);
  }

  isDead() {
    return this.lifespan <= 0;
  }
}

// Subclase: partícula lenta
class SlowParticle extends Particle {
  constructor(x, y) {
    super(x, y);
    this.vx *= 0.5;
    this.vy *= 0.5;
    this.size *= 1.5;
  }

  display() {
    stroke(255, this.lifespan);
    fill(this.color);
    ellipse(this.x, this.y, this.size);
  }
}

// Subclase: partícula rápida
class FastParticle extends Particle {
  constructor(x, y) {
    super(x, y);
    this.vx *= 2;
    this.vy *= 2;
    this.size *= 0.8;
  }

  display() {
    fill(255, 0, 0, this.lifespan);
    ellipse(this.x, this.y, this.size);
  }
}

Enlace al Editor de p5.js

[ Ver obra en p5.js Web Editor](https://editor.p5js.org/

Captura de Pantalla

captura del ejercicio

Consolidación y metacognición 🤔

En esta fase, consolidarás lo aprendido en la unidad y reflexionarás sobre tu proceso de aprendizaje.

Actividad 04

Consolidación de lo aprendido

🎯 Enunciado: en esta actividad vas a revisar y sintetizar lo aprendido en la unidad.

⚠️ IMPORTANTE: te ruego que no uses chatGPT para resolver esta actividad. La idea es que hagas un ejercicio de reflexión y consolidación de lo aprendido.

✅ 1. ¿Cómo se gestiona la creación y la desaparición de las partículas y cómo se gestiona la memoria?

✅ 2. ¿Cómo se aplica el marco de movimiento motion 101 en los sistemas de partículas que analizaste en la actividad anterior?

✅ 3. ¿Cómo se aplican fuerzas externas a los sistemas de partículas que trabajaste en la unidad? ¿Qué fuerzas se aplicaron y cómo están modeladas?

✅ 4. ¿Cómo se aplicaste los conceptos de herencia y polimorfismo en los sistemas de partículas que trabajaste en la unidad?

📤 Entrega: responde a las preguntas del enunciado en tu bitácora.

🚀 Tu solución:

✅ 1. Gestión de creación, desaparición y memoria en sistemas de partículas

Creación: En cada iteración del draw(), se genera una nueva partícula y se añade al arreglo particles.push(new Particle(x, y)). Esto garantiza un flujo constante de partículas en la simulación.
Desaparición: Cada partícula tiene un tiempo de vida (lifespan). Cuando su valor cae por debajo de un umbral (isDead() devuelve true), se elimina usando splice().
Gestión de memoria: La eliminación de partículas evita que el arreglo crezca indefinidamente, y el garbage collector de JavaScript libera memoria automáticamente al eliminar objetos.

✅ 2. Aplicación del marco Motion 101 en los sistemas de partículas

El Motion 101 establece un enfoque basado en:

Posición: Representada por this.position, que se actualiza en cada iteración del ciclo de vida de la partícula.
Velocidad: this.velocity cambia constantemente en función de fuerzas aplicadas.
Aceleración: this.acceleration gestiona cambios de velocidad y dirección en respuesta a fuerzas externas.

Este marco se traduce en simulaciones fluidas donde los objetos en movimiento siguen principios naturales.

✅ 3. Aplicación de fuerzas externas en el sistema de partículas

Las fuerzas en el sistema de partículas se aplican mediante:

Gravedad: let gravity = createVector(0, 0.05); afecta el desplazamiento en el eje Y, simulando caída progresiva.
Fuerzas de aceleración: Se suman a this.velocity y alteran la dirección/magnitud del movimiento.
Modelado: Las fuerzas externas se representan con vectores (applyForce(force)), lo que permite simular viento, gravedad o empujes direccionales de manera dinámica.

✅ 4. Herencia y polimorfismo en sistemas de partículas

Para mejorar la flexibilidad y reutilización del código, se pueden aplicar estos conceptos:

Herencia: Se puede crear una clase base Particle y luego extenderla (class SpecialParticle extends Particle) para agregar comportamientos específicos.
Polimorfismo: Métodos como show() pueden ser redefinidos en las clases derivadas (SpecialParticle podría dibujar partículas con formas diferentes, pero respetando la estructura de Particle).

Estos principios permiten crear múltiples tipos de partículas dentro del mismo sistema sin duplicar código.

Actividad 05

Autoevaluación

🎯 Enunciado: evalúa tu propio proceso y detecta áreas de mejora. Responde las siguientes preguntas en un texto breve (mínimo 5 líneas por pregunta):

✅ 1. En lo que llevas de la carrera has utilizado la programación orientada a objetos en varios proyectos. Tal vez usaste el concepto de polimorfismo sin entender completamente qué significa. Luego de realizar esta unidad ¿Consideras que entiendes mejor este concepto? ¿Por qué si o por qué no?

✅ 2. ¿Qué partes de esta unidad te resultaron más fáciles? ¿Por qué?

✅ 3. ¿Qué parte te pareció más difícil o te tomó más tiempo? ¿Cómo la resolviste?

✅ 4. Si pudieras repetir esta unidad, ¿Qué harías diferente para mejorar tu comprensión de los conceptos?

✅ 5. ¿Crees que lo que aprendiste en esta unidad te servirá en futuros proyectos? ¿Por qué si o por qué no?

✅ 6. ¿Qué parte de esta unidad te gustaría profundizar más? ¿Por qué?

✅ 7. ¿Qué concepto de esta unidad se podría aplicar a tu área de interés profesional? ¿Por qué?

📤 Entrega: responde de maneara reflexiva y con autocrítica a las preguntas planteadas en el enunciado.

🚀 Tu solución:

1. Comprensión del polimorfismo

Sí, después de esta unidad la comprensión del polimorfismo ha mejorado significativamente. Antes, podía aplicarlo sin detenerme demasiado en sus fundamentos, pero ahora entiendo que es clave para escribir código más flexible y reutilizable. Me permitió ver cómo una misma interfaz puede adoptar múltiples formas dependiendo de la implementación, lo que resulta invaluable en sistemas complejos como los de partículas en Unity.

2. Partes más fáciles de la unidad

Las secciones relacionadas con la implementación de clases y objetos fueron más sencillas, ya que ya tenía experiencia previa en programación orientada a objetos. También la aplicación de fuerzas externas en sistemas de partículas se sintió natural, dado mi conocimiento previo de física.

3. Parte más difícil y cómo la resolví

El concepto más desafiante fue la integración de herencia y polimorfismo en sistemas dinámicos. No solo se trataba de definir clases derivadas, sino de asegurarse de que cada tipo de partícula aportara variabilidad sin romper el diseño base. Para solucionarlo, revisé ejemplos prácticos, experimenté con distintas implementaciones y depuré el código hasta lograr un equilibrio funcional.

4. ¿Qué haría diferente en una repetición de la unidad?

Me centraría más en ejemplos prácticos y aplicados en vez de enfocarme solo en la teoría. Es mucho más fácil entender el polimorfismo cuando se implementa en un proyecto real. También exploraría más casos en los que la herencia no es la mejor opción y cómo las composiciones pueden ofrecer soluciones alternativas.

5. Aplicabilidad en futuros proyectos

Definitivamente, los conceptos aprendidos serán útiles en proyectos futuros. La posibilidad de definir sistemas que evolucionan sin necesidad de reescribir grandes partes del código hace que el desarrollo sea más eficiente, sobre todo en proyectos de generative art, simulaciones físicas y diseño de interactividad en Unity.

6. Temas que quisiera profundizar más

Me gustaría explorar más patrones de diseño aplicados a sistemas de partículas. Entender cómo organizar mejor el código para que sea escalable y adaptable me ayudaría en proyectos donde se requiera crear múltiples tipos de sistemas sin comprometer la eficiencia.

7. Aplicación en mi área de interés profesional

El concepto de polimorfismo y herencia se aplica directamente al desarrollo de sistemas interactivos en Unity, especialmente en la creación de mapas dinámicos, simulaciones físicas y generación procedural. Permite estructurar los sistemas para que sean modulares y adaptables a diversas necesidades sin afectar el rendimiento del proyecto.

Actividad 06

Feedback

🎯 Enunciado: ¿Me ayudas a mejorar esta unidad? Responde a las siguientes preguntas pensando en tus compañeros que tomarán este curso en el futuro.

✅ 1. Sobre la dificultad: ¿La unidad fue demasiado fácil, equilibrada o demasiado difícil? ¿Por qué?

✅ 2. Sobre el ritmo: ¿El tiempo asignado fue adecuado?

✅ 3. Sobre los materiales: ¿Qué tan útil fue la estructura de la unidad? ¿Cómo se podrían mejorar?

✅ 4. Sobre la experiencia de aprendizaje: ¿Qué fue lo mejor de esta unidad? ¿Qué te gustaría que se hiciera diferente?

✅ 5. Propuesta de mejora: si fueras el profesor y tuvieras que mejorar esta unidad para los próximos estudiantes, ¿Qué cambiarías y por qué?

📤 Entrega: ¿Me ayudas con estas preguntas justificando de la manera más precisa posible tus argumentos? De verdad, gracias por tu generosidad y sentido crítico.

🚀 Tu solución:

1. Sobre la dificultad

Respuesta:
Considero que la unidad fue equilibrada. Se presentaron conceptos fundamentales de programación orientada a objetos (como la herencia, el polimorfismo y su aplicación práctica en sistemas dinámicos) de forma que, si bien ya teníamos cierta experiencia, se profundizó en aspectos que antes se utilizaban de forma intuitiva. Esto brindó el desafío justo para profundizar el conocimiento sin resultar abrumador. Sin embargo, para aquellos sin una base sólida, algunos ejemplos prácticos podrían haber parecido complejos, por lo que sería útil que se ofrecieran recursos introductorios complementarios.

2. Sobre el ritmo

Respuesta:
El tiempo asignado fue adecuado para la mayoría, ya que permitió avanzar paso a paso en la integración de conceptos teóricos y prácticos. Aun así, valdría la pena considerar que algunos estudiantes podrían necesitar sesiones adicionales de revisión o tutorías en vivo para aclarar dudas en puntos más complicados, especialmente al integrar conceptos como herencia y polimorfismo con aplicaciones prácticas.

3. Sobre los materiales

Respuesta:
La estructura de la unidad resultó muy útil. La división en secciones teóricas y prácticas, junto con ejercicios que forzaban la aplicación de los conceptos en ejemplos reales (como sistemas de partículas), facilitó la asimilación de la teoría.

Propuesta de mejora:

Incluir videos explicativos o tutoriales interactivos que muestren la implementación paso a paso.
Agregar diagramas y recursos visuales para representar las relaciones de herencia y polimorfismo, lo cual puede ayudar a visualizar la arquitectura del código.
Proveer ejemplos adicionales relacionados con diferentes áreas (por ejemplo, sim- art o desarrollo en Unity) para conectar mejor la teoría con aplicaciones reales.

4. Sobre la experiencia de aprendizaje

Respuesta:
Lo mejor de la unidad fue la integración de lo teórico con la práctica. La oportunidad de aplicar conceptos abstractos directamente en proyectos (como la simulación de partículas) permitió ver en tiempo real cómo los principios de OOP se traducen en código eficiente y flexible.

Lo que se podría cambiar:

Incluir actividades colaborativas o foros para compartir experiencias y soluciones, lo que fomentaría el aprendizaje colectivo.
Incrementar la interacción en vivo, a través de sesiones de depuración o talleres en los que se analicen casos reales, permitiendo una retroalimentación inmediata.

5. Propuesta de mejora como profesor

Respuesta:
Si tuviera la posibilidad de mejorar esta unidad para los próximos estudiantes, implementaría las siguientes acciones:

División modular del contenido: Desglosar el material en módulos más cortos con metas específicas, lo que facilitaría la asimilación progresiva de conceptos y permitiría un seguimiento más focalizado.
Ejercicios interactivos y colaborativos: Crear proyectos grupales y repositorios de código colaborativos donde los estudiantes puedan compartir sus implementaciones y solucionen juntos los desafíos.
Recursos multimedia adicionales: Añadir videos, tutoriales y diagramas interactivos que expliquen con mayor detalle la teoría y la arquitectura del software.
Sesiones de tutoría en vivo: Ofrecer horarios de consulta o talleres en línea para resolver dudas en tiempo real, lo que favorecerá la comprensión de temas complejos como herencia y polimorfismo.

Estos cambios permitirían que la unidad no solo resulte instructiva, sino que también fomente una mayor interacción y una comprensión más profunda mediante la práctica colaborativa.