323-22953055-Cuberos-Roberto-Computación

Vista previa del material en texto

UNIVERSIDAD NACIONAL 
ABIERTA VICERRECTORADO 
ACADÉMICO AREA: 
INGENIERÍA 
 
TRABAJO PRÁCTICO 
N°1 
ASIGNATURA: 
COMPUTACIÓN I 
CÓDIGO: 323 
FECHA DE ENTREGA AL ESTUDIANTE: En las primeras semanas de inicio del 
semestre. 
 
FECHA DE DEVOLUCIÓN POR PARTE DEL ESTUDIANTE: 
Hasta el día 23/10/2021 para su realización y envío, 
siNprorroga. 
 NOMBRE DEL ESTUDIANTE: Roberto Jesús Cuberos 
CÉDULA DE IDENTIDAD: V-22953055 
 
CORREO ELECTRÓNICO DEL 
ESTUDIANTE:robertocuberos@gmail.
com 
TELEFONO: 04127799607 
CENTRO LOCAL: Aragua 
CARRERA: 237 
 LAPSO ACADÉMICO: 2021-2 
NUMERO DE ORIGINALES:1 
 
FIRMA DEL ESTUDIANTE: Roberto Cuberos 
 
 
mailto:robertocuberos@gmail.com
mailto:robertocuberos@gmail.com
 
INDICE 
 
INTRODUCCIÓN ............................................................................................................................. 3 
Objetivo II.2................................................................................................................................... 4 
ETAPA 1 El Dialogo ........................................................................................................................ 4 
ETAPA 2 Especificaciones .............................................................................................................. 4 
ETAPA 3: La Partición .................................................................................................................... 5 
ETAPA 4: Definición de Abstracciones ........................................................................................... 6 
ETAPA 5: Codificación.................................................................................................................... 7 
ETAPA 6: Prueba y verificación ...................................................................................................... 7 
ETAPA 7: Presentación .................................................................................................................. 7 
Objetivo II.4................................................................................................................................. 17 
CONCLUSIÓN ............................................................................................................................... 21 
BIBLIOGRAFÍA.............................................................................................................................. 22 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
INTRODUCCIÓN 
 
 El uso de software informática se convierte en una de las cosas de alta demanda 
que se pueden encontrar hoy en día en las organizaciones. Muchos de los problemas en 
cuanto al manejo de la información se pueden resolver con el desarrollo de software que 
permite simplificar cada uno de los procesos que se necesitan hoy en día para realizar las 
actividades en un determinado departamento. 
 En el caso del Instituto Venezolano de los Seguros Sociales se caracteriza por ser 
una de las instituciones de alta importancia para las personas jubiladas que han dedicado 
sus años de servicios en diferentes empresas en el país. Para el IVSS poder llevar el control 
en cuanto a las personas que les corresponde una jubilación muchas veces puede ser algo 
tedioso en especial cuando se lleva el proceso manual o usando software de terceros que 
no se adaptan a los requerimientos o necesidades como es el caso de ingresar datos en un 
sistema para ser luego procesados y otorgar tanto si corresponde la jubilación o no. 
 Para el presente trabajo practico se desarrolló un programa usando el lenguaje de 
programación Pascal que tiene el propósito de poder determinar el tipo de jubilación que 
corresponde una persona ingresando datos principales de los jubilados que serán 
almacenados y organizados de acuerdo al mes que corresponda el tiempo reglamentario 
de acuerdo a la ley vigente sobre la jubilación. 
 Este software fue desarrollado aplicando el método MAPS la cual se encarga de 
sistematizar cada uno de los pasos para llegar al diseño final del programa. De la misma 
manera el mismo se busca que sea ligero e intuitivo de forma que el personal que lo pueda 
usar no tenga inconvenientes de usos y pueda manejar su productividad de forma 
significativa. 
 
 
 
 
 
 
 
