3.

Paradigma estructurado

Paradigma estructurado.
Fuente: Pixabay

Objetivo: 
 Reconocer el paradigma más tradicional de programación.
 Generalmente, cuando aprendemos a programar lo hacemos en el marco del Paradigma
Estructurado. En este componente vamos a hacer un repaso por los conceptos más importantes del
Paradigma Estructurado para luego, en los próximos componentes, poder introducirnos en los otros
paradigmas.

0%0 de 2 temas completos

Mostrar la tabla de datos de En este gráfico se muestra la cantidad de temas completados en
comparación con la cantidad total de temas que contiene un módulo 3. Paradigma estructurado..
Lista de temas y submódulos de 3. Paradigma estructurado
 3.1 Conocimiento
Página web

  3.1 Conocimiento
Enviar comentariosReflexionar en Portafolio digitalDescargar

Estructura general de un programa

El Paradigma Estructurado es con el que generalmente aprendemos a programar, por lo que suponemos que está familiarizado, y por
tal motivo, no entraremos demasiado en detalle. Si no se acuerdan, no se preocupen porque vamos a hacer un repaso. Además, este
repaso nos permitirá sentar las bases a partir de las cuales se marcarán las diferencias con los otros paradigmas.

Como se mencionó en el componente anterior, un programa, en el Paradigma Estructurado, se ve como una secuencia ordenada de
instrucciones. Es decir, es una Programación Imperativa. El programa puede ser leído en secuencia desde el comienzo hasta el final sin
perder la continuidad (excepto porque suelen estar modularizados de modo que habría que ir a leer esa parte del código y volver al flujo
principal).

Algoritmos, diagramas de flujo y representaciones

Los algoritmos de un programa bajo este paradigma son fácilmente representables en un diagrama de flujo. Para armar ese diagrama
utilizamos estos elementos:

Fuente: De elaboracion propia.

Veamos un ejemplo. Supongamos que tenemos que cocinar algo. Como la cocina no es nuestro fuerte, en el Paradigma Estructurado,
el problema lo resolveríamos de esta manera: 

1. Pensar comida a preparar

2. Buscar receta en YouTube
3. Comprar cada uno de los ingredientes
4. Ejecutar cada uno de los pasos de la receta
5. Presentar el plato final
Dijimos que una forma fácil de representar los programas en este paradigma es a través de un diagrama de flujo. El diagrama
correspondiente sería este:

  Fuente: de elaboración propia.

Acá aparecen sentencias como For, While, procedimientos, etc. Hagamos un repaso por cada una de estas estructuras.
Procedimientos y estructuras de datos y control de la programación estructurada
Las estructuras secuenciales están compuestas por acciones que se ejecutan en el orden en que aparecen. Pueden ser instrucciones
de entrada o de salida. Por ejemplo:

a = LeerNumero ();       →  Instrucción de entrada

MostrarNumero(a);      →  Instrucción de salida

Ambas son estructuras secuenciales: la primera de entrada (porque recibimos información desde afuera) y la segunda de salida (porque
mostramos esa información por algún medio, ya sea la pantalla, la impresora o cualquier otro).

Pero imagínense lo que podría pasar si codificamos todo un programa de miles de líneas con instrucciones secuenciales una tras otra...
sería ilegible, difícil de entender y, sobre todo, difícil de mantener. Es decir, las modificaciones que ese programa requiera a lo largo del
tiempo nos llevaría mucho tiempo hacerlas y serían propensas a introducir un montón de errores.

Y es por esto que surge la modularización que vimos en el componente anterior. Gracias a esta herramienta, habrá un flujo principal del
programa que llamará a otros módulos que son independientes y reutilizables y que saben resolver problemas particulares. En la
programación estructurada, a estos módulos se los suele llamar Módulos, Procedimientos, Rutinas o Subprogramas. Por ejemplo,
BuscarReceta() es un módulo que adentro incluye otros pasos. Por ejemplo:

1.  Ingresar a Youtube.

2. Introducir la receta a buscar.
3. Ver varios videos.
4. Seleccionar uno.

Entonces un módulo es un conjunto de sentencias que realiza una determinada tarea y que se ejecutará cuando sea llamado por el flujo
principal. Este módulo a su vez puede llamar a otros módulos. 
Otra ventaja que podemos mencionar de la modularización es que la codificación de los programas es más fácil y la podemos pensar
con una estrategia Top-Down. Es decir, yendo de lo general a lo particular como hicimos recién. Primero nos ocupamos de ver cuáles
eran los pasos generales y luego, bajamos a detalle uno de esos pasos (BuscarReceta). Y luego tendremos que ir bajando a detalle el
resto. Imagínense, si en lugar de poner módulos hubiésemos puesto el paso por paso de cada uno de esos módulos en el programa
principal. Sería muy difícil de entender y eso que estamos tratando con un programa muy chico.

Parámetros y argumentos de los módulos

