Primer Trimestre: Entornos de Desarrollo

• Tarea: Reconocimiento de Elementos en el Desarrollo de un Programa

• Informático

• Objetivo: Evaluar la capacidad de los alumnos para reconocer los elementos y herramientas

• que intervienen en el desarrollo de un programa informático, diferenciando los conceptos de

• código fuente, objeto y ejecutable, así como clasificar los lenguajes de programación

• (imperativos y declarativos).

• Parte 1: Análisis teórico de conceptos

• 1. Explicación de los conceptos básicos:

• o Describe en tus propias palabras qué es el código fuente, código objeto y

• código ejecutable.

• o Explica las fases por las que pasa un programa desde que es escrito en un

• lenguaje de programación hasta que es ejecutado en el procesador.

• o Usa ejemplos concretos para cada concepto, mencionando en qué fase

• interviene cada uno en el desarrollo de un programa (análisis léxico,

• sintáctico, semántico, etc.).

• 2. Clasificación de lenguajes de programación:

• o Investiga y clasifica los lenguajes de programación en función de:

• Nivel de abstracción: alto, medio y bajo.

• Paradigma de programación: imperativo y declarativo.

• o Da al menos dos ejemplos de lenguajes para cada categoría y explica

• brevemente por qué pertenecen a esa clasificación.

• Parte 2: Actividad práctica y de análisis

• 1. Identificación de paradigmas de programación a partir de ejemplos:

• A continuación, se te ofrecen descripciones de fragmentos de código. Tu tarea es

• identificar si cada uno corresponde a un paradigma imperativo o declarativo y

• justificar tu respuesta.

• Fragmento 1 (Descripción):

• o Un programa recorre una lista de números sumándolos uno por uno hasta

• obtener el total.

• o Pista: Se describe cómo se realiza la suma paso a paso.

• Fragmento 2 (Descripción):

• o Una consulta a una base de datos busca empleados mayores de 30 años y

• devuelve solo sus nombres.

• o Pista: Se especifica qué resultado se quiere obtener sin detallar cómo se

• procesa internamente.

• Fragmento 3 (Descripción):

• o Un programa que calcula el factorial de un número n definiendo que el

• factorial de 0 es 1 y, para números mayores, multiplicando el número por el

• factorial del número anterior.

• o Pista: La lógica se define recursivamente sin especificar los pasos detallados.

• Fragmento 4 (Descripción):

• o Un programa filtra productos con precios superiores a 10 dólares recorriendo

• una lista y comprobando cada producto uno por uno.

• o Pista: Se describen detalladamente los pasos del proceso.

• 2. Actividad en grupo:

• o En equipos de 2-3 personas, seleccionen una actividad cotidiana (preparar una

• receta, organizar un evento, etc.) y describan la tarea de dos maneras:

• Imperativa: Indicando cada uno de los pasos detallados.

• Declarativa: Describiendo únicamente el resultado final que quieren

• lograr.

• o Comparen las dos descripciones y discutan las ventajas y desventajas de cada

• enfoque. Incluyan esta comparación en el informe.

• Entrega

• • Una presentación formato de 5 a 10 páginas que contenga:

• o Las respuestas a la Parte 1 (explicación de conceptos y clasificación de

• lenguajes).

• o La clasificación y justificación de los ejemplos de la Parte 2.

• o Una descripción del trabajo en grupo, incluyendo el ejemplo cotidiano y la

• comparación entre descripciones imperativas y declarativas.

• CRITERIOS DE EVALUACIÓN

• RA1. Reconoce los elementos y herramientas que intervienen en el desarrollo de un programa

• informático, analizando sus características y las fases en las que actúan hasta llegar a su

• puesta en funcionamiento.

• 3

• c) Se han diferenciado los conceptos de código fuente, objeto y ejecutable.

• e) Se han clasificado los lenguajes de programación 

Tarea: Reconocimiento de Elementos en el Desarrollo de un Programa

Informático

Objetivo: Aplicar los conceptos vistos en clase sobre Ingeniería de Software, modelos de desarrollo, fases y requisitos, mediante la selección y planteamiento de una aplicación realista.

Instrucciones

1. Selección de la Aplicación (2 pts)

   • Elige una aplicación que te gustaría desarrollar, que refleje lo aprendido en clase (modelo de desarrollo, fases, usuarios, plataformas…).

   • Justifica la elección mencionando al menos dos conceptos vistos: por ejemplo, por qué sería viable con un modelo ágil, quiénes serían los usuarios principales, etc.

2. Listado de Características (2 pts)

   • Haz al menos 10 características o funcionalidades.

   • Que algunas de ellas ilustren lo que significa un requisito funcional y otras lo que significa no funcional.
     
     