Objetivo II.2 Resuelva el problema planteado algorítmicamente usando la metodología 
MAPS, a fin de facilitar la conceptualización, diseño, planificación, ejecución de la solución 
solicitada. 
La metodología MAPS cuyas siglas en inglesas significan traducidas al castellano 
Metodología para Solventar Problemas Algorítmicos, la cual involucra una serie de etapas 
las cuales son: 
 Dialogo. 
 Especificaciones. 
 Subdivisión. 
 Definición de abstracciones. 
 Codificación. 
 Prueba y Verificación. 
 Presentación. 
ETAPA 1 El Dialogo 
 
 Se realizo la consulta de fuentes bibliográficas y audiovisuales de manera 
que se pueda entender el desarrollo de este tipo de software, así como el respectivo 
análisis de los criterios que deben ser tomado en cuanto para dar solución a los 
requerimientos del problema planteado acerca del IVSS. 
Definición del problema: el IVSS necesita desarrollar un software que permita 
clasificar a los jubilados de acuerdo a la edad y años de servicios, el mismo debe 
generar un reporte con datos básicos de cada persona que sería candidato para la 
jubilación correspondiente y el mismo software debe determinar si cumplen con la 
condición para jubilarse, posterior a esto registrar datos y mostrar el reporte de cada 
uno de los datos ingresados. 
ETAPA 2 Especificaciones 
 
Datos de Entrada: Se debe tomar como entrada los siguientes: 
 Edad de la persona que corresponde jubilarse. 
 Años de Antigüedad. 
Si los datos ingresados se adaptan a los parámetros establecidos que 
corresponden a una persona una jubilación se ingresan los siguientes datos: 
 Cedula de Identidad. 
 Nombres. 
 Apellidos. 
 Edad. 
 Mes. 
 Fecha de Nacimiento. 
 
Proceso: los datos ingresados deben ser validados de manera que se graban 
aquellos que cumplan los criterios preestablecidos. Se diseñará en el lenguaje de 
programación Pascal haciendo uso de arreglos de registros y los mismos muestren 
en este caso los reportes que solicita el planteamiento planteado. 
Datos de Salida: este mostrara de forma previa: 
 Cuenta con un menú donde se podrá realizar las siguientes funciones como crear 
un registro, ver un registro y mostrar un reporte. 
 En el reporte se mostrará los siguiente: 
 Se muestran cada una de las edades de jubilación la cual están organizadas para 
cada el mes correspondiente donde se mostrarán los registros. En este caso enero 
corresponde a jubilación por edad, mayo jubilación por antigüedad joven y 
diciembre jubilación por antigüedad adulta. 
 En cuanto a los datos se mostrarán los solicitados previamente al crear el registro 
y van en el siguiente orden mes de jubilación, apellidos, nombres, cedula de 
identidad y la edad. 
De esta forma se muestran cada uno de los datos organizados en sus respectivos campos 
la cual se pueda visualizar y obtener en simples pasos facilitando muchos procesos para el 
IVSS en cuanto a determinar tanto a las personas que tienen una jubilación y los respectivos 
datos. 
ETAPA 3: La Partición 
 
 La solución de este problema se puede resolver con la implementación de un menú 
principal. 
 
 Cada uno de estas opciones están diseñados en base a los procedimientos la cual 
parte de la programación estructurada. 
1. Crear registro: en este caso es uno de las primeras opciones que se deben usar 
cuando no se ha ingresado datos previamente o simplemente se busca ingresas a 
nuevos jubilados. Esta pregunta los datos como es la edad y la antigüedad la cual 
se utilizan como para parámetro previo para poder verificar utilizando condicionales 
si realmente corresponde a una persona que debe jubilarsey agregarlo de acuerdo 
al tipo de jubilación. Al colocar los datos como es la edad y la antigüedad los valores 
no pueden ser menores de cero de forma que si fuese el caso se puede repetir otra 
vez la pregunta hasta que se cumpla la condición y se realice el registro con los 
respectivos campos. 
2. Ver un registro: se utiliza para poder verificar si existe una persona registrada en 
el programa la cual el parámetro que utiliza para poder verificar de una forma rápida 
es la cedula de identidad. 
3. Mostrar reporte: en este caso muestra todos los jubilados de acuerdo al tipo de 
jubilación la cual se pueden encontrar todos los datos que incluyen apellidos, 
nombres, cedula de identidad, fecha de nacimiento y edad. 
4. Salir: se encarga de ofrecer la posibilidad de cerrar el programa sino se realizará 
ninguna acción en particular. 
ETAPA 4: Definición de Abstracciones 
 