Algo importante para recordar es la diferencia entre parámetros y argumentos. Un módulo en su definición, puede tener de 0 a n
parámetros. Sumar (int num1, int num2);
Cuando ese modulo sea invocado, esos parámetros se van a instanciar con argumentos de la siguiente manera Sumar (1, 2);

Hasta acá se habló de estructuras secuenciales pero no todo en un programa es secuencial. Muchas veces pasa que, dependiendo del
valor de ciertas variables se debe seguir un camino o el otro. Repasemos entonces, cómo hacer para alterar ese flujo secuencial.

Estructura de control
Estructura condicional

La estructura condicional simple es el IF que la podemos representar como:

IF (condición) then Accion1 else Accion2.

Si se cumple la condición, se ejecuta la sentencia Accion1 y si no se cumple, se ejecuta la Accion2.

IF Llueve then MiroPeliculaEnCasa else VoyAlCine

Como hoy llueve, entonces miro una película en mi casa.

Luego están los IF anidados que tienen esta forma: IF (condición1) then (IF (condición2) then Accion1 else Accion2) else Accion3.

Por ejemplo:

IF NoJuegaVelez then (IF Llueve then MiroPeliculaEnCasa else VoyAlCine) else VoyALaCancha.

Es decir que, si juega Vélez, voy a la cancha, pero si no juega, mis planes dependen de si llueve o no llueve como en el caso anterior.

Estructura de selección múltiple

Este es el caso del Switch y se utiliza cuando hay muchas opciones para elegir al momento de tomar la decisión. Antes teníamos dos
decisiones llueve o no llueve, juega Vélez o no juega. Pero qué pasa si lo que hagamos depende de qué día de la semana es. Ahí
tenemos 7 opciones. Eso se representaría así:

SWITCH (diaDeLaSemana)
 Lunes: IrAlGimansio();
Martes: IrAlSupermercado();
Miércoles: IrALaPeluqueria();
Jueves: IrAlGimansio();
Viernes: SalidaConAmigos();
Sabado: SalidaConPareja();
Domingo: AsadoFamiliar();

End switch;

Claro que esto también podría resolverse con muchos IF anidados pero sería demasiado engorroso. 

Estructuras cíclicas
Estas son las que se utilizan para repetir un determinado conjunto de acciones. La primera de ellas es el WHILE

While (condición) do

Accion1;

Accion2;

End while

Por ejemplo: 

Ingresar(Edad);
 Mientras Edad >= 18 do

MostrarEnPantalla(“Acceso autorizado”);

Ingresar(Edad);

End while

Mientras que la edad que se ingrese sea mayor o igual a 18 años, se mostrará por pantalla un mensaje de Acceso Autorizado y se
volverá a pedir que ingrese otra edad. Cuando se ingrese una edad menor a 18 años, se cortará el ciclo.

La otra estructura cíclica es el REPEAT. En este caso la secuencia de control está al final por lo que la secuencia de control se ejecuta
siempre (por lo menos una vez). Esto no ocurría en el WHILE ya que, si la condición no se cumplía, no ingresaba ni una vez a ejecutar
su contenido. La estructura es:

REPEAT

Accion1;

Accion2;

Until (condicion);

Espacio

Volviendo al ejemplo anterior: 

Edad:= 18;
 Repeat

MostrarEnPantalla(“Acceso autorizado”);

Ingresar(Edad);

Until (edad < 18);

Es decir, el While itera mientras que la condición sea verdadera y el Repeat itera hasta que la condición sea verdadera.

Hay otra forma de iterar que es a través del FOR que permite iterar una cierta cantidad de veces. Por ejemplo, si queremos pedir 5
edades sería:

I:= 1;

For i:= 1 to 5 do

Ingresar(FechaDeNacimiento);

Edad:= Calcular(FechaDeNacimiento);

MostrarEdadEnPantalla(“Usted tiene ”,edad,” años”);

I:= i+1;

End for

Por último, repasemos las variables y estructuras de datos.

Variables, constantes y estructuras de datos
Variables y constantes
Las variables y constantes son espacios de memoria que contienen determinada información. En el caso de las constantes, esa
información no cambia durante la ejecución del sistema. En el caso de las variables sí, se pueden modificar en tiempo de ejecución.
Estas variables pueden ser globales o locales. La diferencia radica en su ámbito de acción. La variable local es aquella que se utiliza
solamente en el código de ese módulo o función. La variable global tiene por ámbito de acción la totalidad del programa.

Estructuras de datos
Las estructuras más conocidas con las que solemos manejarnos en este paradigma son:

 Arreglos o vectores: conjunto de datos del mismo tipo a las que se accede a través de un subíndice. Son estáticos (tienen reservado el
espacio en memoria). Por ejemplo: Vector[i].
 Matrices: son arreglos multidimensionales a los que se accede a través de n subíndices. También son estáticos. Por ejemplo: Celda[i][j]
 Registros: a diferencia de los anteriores nos permiten combinar diferentes tipos de datos. Por ejemplo:

Tipo Persona := Registro

