Programación Orientada a Objetos: Fundamentos y Aplicaciones en Ingeniería

1. Fundamentos históricos y conceptuales de la Programación Orientada a Objetos (POO)

• Origen y evolución de la POO: Historia desde Simula y Smalltalk hasta los lenguajes modernos.
• Diferencias entre programación estructurada y orientada a objetos: Paradigmas, enfoques y ejemplos comparativos.
• Contexto de la POO en ingeniería: Relevancia y aplicaciones en desarrollo de software para ingeniería.

2. Conceptos básicos de la POO: Clases, objetos y métodos

• Definición y estructura de una clase: Atributos, comportamiento y encapsulamiento.
• Objetos como instancias de clases: Creación, estado y comportamiento dinámico.
• Métodos y funciones miembro: Declaración, llamadas y ejemplos prácticos simples.
• Relación entre clases y objetos: Cómo se modelan entidades del mundo real.

3. Ventajas de la POO en el desarrollo de software modular y reutilizable

• Modularidad: Segmentación del código en unidades independientes (clases).
• Reutilización de código: Herencia y composición para evitar redundancias.
• Mantenimiento y escalabilidad: Facilidad para modificar y extender sistemas.
• Abstracción y encapsulamiento: Protección de datos y simplificación del diseño.

4. Terminología y conceptos fundamentales para interpretar diagramas y códigos orientados a objetos

• Diagramas UML básicos: Clases, objetos, atributos y métodos.
• Interpretación de códigos simples: Análisis de ejemplos de código orientado a objetos en pseudocódigo o lenguajes como Java o Python.
• Vocabulario esencial: Instancia, constructor, mensaje, encapsulación, herencia básica (introducción).

Actividad 1: Línea de tiempo histórica de la POO

Objetivo: Explicar los fundamentos históricos y conceptuales de la programación orientada a objetos, diferenciándola de la programación estructurada.

Descripción paso a paso:

• Dividir a los estudiantes en grupos pequeños.
• Asignar diferentes hitos históricos (por ejemplo, Simula, Smalltalk, C++, Java) a cada grupo.
• Investigar brevemente el aporte de cada hito al paradigma orientado a objetos.
• Construir una línea de tiempo visual en una cartulina o presentación digital.
• Presentar y discutir las diferencias con la programación estructurada.

Organización: Grupos de 3-4 estudiantes

Producto esperado: Línea de tiempo visual y presentación corta en clase

Duración estimada: 1.5 horas

Actividad 2: Creación y análisis de clases y objetos

Objetivo: Identificar y describir los conceptos básicos de clases, objetos y métodos mediante ejemplos prácticos.

Descripción paso a paso:

• Proporcionar un caso de estudio sencillo (por ejemplo, modelar un automóvil o una calculadora).
• Solicitar que definan atributos y métodos para la clase.
• Crear objetos concretos con valores específicos.
• Escribir pseudocódigo o código en lenguaje simple para ilustrar la clase y sus objetos.
• Compartir y discutir sus definiciones en plenaria.

Organización: Parejas o individual

Producto esperado: Documento con definición de clase, objetos y métodos; código o pseudocódigo.

Duración estimada: 2 horas

Actividad 3: Debate sobre ventajas de la POO en ingeniería

Objetivo: Analizar las ventajas de la programación orientada a objetos en el desarrollo de software modular y reutilizable en contextos de ingeniería.

Descripción paso a paso:

• Formar dos grupos, uno a favor y otro crítico de la POO.
• Cada grupo prepara argumentos basados en la modularidad, reutilización, mantenimiento, etc.
• Realizar un debate estructurado en clase.
• Finalizar con una reflexión conjunta y resumen de las ventajas principales.

Organización: Grupos grandes

Producto esperado: Lista de ventajas documentada y síntesis del debate.

Duración estimada: 1.5 horas

Actividad 4: Interpretación de diagramas UML y fragmentos de código

Objetivo: Aplicar la terminología y los conceptos fundamentales de la POO para interpretar diagramas y códigos simples orientados a objetos.

Descripción paso a paso:

• Entregar diagramas UML sencillos de clases con atributos y métodos.
• Presentar fragmentos de código orientado a objetos relacionados.
• Solicitar que identifiquen clases, atributos, métodos y relaciones.
• Resolver preguntas para interpretar el comportamiento del código.
• Revisar respuestas en plenaria para aclarar dudas.

Organización: Individual o parejas

Producto esperado: Respuestas escritas que describan la interpretación del diagrama y código.

Duración estimada: 2 horas

Evaluación diagnóstica

Qué se evalúa: Conocimientos previos sobre paradigmas de programación, especialmente estructurada y orientada a objetos, y familiaridad con conceptos básicos.

Cómo se evalúa: Cuestionario breve con preguntas de opción múltiple y verdadero/falso sobre definiciones y diferencias entre paradigmas.

Instrumento sugerido: Prueba escrita o en línea al inicio de la unidad (15-20 minutos).

Evaluación formativa

Qué se evalúa: Comprensión y aplicación de conceptos básicos (clases, objetos, métodos) y análisis de ventajas de la POO.

Cómo se evalúa: Revisión continua de las actividades prácticas, participación en debates y análisis de diagramas y códigos.

Instrumento sugerido: Rúbrica para evaluar actividades, observación directa y feedback durante las sesiones.

Evaluación sumativa

Qué se evalúa: Capacidad para explicar fundamentos históricos, describir conceptos básicos, analizar ventajas, e interpretar diagramas y códigos simples.

Cómo se evalúa: Examen escrito o proyecto corto donde se solicite:

• Explicar la historia y diferencias con programación estructurada.
• Definir y ejemplificar clases, objetos y métodos.
• Argumentar ventajas de la POO en ingeniería.
• Interpretar un diagrama UML y fragmento de código orientado a objetos.

Instrumento sugerido: Prueba escrita con preguntas teóricas y ejercicios prácticos (90 minutos).

La unidad "Introducción a la Programación Orientada a Objetos" se sugiere impartir en un total de 8 horas distribuidas en 2 semanas, organizadas de la siguiente manera:

• Semana 1 (4 horas): Presentación de fundamentos históricos y conceptuales (tema 1), actividades 1 y 2 para consolidar clases, objetos y métodos.
• Semana 2 (4 horas): Análisis de ventajas de la POO (tema 3), interpretación de diagramas y códigos (tema 4), actividades 3 y 4, y evaluación formativa.

Al final de la segunda semana se recomienda realizar la evaluación sumativa para verificar el logro de los objetivos de la unidad.

1. Introducción a la Programación Orientada a Objetos (POO)

• Concepto y evolución de la POO: se explicará el paradigma de programación orientado a objetos, su origen y sus ventajas frente a otros paradigmas.
• Terminología básica: clase, objeto, atributo, método, instancia.

2. Conceptos fundamentales: Clases y Objetos

• Definición de clase: estructura, propósito y cómo representa un concepto o entidad en ingeniería.
• Definición de objeto: instancia de una clase, identidad, estado y comportamiento.
• Atributos: propiedades o características de una clase/objeto.
• Métodos: funciones o procedimientos que definen el comportamiento de una clase/objeto.
• Relación entre clase y objeto: explicación de la instancia y del ciclo de vida del objeto.

3. Declaración y creación de clases y objetos en un lenguaje de programación orientado a objetos

• Sintaxis para declarar una clase: estructura general, definición de atributos y métodos.
• Tipos de atributos: variables de instancia y variables de clase (estáticas).
• Declaración y definición de métodos: firmas, parámetros, valor de retorno.
• Instanciación de objetos: creación de objetos y asignación a variables.
• Uso de constructor: definición, propósito y sobrecarga si aplica.

4. Encapsulamiento y manipulación de atributos a través de métodos

• Principio de encapsulamiento: proteger los datos y controlar el acceso mediante modificadores de acceso.
• Modificadores de acceso: público, privado, protegido (según lenguaje).
• Métodos getters y setters: implementación y uso para acceder y modificar atributos.
• Validación y control dentro de métodos: asegurar la integridad de los datos.

5. Aplicación de clases y objetos para resolver problemas simples de ingeniería

• Modelación de un problema de ingeniería usando clases y objetos: análisis y diseño.
• Relación entre atributos y comportamiento para representar entidades reales.
• Ejemplos prácticos: modelación de un sistema de control simple, componentes mecánicos o eléctricos como objetos.

6. Comunicación y documentación del diseño orientado a objetos

• Diagramas de clases UML: elementos básicos, representación de clases, atributos, métodos y relaciones.
• Descripciones técnicas: cómo redactar definiciones claras y precisas de clases y objetos.
• Interpretación y generación de diagramas para documentar soluciones.

Actividad 1: Análisis y explicación de conceptos clave de POO

Objetivo: Definir y explicar los conceptos de clase, objeto, atributos y métodos.

Descripción:

• Lectura guiada sobre conceptos básicos de POO.
• Discusión en clase para identificar ejemplos de la vida real que representen clases y objetos.
• Redacción individual de definiciones técnicas con terminología adecuada.

Organización: Individual

Producto esperado: Documento con definiciones y ejemplos propios.

Duración estimada: 1 hora

Actividad 2: Creación y declaración de clases y objetos en código

Objetivo: Crear y declarar clases con atributos y métodos, e instanciar objetos aplicando sintaxis correcta.

Descripción:

• Se proporciona un problema sencillo de ingeniería (por ejemplo, modelar un sensor o componente).
• Los estudiantes escriben la clase con atributos y métodos en el lenguaje seleccionado.
• Instancian objetos y realizan llamadas a métodos para demostrar funcionalidad.

Organización: Parejas

Producto esperado: Código funcional con clase, objeto y métodos implementados.

Duración estimada: 2 horas

Actividad 3: Implementación de encapsulamiento y modificación de métodos

Objetivo: Implementar y modificar métodos para manipular atributos garantizando encapsulamiento e integridad.

Descripción:

• Se entrega una clase sin encapsulamiento ni validación.
• Los estudiantes modifican la clase para agregar modificadores de acceso y crear getters/setters.
• Se implementan validaciones simples en setters para asegurar la integridad de datos.
• Pruebas para verificar el correcto funcionamiento.

Organización: Individual

Producto esperado: Código mejorado con encapsulamiento y validación.

Duración estimada: 1.5 horas

Actividad 4: Modelación y documentación de un problema de ingeniería con diagramas UML

Objetivo: Comunicar diseño de clases e interacción entre objetos mediante diagramas y descripciones técnicas.

Descripción:

• Se presenta un caso de estudio de ingeniería simple (por ejemplo, sistema de control de temperatura).
• Los estudiantes identifican clases, atributos y métodos necesarios.
• Elaboran un diagrama de clases UML.
• Redactan una breve descripción técnica explicando el diseño y la interacción.

Organización: Grupos pequeños (3-4 personas)

Producto esperado: Diagrama UML y documento con descripción técnica.

Duración estimada: 2 horas

Evaluación diagnóstica

Qué se evalúa: Conocimientos previos sobre conceptos básicos de POO: clase, objeto, atributos y métodos.

Cómo se evalúa: Cuestionario corto con preguntas teóricas y ejemplos para definir conceptos.

Instrumento sugerido: Test en línea o en papel con preguntas de opción múltiple y respuestas abiertas.

Evaluación formativa

Qué se evalúa: Progreso en la creación de clases y objetos, implementación de encapsulamiento y comprensión de la modelación.

Cómo se evalúa: Revisión continua de códigos entregados, retroalimentación en actividades prácticas y observación de participación en discusiones y trabajo en equipo.

Instrumento sugerido: Lista de cotejo para revisión de código, rúbrica para evaluación de diagramas UML y participación.

Evaluación sumativa

Qué se evalúa: Dominio integral de los conceptos, aplicación correcta de sintaxis, encapsulamiento, y capacidad para modelar y documentar problemas de ingeniería con clases y objetos.

Cómo se evalúa: Proyecto final individual o grupal que incluye:

• Definición y explicación técnica de conceptos aplicados.
• Implementación de clases y objetos con encapsulamiento en código.
• Modelación del problema con diagramas UML.
• Documentación escrita clara y técnica.

Instrumento sugerido: Rúbrica detallada que valore aspectos técnicos, sintaxis, diseño y comunicación.

La unidad "Clases y Objetos" se recomienda impartir en un total de 8 horas distribuidas en 4 sesiones de 2 horas cada una. La primera sesión se enfocará en los conceptos teóricos y la evaluación diagnóstica, la segunda y tercera sesión en actividades prácticas de programación y encapsulamiento, y la última sesión en la modelación, documentación y evaluación sumativa. Se sugiere complementar con ejercicios autónomos y revisión adicional fuera de clase.

1. Introducción a la Encapsulación y Abstracción

• Definición de encapsulación en programación orientada a objetos (POO)
• Definición de abstracción y su relación con la encapsulación
• Beneficios de encapsulación y abstracción en la protección y organización de datos
• Ejemplos conceptuales para distinguir encapsulación y abstracción

2. Modificadores de Acceso y Protección de Datos

• Tipos de modificadores de acceso comunes (private, protected, public, y otros según lenguaje)
• Cómo aplicar modificadores de acceso en atributos y métodos
• Impacto de los modificadores en la integridad y seguridad de los datos
• Buenas prácticas para la gestión de acceso a miembros de clase
• Ejemplos prácticos en lenguajes típicos (Java, C++, Python)