Para el lenguaje de programación Pascal se aplicaron los siguientes comandos: 
 Lectura (read, readln) y escritura (write, writeln) de datos. 
 Limpieza de pantalla (clrscrc), leer una tecla cualquiera (readkey). 
 Ciclos repetitivos como es caso de ( for…to..do) donde la variable se caracteriza por 
tener un incremento de forma automática. 
 Ciclos repetitivos (repeat … until) la cual se aplica como una forma de poder colocar 
datos que sean válidos para poder continuar con un proceso como es caso a la hora 
de verificar si una persona le corresponde una jubilación o los datos numéricos como 
es caso de la edad y antigüedad no sean menores que cero. También se suele 
combinar con indicadores boleanos verdaderos o falsos que son los que 
determinaran si el dato ingresado es correcto o no. 
 Ciclos selectivos como es el caso de si_entonces_si_ no (if…then…else) la 
condicional es una de las formas lógicas que se aplica de forma habitual en cada 
programa. La cual se entiende que si una condición es verdadera corresponde una 
acción, muestra un mensaje o permite realizar una acción en particular. 
 Ciclos selectivos como En_caso_de_Hacer (case…of...do) se utilizó para poder ser 
usado en la construcción de menú y de acciones como presionar una tecla para 
continuar. 
 Funciones: se utilizan para poder realizar acciones que se ejecutan de forma 
constante en este caso para guardar datos de todo lo que cumpla con las 
condiciones previas se registrara y guardara de forma adecuada. 
ETAPA 5: Codificación 
 
Corresponde al objetivo Objetivo II.3 
ETAPA 6: Prueba y verificación 
 
Corresponde al objetivo Objetivo II.4 
ETAPA 7: Presentación 
Programa Jubilación_IVSS 
Comenzar 
Asignar valores Tipo 
Edad: como entero 
Apellido: como carácter 
Nombre: como carácter 
Nacimiento: como carácter 
Fin. 
Constante. 
Jubilación: array [1..3] de string = (“Jubilación por edad”, “Jubilación por 
antigüedad joven”, “Jubilación por antigüedad adulta”); 
Variable 
Datos para registrar; 
l: archivo registro; 
Procedimientos Guardar Registro; 
Comenzar 
Asignar (l, “datos.da”); 
 Resetear (l); 
Si resultado <> 0 entonces 
Comenzar 
Reescribir (l); 
Var (l,0); 
Escribir (l,datos); 
Cerrar (l); 
Fin 
Además 
Comenzar 
Var (l, tamaño archivo (l)); 
Escribir (l, datos); 
Cerrar (l); 
Fin; 
 Fin; 
 Procedimiento Cargas registro 
Variable 
rec: entero 
rp: entero 
Comenzar 
Asignar (l, “datos.dad”); 
 Resetear(l); 
Si ioresultal <> 0 entonces 
Comenzar 
Escribir (“Este archivo tiene un error presiona una tecla para continuar”) 
Leer tecla; 
Salir; 
 Además 
 Comenzar 
Para rp: = 1 hasta longitud (cedu) 
Hacer 
Cedu [rp]: = Letra en Mayúscula (cedu [rp]); 
Para rec: = 0 hasta tamaño (l) -1 
 Hacer 
Comenzar 
Variable (l,rec) 
Leer (l,datos); 
 Para rp:= 1 hasta longitud (datos.cedula) hacer 