3. Documentación Inicial (2 pts)
   
   

   • Nombre de la aplicación.

   • Descripción breve.

   • Objetivos (qué problema resuelve).

   • Usuarios principales (roles).

   • Plataforma/s (móvil, web, escritorio).

   • Modelo de desarrollo sugerido (por qué usarías ágil, espiral u otro).
     
     

4. Análisis de Requisitos (2 pts)

   • Definir al menos 5 requisitos funcionales: qué debe hacer la aplicación.

   • Definir al menos 5 requisitos no funcionales: rendimiento, seguridad, usabilidad, etc.

   • Explica por qué cada uno es importante, referenciando algo de lo visto en clase (por ejemplo: “usabilidad es clave porque el usuario será novato”, “seguridad importante por los datos personales”).

5. Comunicación y Colaboración (2 pts)

   • Trabajo en equipo de 2–3 personas.

   • Cada uno debe contribuir, y al final entregar un breve informe de qué hizo cada uno.
     
     

Además, incorporar una breve reflexión sobre qué fases del desarrollo les parecieron más desafiantes, citando los modelos vistos en clase.

Entrega

• Documento en PDF.
  
  

• 5–7 páginas.
  
  

• Entregar en Aula Virtual.

💻 Tarea grupal: Instalación y evaluación comparativa de IDEs

🎯 Objetivo

Instalar, configurar y comparar dos entornos de desarrollo (IDE) distintos, demostrando comprensión de sus funcionalidades, personalización y documentación.
Finalmente, ejecutar un pequeño programa en Java en cada entorno para comprobar su correcto funcionamiento.

🧠 Competencias y resultados de aprendizaje

• RA2 (Entornos de Desarrollo): Evalúa entornos integrados de desarrollo analizando sus características para editar código fuente y generar ejecutables.
  
  

• RA3 (Entornos de Desarrollo): Verifica el funcionamiento de programas diseñando y realizando pruebas básicas.
  
  

🧍‍♀️🧍‍♂️ Trabajo en grupos

Grupos de 3–4 alumnos/as. Todos los miembros deben aparecer reflejados en la presentación (nombre y aportación).

⚙️ Instrucciones de la tarea

1️⃣ Elección de IDE

Seleccionad dos entornos de desarrollo diferentes:

• Uno libre o de código abierto (por ejemplo: Eclipse, NetBeans, VS Code).
  
  

• Otro propietario o semipropietario (por ejemplo: IntelliJ IDEA, Android Studio, Visual Studio).
  
  

2️⃣ Instalación y configuración

• Descargad ambos IDE desde sus webs oficiales.
  
  

• Mostrad capturas de cada paso: descarga, instalación, configuración del JDK o SDK, creación del primer proyecto.
  
  

• Describid los problemas encontrados y cómo los resolvisteis.
  
  

3️⃣ Personalización

• Cambiad el tema, colores o fuentes.
  
  

• Instalad al menos un plugin o extensión útil en cada IDE y explicad su función.
  
  

• Añadid capturas del resultado.
  
  

4️⃣ Comparativa funcional

Realizad una tabla comparativa con los siguientes aspectos:

Característica

IDE 1

IDE 2

Facilidad de instalación

Consumo de recursos

Idiomas/lenguajes soportados

Autocompletado

Depuración

Plugins/extensiones

Interfaz y usabilidad

Opinión final

5️⃣ Mini práctica Java

Para comprobar el correcto funcionamiento de ambos IDE:

• Cread un programa sencillo en Java, por ejemplo:
  
  

public class HolaEntornos {

    public static void main(String[] args) {

        System.out.println("¡Hola desde mi entorno de desarrollo!");

    }

}

• Mostrad capturas de:
  
  

  • El código fuente.
    
    

  • La ejecución correcta (consola mostrando el mensaje).
    
    

  • Si es posible, una breve prueba con un punto de ruptura (depuración).
    
    

6️⃣ Presentación final

• Entrega en PowerPoint, Canva o Google Slides.
  
  

• Incluye:
  
  

  • Portada (grupo, nombres, módulo, fecha)
    
    

  • Explicaciones y capturas
    
    

  • Comparativa y conclusiones
    
    

  • Diseño visual cuidado y coherente
    
    

📤 Entrega

• Subir la presentación final en PDF o enlace público.
  
  

• Nombre del archivo: GrupoX_Tarea_IDE.pdf.
  
  

• Fecha límite: (indica la fecha).
  
  

🧾 Rúbrica de evaluación (10 puntos)

Criterio

Excelente (2 p)

Bien (1 p)

Insuficiente (0 p)

Instalación y configuración

Instala correctamente ambos IDE con capturas y explicación clara.

Falta un IDE o documentación incompleta.