3. Diseño de Interfaces Claras y Seguras

• Concepto de interfaz en POO y su función en la abstracción
• Cómo diseñar interfaces que oculten la implementación interna
• Principios para facilitar la reutilización y el mantenimiento del software
• Ejemplos de interfaces seguras y su implementación
• Relación entre interfaces y encapsulación

4. Análisis y Evaluación de Diseños con Encapsulación y Abstracción

• Principios SOLID relacionados con encapsulación y abstracción
• Evaluación de diseños de clase para modularidad y robustez
• Identificación de problemas comunes en diseño por falta de encapsulación o abstracción
• Casos de estudio y análisis de diseños reales o simulados
• Uso de diagramas UML para visualizar encapsulación y abstracción en clases

Actividad 1: Debate y Mapa Conceptual sobre Encapsulación y Abstracción

Objetivo: Explicar los conceptos de encapsulación y abstracción y sus beneficios (Objetivo 1).

Descripción:

• Dividir a los estudiantes en grupos de 3-4 personas.
• Cada grupo discute y define en sus propias palabras qué es encapsulación y qué es abstracción.
• Elaboran un mapa conceptual que relacione ambos conceptos y sus beneficios para la protección y organización de datos.
• Presentan su mapa y conclusiones al resto de la clase.

Organización: Grupos

Producto esperado: Mapa conceptual digital o en papel y presentación oral breve.

Duración estimada: 1 hora

Actividad 2: Implementación Práctica de Modificadores de Acceso

Objetivo: Aplicar modificadores de acceso para proteger atributos y métodos (Objetivo 2).

Descripción:

• El docente entrega una clase base con atributos y métodos públicos sin protección.
• Los estudiantes modifican la clase para aplicar los modificadores de acceso adecuados, protegiendo los datos sensibles.
• Implementan métodos getters y setters para acceso controlado.
• Prueban la clase con un programa que intente acceder a atributos protegidos y validan la seguridad.

Organización: Individual o en parejas

Producto esperado: Código fuente de la clase modificada y programa de prueba.

Duración estimada: 2 horas

Actividad 3: Diseño de Interfaces para un Sistema de Ingeniería

Objetivo: Diseñar interfaces claras y seguras que oculten la implementación interna (Objetivo 3).

Descripción:

• En grupos, seleccionar un sistema de ingeniería simple (ej. sistema de control de temperatura, gestión de sensores).
• Identificar las funcionalidades principales y definir interfaces públicas que permitan usar el sistema sin exponer detalles internos.
• Escribir las firmas de métodos y atributos públicos, y describir qué queda oculto.
• Presentar el diseño y justificar cómo facilita la reutilización y mantenimiento.

Organización: Grupos

Producto esperado: Documento de diseño de interfaz y presentación.

Duración estimada: 2 horas

Actividad 4: Análisis Crítico de Diseños de Clases con Encapsulación y Abstracción

Objetivo: Analizar y evaluar diseños de clases para mejorar modularidad y robustez (Objetivo 4).

Descripción:

• Proveer a los estudiantes con varios ejemplos de clases con distinto nivel de encapsulación y abstracción.
• Los estudiantes identifican problemas, riesgos y oportunidades de mejora en cada diseño.
• Proponen modificaciones para corregir o mejorar el diseño.
• Discuten en clase los análisis y recomendaciones.

Organización: Individual o parejas

Producto esperado: Informe de análisis y propuesta de mejora.

Duración estimada: 1.5 horas

Evaluación Diagnóstica

Qué se evalúa: Conocimientos previos sobre encapsulación, abstracción y modificadores de acceso.

Cómo se evalúa: Cuestionario de opción múltiple y preguntas cortas para definir conceptos básicos y reconocer ejemplos.

Instrumento sugerido: Test en línea o en papel al inicio de la unidad.

Evaluación Formativa

Qué se evalúa: Aplicación práctica de modificadores de acceso, diseño de interfaces y análisis de clases durante las actividades.

Cómo se evalúa: Revisión continua de productos parciales (código, mapas conceptuales, diseños, informes) y retroalimentación en clase.

Instrumento sugerido: Rubricas para proyectos y participación en clase.

Evaluación Sumativa

Qué se evalúa: Comprensión integral y aplicación de encapsulación y abstracción, desde explicación conceptual hasta diseño y análisis crítico.

Cómo se evalúa: Examen teórico-práctico donde se pide explicar conceptos, modificar código con modificadores de acceso, diseñar interfaces y analizar un diseño dado.

Instrumento sugerido: Examen escrito y entrega de proyecto final de diseño de clases.

La unidad "Encapsulación y Abstracción" se sugiere impartir en un total de 6.5 horas distribuidas en dos semanas, con la siguiente distribución:

• Semana 1 (3 horas): Introducción a los conceptos (1 hora) y actividad de debate/mapa conceptual (1 hora), seguida de explicación y práctica inicial de modificadores de acceso (1 hora).
• Semana 2 (3.5 horas): Actividad práctica de implementación de modificadores (2 horas), diseño de interfaces (2 horas, puede extenderse a la semana siguiente si es necesario), y análisis crítico de diseños (1.5 horas).

Los tiempos incluyen explicación, actividades prácticas, discusión y retroalimentación.

1. Introducción a la Herencia en Programación Orientada a Objetos

• Concepto de herencia: definición y propósito fundamental.
• Importancia de la herencia para la reutilización de código y mantenimiento.
• Terminología básica: superclase, subclase, clase base, clase derivada.
• Ejemplos conceptuales simples para entender la relación "es un".

2. Diagramas de Clases para Modelar Herencia

• Elementos básicos de un diagrama de clases UML.
• Representación gráfica de la herencia: flechas y relaciones.
• Construcción de jerarquías de clases mediante diagramas.
• Interpretación de diagramas para identificar superclases y subclases.

3. Diseño y Construcción de Jerarquías de Clases

• Principios para diseñar jerarquías eficientes y coherentes.
• Modelado de relaciones "es un" en problemas de ingeniería.
• Creación de superclases que encapsulan atributos y métodos comunes.
• Definición de subclases que extienden o especializan el comportamiento.
• Buenas prácticas para evitar problemas comunes (herencia múltiple, jerarquías profundas).

4. Implementación de Herencia en Lenguajes Orientados a Objetos

• Sintaxis básica para definir herencia en lenguajes como Java, C++ o Python.
• Uso de constructores en herencia y llamada a constructores de superclases.
• Extensión de funcionalidades mediante sobreescritura (override) y sobrecarga.
• Acceso a miembros de la superclase desde la subclase.
• Ejemplos prácticos de implementación en problemas de ingeniería.

5. Análisis y Evaluación de Diseños de Herencia

• Evaluación de modularidad y cohesión en jerarquías de herencia.
• Ventajas y desventajas de diferentes estrategias de herencia.
• Problemas comunes: herencia múltiple, fragilidad, acoplamiento excesivo.
• Alternativas y patrones de diseño relacionados (composición vs herencia).
• Estudio de casos reales en proyectos de ingeniería.

6. Comunicación Técnica de Diseños y Resultados

• Estructura y elementos clave de informes técnicos sobre herencia.
• Uso de diagramas y código para apoyar explicaciones.
• Técnicas para presentar resultados y análisis en presentaciones orales.
• Recomendaciones para claridad y precisión en la comunicación técnica.

Actividad 1: Análisis y Diagramación de Jerarquías de Herencia

Objetivo: Explicar el concepto de herencia y utilizar diagramas UML para ilustrar jerarquías de herencia.

Descripción:

• Se presenta un conjunto de clases y relaciones en un escenario de ingeniería (por ejemplo, vehículos, máquinas, o dispositivos).
• Los estudiantes analizan las relaciones "es un" y diseñan un diagrama de clases UML que represente la jerarquía de herencia.
• Discusión en grupo sobre las decisiones de diseño tomadas y la claridad del diagrama.

Organización: Grupos de 3-4 estudiantes.

Producto esperado: Diagrama UML impreso o digital que refleje la jerarquía de herencia del escenario.

Duración estimada: 90 minutos.

Actividad 2: Diseño y Codificación de Jerarquías con Herencia

Objetivo: Diseñar y construir jerarquías de clases con superclases y subclases, aplicando herencia para modelar relaciones "es un".

Descripción:

• Se asigna un problema práctico de ingeniería (por ejemplo, modelar diferentes tipos de sensores o componentes electrónicos).
• Los estudiantes diseñan la jerarquía de clases en UML y luego implementan el código en un lenguaje orientado a objetos.
• Se debe incluir la definición de superclase y al menos dos subclases que extiendan sus funcionalidades.
• Se realiza una prueba simple para validar el funcionamiento del código.

Organización: Parejas o individual.

Producto esperado: Código fuente funcional y diagrama UML correspondiente.

Duración estimada: 3 horas.

Actividad 3: Análisis Crítico de Diseños de Herencia

Objetivo: Analizar y evaluar diferentes diseños de herencia identificando ventajas y desventajas en términos de modularidad y mantenimiento.

Descripción:

• Se proporcionan varios ejemplos de jerarquías de clases con herencia, algunos bien diseñados y otros con problemas.
• Los estudiantes evalúan cada diseño identificando posibles mejoras, problemas de acoplamiento o falta de cohesión.
• Se redacta un informe breve con el análisis y propuestas de optimización.

Organización: Individual.

Producto esperado: Informe escrito con análisis crítico y recomendaciones.

Duración estimada: 2 horas.

Actividad 4: Presentación Técnica de un Proyecto de Herencia

Objetivo: Comunicar de manera clara y técnica los diseños y resultados obtenidos al aplicar herencia en soluciones orientadas a objetos.

Descripción:

• Cada estudiante o pareja prepara una presentación de 10 minutos sobre el diseño y la implementación de una jerarquía de herencia desarrollada en actividades previas.
• La presentación debe incluir diagramas UML, fragmentos de código y análisis de ventajas del diseño.
• Se responderán preguntas del resto del grupo y del docente para fomentar discusión técnica.

Organización: Individual o parejas.

Producto esperado: Presentación oral apoyada con diapositivas digitales.

Duración estimada: 1 hora (dependiendo del número de presentaciones).

Evaluación Diagnóstica

Qué se evalúa: Conocimientos previos sobre conceptos básicos de herencia y diagramas UML.

Cómo se evalúa: Cuestionario escrito o digital con preguntas conceptuales y de reconocimiento de diagramas.

Instrumento sugerido: Test de opción múltiple con 10 preguntas breves.

Evaluación Formativa

Qué se evalúa: Progreso en diseño, implementación y análisis crítico de herencia durante las actividades prácticas.

Cómo se evalúa: Revisión continua de diagramas, código fuente, informes y participación en discusiones.

Instrumento sugerido: Lista de cotejo para cada actividad con indicadores de cumplimiento técnico y conceptual.

Evaluación Sumativa

Qué se evalúa: Competencia global para diseñar, implementar, analizar y comunicar soluciones basadas en herencia.

Cómo se evalúa: Proyecto final que incluya diseño UML, código implementado, análisis crítico y presentación técnica.

Instrumento sugerido: Rúbrica detallada que valore cada componente (diseño, implementación, análisis y comunicación) con criterios claros y puntajes asignados.

La unidad "Herencia" está diseñada para desarrollarse en un total de 10 horas distribuidas en 2 semanas, considerando las siguientes sesiones:

• Semana 1: 4 horas dedicadas a la introducción conceptual, diagramación y diseño de jerarquías (temas 1 a 3), incluyendo la actividad 1.
• Semana 2: 6 horas para implementación práctica, análisis crítico, y comunicación técnica (temas 4 a 6), incluyendo actividades 2, 3 y 4.

Esta distribución permite un equilibrio entre teoría, práctica y evaluación continua para asegurar la comprensión y aplicación efectiva de la herencia en programación orientada a objetos.

1. Introducción al Polimorfismo

• Definición y concepto general de polimorfismo en programación orientada a objetos.
• Importancia del polimorfismo para la ingeniería de software y desarrollo de sistemas flexibles.
• Relación entre polimorfismo, encapsulamiento y herencia.

2. Tipos de Polimorfismo

• Polimorfismo estático (o en tiempo de compilación)
  • Concepto y características.
  • Implementación mediante sobrecarga de métodos.
  • Ventajas y limitaciones en problemas de ingeniería.
• Polimorfismo dinámico (o en tiempo de ejecución)
  • Concepto y características.
  • Implementación mediante sobreescritura de métodos y uso de clases base y derivadas.
  • Ventajas para la extensibilidad y mantenimiento del código.
• Diferencias clave entre polimorfismo estático y dinámico.

3. Sobrecarga y Sobreescritura de Métodos