Datos.cedula [rp]: = Mayúscula (Datos.cedula [rp]); 
Si datos.cedula = cedu entonces 
Comenzar 
Limpiar 
Escribir (“Cargar registros”); 
Escribir (“Edad:”, datos.edad); 
Escribir(“Mes: ”, datos.mes); 
Escribir (“Apellido: ”, datos.apellido); 
Escribir (“Cedula: ” datos.cedula); 
Escribir (“Entre edad: ”, leer(edad); 
Escribir; 
Escribir (“Entre antigüedad: “); leer antigüedad); 
 Si edad < 0 entonces 
Escribir (“La edad debe ser mayor o igual que 0”); leer antigüedad 
Si edad < 0 entonces 
Escribir (“La edad deber ser mayor o igual que 0”) 
Si antiguedad < 0 
Escribir (“La antigüedad debe ser mayor o igual que 0”); 
Si (edad >=60) y (antigüedad<25) entonces 
Escribir (“Corresponde a jubilación por edad”) 
Entonces 
So (edad<60) y (antigüedad>= 25) entonces 
Escribir (“Corresponde a jubilación por adulto”); 
Entonces 
Si (edad<60) y (antigüedad<25) entonces 
Escribir (“No le corresponde jubilarse”); 
Escribir; 
Escribir (“Presione f para continuar”); 
 Repetir 
Da: = Mayúscula (leer tecla); 
Hasta de en [“F”]; 
Si da = “F” entonces 
Fin; 
Comenzar 
Si (edad<60) y (antigüedad < 25) entonces 
Verificar asegurado; 
 Fin 
Fin; 
Procedimiento crear registro; 
 Variable 