No se evidencia instalación.

Comparativa funcional

Analiza diferencias con criterio técnico.

Comparativa básica o incompleta.

No compara adecuadamente.

Personalización y plugins

Aplica y explica cambios útiles.

Cambios mínimos o sin explicación.

No hay personalización.

Prueba Java

Código funcional en ambos IDE, con capturas de ejecución.

Ejecuta en uno o sin capturas completas.

No ejecuta el programa.

Presentación y trabajo en grupo

Claridad, diseño cuidado, colaboración visible.

Presentación básica o poco cohesionada.

Desorden, sin formato o sin trabajo grupal.

¿Quieres que te la monte en Word o PDF con el formato oficial MEDAC (logo, encabezado con “Actividad Evaluable – Entornos de

Caso práctico: Sistema de Gestión de Biblioteca

Contexto:
Se les solicita a los estudiantes diseñar un sistema de gestión de una biblioteca utilizando un diagrama de clases UML. El sistema debe incluir las siguientes funcionalidades:

• Gestión de libros.

• Gestión de usuarios.

• Préstamo y devolución de libros.

• Categorías de libros.

Especificaciones:

1. Clases principales:

   • Libro:

     • Atributos: título, autor, ISBN, categoría.

     • Métodos: consultarDisponibilidad(), prestar(), devolver().

   • Usuario:

     • Atributos: nombre, IDUsuario, dirección.

     • Métodos: registrar(), consultarPréstamos().

   • Préstamo:

     • Atributos: fechaPréstamo, fechaDevolución.

     • Métodos: iniciarPréstamo(), finalizarPréstamo().

   • Categoría:

     • Atributos: nombreCategoría, descripción.

     • Métodos: asignarCategoría().

Objetivos del ejercicio:

1. Definir las relaciones entre las clases según las especificaciones. Los estudiantes deberán decidir:

   • ¿Qué tipo de relación existe entre Libro y Categoría?

   • ¿Qué tipo de relación hay entre Préstamo, Usuario y Libro?

   • ¿Se necesita algún tipo de herencia entre las clases?

   • ¿Qué métodos deben implementarse para gestionar las interacciones entre los objetos?

2. Crear un diagrama de clases UML con las relaciones que han determinado, utilizando star UML.

3. Ahora realizar la ingeniería inversa instalando la extensión Java. Veamos ahora si nos genera el código de forma correcta.

4. Presentar y justificar las relaciones elegidas en el diagrama, explicando cómo se modela cada aspecto del sistema a través de la herramienta presentaciones.

Criterios de Evaluación RA5:a) b) c) d) e) f)

Puntos

10

Presentando

una carga de archivo

Fecha de entrega

Para

Disponible desde

Hasta

30 de oct de 2024

30 de oct de 2024 en 23:59

Todos

23 de oct de 2024 en 9:00

23 de oct de 2024 en 9:00

-

N. a.

Rúbrica

Rubrica T7

Criterios

Calificaciones

Pts

Este criterio depende de una competencia de aprendizaje

Instalación de Herramientas

1 ptsBienSe ha instalado correctamente StarUML y el plugin para trabajar con Java

0 ptsMal/No realizado

1 pts

Este criterio depende de una competencia de aprendizaje

Desarrollo del Diagrama de Clases

3 ptsExcelenteSe ha creado un diagrama de clases completo que incluye todas las entidades especificadas: Clientes, Empleados, Vehículos y Reparaciones, con sus respectivas propiedades y métodos

2 ptsCorrectoSe han establecido correctamente las relaciones entre las clases, incluyendo asociaciones, composiciones y herencias

1 ptsRegular o IncompletoFalta alguna entidad, propiedad, método o relación

0 ptsMal/No realizado

3 pts

Este criterio depende de una competencia de aprendizaje

Visibilidad y Tipos de Datos

2 ptsExcelenteSe han asignado correctamente los tipos de datos para cada propiedad y la visibilidad adecuada para propiedades y métodos

1.5 ptsCorrectoHay errores en la asignación de tipos de datos o en la visibilidad de propiedades y métodos

1 ptsIncorrecto o incompletoNo se ha prestado atención a los tipos de datos y visibilidad

0 ptsMal/No realizado

2 pts

Este criterio depende de una competencia de aprendizaje

Generación de Código Java

2 ptsExcelenteSe ha utilizado el plugin de StarUML para generar el código Java de manera correcta a partir del diagrama de clases

1 ptsRegular o IncompletoSe ha generado el código pero contiene errores o no compila

0 ptsMal/No realizado

2 pts

Este criterio depende de una competencia de aprendizaje

Ingeniería Inversa