• Sobrecarga de métodos
  • Definición y características.
  • Ejemplos prácticos en lenguajes orientados a objetos comunes (Java, C++, C#).
  • Aplicaciones en ingeniería para aumentar la flexibilidad funcional.
• Sobreescritura de métodos
  • Definición y características.
  • Uso de anotaciones o modificadores (como @Override en Java).
  • Ejemplos y casos de uso para extender comportamiento de clases base.
  • Impacto en el polimorfismo dinámico.
• Comparación entre sobrecarga y sobreescritura.

4. Diseño de Soluciones Modulares con Polimorfismo

• Principios de diseño orientado a objetos que favorecen el uso del polimorfismo.
• Patrones de diseño relacionados con polimorfismo (Ej: Estrategia, Estado, Factory).
• Diseño de sistemas modulares y flexibles mediante interfaces y clases abstractas.
• Evaluación del impacto del polimorfismo en la reutilización y mantenimiento del software.
• Ejemplos de aplicación en problemas de ingeniería reales.

5. Análisis y Depuración de Código con Polimorfismo

• Identificación de errores comunes al implementar polimorfismo (ej. errores en sobreescritura, problemas con tipos de referencia).
• Buenas prácticas para mejorar la robustez y claridad del código polimórfico.
• Uso de herramientas y técnicas para depurar y probar código orientado a objetos con polimorfismo.
• Ejercicios prácticos de análisis y corrección de código.

Actividad 1: Debate y análisis conceptual sobre polimorfismo estático y dinámico

Objetivo: Explicar y diferenciar los conceptos de polimorfismo estático y dinámico.

Descripción:

• Se divide a la clase en grupos pequeños (3-4 estudiantes).
• Cada grupo investiga y prepara una explicación clara con ejemplos reales de polimorfismo estático y dinámico.
• Los grupos presentan sus conclusiones y ejemplos al resto de la clase.
• Se realiza un debate guiado por el docente para aclarar dudas y destacar diferencias y aplicaciones en ingeniería.

Organización: Grupos pequeños

Producto esperado: Presentación y resumen escrito de las diferencias y aplicaciones del polimorfismo.

Duración: 1.5 horas

Actividad 2: Implementación práctica de sobrecarga y sobreescritura de métodos

Objetivo: Implementar y diferenciar la sobrecarga y sobreescritura de métodos en código orientado a objetos.

Descripción:

• Se entrega un conjunto base de clases con funcionalidades básicas.
• Cada estudiante realiza ejercicios de programación para:
  • Crear métodos sobrecargados que permitan diferentes formas de entrada para una misma operación.
  • Sobreescribir métodos para modificar el comportamiento heredado en clases derivadas.
• Se realiza una sesión de revisión y discusión del código desarrollado para comprender las diferencias y efectos de cada técnica.

Organización: Individual

Producto esperado: Código fuente funcional con ejemplos de sobrecarga y sobreescritura, y breve informe explicativo.

Duración: 2 horas

Actividad 3: Diseño modular con polimorfismo para solución de un problema de ingeniería

Objetivo: Diseñar soluciones modulares que utilicen polimorfismo, evaluando su impacto en reutilización y mantenimiento.

Descripción:

• Se presenta un problema de ingeniería típico (ejemplo: sistema de control de dispositivos con diferentes comportamientos).
• En grupos, los estudiantes diseñan una solución orientada a objetos que implemente polimorfismo para flexibilizar el sistema.
• El diseño debe incluir diagramas UML, justificación del uso de polimorfismo y análisis del impacto en mantenimiento y reutilización.
• Se realiza una presentación final con discusión crítica y retroalimentación del docente.

Organización: Grupos de 3-4 estudiantes

Producto esperado: Documento de diseño y presentación oral.

Duración: 3 horas

Actividad 4: Análisis y depuración de código con errores comunes en polimorfismo

Objetivo: Analizar y depurar código orientado a objetos que emplea polimorfismo, identificando errores comunes y aplicando buenas prácticas.

Descripción:

• Se proporciona código fuente con errores típicos relacionados con polimorfismo (por ejemplo, incorrecta sobreescritura, mal uso de tipos, problemas en llamadas dinámicas).
• En parejas, los estudiantes analizan el código, identifican los errores y proponen correcciones aplicando buenas prácticas.
• Luego presentan sus hallazgos y correcciones al grupo para discusión y validación.

Organización: Parejas

Producto esperado: Informe de análisis y código corregido.

Duración: 2 horas

Evaluación Diagnóstica

Qué se evalúa: Conocimiento previo sobre conceptos básicos de polimorfismo, sobrecarga y sobreescritura.

Cómo se evalúa: Cuestionario breve con preguntas teóricas y ejercicios cortos para identificar comprensión inicial.

Instrumento sugerido: Test en línea o en papel con preguntas de opción múltiple y desarrollo corto.

Evaluación Formativa

Qué se evalúa: Aplicación práctica y comprensión progresiva de los conceptos mediante actividades prácticas y participación en debates.

Cómo se evalúa: Revisión y retroalimentación continua de las actividades de implementación de código, análisis y diseño; observación de participación en debates y presentaciones.

Instrumento sugerido: Rúbricas para evaluación de código y presentaciones, listas de cotejo para participación y entrega de productos.

Evaluación Sumativa

Qué se evalúa: Dominio integral de conceptos, implementación correcta de polimorfismo, capacidad de diseño modular y análisis crítico de código.

Cómo se evalúa: Examen teórico-práctico que incluya preguntas conceptuales, diseño de soluciones y ejercicios de programación con polimorfismo.

Instrumento sugerido: Examen escrito y evaluación de proyectos o tareas finales entregadas por los estudiantes.

La unidad "Polimorfismo" se sugiere desarrollar en un período de 2 semanas, con una dedicación aproximada de 10 horas distribuidas de la siguiente manera:

• 4 horas para la introducción teórica y explicación de conceptos (temas 1 y 2).
• 2 horas para la implementación práctica de sobrecarga y sobreescritura (tema 3).
• 3 horas para el diseño modular y actividades de análisis de casos (tema 4).
• 1 hora para análisis, depuración y buenas prácticas (tema 5).

Esta distribución permite combinar teoría con práctica y evaluación formativa, favoreciendo un aprendizaje integral y aplicado.

1. Introducción a las Excepciones y Errores en Programación Orientada a Objetos

• Definición de errores y excepciones: diferencias fundamentales.
• Tipos de errores: sintácticos, lógicos y en tiempo de ejecución.
• Clasificación de excepciones: comprobadas (checked) y no comprobadas (unchecked).
• Terminología técnica relevante: stack trace, propagación de excepciones, captura y manejo.
• Importancia del manejo adecuado de excepciones en la robustez del software.

2. Mecanismos de Manejo de Excepciones en Lenguajes Orientados a Objetos

• Estructura básica de manejo: bloques try, catch y finally.
• Uso del bloque try: definición y alcance.
• Captura de excepciones con catch: múltiples catch y jerarquía de excepciones.
• Bloque finally: usos y garantías de ejecución.
• Propagación de excepciones: throws y throw.
• Buenas prácticas para el manejo de excepciones.

3. Diseño y Lanzamiento de Excepciones Personalizadas

• Motivación para crear excepciones personalizadas en aplicaciones de ingeniería.
• Definición de clases de excepción personalizadas: herencia y extensión de clases base de excepción.
• Implementación de constructores y mensajes personalizados.
• Lanzamiento de excepciones personalizadas con throw.
• Integración de excepciones personalizadas en el flujo normal del programa.
• Buenas prácticas para la creación y documentación de excepciones personalizadas.

4. Evaluación y Corrección del Manejo de Excepciones en Código Existente

• Identificación de problemas comunes en el manejo de excepciones: capturas genéricas, bloques vacíos, falta de finally.
• Análisis de ejemplos de código con manejo inadecuado.
• Estrategias para mejorar la confiabilidad y mantenibilidad a través de un manejo correcto de excepciones.
• Refactorización de código para optimizar el manejo de errores.
• Pruebas y validación del manejo de excepciones mejorado.

Actividad 1: Identificación y Clasificación de Excepciones en Código

Objetivo: Identificar y explicar los diferentes tipos de excepciones y errores en programas orientados a objetos utilizando terminología técnica adecuada.

Descripción:

• Se proporciona a los estudiantes fragmentos de código con diferentes tipos de errores y excepciones.
• Cada estudiante debe analizar el código, identificar el tipo de error o excepción y clasificarlo (checked, unchecked, error lógico, etc.).
• Realizar una pequeña presentación explicando el porqué de su clasificación y la terminología técnica involucrada.

Organización: Individual

Producto esperado: Informe corto con la clasificación y explicación técnica de cada caso.

Duración estimada: 1 hora

Actividad 2: Implementación Práctica de Try-Catch-Finally

Objetivo: Implementar bloques try-catch-finally para manejar excepciones, garantizando la robustez del software.

Descripción:

• Se entrega un programa base con manejo deficiente o inexistente de excepciones.
• Los estudiantes deben modificar el código para incluir bloques try-catch-finally adecuados.
• Se deben manejar al menos dos tipos de excepción diferentes y garantizar la liberación de recursos en finally.
• Al finalizar, se realiza una sesión de revisión grupal para discutir las soluciones.

Organización: Parejas

Producto esperado: Código corregido con manejo adecuado de excepciones y breve explicación de las decisiones tomadas.

Duración estimada: 2 horas

Actividad 3: Diseño y Uso de Excepciones Personalizadas

Objetivo: Diseñar y lanzar excepciones personalizadas para mejorar la gestión de errores en aplicaciones de ingeniería.

Descripción:

• Se propone un escenario típico de ingeniería donde un componente debe lanzar excepciones específicas (por ejemplo, validación de datos de sensores o cálculos críticos).
• Los estudiantes deben crear una clase de excepción personalizada, con mensajes y atributos relevantes.
• Modificar el código para lanzar la excepción personalizada cuando corresponda y capturarla adecuadamente.
• Presentar un pequeño documento explicando la utilidad de la excepción personalizada y cómo mejora la gestión de errores.

Organización: Grupos de 3

Producto esperado: Código con excepciones personalizadas implementadas y documento explicativo.

Duración estimada: 3 horas

Actividad 4: Análisis y Refactorización de Código con Manejo Inadecuado de Excepciones

Objetivo: Evaluar y corregir códigos con manejo inadecuado de excepciones para optimizar la confiabilidad y mantenibilidad.

Descripción:

• Se entrega a los estudiantes un programa con problemas en el manejo de excepciones (catch genéricos, bloques vacíos, ausencia de finally, etc.).
• En equipos deben identificar los errores, justificar por qué afectan la confiabilidad y mantenimiento, y proponer correcciones.
• Implementar las correcciones en el código y explicar cómo mejoran el software.
• Presentar un informe con análisis, correcciones y código refactorizado.

Organización: Grupos de 4

Producto esperado: Informe de análisis y código corregido.

Duración estimada: 3 horas

Evaluación Diagnóstica

Qué se evalúa: Conocimientos previos sobre errores y excepciones en programación orientada a objetos.

Cómo se evalúa: Cuestionario corto con preguntas de opción múltiple y de respuesta abierta sobre tipos de errores, terminología y conceptos básicos.

Instrumento sugerido: Prueba escrita o plataforma digital de evaluación rápida.

Evaluación Formativa

Qué se evalúa: Aplicación práctica del manejo de excepciones, diseño de excepciones personalizadas y análisis crítico de código.

Cómo se evalúa: Revisión continua de actividades prácticas, retroalimentación en sesiones de trabajo en clase, análisis de informes de actividades.

Instrumento sugerido: Lista de cotejo para revisión de código, rúbrica para evaluación de informes y presentaciones.

Evaluación Sumativa

Qué se evalúa: Comprensión integral y aplicación de los conceptos de manejo de excepciones, diseño y corrección de código.

Cómo se evalúa: Examen práctico que incluye:

• Identificación y clasificación de excepciones en fragmentos de código.
• Implementación de bloques try-catch-finally en un programa dado.
• Diseño y despliegue de una excepción personalizada para un problema específico.
• Análisis y refactorización de un código con manejo inadecuado de excepciones.

Instrumento sugerido: Examen práctico escrito y/o en entorno de programación con rúbrica detallada para evaluación.

La unidad "Manejo de Excepciones y Errores" está diseñada para desarrollarse en un total de 9 horas distribuidas en 3 semanas, con la siguiente organización sugerida:

• Semana 1 (3 horas): Introducción a excepciones y manejo básico con try-catch-finally. Incluye la Actividad 1 e inicio de la Actividad 2.
• Semana 2 (3 horas): Diseño y lanzamiento de excepciones personalizadas. Desarrollo completo de la Actividad 3.
• Semana 3 (3 horas): Evaluación y corrección de código con manejo inadecuado. Desarrollo de la Actividad 4 y preparación para evaluación sumativa.

Esta distribución permite una combinación equilibrada entre teoría, práctica y evaluación, facilitando la comprensión profunda y aplicación efectiva de los contenidos.

1. Introducción a las colecciones y estructuras de datos en POO

• Concepto de colecciones y estructuras de datos desde la perspectiva orientada a objetos
• Importancia de encapsulación y modularidad en el diseño de colecciones
• Visión general de las colecciones más comunes: listas, pilas y colas

2. Listas en programación orientada a objetos

• Definición y características de una lista
• Tipos de listas: listas enlazadas (simples y dobles) y listas estáticas (arrays)
• Diseño de la clase Lista: atributos y métodos fundamentales (inserción, eliminación, búsqueda, recorrido)
• Implementación de encapsulación: atributos privados y métodos públicos
• Ejemplo práctico: implementación de una lista enlazada simple en un lenguaje orientado a objetos

3. Pilas (Stacks) en programación orientada a objetos

• Definición y características de las pilas: estructura LIFO (Last In, First Out)
• Operaciones básicas: push, pop, peek/peek
• Diseño e implementación de la clase Pila con encapsulación y métodos de operación
• Manejo de excepciones: pila vacía y pila llena
• Ejemplo práctico: implementación de una pila usando lista enlazada o array

4. Colas (Queues) en programación orientada a objetos

• Definición y características de las colas: estructura FIFO (First In, First Out)
• Operaciones básicas: enqueue, dequeue, front/peek
• Diseño e implementación de la clase Cola con encapsulación y métodos funcionales
• Variantes de colas: colas circulares, colas con prioridad (introducción conceptual)
• Ejemplo práctico: implementación de una cola simple en lenguaje orientado a objetos

5. Operaciones comunes y manipulación de colecciones en POO

• Inserción, eliminación y recorrido en listas, pilas y colas
• Implementación de iteradores y métodos para recorrer colecciones
• Gestión de errores y validaciones en métodos de manipulación

6. Evaluación de eficiencia y adecuación de estructuras de datos en ingeniería

• Análisis de complejidad temporal y espacial (Big O) para operaciones básicas en listas, pilas y colas
• Comparación de estructuras para diferentes escenarios prácticos en ingeniería
• Criterios para seleccionar la estructura adecuada según el problema a resolver

7. Documentación y comunicación de diseños de colecciones en POO

• Buenas prácticas para documentar clases y métodos (comentarios, diagramas UML básicos)
• Uso de diagramas de clases para representar colecciones y sus relaciones
• Redacción clara y técnica de la funcionalidad y diseño de las estructuras implementadas
• Presentación y defensa de proyectos de colecciones orientadas a objetos

Actividad 1: Análisis comparativo de listas, pilas y colas

Objetivo: Identificar y explicar las características y diferencias entre listas, pilas y colas (objetivo 1).

Descripción:

• En parejas, los estudiantes investigan y describen las características de listas, pilas y colas bajo POO.
• Realizan un cuadro comparativo que incluya definición, estructura, operaciones principales y ejemplos de uso.
• Presentan sus resultados brevemente al grupo para discusión y retroalimentación.

Organización: Parejas

Producto esperado: Cuadro comparativo impreso o digital y presentación oral corta.

Duración estimada: 1.5 horas

Actividad 2: Diseño y codificación de una clase lista enlazada

Objetivo: Diseñar e implementar una clase que represente una lista enlazada aplicando encapsulación y modularidad (objetivo 2).

Descripción:

• Individualmente, diseñar el diagrama de clases para una lista enlazada simple con métodos para inserción, eliminación y recorrido.
• Codificar la clase en un lenguaje orientado a objetos (por ejemplo, Java, C++ o Python).
• Probar la clase con un programa que demuestre las operaciones básicas.

Organización: Individual

Producto esperado: Código fuente de la clase lista enlazada y programa de prueba.

Duración estimada: 3 horas

Actividad 3: Implementación y prueba de pilas y colas

Objetivo: Aplicar operaciones básicas en pilas y colas utilizando métodos orientados a objetos (objetivo 3).

Descripción:

• En grupos de tres, implementar las clases Pila y Cola con sus operaciones fundamentales.
• Realizar pruebas de inserción, eliminación y recorrido, manejando posibles errores (pila o cola vacía).
• Comparar y discutir la similitud y diferencias entre ambas implementaciones.

Organización: Grupos de 3 estudiantes

Producto esperado: Código fuente de las clases Pila y Cola con casos de prueba documentados.

Duración estimada: 3 horas

Actividad 4: Análisis de eficiencia y selección de estructura para un caso de ingeniería

Objetivo: Evaluar la eficiencia y adecuación de diferentes estructuras para resolver problemas prácticos (objetivo 4).

Descripción:

• En grupos, se presenta un caso práctico típico de ingeniería (por ejemplo, simulación de procesos, gestión de tareas).
• Analizan qué estructura (lista, pila o cola) es más adecuada, justificando su elección con análisis de eficiencia.
• Preparan un reporte escrito y una presentación breve explicando su decisión.

Organización: Grupos de 3-4 estudiantes

Producto esperado: Reporte escrito y presentación oral.

Duración estimada: 2 horas

Actividad 5: Documentación y presentación de un proyecto de estructuras de datos

Objetivo: Documentar y comunicar claramente el diseño y funcionalidad de colecciones desarrolladas (objetivo 5).

Descripción:

• Individualmente, elegir una estructura implementada (lista, pila o cola).
• Elaborar documentación técnica que incluya: descripción, diagrama UML, explicación de métodos y ejemplos de uso.
• Realizar una presentación oral de 5 minutos para explicar su diseño y funcionamiento.

Organización: Individual

Producto esperado: Documento técnico y presentación oral.

Duración estimada: 2 horas

Evaluación diagnóstica

Qué se evalúa: Conocimientos previos sobre colecciones y estructuras de datos básicas, y nociones de POO.

Cómo se evalúa: Cuestionario escrito o digital con preguntas teóricas y de definición sobre listas, pilas, colas y conceptos de encapsulación.

Instrumento sugerido: Test de opción múltiple y preguntas abiertas breves.

Evaluación formativa

Qué se evalúa: Desarrollo progresivo de habilidades en diseño, implementación y manipulación de colecciones orientadas a objetos.

Cómo se evalúa: Revisión continua de los avances en actividades prácticas, revisión de código, participación en discusiones y retroalimentación en presentaciones.

Instrumento sugerido: Rúbrica de evaluación para proyectos de codificación, listas de cotejo para participación y presentación oral.

Evaluación sumativa

Qué se evalúa: Competencia integral para diseñar, implementar, aplicar, evaluar y documentar colecciones orientadas a objetos.

Cómo se evalúa: Proyecto final que incluya implementación completa de al menos una colección, análisis de eficiencia para un caso práctico, y documentación técnica con presentación oral.

Instrumento sugerido: Rúbrica detallada que contemple calidad del código, cumplimiento de requisitos, análisis crítico y calidad de la documentación y presentación.

La unidad "Colecciones y Estructuras de Datos Orientadas a Objetos" está diseñada para desarrollarse en aproximadamente 2 semanas, con una dedicación total estimada de 12 a 14 horas distribuidas de la siguiente manera:

• Sesiones teóricas y explicativas: 4 horas
• Actividades prácticas de diseño y codificación: 6 a 7 horas
• Evaluaciones formativas y sumativas: 2 a 3 horas

Esta distribución permite combinar teoría, práctica y evaluación para un aprendizaje integral y aplicado de las colecciones y estructuras de datos bajo el paradigma orientado a objetos.

1. Introducción al Lenguaje Unificado de Modelado (UML)

• Concepto y propósito de UML: Definición de UML como lenguaje estándar para la visualización, especificación, construcción y documentación de sistemas orientados a objetos.
• Historia y evolución de UML: Breve repaso de la evolución de UML y su adopción en la ingeniería de software.
• Importancia del modelado en el desarrollo de software: Rol de los diagramas UML para mejorar la comunicación, planificación y calidad del software.

2. Elementos básicos de UML para modelado orientado a objetos

• Elementos estructurales: Clases, objetos, atributos y métodos. Definiciones y notaciones básicas.
• Relaciones entre elementos: Asociación, agregación, composición, herencia (generalización/especialización) y dependencia.
• Paquetes y visibilidad: Organización del modelo y control de acceso (público, privado, protegido).

3. Diagramas de clases UML

• Concepto y finalidad: Representación estática de la estructura del sistema mediante clases y relaciones.
• Componentes del diagrama de clases: Clases, interfaces, atributos, operaciones, multiplicidad y roles.
• Notaciones y convenciones estándar: Símbolos, estereotipos, y formas correctas de representar relaciones (líneas, flechas, rombos).
• Construcción paso a paso de diagramas de clases: Identificación de clases relevantes, definición de atributos y métodos, establecimiento de relaciones.

4. Análisis y evaluación de diagramas UML

• Verificación de coherencia: Revisión de consistencia interna del modelo, correcta aplicación de relaciones y notaciones.
• Detección de errores comunes: Problemas en diseño como relaciones incorrectas, atributos no pertinentes o falta de encapsulación.
• Evaluación de adecuación al problema: Comprobación de que el diagrama refleja correctamente los requisitos y funcionalidades esperadas.

5. Comunicación efectiva de diseños mediante UML

• Buenas prácticas para la presentación de diagramas: Claridad, organización visual, uso adecuado de etiquetas y leyendas.
• Uso de herramientas para elaboración de diagramas UML: Introducción a herramientas gratuitas y comerciales (por ejemplo, StarUML, Visual Paradigm, Draw.io).
• Presentación y defensa de diseños orientados a objetos: Técnicas para explicar diagramas en contextos académicos y profesionales, anticipando preguntas y retroalimentación.

Actividad 1: Identificación y descripción de elementos UML

Objetivo: Contribuye al primer objetivo de la unidad: identificar y describir los elementos básicos del UML.

Descripción:

• Se proporcionará a los estudiantes un conjunto de diagramas UML simples.
• Los estudiantes deberán identificar y listar los elementos básicos presentes (clases, objetos, relaciones).
• Para cada elemento identificado, describirán su función y notación.
• Se realizará una discusión grupal para corregir y complementar la información.

Organización: Individual

Producto esperado: Informe escrito con identificación y descripción de elementos UML.

Duración estimada: 1 hora

Actividad 2: Construcción de un diagrama de clases UML

Objetivo: Contribuye al segundo objetivo: construir diagramas de clases UML aplicando notaciones estándar.

Descripción:

• Se entregará un caso de estudio sencillo con requisitos funcionales.
• Los estudiantes identificarán las clases, atributos, métodos y relaciones necesarias.
• Utilizando papel o una herramienta digital, construirán el diagrama de clases UML correspondiente.
• Se realizará revisión por pares para retroalimentar el diseño.

Organización: Parejas o grupos pequeños (3-4 estudiantes)

Producto esperado: Diagrama de clases UML completo y documentado.

Duración estimada: 2 horas

Actividad 3: Análisis crítico de diagramas UML

Objetivo: Contribuye al tercer objetivo: analizar y evaluar diagramas UML para verificar coherencia y adecuación.

Descripción:

• Se proporcionarán varios diagramas de clases con errores o deficiencias intencionales.
• Los estudiantes identificarán problemas, inconsistencias o mejoras posibles.
• Realizarán un informe con recomendaciones para corregir o mejorar el diseño.
• Se compartirá y discutirá en clase para consolidar el aprendizaje.

Organización: Individual o en parejas

Producto esperado: Informe de análisis crítico con recomendaciones.

Duración estimada: 1.5 horas

Actividad 4: Presentación y defensa de un diseño UML

Objetivo: Contribuye al cuarto objetivo: comunicar de manera efectiva diseños orientados a objetos mediante diagramas UML.

Descripción:

• Cada grupo presentará un diagrama de clases elaborado previamente ante sus compañeros.
• Deberán explicar la estructura, relaciones y decisiones de diseño.
• Responderán preguntas y recibirán retroalimentación del instructor y pares.
• Se fomentará el uso de herramientas digitales para mejorar la presentación.

Organización: Grupos (3-4 estudiantes)

Producto esperado: Presentación oral acompañada de diagramas UML visibles y explicados.

Duración estimada: 1.5 horas

Evaluación diagnóstica

Qué se evalúa: Conocimientos previos sobre UML y modelado orientado a objetos.

Cómodo se evalúa: Mediante un cuestionario breve con preguntas de selección múltiple y de respuesta corta sobre conceptos básicos de UML y elementos de diagramas.

Instrumento sugerido: Cuestionario en línea o en papel al inicio de la unidad.

Evaluación formativa

Qué se evalúa: Progreso en la comprensión y aplicación de conceptos UML a través de actividades prácticas.

Cómodo se evalúa: Revisión y retroalimentación continua de las actividades 1, 2 y 3, incluyendo informes y diagramas elaborados por los estudiantes.

Instrumento sugerido: Rúbricas para evaluación de diagramas UML y análisis crítico, observación directa y retroalimentación escrita.

Evaluación sumativa

Qué se evalúa: Dominio integral de los objetivos de la unidad: identificación, construcción, análisis y comunicación de diagramas UML.

Cómodo se evalúa: Evaluación final que incluye la presentación oral con defensa de un diagrama UML completo y un examen escrito que contemple preguntas teóricas y prácticas.

Instrumento sugerido: Rúbrica para presentación y examen escrito estructurado con preguntas de desarrollo y ejercicios de modelado.

Se sugiere una duración total de 2 semanas para la unidad "Diseño y Modelado con UML", con una distribución aproximada de 8 a 10 horas de clase y actividades prácticas. Se puede distribuir de la siguiente manera:

• Semana 1: Introducción a UML y elementos básicos (3 horas teóricas + 2 horas actividad 1 y 2)
• Semana 2: Construcción, análisis y presentación de diagramas (3 horas teórico-prácticas + 3 horas actividades 3 y 4 + evaluación sumativa)

1. Introducción a los Principios SOLID y Buenas Prácticas de Diseño

• Contexto histórico y evolución de la programación orientada a objetos.
• Importancia de los principios SOLID en el desarrollo de software moderno.
• Relación entre principios SOLID y buenas prácticas de diseño orientado a objetos.

2. Principio de Responsabilidad Única (Single Responsibility Principle - SRP)

• Definición y fundamentos del SRP.
• Identificación de responsabilidades en clases y módulos.
• Ejemplos prácticos de aplicación y violaciones comunes.
• Impacto del SRP en la mantenibilidad del software.

3. Principio de Abierto/Cerrado (Open/Closed Principle - OCP)

• Concepto de extensibilidad sin modificación.
• Mecanismos para implementar OCP: abstracciones y herencia.
• Ejemplos de diseño abierto para extensión pero cerrado para modificación.
• Ventajas en escalabilidad y mantenimiento.

4. Principio de Sustitución de Liskov (Liskov Substitution Principle - LSP)

• Formalización del LSP y su relevancia en la herencia.
• Condiciones para que una subclase pueda sustituir a su superclase.
• Ejemplos de violaciones y cómo corregirlas.
• Implicaciones para el diseño robusto y fiable.

5. Principio de Segregación de Interfaces (Interface Segregation Principle - ISP)

• Motivación para evitar interfaces "gruesas".
• Diseño de interfaces específicas y cohesivas.
• Ejemplos prácticos y patrones relacionados.
• Beneficios en flexibilidad y reutilización del código.

6. Principio de Inversión de Dependencias (Dependency Inversion Principle - DIP)

• Relación entre módulos de alto y bajo nivel.
• Uso de abstracciones para reducir acoplamiento.
• Ejemplos con inyección de dependencias y patrones de diseño.
• Mejoras en testabilidad y mantenimiento.

7. Buenas Prácticas de Diseño Orientado a Objetos

• Modularidad y encapsulamiento efectivo.
• Reutilización y composición sobre herencia.
• Patrones de diseño comunes relacionados con SOLID.
• Documentación y comunicación clara del diseño.
• Herramientas y técnicas para evaluar la calidad del diseño.

8. Análisis y Evaluación de Diseños con Principios SOLID

• Metodologías para inspección y revisión de código.
• Detección de violaciones a principios SOLID en diseños reales.
• Propuestas de refactorización y mejora.
• Casos prácticos de aplicación en proyectos de ingeniería.

9. Integración de los Principios SOLID en el Desarrollo de Software

• Diseño de soluciones completas aplicando SOLID.
• Herramientas y frameworks que facilitan la implementación.
• Ejemplos de sistemas robustos y mantenibles.
• Evaluación de impacto en el ciclo de vida del software.

10. Comunicación Técnica sobre Principios SOLID y Buenas Prácticas

• Elaboración de informes técnicos claros y estructurados.
• Preparación y presentación de casos de estudio y proyectos.
• Uso de diagramas UML y otras representaciones visuales.
• Argumentación y justificación de decisiones de diseño.

Actividad 1: Identificación y explicación de los principios SOLID

Objetivo: Identificar y explicar cada uno de los principios SOLID con ejemplos prácticos.

Descripción:

• El docente presenta breves casos de código que violan o cumplen cada principio SOLID.
• Los estudiantes, en parejas, analizan cada caso para identificar el principio relacionado.
• Discuten y redactan una explicación breve sobre el principio aplicado y cómo se refleja en el ejemplo.
• Comparten sus análisis con el grupo para retroalimentación.

Organización: Parejas

Producto esperado: Documento con explicación y análisis de ejemplos para cada principio SOLID.

Duración estimada: 90 minutos

Actividad 2: Evaluación y mejora de un diseño orientado a objetos

Objetivo: Analizar y evaluar diseños para detectar violaciones a SOLID y proponer mejoras.

Descripción:

• Se proporciona un diseño de software con código o diagramas que presenta violaciones a SOLID.
• En grupos de 3-4, los estudiantes identifican las violaciones presentes.
• Desarrollan propuestas de refactorización o rediseño para cumplir con los principios.
• Presentan su análisis y propuestas ante la clase para discusión.

Organización: Grupos

Producto esperado: Informe con análisis de violaciones y propuestas de mejora.

Duración estimada: 2 horas

Actividad 3: Diseño de un sistema aplicando principios SOLID y buenas prácticas

Objetivo: Diseñar soluciones de software integrando SOLID y buenas prácticas de diseño.

Descripción:

• Se asigna un problema de ingeniería para resolver mediante programación orientada a objetos.
• Cada estudiante diseña las clases y módulos aplicando los principios SOLID y buenas prácticas.
• Preparan diagramas UML y justificaciones técnicas del diseño.
• Socializan su diseño en presentaciones breves ante el grupo.

Organización: Individual

Producto esperado: Diseño UML y presentación técnica.

Duración estimada: 3 horas

Actividad 4: Elaboración de un informe técnico y presentación sobre la importancia de SOLID

Objetivo: Comunicar de forma clara y técnica la importancia de los principios SOLID y buenas prácticas.

Descripción:

• Los estudiantes elaboran un informe técnico que explique los principios SOLID y su impacto en proyectos reales.
• Preparan una presentación que resuma los puntos clave y ejemplos ilustrativos.
• Realizan la presentación ante la clase y responden preguntas.

Organización: Individual o parejas

Producto esperado: Informe técnico y presentación oral.

Duración estimada: 2 horas

Evaluación Diagnóstica

Qué se evalúa: Conocimientos previos sobre principios de diseño orientado a objetos y comprensión básica de SOLID.

Cómo se evalúa: Cuestionario de opción múltiple y preguntas abiertas breves sobre conceptos fundamentales.

Instrumento sugerido: Test en línea o papel con preguntas diseñadas para identificar nivel inicial.

Evaluación Formativa

Qué se evalúa: Progreso en la comprensión y aplicación de los principios SOLID, análisis crítico de diseños y desarrollo de buenas prácticas.

Cómo se evalúa: Revisión de actividades prácticas, retroalimentación en discusiones en clase, y seguimiento de informes parciales.

Instrumento sugerido: Rúbricas para actividades, observación directa, y feedback escrito.

Evaluación Sumativa

Qué se evalúa: Capacidad para integrar y aplicar los principios SOLID en diseño, análisis crítico, y comunicación técnica.

Cómo se evalúa: Examen escrito con preguntas de desarrollo y análisis de casos, entrega final de diseño UML y presentación oral o informe técnico.

Instrumento sugerido: Examen, rúbrica para evaluación de diseño y presentación, evaluación de informe técnico.

La unidad "Principios SOLID y Buenas Prácticas de Diseño" está diseñada para desarrollarse en 4 semanas, con una dedicación aproximada de 12 horas totales:

• Semana 1 (3 horas): Introducción a SOLID y estudio detallado de SRP y OCP con ejemplos y actividades de identificación.
• Semana 2 (3 horas): Profundización en LSP, ISP y DIP, análisis de casos y evaluación formativa mediante actividades grupales.
• Semana 3 (3 horas): Buenas prácticas de diseño, análisis de diseños existentes y propuesta de mejoras con trabajo en grupos y entregables parciales.
• Semana 4 (3 horas): Diseño integral aplicando SOLID, elaboración de informes técnicos y presentación final con evaluación sumativa.

Introducción a los Patrones de Diseño Creacionales

• Concepto de patrones de diseño en programación orientada a objetos: definición, importancia y clasificación.
• Características generales de los patrones creacionales: propósito, beneficios y enfoque en la creación de objetos.
• Contextualización en ingeniería de software: problemas comunes en la creación y gestión de objetos en proyectos de ingeniería.

Patrón Singleton

• Definición y objetivo del patrón Singleton: garantizar una única instancia de una clase.
• Implementación detallada del patrón Singleton: métodos estáticos, control de instancias, manejo en entornos multihilo.
• Ventajas y limitaciones del patrón Singleton en proyectos de ingeniería.
• Ejemplos prácticos y casos de uso en ingeniería: gestión de configuraciones, conexión a bases de datos, manejo de recursos compartidos.

Patrón Factory (Fábrica)

• Concepto y objetivo del patrón Factory: creación flexible y desacoplada de objetos.
• Tipos de Factory: Factory Method y Abstract Factory, diferencias y aplicaciones.
• Diseño e implementación de una fábrica de objetos: interfaz, clases concretas y método de creación.
• Ventajas del patrón Factory: encapsulamiento, extensión y mantenimiento del código.
• Ejemplos prácticos en ingeniería: generación de diferentes tipos de componentes, productos o dispositivos según parámetros.

Patrón Builder

• Definición y objetivo del patrón Builder: construcción paso a paso de objetos complejos.
• Componentes del patrón Builder: Director, Builder abstracto, Builders concretos y producto final.
• Implementación práctica del patrón Builder: separación de construcción y representación.
• Ventajas en ingeniería: modularidad, claridad, flexibilidad para construir objetos con múltiples configuraciones.
• Ejemplos de aplicación: diseño de configuradores de máquinas, ensamblaje de estructuras o sistemas complejos.

Comparación y Evaluación de los Patrones Singleton, Factory y Builder

• Análisis de idoneidad: criterios para seleccionar el patrón adecuado según el problema.
• Comparación de ventajas y desventajas en diferentes escenarios de ingeniería.
• Estudio de casos prácticos y discusión sobre la elección del patrón más adecuado.
• Buenas prácticas y recomendaciones para la aplicación efectiva de los patrones creacionales.

Actividad 1: Análisis y presentación de patrones creacionales

Objetivo: Identificar y describir las características y ventajas de los patrones Singleton, Factory y Builder en contextos de ingeniería.

Descripción:

• Los estudiantes, en grupos de 3, investigarán cada uno de los patrones Singleton, Factory y Builder, enfocándose en su definición, características y aplicaciones en ingeniería.
• Prepararán una presentación visual (diapositivas o póster digital) que resuma la información recolectada, incluyendo ejemplos reales o hipotéticos.
• Expondrán sus presentaciones al resto de la clase para fomentar la discusión y aclarar dudas.

Organización: Grupos de 3 estudiantes.

Producto esperado: Presentación visual y exposición oral.

Duración estimada: 2 horas (1.5 horas para preparación y 0.5 horas para exposiciones).

Actividad 2: Implementación práctica del patrón Singleton

Objetivo: Aplicar el patrón Singleton para garantizar la existencia de una única instancia en un proyecto de software.

Descripción:

• Individualmente, los estudiantes desarrollarán una clase Singleton en un lenguaje orientado a objetos (por ejemplo, Java o C#), que controle el acceso a una configuración global del sistema.
• Deberán implementar mecanismos para asegurar la única instancia, incluyendo consideraciones de sincronización para entornos multihilo.
• Probarán su implementación mediante un programa que intente crear múltiples instancias y verificar que sólo se utiliza una.

Organización: Individual.

Producto esperado: Código fuente funcional y reporte breve que explique su diseño.

Duración estimada: 2 horas.

Actividad 3: Diseño y codificación de una fábrica de objetos (Factory)

Objetivo: Diseñar e implementar una solución utilizando el patrón Factory para crear objetos de manera flexible y desacoplada.

Descripción:

• En parejas, los estudiantes diseñarán un sistema que permita crear diferentes tipos de sensores (por ejemplo, temperatura, humedad, presión) mediante una fábrica.
• Implementarán el patrón Factory Method, definiendo interfaces, clases concretas y la lógica para la creación de objetos según parámetros.
• Realizarán pruebas que demuestren la flexibilidad y extensibilidad del sistema para agregar nuevos tipos de sensores sin modificar el cliente.

Organización: Parejas.

Producto esperado: Código fuente con documentación y casos de prueba.

Duración estimada: 3 horas.

Actividad 4: Construcción de un objeto complejo mediante Builder

Objetivo: Construir un objeto complejo paso a paso usando el patrón Builder, asegurando modularidad y claridad.

Descripción:

• En grupos de 3, diseñarán y desarrollarán un sistema para ensamblar un vehículo (por ejemplo, un robot o un dron) utilizando el patrón Builder.
• Definirán el Director, el Builder abstracto, builders concretos para diferentes configuraciones y el producto final.
• Demostrarán la construcción modular y flexible del vehículo mediante la generación de diferentes variantes del mismo objeto.

Organización: Grupos de 3 estudiantes.

Producto esperado: Código fuente bien documentado y presentación del funcionamiento.

Duración estimada: 4 horas.

Evaluación Diagnóstica

Qué se evalúa: Conocimientos previos sobre patrones de diseño y conceptos básicos de creación de objetos en POO.

Cómo se evalúa: Cuestionario escrito o en línea con preguntas abiertas y de opción múltiple sobre conceptos generales de patrones y creación de objetos.

Instrumento sugerido: Test de diagnóstico con 15 preguntas.

Evaluación Formativa

Qué se evalúa: Progresos en la comprensión e implementación de los patrones Singleton, Factory y Builder durante las actividades prácticas.

Cómo se evalúa: Observación directa, revisión de avances en código fuente, retroalimentación en presentaciones y debates de grupo.

Instrumento sugerido: Rúbrica de evaluación para actividades prácticas, incluyendo criterios de diseño, funcionalidad, documentación y trabajo colaborativo.

Evaluación Sumativa

Qué se evalúa: Capacidad para identificar, aplicar y comparar patrones Singleton, Factory y Builder en un proyecto integrado.

Cómo se evalúa: Desarrollo de un proyecto final individual o grupal en el que se utilicen los tres patrones para resolver un problema específico de ingeniería, acompañado de un informe escrito y presentación oral.

Instrumento sugerido: Rúbrica detallada que valore diseño, implementación, justificación del uso de patrones, calidad del código, documentación y presentación.

La unidad "Patrones de Diseño Creacionales" se sugiere impartir en un total de 2 semanas, distribuidas en 12 horas de clase y trabajo guiado, con la siguiente distribución:

• Semana 1 (6 horas): Introducción a los patrones creacionales, explicación teórica y actividad 1 (análisis y presentación).
• Semana 2 (6 horas): Implementación práctica con actividades 2, 3 y 4, seguidas de discusiones y retroalimentación continua.

Se recomienda complementar con sesiones de tutoría y revisión de avances entre clases para asegurar la comprensión y aplicación efectiva de los patrones.

1. Introducción a los Patrones de Diseño Estructurales

• Definición y propósito de los patrones de diseño estructurales
• Importancia en la ingeniería de software y la programación orientada a objetos
• Visión general de los patrones Adapter, Composite y Decorator

2. Patrón Adapter

• Concepto y motivación del patrón Adapter
• Estructura y roles: cliente, adaptador, adaptado y objetivo
• Implementación en lenguaje orientado a objetos (ejemplos en Java o C++)
• Casos de uso en ingeniería de sistemas
• Ventajas y limitaciones del patrón Adapter

3. Patrón Composite

• Concepto y motivación del patrón Composite
• Jerarquía de objetos: componentes, hojas y compuestos
• Implementación práctica y ejemplos en programación orientada a objetos
• Aplicaciones típicas en sistemas de ingeniería
• Ventajas y desafíos del uso del patrón Composite

4. Patrón Decorator

• Concepto y propósito del patrón Decorator
• Estructura y roles: componente, decorador concreto y decorador base
• Implementación con ejemplos prácticos orientados a objetos
• Aplicaciones en ingeniería para ampliar funcionalidades sin modificar clases originales
• Beneficios y consideraciones al utilizar el patrón Decorator

5. Diagramas UML para Patrones Estructurales

• Elementos UML relevantes: clases, interfaces, relaciones
• Representación del patrón Adapter en diagramas UML
• Representación del patrón Composite en diagramas UML
• Representación del patrón Decorator en diagramas UML
• Análisis del impacto de la estructura UML en mantenibilidad y eficiencia

6. Análisis Crítico y Selección de Patrones Estructurales

• Comparación entre Adapter, Composite y Decorator
• Criterios para la selección del patrón adecuado según el problema de diseño
• Estudio de casos reales y discusión de enfoques alternativos
• Evaluación del impacto en la modularidad y reutilización del software

7. Comunicación Técnica de Patrones de Diseño

• Redacción de informes técnicos sobre implementación de patrones estructurales
• Preparación de presentaciones claras y técnicas para audiencias de ingeniería
• Uso de diagramas y ejemplos para ilustrar conceptos
• Revisión y retroalimentación en comunicación escrita y oral

1. Análisis y explicación de patrones estructurales

Objetivo: Identificar y explicar las características principales de los patrones Adapter, Composite y Decorator.

Descripción:

• Se asigna a cada estudiante uno de los patrones para investigar.
• Debe elaborar un resumen que describa su patrón, roles y ejemplos de aplicación.
• Presentar su resumen en sesión de clase para discusión grupal.

Organización: Individual

Producto esperado: Resumen escrito y presentación oral breve (5 minutos).

Duración estimada: 2 horas (incluye preparación y presentación).

2. Implementación práctica de patrones estructurales

Objetivo: Analizar problemas de diseño e implementar soluciones usando Adapter, Composite y Decorator.

Descripción:

• Se proporcionan casos de estudio con problemas de diseño concretos.
• En grupos, los estudiantes seleccionan el patrón adecuado y desarrollan código que lo implemente.
• Se realiza demostración del código y explicación del diseño.

Organización: Grupos de 3-4 estudiantes

Producto esperado: Código funcional y presentación técnica del diseño y solución.

Duración estimada: 4 horas (incluye desarrollo y presentación).

3. Diseño de diagramas UML para patrones estructurales

Objetivo: Diseñar diagramas UML que representen patrones estructurales y evaluar su impacto.

Descripción:

• Se entrega un sistema base y los estudiantes deben representar su diseño usando UML incluyendo el patrón aplicado.
• Analizar en un informe cómo el patrón mejora la mantenibilidad y eficiencia.
• Compartir y discutir los diagramas y análisis con el grupo.

Organización: Parejas

Producto esperado: Diagramas UML y reporte analítico.

Duración estimada: 3 horas.

4. Debate crítico sobre selección y aplicación de patrones estructurales

Objetivo: Evaluar críticamente enfoques y justificar la elección de patrones según el contexto.

Descripción:

• Se presentan varios escenarios de diseño con posibles patrones aplicables.
• Los grupos discuten ventajas y desventajas y eligen el patrón más adecuado justificando su elección.
• Cada grupo expone su razonamiento y recibe retroalimentación.

Organización: Grupos de 4 estudiantes

Producto esperado: Informe de justificación y exposición oral.

Duración estimada: 2 horas.

Evaluación Diagnóstica

Qué se evalúa: Conocimientos previos sobre patrones de diseño y programación orientada a objetos.

Cómo se evalúa: Cuestionario de opción múltiple y preguntas abiertas breves sobre conceptos básicos.

Instrumento sugerido: Test escrito o en plataforma virtual al inicio de la unidad.

Evaluación Formativa

Qué se evalúa: Progreso en la comprensión y aplicación de los patrones durante las actividades prácticas.

Cómo se evalúa: Observación continua, retroalimentación en presentaciones y revisión de productos parciales.

Instrumento sugerido: Rúbrica para presentaciones, revisión de código y diagramas UML, y participación en debates.

Evaluación Sumativa

Qué se evalúa: Dominio integral de los patrones estructurales en identificación, implementación, diseño UML, análisis crítico y comunicación técnica.

Cómo se evalúa: Examen escrito con preguntas teóricas y prácticas, entrega de proyecto final con código, diagramas UML y reporte técnico.

Instrumento sugerido: Examen parcial y evaluación del proyecto final con rúbricas detalladas para cada componente.

La unidad "Patrones de Diseño Estructurales" se recomienda impartir en un periodo de 3 semanas, con una dedicación total aproximada de 15 horas distribuidas de la siguiente manera:

• Semana 1 (5 horas): Introducción, estudio y explicación individual de los patrones (tema 1 y 2, actividad 1).
• Semana 2 (6 horas): Implementación práctica en grupos y diseño de diagramas UML (tema 3, 4, 5; actividades 2 y 3).
• Semana 3 (4 horas): Análisis crítico, debate y comunicación técnica (tema 6 y 7; actividad 4), evaluación sumativa y cierre.

Introducción a los Patrones de Diseño Comportamentales

• Definición y propósito de los patrones de diseño comportamentales: gestión de la comunicación y el comportamiento entre objetos.
• Importancia en la programación orientada a objetos y en la ingeniería de software.
• Visión general de los patrones Observer, Strategy y Command.

Patrón Observer

• Principios fundamentales del patrón Observer: suscriptores, sujetos y notificaciones.
• Componentes del patrón: Observador (Observer), Sujeto (Subject), ConcreteObserver y ConcreteSubject.
• Funcionamiento y flujo de comunicación entre objetos.
• Ventajas: desacoplamiento, extensibilidad y mantenimiento.
• Análisis de casos de estudio reales en ingeniería: sistemas de monitoreo, interfaces de usuario, etc.
• Implementación práctica en un lenguaje orientado a objetos: diseño de una aplicación básica de notificaciones.
• Evaluación del impacto del patrón en la modularidad y mantenibilidad del software.

Patrón Strategy

• Conceptos clave del patrón Strategy: definición de familia de algoritmos, encapsulación y selección dinámica.
• Componentes: Contexto, Estrategia y Estrategias Concretas.
• Cómo facilita la extensión y modificación del comportamiento sin alterar el contexto.
• Análisis de casos de estudio en ingeniería: selección de algoritmos de optimización, clasificación, etc.
• Diseño e implementación de soluciones con Strategy para permitir la selección dinámica de algoritmos.
• Pruebas de software para validar la efectividad y flexibilidad de la implementación.

Patrón Command

• Definición y propósito: encapsular solicitudes como objetos para separar el emisor del receptor.
• Componentes: Comando, Receptor, Invocador y Cliente.
• Gestión de operaciones, solicitudes y ejecución diferida.
• Ejemplos prácticos en ingeniería: sistemas de control remoto, undo/redo, colas de solicitudes.
• Desarrollo de aplicaciones que integren el patrón Command para coordinar el comportamiento entre objetos.

Análisis Comparativo y Selección de Patrones

• Criterios técnicos para seleccionar patrones de diseño comportamentales adecuados.
• Comparación entre Observer, Strategy y Command en función del problema y contexto de ingeniería.
• Casos prácticos para justificar la elección del patrón más adecuado.
• Buenas prácticas y recomendaciones para aplicar patrones comportamentales en proyectos reales.

Actividad 1: Análisis de Casos de Estudio de Patrones Comportamentales

Objetivo: Identificar y explicar los principios fundamentales de los patrones Observer, Strategy y Command mediante análisis de casos de estudio.

Descripción:

• Se entregarán a los estudiantes tres casos de estudio, cada uno relacionado con un patrón (Observer, Strategy, Command).
• Los estudiantes deberán analizar y describir los componentes involucrados, el flujo de comunicación y los beneficios del patrón aplicado.
• Se realizará una presentación breve de las conclusiones, enfatizando la explicación de los principios fundamentales.

Organización: Grupos de 3-4 estudiantes.

Producto esperado: Informe escrito y presentación oral del análisis del caso de estudio.

Duración estimada: 2 horas.

Actividad 2: Implementación del Patrón Observer en un Sistema de Notificaciones

Objetivo: Aplicar el patrón Observer para implementar sistemas que gestionen la comunicación entre objetos, evaluando su impacto en modularidad y mantenibilidad.

Descripción:

• Diseñar e implementar una aplicación sencilla que simule un sistema de notificaciones donde múltiples observadores reaccionan a cambios en un sujeto.
• Refactorizar el código para mejorar la modularidad utilizando el patrón Observer.
• Documentar cómo el uso del patrón mejora la mantenibilidad del sistema.

Organización: Parejas.

Producto esperado: Código fuente funcional y documento de análisis de impacto.

Duración estimada: 3 horas.

Actividad 3: Diseño y Prueba de Soluciones Usando el Patrón Strategy

Objetivo: Diseñar e implementar soluciones utilizando el patrón Strategy y comprobar su efectividad mediante pruebas de software.

Descripción:

• Identificar un problema común de ingeniería que requiera selección dinámica de algoritmos (por ejemplo, métodos de ordenación o cálculo).
• Implementar varias estrategias y un contexto que permita cambiar la estrategia en tiempo de ejecución.
• Desarrollar casos de prueba para validar el comportamiento correcto con diferentes estrategias.

Organización: Individual.

Producto esperado: Código fuente y reporte de pruebas de software.

Duración estimada: 3 horas.

Actividad 4: Desarrollo de Aplicación con Patrón Command y Análisis Comparativo

Objetivo: Desarrollar una aplicación que integre el patrón Command y analizar comparativamente patrones para seleccionar la solución adecuada.

Descripción:

• Implementar una aplicación que utilice el patrón Command para encapsular y ejecutar operaciones (por ejemplo, un sistema de control de tareas con undo/redo).
• Realizar un análisis comparativo entre Observer, Strategy y Command para resolver un problema dado, justificando la elección del patrón Command para la aplicación desarrollada.
• Preparar una presentación que exponga la solución técnica y la justificación del patrón seleccionado.

Organización: Grupos de 3 estudiantes.

Producto esperado: Código fuente, análisis comparativo escrito y presentación.

Duración estimada: 4 horas.

Evaluación Diagnóstica

Qué se evalúa: Conocimientos previos sobre patrones de diseño y comunicación entre objetos.

Cómo se evalúa: Cuestionario breve con preguntas abiertas y de opción múltiple sobre conceptos generales de patrones de diseño y comunicación en POO.

Instrumento sugerido: Prueba escrita o en línea al inicio de la unidad.

Evaluación Formativa

Qué se evalúa: Progreso en la comprensión y aplicación de los patrones Observer, Strategy y Command.

Cómo se evalúa: Revisión y retroalimentación continua de las actividades prácticas (implementaciones, análisis de casos, pruebas de software), participación en presentaciones y discusiones.

Instrumento sugerido: Listas de cotejo para actividades, rúbricas para presentaciones, revisiones de código y reportes.

Evaluación Sumativa

Qué se evalúa: Capacidad para identificar, explicar, aplicar y seleccionar patrones de diseño comportamentales en contextos de ingeniería.

Cómo se evalúa: Proyecto integrador que incluye desarrollo de software con los patrones estudiados, análisis comparativo y justificación técnica.

Instrumento sugerido: Rúbrica detallada que evalúe aspectos técnicos, diseño, documentación y presentación final.

La unidad "Patrones de Diseño Comportamentales" se sugiere impartir en un total de 12 horas distribuidas en 4 semanas (3 horas por semana). La distribución recomendada es:

• Semana 1: Introducción general y análisis de casos de estudio (Actividad 1).
• Semana 2: Profundización y aplicación del patrón Observer (Actividad 2).
• Semana 3: Diseño e implementación del patrón Strategy con pruebas (Actividad 3).
• Semana 4: Desarrollo con patrón Command y análisis comparativo (Actividad 4), además de la evaluación sumativa.

1. Introducción a la Implementación de Proyectos Orientados a Objetos

• Contextualización del proyecto de ingeniería: definición del problema y alcance
• Revisión de los principios básicos de Programación Orientada a Objetos (POO)
• Importancia de la planificación y diseño previo para proyectos orientados a objetos

2. Diseño de Proyectos Orientados a Objetos

• Identificación de clases y objetos pertinentes al problema planteado
• Definición de atributos, métodos y relaciones entre clases (herencia, asociación, composición)
• Aplicación de principios SOLID y buenas prácticas en el diseño
• Introducción y uso de patrones de diseño básicos: Singleton, Factory, Observer, Strategy

3. Implementación Modular y Reutilización de Código

• Estructuración del proyecto en módulos y paquetes
• Técnicas para promover la reutilización: herencia, composición, interfaces y clases abstractas
• Gestión de dependencias y desacoplamiento entre módulos
• Herramientas y entornos para la implementación eficiente (IDE, control de versiones)

4. Evaluación y Selección de Patrones de Diseño

• Clasificación y características de patrones de diseño relevantes para ingeniería
• Criterios para seleccionar patrones adecuados según el problema y contexto
• Análisis comparativo de patrones: eficiencia, mantenibilidad y escalabilidad
• Justificación técnica de la elección de patrones en proyectos reales

5. Documentación y Comunicación del Proyecto Orientado a Objetos

• Elaboración de diagramas UML: clases, secuencia, estado y casos de uso
• Buenas prácticas en la documentación técnica y reportes escritos
• Comunicación efectiva de resultados y diseño a audiencias técnicas y no técnicas
• Uso de herramientas para la generación y mantenimiento de documentación

Actividad 1: Análisis y Diseño de un Proyecto Orientado a Objetos

Objetivo: Diseñar un proyecto de ingeniería usando principios de POO, integrando clases y patrones de diseño (objetivo 1).

Descripción:

• Se presenta un problema de ingeniería específico (por ejemplo, sistema de gestión de sensores en una planta industrial).
• Los estudiantes analizan el problema para identificar las clases, sus atributos y métodos.
• Definen las relaciones entre clases y proponen patrones de diseño adecuados.
• Elaboran un diagrama UML de clases que refleje su diseño.

Organización: Grupos de 3-4 estudiantes.

Producto esperado: Documento con el análisis, diseño y diagrama UML de clases.

Duración estimada: 3 horas.

Actividad 2: Implementación Modular del Proyecto

Objetivo: Implementar el proyecto aplicando técnicas de modularidad y reutilización de código (objetivo 2).

Descripción:

• Partiendo del diseño elaborado, los estudiantes codifican las clases y módulos en un lenguaje orientado a objetos (e.g., Java, C++ o Python).
• Implementan patrones de diseño seleccionados para resolver problemas específicos.
• Prueban la interacción entre módulos y aseguran la reutilización y mantenibilidad del código.

Organización: Grupos de 3-4 estudiantes (puede ser el mismo grupo de la actividad anterior).

Producto esperado: Código fuente modularizado y documentado con comentarios.

Duración estimada: 6 horas.

Actividad 3: Evaluación y Justificación de Patrones de Diseño

Objetivo: Evaluar y seleccionar patrones de diseño adecuados, justificando su elección (objetivo 3).

Descripción:

• Los estudiantes analizan diferentes patrones de diseño que podrían aplicarse en el proyecto.
• Comparan ventajas y desventajas de cada patrón en el contexto del problema.
• Preparan una presentación escrita o oral justificando la elección final de los patrones implementados.

Organización: Individual o en parejas.

Producto esperado: Informe o presentación con análisis comparativo y justificación técnica.

Duración estimada: 2 horas.

Actividad 4: Documentación y Presentación Técnica del Proyecto

Objetivo: Documentar y comunicar el diseño, implementación y resultados usando diagramas UML y reportes técnicos (objetivo 4).

Descripción:

• Los estudiantes elaboran un reporte técnico detallado que incluya: descripción del problema, diseño UML, implementación, pruebas y conclusiones.
• Complementan con diagramas UML adicionales (secuencia, casos de uso) para ilustrar la interacción y comportamiento.
• Presentan el proyecto a la clase o docente, explicando el diseño y resultados obtenidos.

Organización: Grupos o individual según preferencia.

Producto esperado: Reporte técnico completo y presentación oral o multimedia.

Duración estimada: 4 horas.

Evaluación Diagnóstica

Qué se evalúa: Conocimientos previos sobre principios de POO, identificación de clases y patrones básicos.

Cómo se evalúa: Cuestionario escrito o en línea con preguntas teóricas y ejercicios cortos de diseño.

Instrumento sugerido: Test de opción múltiple y preguntas abiertas.

Evaluación Formativa

Qué se evalúa: Progreso en el diseño, implementación modular, selección de patrones y documentación.

Cómo se evalúa: Revisión continua de entregables parciales (diagramas, código, informes), retroalimentación en clase y tutorías.

Instrumento sugerido: Rúbricas de evaluación para diseño UML, calidad de código, justificación de patrones y documentación técnica.

Evaluación Sumativa

Qué se evalúa: Producto final del proyecto: diseño completo, código implementado, justificación de patrones y documentación integral.

Cómo se evalúa: Evaluación del proyecto final entregado y presentación oral ante el docente y compañeros.

Instrumento sugerido: Rúbrica detallada que contemple criterios de diseño, funcionalidad, modularidad, justificación técnica y calidad de la presentación.

La unidad "Implementación de Proyectos Orientados a Objetos" se recomienda que tenga una duración total de 3 semanas, con una dedicación aproximada de 15 horas distribuidas de la siguiente forma: 4 horas para análisis y diseño, 6 horas para implementación, 2 horas para evaluación y justificación de patrones, y 3 horas para documentación y presentación final. Esta distribución permite un desarrollo progresivo y profundo de cada objetivo de aprendizaje.

1. Introducción a las pruebas en programación orientada a objetos

• Concepto y relevancia de las pruebas en software orientado a objetos: importancia para la calidad y mantenimiento.
• Tipos de pruebas: unitaria, de integración, funcional y de sistema en el contexto OOP.
• Principios básicos de diseño de casos de prueba para clases y métodos.

2. Diseño y ejecución de pruebas unitarias y de integración

• Pruebas unitarias: definición, alcance y enfoque en métodos y clases.
• Herramientas para pruebas unitarias en lenguajes orientados a objetos (JUnit, NUnit, PyTest, etc.).
• Diseño de casos de prueba para métodos y clases: criterios de cobertura, casos de frontera, casos normales y excepciones.
• Pruebas de integración: tipos (incrementales, no incrementales), objetivos y técnicas para integración de clases y módulos.
• Automatización de pruebas unitarias e integración: configuración y ejecución de suites de pruebas.

3. Técnicas y herramientas de depuración en programación orientada a objetos

• Conceptos fundamentales de depuración: identificación, análisis y corrección de errores.
• Errores comunes en programación orientada a objetos: errores lógicos, de referencia, de concurrencia y de diseño.
• Herramientas de depuración: depuradores integrados (IDE), breakpoints, watchpoints, inspección de variables y pilas de ejecución.
• Técnicas avanzadas de depuración: análisis de logs, pruebas bajo condiciones específicas, uso de perfiles y simuladores.
• Buenas prácticas para documentar y reproducir errores durante el proceso de depuración.

4. Evaluación de la calidad del software orientado a objetos mediante pruebas automatizadas

• Indicadores de calidad del software: cobertura de código, densidad de defectos, rendimiento y mantenibilidad.
• Análisis de cobertura de código: tipos (cobertura de líneas, de ramas, de condiciones), herramientas y métricas.
• Integración continua y pruebas automatizadas: conceptos y beneficios para la calidad del software.
• Implementación de pipelines de pruebas automatizadas en proyectos orientados a objetos.

5. Documentación y comunicación de resultados de pruebas y depuración

• Estructura y contenido de reportes técnicos de pruebas y depuración.
• Buenas prácticas para la redacción clara, precisa y técnica de resultados.
• Comunicación efectiva con equipos de desarrollo y gestión de proyectos.
• Uso de herramientas para la gestión y seguimiento de incidencias y reportes de pruebas.

Diseño y ejecución de casos de prueba para una clase

Objetivo: Diseñar casos de prueba para clases y métodos usando técnicas de prueba unitaria.

Descripción:

• Se asigna una clase orientada a objetos con funcionalidad definida (por ejemplo, una clase CuentaBancaria).
• Los estudiantes analizan la clase y diseñan casos de prueba unitarios para cada método, considerando casos normales y excepcionales.
• Implementan los casos de prueba con una herramienta adecuada (JUnit, NUnit, PyTest, etc.).
• Ejecutan las pruebas, documentan los resultados y proponen correcciones si es necesario.

Organización: Individual o en parejas

Producto esperado: Código de pruebas unitarias implementadas, reporte de resultados y análisis.

Duración estimada: 3 horas

Depuración guiada con herramientas integradas en IDE

Objetivo: Aplicar herramientas y técnicas de depuración para identificar y corregir errores.

Descripción:

• Se entrega un programa orientado a objetos con errores intencionales.
• Los estudiantes usan un depurador integrado (Eclipse, Visual Studio, PyCharm) para localizar errores.
• Implementan breakpoints, monitorean variables y rastrean la ejecución paso a paso.
• Corrigen los errores y verifican la funcionalidad corregida mediante pruebas.

Organización: Individual

Producto esperado: Código corregido y reporte detallado del proceso de depuración.

Duración estimada: 2.5 horas

Evaluación de cobertura de código y automatización de pruebas

Objetivo: Evaluar la calidad mediante pruebas automatizadas y análisis de cobertura.

Descripción:

• Los estudiantes integran herramientas de análisis de cobertura (Jacoco, Coverage.py, etc.) en un proyecto orientado a objetos.
• Ejecutan una suite de pruebas automatizadas y analizan los resultados de cobertura, identificando áreas no cubiertas.
• Diseñan pruebas adicionales para mejorar la cobertura y ejecutan nuevamente los análisis.
• Documentan el proceso y presentan conclusiones sobre la calidad del software.

Organización: Grupos pequeños (3-4 estudiantes)

Producto esperado: Informe técnico con resultados de cobertura y pruebas, código actualizado.

Duración estimada: 4 horas

Reporte técnico y presentación de resultados de pruebas y depuración

Objetivo: Documentar y comunicar resultados de pruebas y depuración de forma clara y técnica.

Descripción:

• Los estudiantes preparan un reporte técnico que incluya la descripción del proyecto, metodología de pruebas, resultados y análisis.
• Incluyen documentación de errores encontrados, pasos de depuración y correcciones realizadas.
• Presentan oralmente sus hallazgos y recomendaciones ante el grupo, utilizando soporte visual.

Organización: Individual o parejas

Producto esperado: Documento técnico y presentación oral.

Duración estimada: 3 horas

Evaluación diagnóstica

Qué se evalúa: Conocimientos previos sobre conceptos básicos de pruebas y depuración en orientación a objetos.

Cómo se evalúa: Cuestionario corto de opción múltiple y preguntas abiertas al inicio de la unidad.

Instrumento sugerido: Test en plataforma digital o papel con preguntas relacionadas a tipos de pruebas, herramientas y conceptos de depuración.

Evaluación formativa

Qué se evalúa: Aplicación práctica de diseño de casos de prueba, uso de depuradores y análisis de cobertura durante las actividades.

Cómo se evalúa: Revisión continua de productos parciales: código de pruebas, reportes de depuración, logs de ejecución y feedback en clase.

Instrumento sugerido: Listas de cotejo para evaluación de código, rúbricas para informes y observación directa.

Evaluación sumativa

Qué se evalúa: Competencia para diseñar, ejecutar y documentar pruebas, depurar programas orientados a objetos y evaluar calidad con pruebas automatizadas.

Cómo se evalúa: Proyecto final que incluya: conjunto de pruebas unitarias e integración, corrección de errores mediante depuración, análisis de cobertura y reporte técnico completo.

Instrumento sugerido: Rúbrica detallada que contemple calidad de pruebas, efectividad en depuración, profundidad del análisis de cobertura y claridad en la documentación.

La unidad "Pruebas y Depuración en Programación Orientada a Objetos" está diseñada para impartirse en 3 semanas, con una dedicación total aproximada de 12 horas distribuidas de la siguiente forma:

• Semana 1 (4 horas): Introducción a pruebas y diseño de casos unitarios e integración, con actividades prácticas de diseño y ejecución de pruebas.
• Semana 2 (4 horas): Técnicas y herramientas de depuración, con sesión práctica guiada de depuración y análisis de errores.
• Semana 3 (4 horas): Evaluación de calidad mediante pruebas automatizadas y cobertura de código, junto con actividades de documentación y presentación de resultados.

Esta distribución permite un avance progresivo desde la comprensión teórica hasta la aplicación práctica y la comunicación técnica, alineada con los objetivos de la unidad.

1. Introducción al desarrollo colaborativo en proyectos orientados a objetos

• Contexto y relevancia del trabajo en equipo en ingeniería de software.
• Desafíos comunes en proyectos colaborativos de programación orientada a objetos.
• Ventajas del enfoque orientado a objetos en equipos de desarrollo.

2. Metodologías ágiles en el desarrollo de software orientado a objetos

• Conceptos básicos de metodologías ágiles.
• Scrum: estructura, roles, eventos y artefactos.
• Kanban: principios, gestión visual y flujo continuo.
• Extreme Programming (XP): prácticas clave y su impacto en la calidad del código orientado a objetos.
• Comparativa de metodologías ágiles: características, beneficios y limitaciones para proyectos orientados a objetos.

3. Buenas prácticas de programación orientada a objetos en entornos colaborativos

• Principios SOLID aplicados en equipo.
• Patrones de diseño comunes y su utilidad colaborativa.
• Normas de codificación y convenciones para mantener la coherencia.
• Revisión de código y pair programming como herramientas colaborativas.

4. Herramientas para el desarrollo colaborativo y control de versiones

• Introducción a sistemas de control de versiones: Git y GitHub.
• Flujos de trabajo Git para equipos: branching, pull requests y resolución de conflictos.
• Herramientas de colaboración: integración continua y gestión de tareas (Jira, Trello).

5. Diseño y organización de tareas en equipos utilizando metodologías ágiles

• Definición y asignación de roles en Scrum y XP.
• Planificación de sprint y elaboración de backlog orientado a objetos.
• Estimación de esfuerzo y seguimiento de progreso.
• Comunicación efectiva y manejo de reuniones ágiles.

6. Análisis y evaluación de metodologías ágiles y prácticas colaborativas en proyectos orientados a objetos

• Estudio de casos reales de aplicación de metodologías ágiles en proyectos OO.
• Indicadores de efectividad y productividad en desarrollo colaborativo.
• Identificación de buenas prácticas y áreas de mejora.
• Reflexión crítica sobre la adaptabilidad de metodologías según el contexto del proyecto.

Actividad 1: Análisis comparativo de metodologías ágiles

Objetivo: Identificar y explicar las principales metodologías ágiles y sus beneficios en el trabajo colaborativo.

Descripción:

• En grupos de 3-4 estudiantes, se asigna una metodología ágil (Scrum, Kanban o XP).
• Investigar características, roles, procesos y beneficios de la metodología asignada.
• Preparar una presentación breve (10 minutos) explicando la metodología y su aplicabilidad en proyectos orientados a objetos.
• Realizar una sesión de preguntas y respuestas con el resto de la clase.

Organización: Grupos

Producto esperado: Presentación y documento resumen.

Duración estimada: 2 horas (incluye investigación y presentación).

Actividad 2: Aplicación práctica de control de versiones con Git en un proyecto orientado a objetos

Objetivo: Aplicar buenas prácticas y herramientas de control de versiones en un entorno colaborativo.

Descripción:

• Formar parejas o tríos para trabajar en un pequeño proyecto orientado a objetos.
• Crear un repositorio Git en GitHub e implementar funciones básicas siguiendo principios SOLID.
• Practicar branching, commits significativos, pull requests y resolución de conflictos.
• Realizar revisiones cruzadas del código mediante pull requests.

Organización: Parejas o grupos pequeños

Producto esperado: Repositorio Git con historial y código documentado.

Duración estimada: 3 horas.

Actividad 3: Diseño y planificación de un sprint para proyecto orientado a objetos

Objetivo: Diseñar y organizar tareas de programación orientada a objetos utilizando roles y procesos ágiles.

Descripción:

• En grupos de 4-5 estudiantes, simular la planificación de un sprint para un proyecto OO.
• Definir roles (Scrum Master, Product Owner, Developers).
• Crear backlog con tareas específicas orientadas a objetos.
• Estimar esfuerzo y planificar el sprint con herramientas como Jira o Trello.
• Presentar el plan al grupo y discutir sobre la organización y asignación de tareas.

Organización: Grupos

Producto esperado: Plan de sprint documentado y tablero de gestión de tareas.

Duración estimada: 2 horas.

Actividad 4: Análisis crítico de casos prácticos de metodologías ágiles en proyectos OO

Objetivo: Evaluar la efectividad de metodologías ágiles y prácticas colaborativas mediante análisis de casos reales.

Descripción:

• Leer y analizar casos de estudio proporcionados sobre proyectos orientados a objetos que aplicaron metodologías ágiles.
• Identificar aspectos exitosos y dificultades encontradas.
• Realizar un informe crítico que incluya recomendaciones y lecciones aprendidas.
• Compartir conclusiones en una discusión grupal.

Organización: Individual y posterior discusión grupal

Producto esperado: Informe crítico escrito y participación en discusión.

Duración estimada: 2 horas.

Evaluación diagnóstica

Qué se evalúa: Conocimientos previos sobre metodologías ágiles, trabajo en equipo y programación orientada a objetos.

Cómo se evalúa: Cuestionario breve con preguntas de opción múltiple y verdadero/falso.

Instrumento sugerido: Test en línea o en papel al inicio de la unidad.

Evaluación formativa

Qué se evalúa: Progreso en la comprensión y aplicación de metodologías ágiles, uso de herramientas colaborativas y buenas prácticas OO.

Cómo se evalúa: Observación y retroalimentación continua durante actividades prácticas, revisión de productos parciales (repositorios, presentaciones, planes de sprint).

Instrumento sugerido: Lista de cotejo para seguimiento de actividades, rúbricas para presentación y código.

Evaluación sumativa

Qué se evalúa: Capacidad para identificar, aplicar, diseñar y evaluar metodologías ágiles y prácticas colaborativas en desarrollo orientado a objetos.

Cómo se evalúa: Proyecto final en equipo que incluya:

• Implementación colaborativa de un módulo de software orientado a objetos con control de versiones.
• Documentación del uso de una metodología ágil para la organización del trabajo.
• Informe crítico que evalúe la efectividad de la metodología aplicada y las prácticas colaborativas.

Instrumento sugerido: Rúbrica integral que valore código, documentación, organización y análisis crítico.

La unidad se sugiere desarrollar en un total de 12 horas distribuidas en 4 semanas, considerando sesiones teóricas y prácticas:

• Semana 1 (3 horas): Introducción y metodologías ágiles.
• Semana 2 (3 horas): Buenas prácticas OO y herramientas de control de versiones.
• Semana 3 (3 horas): Diseño y planificación ágil de tareas.
• Semana 4 (3 horas): Análisis de casos prácticos y evaluación final.

Esta distribución permite integrar teoría, práctica y evaluación de forma equilibrada para facilitar el aprendizaje significativo.

1. Revisión integral de conceptos y técnicas de programación orientada a objetos

• Repaso de principios fundamentales: encapsulación, herencia, polimorfismo y abstracción.
• Patrones de diseño básicos: Singleton, Factory, Observer y su aplicación práctica.
• Buenas prácticas en diseño y codificación: modularidad, cohesión, acoplamiento y mantenimiento del código.
• Errores comunes y cómo evitarlos: manejo de excepciones, diseño antipatrón y refactorización.

2. Diseño y desarrollo del proyecto final

• Selección y definición del problema: análisis de requerimientos y especificaciones.
• Diseño orientado a objetos: diagramas UML (clases, secuencia, casos de uso) y planificación del proyecto.
• Implementación práctica: codificación siguiendo principios orientados a objetos y uso de herramientas de control de versiones.
• Documentación técnica: elaboración de manuales, comentarios claros y diagramas explicativos.

3. Evaluación crítica y retroalimentación de proyectos

• Criterios para evaluación de proyectos: calidad del código, uso adecuado de principios, modularidad y mantenibilidad.
• Análisis comparativo: revisión entre pares y autoevaluación.
• Técnicas para dar y recibir retroalimentación constructiva: comunicación efectiva y respeto en la crítica técnica.

4. Presentación y defensa oral del proyecto final

• Estructura de una presentación técnica efectiva: introducción, desarrollo, resultados y conclusiones.
• Comunicación clara y concisa: uso de lenguaje técnico apropiado, soporte visual y manejo del tiempo.
• Preparación para preguntas y respuestas: anticipación de preguntas técnicas, argumentación y justificación de decisiones de diseño.
• Técnicas para manejo de nervios y confianza al hablar en público.

Actividad 1: Examen integral de programación orientada a objetos

Objetivo: Analizar integralmente los conceptos y técnicas de programación orientada a objetos aplicados durante el curso.

Descripción:

• Aplicar un examen escrito que incluya preguntas teóricas y problemas prácticos para resolver.
• Los problemas incluyen diseño de clases, diagramas UML, y fragmentos de código para interpretar o corregir.
• El examen se realiza en un tiempo establecido y bajo supervisión.

Organización: individual

Producto esperado: examen completo con respuestas correctas y bien fundamentadas.

Duración estimada: 2 horas

Actividad 2: Desarrollo y presentación del proyecto final

Objetivo: Diseñar y presentar un proyecto final que demuestre la aplicación práctica de principios orientados a objetos con comunicación técnica clara.

Descripción:

• Seleccionar un problema de ingeniería para resolver con programación orientada a objetos.
• Realizar el diseño UML y planificar la implementación.
• Codificar el proyecto en un lenguaje orientado a objetos.
• Preparar una presentación técnica con diapositivas que incluya explicación del diseño, implementación y resultados.
• Exponer oralmente ante el grupo y docente, utilizando soporte visual.

Organización: individual o en parejas (según indicación del docente)

Producto esperado: proyecto funcional con documentación y presentación oral realizada.

Duración estimada: 2 semanas (para desarrollo) y 30 minutos de presentación por equipo/individuo

Actividad 3: Evaluación entre pares de proyectos finales

Objetivo: Evaluar críticamente el diseño y la implementación de proyectos propios y de compañeros utilizando criterios de calidad, modularidad y mantenibilidad.

Descripción:

• Revisar el código y documentación de uno o dos proyectos de compañeros.
• Aplicar una rúbrica de evaluación con criterios específicos.
• Proporcionar retroalimentación escrita y oral constructiva.
• Recibir retroalimentación sobre su propio proyecto y reflexionar sobre mejoras.

Organización: grupos pequeños (3-4 estudiantes)

Producto esperado: informes de evaluación y retroalimentación documentados.

Duración estimada: 2 sesiones de 1.5 horas cada una

Actividad 4: Defensa oral de decisiones de diseño y soluciones implementadas

Objetivo: Defender oralmente las decisiones de diseño y las soluciones implementadas en el proyecto final, respondiendo preguntas técnicas de manera coherente y fundamentada.

Descripción:

• Preparar respuestas para posibles preguntas técnicas sobre el proyecto.
• Simular una sesión de preguntas y respuestas con el docente y compañeros.
• Recibir retroalimentación sobre claridad, coherencia y fundamento de las respuestas.

Organización: individual o en parejas

Producto esperado: defensa oral efectiva y fundamentada.

Duración estimada: 1 hora por estudiante o pareja

Evaluación diagnóstica

Qué se evalúa: Conocimientos previos y nivel de dominio sobre conceptos básicos de programación orientada a objetos antes de la unidad.

Cómo se evalúa: Cuestionario corto con preguntas de opción múltiple y preguntas abiertas sobre principios y técnicas básicas.

Instrumento sugerido: Test en línea o impreso con 10-15 preguntas.

Evaluación formativa

Qué se evalúa: Progreso en el diseño, implementación y documentación del proyecto final; participación en evaluaciones entre pares y capacidad para dar/recibir retroalimentación.

Cómo se evalúa: Revisión continua de avances del proyecto, observación de sesiones de retroalimentación y participación en actividades.

Instrumento sugerido: Lista de cotejo para seguimiento de avances, rúbrica para evaluación entre pares, y registros de participación.

Evaluación sumativa

Qué se evalúa: Dominio integral de conceptos y técnicas a través del examen final, calidad y funcionalidad del proyecto final, claridad y eficacia en la presentación oral, y capacidad para defender decisiones técnicas.

Cómo se evalúa: Examen escrito y práctico, evaluación del proyecto con rúbrica detallada, evaluación de la presentación y defensa oral según criterios definidos.

Instrumento sugerido: Examen formal, rúbricas para proyecto y presentación, y lista de criterios para defensa oral.

La unidad "Evaluación Final y Presentación de Proyectos" se sugiere impartir en un periodo total de 3 semanas.
- Semana 1: Aplicación del examen integral (2 horas) y inicio del desarrollo del proyecto final.
- Semana 2: Continuación y culminación del desarrollo del proyecto, preparación de la documentación y presentación (aproximadamente 10-12 horas distribuidas en la semana).
- Semana 3: Presentaciones orales (30 minutos por estudiante o pareja), evaluación entre pares (3 horas distribuidas), y defensa oral (1 hora por estudiante o pareja).
Este cronograma permite una integración equilibrada de actividades teóricas, prácticas y comunicativas, asegurando el logro de los objetivos de la unidad.