da: carácter; 
comenzar 
Limpiar 
Escribir (Creación de Registro); 
Escribir; 
Escribir (“Ingrese cedula: ”); leer (datos.cedula); 
Escribir (“Ingrese Nombres: “); leer(datos.nombre); 
Escribir (“Ingrese apellidos: “); leer (datos.mes); 
Escribir (“Ingrese mes; “); leer (datos.mes); 
Escribir (“Ingrese fecha de Nacimiento”); leer (datos.nacimiento) 
Escribir; 
Escribir (“Datos correctos” [S,N, F=salir] 
 Repetir 
da:= mayúscula (leer tecla); 
hasta da en [“S”, “N”,” F”]; 
Si da = “F ” entonces 
Salir; 
Si da = “N” entonces 
Crea registro; 
Si da =” S” entonces 
Guarda registro; 
Fin 
Procedimiento muestra reporte; 
Variable 
Rp: entero 
m: entero 
 tt: carácter 
 Comenzar 
Limpiar; 
Escribir (“Reporte”); 
Escribir; 
Escribir;( “[E] = “, jubilación [1]); 
Escribir:( “[M] = “, jubilación [2]); 
Escribir:( “[D] = “, jubilación [3]); 
Escribir; 
Escribir (“Elige Reporte”); 
Repetir 
tt:= mayuscula(leer tecla); 
hasta en [“E”, “M”, “D”]< 
Caso tt de 
“E”: mes: = “enero”; 
“M”: mes: = “mayo”; 
“D”: mes: = “diciembre” 
 Fin; 
Función asignad (l, “datos.dat”); 
 Resetear(l); 
Si ioresultado <> 0 entonces 
Comenzar 
Escribir (“Error de archivo o no existe pulse una tecla”); 
Leer tecla; 
Salir; 
Fin. 
Además 
 Comenzar 
 Limpiar; 
Escribir(“Reporte”); 
Escribir(“Mes, apellidos, nombre, cedula, fecha de nacimiento”); 
Escribir; 
Para rp: = 0 hasta tamaño archivo (l) – 1 hacer 
Comenzar 
Ver (l, rp); 
Leer (l,datos); 
Para m:=1 hasta longitud(datos.mes) hacer 
Datos.mes[m]:= mayuscula(datos.mes[m]); 
Si datos.mes = mess entonces 
Comenzar 
Escribir (datos.mes, “ ”, datos.apellido, “ ”,datos.nombre, “ ”,datos.cedula, “ ”, 
datos.nacimiento, “ ”, datos.edad, “ ”); 
Fin 
Fin 
Cerrar (l); 
Fin; 
Escribir(“Pulse una tecla”); 
Leer tecla; 
Fin. 
Procedimiento Menu; 
Variable 
Tec: carácter; 
Sal: booleano; 
Ced: numero; 
 Comenzar; 
Sal:= falso; 
 Repetir; 
Limpiar; 
Escribir (“Escribir Jubilación IVSS V1.0)” 
Escribir; 
Escribir (“Menu principal”); 
Escribir(“´[C] = Crear registro”); 
Escribir(“[V]= Ver un Registro”); 
Escribir(“[M] = Mostrar Reporte”); 
Escribir(“[S] =Salir”); 
Escribir; 
Escribir (“Elija Operación”); 
Repetir 
Tec:= Mayuscula (leertecla); 
Hasta tec en [“C”, “V”, “M”, “S”]; 
Caso tec de 
“C”: comenzar 
 Verificar asegurado; 
Crea registro 
Fin; 
“V”; 
Comenzar 
Escribir(“Entre Cedula: ”); 
Leer (ced); 
Carga registro (ced); 
Fin; 
“M”: muestra Reporte; 
“S”: sol:= verdadero; 
Fin; 
Hasta sol = verdadero; 
Fin; 
 Comenzar 
Limpiar 
Menú. 
FIN. 
 
 
2. Objetivo II.3 después de haber aplicado cada una de las etapas de la metodología MAPS 
en el objetivo II.2, codifique el algoritmo en lenguaje PASCAL, a fin de obtener un programa 
estructurado que cumpla con los requerimientos especificados, aplicando tipo de datos y/o 
procedimientos y funciones y/o métodos de archivos, según se requiera. 
program jubilacion_ivss; 
 uses 
 crt; 
 type 
 string100 = string[100]; 
 registro = record 
 edad : integer; 
 mes : string[12]; 
 apellido : string100; 
 nombre : string100; 
 cedula : string100; 
 nacimiento : string;end; 
 
 const 
 jubilacion : array[1..3] of string[32] = ('JUBILACION POR EDAD', 
 'JUBILACION POR ANTIGUEDAD JOVEN','JUBILACION POR ANTIGUEDAD 
ADULTA'); 
 
 
 var 
 datos : registro; 
 l : file of registro; 
 
 
 procedure guarda_registro; 
 begin 
 assign(l,'datos.dat'); 
 {$I-} reset(l); {$I+} 
 if ioresult <> 0 then 
 begin 
 rewrite(l); 
 seek(l,0); 
 write(l,datos); 
 close(l); 
 end 
 else 
 begin 
 seek(l,filesize(l)); 
 write(l,datos); 
 close(l); 
 end; 
end; 
 
 
 procedure carga_registro(cedu : string100); 
 var 
 rec : longint; 
 rp : integer; 
 begin 
 assign(l,'datos.dat'); 
 {$I-} reset(l); {$I+} 
 if ioresult <> 0 then 
 begin 
 writeln('Este archivo tiene un error presiona una tecla para continuar'); 
 readkey; 
 exit; 
 end 
 else 
 begin 
 for rp := 1 to length(cedu) do 
 cedu[rp] := upcase(cedu[rp]); 
 for rec := 0 to filesize(l) - 1 do 
 begin 
 seek(l,rec); 
 read(l,datos); 
 for rp := 1 to length(datos.cedula) do 
 datos.cedula[rp] := upcase(datos.cedula[rp]); 
 if datos.cedula = cedu then 
 begin 
 clrscr; 
 writeln('********>Cargar Registros<********'); 
 writeln; 
 writeln('Edad : ',datos.edad); 
 writeln('Mes : ',datos.mes); 
 writeln('Apellido : ',datos.apellido); 
 writeln('Nombre : ',datos.nombre); 
 writeln('Cedula : ',datos.cedula); 
 writeln('Nacimiento : ',datos.nacimiento); 
 writeln; 
 writeln('Pulse Una Tecla'); 
 readkey; 
 break; 
 end; 
 end; 
 close(l); 
 end; 
 end; 
 
 procedure verificar_asegurado; 
 var 
 edad: integer; 
 antiguedad: integer; 
 da: char; 
 begin 
 begin 
 
 Repeat 
 clrscr; 
 writeln; 
 write('Entre Edad : ');readln(edad); 
 writeln; 
 write('Entre Antiguedad : '); readln(antiguedad); 
 if Edad<0 then 
 writeln('La edad debe ser mayor o igual que 0'); 
 if Antiguedad < 0 then 
 Writeln('La antiguedad debe ser mayor o igual que 0'); 
 until((Edad >= 0) and (Antiguedad >= 0)); 
 if (edad>=60) and (antiguedad<25) then 
 write ('Corresponde a jubilacion por edad') 
 
 else 
 if (edad<60) and (antiguedad>=25) then 
 write ('Corresponde a jubilacion por antiguedad joven') 
 
 else 
 if (edad >= 60) and (antiguedad >= 25) then 
 write ('Corresponde a jubilacion por adulto') 
 
 else 
 if (edad < 60) and (antiguedad < 25) then 
 write ('No le corresponde jubilarse'); 
 writeln; 
 write ('presione f para continuar'); 
 repeat 
 da := upcase(readkey); 
 until da in['F']; 
 if da = 'F' then 
 end; 
 begin 
 if (edad < 60) and (antiguedad < 25) then 
 verificar_asegurado; 
 end; 
 end; 
 
 procedure crea_registro; 
 
 var 
 da : char; 
 begin 
 clrscr; 
 writeln('******** Creacion De Registro ********'); 
 writeln; 
 write('Ingrese Cedula : ');readln(datos.cedula); 
 write('Ingrese Nombres : ');readln(datos.nombre); 
 write('Ingrese Apellidos : ');readln(datos.apellido); 
 write('Ingrese Edad : ');readln(datos.edad); 
 write('Ingrese Mes : ');readln(datos.mes); 
 write('Ingrese Fecha Nacimiento : ');readln(datos.nacimiento); 
 writeln; 
 write('((((((( Datos Correctos [S/N/F = Salir]'); 
 
 repeat 
 da := upcase(readkey); 
 until da in['S','N','F']; 
 if da = 'F' then 
 exit; 
 if da = 'N' then 
 crea_registro; 
 if da = 'S' then 
 guarda_registro; 
 end; 
 procedure muestra_reporte; 
 var 
 rp : longint; 
 m : integer; 
 mess : string[12]; 
 tt : char; 
 begin 
 clrscr; 
 writeln('************* Reporte *************'); 
 writeln; 
 writeln(' [E]= ',jubilacion[1]); 
 writeln(' [M]= ',jubilacion[2]); 
 writeln(' [D]= ',jubilacion[3]); 
 writeln; 
 writeln('Elije Reporte'); 
 repeat 
 tt := upcase(readkey); 
 until tt in['E','M','D']; 
 case tt of 
 'E' : mess := 'ENERO'; 
 'M' : mess := 'MAYO'; 
 'D' : mess := 'DICIEMBRE'; 
 end; 
 assign(l,'datos.dat'); 
 {$I-} reset(l); {$I+} 
 if ioresult <> 0 then 
 begin 
 writeln('Error de archivo o no existe pulse una tecla'); 
 readkey; 
 exit; 
 end 
 else 
 begin 
 clrscr; 
writeln('************************************Reporte***********************************************'); 
 
 writeln('Mes...........Apellidos...........Nombres...........Cedula...........Nacimiento...........
Edad'); 
 
 writeln; 
 
 for rp := 0 to filesize(l) - 1 do 
 begin 
 seek(l,rp); 
 read(l,datos); 
 for m := 1 to length(datos.mes) do 
 datos.mes[m] := upcase(datos.mes[m]); 
 if datos.mes = mess then 
 begin 
 writeln(datos.mes,'..........',datos.apellido,'.............',datos.nombre,'.......... ', 
 datos.cedula,'........ ',datos.nacimiento,'........... ',datos.edad); 
 end; 
 end; 
 close(l); 
 end; 
 writeln; 
 writeln('Pulse Una Tecla'); 
 readkey; 
 end; 
 
 procedure menu; 
 var 
 tec : char; 
 sal : boolean; 
 ced : string100; 
 begin 
 sal := false; 
 repeat 
 clrscr; 
 writeln('********> JUBILACION IVSS v1.0 <********'); 
 writeln; 
 writeln('***********> MENU PRINCIPAL <******<<*****'); 
 writeln(' [C] = Crear Registro'); 
 writeln(' [V] = Ver un Registro'); 
 writeln(' [M] = Mostrar Reporte'); 
 writeln(' [S] = Salir'); 
 writeln; 
 writeln(' Elija Opcion '); 
 repeat 
 tec := upcase(readkey); 
 until tec in['C','V','M','S']; 
 case tec of 
 'C' :begin 
 verificar_asegurado; 
 crea_registro; 
 
 end; 
 'V' : 
 begin 
 write('Entre Cedula : '); 
 readln(ced); 
 carga_registro(ced); 
 end; 
 'M' :muestra_reporte; 
 'S' : sal := true; 
 end; 
 until sal = true; 
 end; 
 begin 
 clrscr; 
 menu; 
 end. 
3.Objetivo II.4 Pruebe el algoritmo diseñado en el Objetivo II.3 usando el concepto de 
Robustez; se requiere que Ud. presente en el informe del trabajo, el algoritmo original, y el 
ajustado después de aplicarle la definición de la propiedad algorítmica mencionada. 
Un programa está desarrollado adecuadamente cuando cumple las condiciones 
necesarias en cuanto a los requerimientos previos y muestra como una salida o respuesta. 
Un programa es robusto cuando reúne unas condiciones específicas como es el caso de: 
 Es correcto. 
 Para todas las entradas que no satisfacen las precondiciones el programa termina 
y produce una salida y brinda la oportunidad al usuario de poder elegir una opción 
para realizar una corrección. 
En el caso del programa desarrollado para el IVSS uno de los primeros requisitos 
que se utiliza como parámetro es la edad de una persona y los años de antigüedad. 
Esto permite determinar en primer lugar que tipo de jubilación corresponde debido a 
que existen tres categorías y si no se cumplen ninguna de las condiciones simple brinda 
la opción de ingresar el dato correspondiente de la misma forma sucede que la edad y 
la antigüedad no deben ser valores negativos y deben ser números enteros. 
La validación de estos permite determinar si la persona es jubilada de forma que 
pueda proceder a cargar el registro de las personas. 
Para probar la robustez y el programa se utilizó la siguiente tabla de datos de 
personas que corresponde una jubilación la cual serán registradas con el programa 
IVSS. 
N° Nac Nombre y Apellidos Cedula Edad Antigüedad F. Nacimiento 
1 V MARJORIE BUSTAMENTE 6.084.495 65 30 2/12/1956 
2 V MIRIAN GARCIA 2.479.077 75 40 15/10/1946 
3 V JAVIER GOMEZ 6.875.894 65 30 2/11/1956 
4 V LUIS PEREZ 8.544.545 55 35 4/4/1966 
5 V MARIA GUTIERREZ 5.158.062 63 30 8/8/1958 
6 V JORGE LINERO 9.501.854 51 30 15/10/1970 
7 V ANDRES MARTINEZ 9.533.983 53 25 17/11/1968 
8 V JULIAN GOMOZ 7.990.610 54 35 28/10/1967 
9 V VICENTE GOMEZ 6.159.723 65 37 12/2/1956 
10 V GLORIA SABOGAL 6.901.665 55 29 18/12/1966 
 
Primero se crea el registro presionando la tecla “C” y se agrega a la persona la cual 
previamente se debe ingresar la edad y la antigüedad: 
 
Se ingresa la edad de la primera persona en la lista y la antiguedad 
 
 
Se ingresan los datos ya que la persona cumple las condiciones de que le corresponde un 
tipo de jubilación, en cuanto al mes para la jubilación por adulto corresponde el mes de 
diciembre. 
 
Se busca en el reporte de acuerdo al tipo de jubilaciónEn el reporte se muestran los datos introducidos brevemente de acuerdo a los 
requerimientos previos: 
 
De la misma manera sucede que se puede verificar un registro como en el siguiente: 
 
Se muestran estos datos guardados de forma previa 
 
 
 De esta forma se puede demostrar el funcionamiento del programa haciendo uso de 
cada una de las funciones que ofrece y cumpliendo los requerimientos que la empresa IVSS 
necesitaba. 
 
 
 
 
 
CONCLUSIÓN 
 
 El uso de la metodología MAPS se convierte en una de las cosas de alta importancia 
para poder determinar los pasos necesarios para la implementación de software en una 
organización. En este caso poder determinar los parámetros y necesidades previas son una 
de las etapas iniciales antes de desarrollar cualquier proyecto de forma que se pueden 
definir cada una de las etapas que se llevaran a cabo en cuanto al desarrollo del software 
en un determinado lenguaje de programación. 
 Al poder estar claro de todos los requerimientos tanto de entrada y salida se procedió 
a la creación del seudocódigo la cual es una de las cosas esenciales que se pueden tener 
previa antes de crear el código definitivo que dará la solución requerida para un cliente en 
particular. 
 A nivel de software el desarrollo debe cumplir el concepto de robustez, pero a la vez 
se debe tratar de un programa que sea intuitivo. La cual son aspectos que son tomados en 
cuanta y realmente también permite poder garantizar una eficiencia en cuanto a las 
operaciones a las cuales está destinado el desarrollo de un software. 
 Poder comprender tantos las etapas de análisis y desarrollo de software son 
esenciales para la formación de cualquier persona que este vinculado con el área de 
tecnología de información y comunicación. Así como también conocer todos aspectos se 
convierten en una parte introductoria para poder aprender habilidades para el desarrollo de 
software la cual son esenciales para solventar diversas necesidades tanto a nivel 
empresarial y necesidades a niveles individuales de personas que buscan llevar a cabo 
emprendimientos. 
 
 
 
 
 
 
 
 
 
BIBLIOGRAFÍA 
 
Aguilar, L. (2008). Fundamentos de Programación. Macgraw Hill. 
Https://drive.google.com/drive/folders/1bwdv7eomeharujhkg9mzmigh8gka8isz 
Tutorialesnet.(2021).Pascal.https://www.youtube.com/watch?V=twz1uonqdzc&list=PL8B7
62B052A22636C 
Torrealba, J. (2004). Computación I. Universidad Nacional Abierta. 
Https://drive.google.com/drive/folders/1bwdv7eomeharujhkg9mzmigh8gka8isz 
Zamantha González. (2021). Metodología para la Resolución de Problemas Algorítmicos. 
Https://www.youtube.com/watch?V=csweihh5pqe 
 
 
 
 
 
 
https://drive.google.com/drive/folders/1BWDv7eomEHArujhkg9MzMiGH8GKa8isz
https://www.youtube.com/watch?v=cswEiHH5pQE
	UNIVERSIDAD NACIONAL ABIERTA VICERRECTORADO ACADÉMICO AREA: INGENIERÍA
	INTRODUCCIÓN
	ETAPA 1 El Dialogo
	ETAPA 2 Especificaciones
	ETAPA 3: La Partición
	ETAPA 4: Definición de Abstracciones
	ETAPA 5: Codificación
	ETAPA 6: Prueba y verificación
	ETAPA 7: Presentación
	CONCLUSIÓN
	BIBLIOGRAFÍA