2 ptsExcelenteSe ha obtenido el código fuente del archivo .jar y se ha creado el diagrama de clases correspondiente en StarUML utilizando ingeniería inversa

1 ptsCorrectoSe ha obtenido el código fuente pero el diagrama de clases no es completo o correcto

0 ptsMal/No realizado

2 pts

Puntos totales: 10

Ejemplo: “Gestión de un Coche y su Fabricante”

Tendremos las clases:

• Fabricante

• Coche

• Motor

• Conductor

Con las siguientes relaciones:

• Agregación: Fabricante ◇→ Coche

• Composición: Coche ♦→ Motor

• Asociación simple: Coche → Conductor

💠 Diagrama de clases (texto UML)

+------------------------------------+

|            Fabricante          |

+------------------------------------+

| - nombre: String               |

| - pais: String                 |

+------------------------------------+

| +fabricarCoche(): Coche        |

| +mostrarModelos(): void        |

+------------------------------------+

       ◇

       │ (agregación)

       │ 1..*

       ▼

+------------------------------------+

|               Coche            |

+------------------------------------+

| - modelo: String               |

| - año: Int                     |

+------------------------------------+

| +arrancar(): void              |

| +detener(): void               |

+------------------------------------+

       ♦

       │ (composición)

       │ 1..1

       ▼

+------------------------------------+

|              Motor             |

+------------------------------------+

| - tipo: String                 |

| - potencia: Int                |

+------------------------------------+

| +encender(): void              |

| +apagar(): void                |

+------------------------------------+

Coche ──────────────── Conductor

   (asociación simple)

🧠 Explicación de las relaciones

🔹 Agregación (◇)

Fabricante ◇──▶ Coche

• El fabricante tiene coches en su catálogo, pero estos pueden existir sin él.
  Por ejemplo, un coche fabricado por “Toyota” sigue existiendo aunque Toyota cierre.

• Es una relación de “tiene-un” pero no de dependencia vital.

🔸 Composición (♦)

Coche ♦──▶ Motor

• El motor es parte esencial del coche.

• Si se destruye el coche, el motor deja de existir como entidad independiente.

• Ejemplo: no puedes tener el motor “como objeto lógico” si el coche ha sido destruido.

⚪ Asociación simple

Coche ──▶ Conductor

• Un coche puede ser conducido por uno o varios conductores.

• Un conductor puede tener varios coches.

• Ambos objetos pueden existir independientemente (un coche aparcado sin conductor, o un conductor sin coche propio).

• Representa una relación temporal o de uso.

Diagrama de Clases (representación textual UML)

+------------------------------------+

|              Colegio               |

+------------------------------------+

| - nombre: String                   |

| - codigoCentro: String             |

+------------------------------------+

| +agregarAula(aula: Aula): void     |

| +mostrarAulas(): void              |

+------------------------------------+

          ◇

          │ (agregación)

          │ 1..*

          ▼

+------------------------------------+

|               Aula                 |

+------------------------------------+

| - numero: Int                      |

| - capacidad: Int                   |

+------------------------------------+

| +impartirClase(): void             |

| +limpiar(): void                   |

+------------------------------------+

          │

          │ (asociación simple)

          ▼

+------------------------------------+

|             Profesor               |

+------------------------------------+

| - nombre: String                   |

| - especialidad: String             |

+------------------------------------+

| +enseñar(): void                   |

+------------------------------------+

          ♦

          │ (composición)

          │ 1..1

          ▼

+------------------------------------+

|             Dirección              |

+------------------------------------+

| - calle: String                    |

| - ciudad: String                   |

| - codigoPostal: String             |

+------------------------------------+

Explicación de las relaciones

Agregación (◇)

Colegio ◇──▶ Aula

• El colegio tiene varias aulas, pero una aula puede existir sin pertenecer al colegio (por ejemplo, si el colegio se reforma o cambia de edificio).
  
  

• Es una relación “tiene-un” pero sin dependencia vital.
  
  

Composición (♦)

Colegio ♦──▶ Dirección

• La dirección es parte esencial del colegio.
  
  

• Si el colegio se elimina, también desaparece su dirección.
  
  

• Ejemplo: la dirección pertenece exclusivamente a ese colegio.
  
  

Asociación simple

Aula ──▶ Profesor

• Un aula puede ser usada por varios profesores (mañana/tarde).
  
  

• Un profesor puede impartir clases en varias aulas.
  
  

• Ninguno depende del otro para existir.
  
  

🧩 Tabla resumen

Tipo de relación

Símbolo UML

Ejemplo

Dependencia

Asociación simple

Línea simple

Aula ↔ Profesor

No

Agregación

Rombo blanco

Colegio ◇→ Aula

No

Composición

Rombo negro

Colegio ♦→ Dirección

Sí