Nombre: string;
Documento: integer;
Edad: integer;
Sexo: boolean;

End registro.

 Archivos: conjunto de registros de la misma naturaleza. 

 Listas o colas: estructuras dinámicas de datos.

Recursividad
La recursividad es la propiedad mediante la cual un subprograma o rutina puede llamarse a sí mismo para realizar una tarea. A pesar de
que resulta muy útil, no todos los lenguajes admiten hacer uso de esta propiedad. El ejemplo clásico del uso de esta propiedad es el
factorial. El factorial de un número (se simboliza n!) es:

n!=n*(n-1)*(n-2)*(n.-3)*(n-4)… siempre que n>0 o

n!=1 en caso que N=0

Para simplificar esa fórmula podemos decir que el factorial se define de esta forma:

n!= n*(n-1)! Siempre que n>0 o

n!=1 en caso que N=0

Esta última es la definición recursiva del factorial.

Por ejemplo:

0! = 1
1!= 1*0! = 1*1= 1
2! = 2*1! = 2 * 1 = 2
3! = 3*2!= 3*2= 6
4!=4*3!=4*6= 24

Y así sucesivamente. De la misma forma que definimos el factorial de dos maneras (recursiva y no recursiva), en código lo podemos
implementar igual, de una forma recursiva o no recursiva:

Función no recursiva o iterativa

function factorial(n:word):word;
 var i,aux:word;

begin

aux:=1;

for i:=1 to n do aux:=i*aux;

factorial:=aux

end; 

Función recursiva
function factorial(n:word):word;

begin

if n>0 then factorial:=n*factorial(n-1)

else factorial:=1

end;

Hasta acá fue un repaso del paradigma estructurado. Veamos un ejemplo integrador de todos estos conceptos:

Ejemplo integrador de todos los conceptos.

 Necesitamos crear un sistema que nos ayude en la gestión de los almuerzos de los eventos que organizamos.

El sistema requerirá la fecha del evento, la cantidad de asistentes y el lugar donde se debe preparar el mismo. Se sabe que:

 Por cada 3 asistentes se pide 1 ensalada porque no todos comen. 

 Por cada asistente se piden 3 empanadas. 
 Por cada 2 asistentes se pide 1 ensalada de frutas de postre. 
 Por cada asistente se pide una botellita de agua. 
 La mitad de las empanadas se pide de carne, el resto, de jamón y queso.

Realizar un programa que gestione esto y al finalizar muestre por pantalla el pedido de esta manera:

Para el evento del día 22/03/2018 se requieren:

3 ensaladas,

15 empanadas de jamón y queso, 15 de carne,

10 botellitas de agua y

5 ensaladas de frutas

en Int. Witcomb 2281, 3 A. Sala de reuniones azul.

Presione 1 para registrar otro pedido o 0 para finalizar.

Vamos a hacer un programa modular. Si lo pensamos a grandes rasgos los pasos que deberíamos hacer son: 

1. Inicializar las contantes

2. Pedir lo datos del evento
3. Hacer el cálculo del catering
4. Informarlo
5. Preguntar si se desea ingresar otro evento
6. En caso afirmativo, repetir los pasos anteriores.

Gráficamente en un diagrama de flujo se vería así: 

 Fuente: de elaboración propia.

Pasemos a ver qué es lo que hay que hacer en cada módulo: 

Material de lectura
 (UTN-FRM). Programación estructurada.

García-Beltrán, Jaén, J. A. y Martínez, R. (2008) Fundamentos de programación.

Capítulo 7: Procedimientos y funciones .

Repasamos los conceptos más importantes del Paradigma

 
Estructurado.
 3.2 Reflexión
Página web

Para seguir pensando

Se requiere el desarrollo de un sistema para los docentes de Escuelas Técnicas que reciba el nombre y apellido de los
alumnos de un curso con dos calificaciones obtenidas por ellos en diferentes instancias de evaluación (por ejemplo: Juan
Pérez 8 y 9) y luego devuelva un listado con el nombre, apellido, el promedio de sus notas y un texto de referencia. De
acuerdo al promedio de las notas se calcula el texto de referencia según la siguiente tabla:

  
A partir de esto los invitamos a pensar, ¿Cómo diseñar el algoritmo que permita resolver este problema representándolo
en un diagrama de flujo?

Sugerimos proponer a los alumnos que se distribuyan en grupos de no más de 4 personas que lo resuelvan a través de
un diagrama de flujo.

Luego de corregir las soluciones propuestas, hacer un análisis de los errores comunes que aparecieron.

Las siguientes preguntas nos ayudan a reflexionar sobre la propia práctica:

-¿Cuáles fueron los errores comunes que aparecieron?

-¿Qué recuperas de esta experiencia?

-¿Qué cambiarías para tus futuras prácticas con los/las estudiantes de la ETP?

A través de la actividad diseñamos el algoritmo que permita resolver el problema representándolo en un diagrama de flujo.
 
Actividad optativa.