Este documento describe las estructuras básicas en Pseint como constantes, variables, acumuladores, contadores e identificadores. También explica qué son los diagramas de flujo y proporciona información sobre la historia y el creador de Pseint.

1. i
Estructuras básicas en Pseint
Dana Sofía Morales Rico
Haddy Andrés Ortiz Pedroza
Ana Sofía Ramírez Prieto
Laura Sofía Sepúlveda
Murillo
Área de Tecnología e Informática, I.E Liceo
Departamental Lic. Guillermo Mondragón
20 de octubre de 2020

2. ii
Tabla de Contenidos
¿Qué es Pseint?................................................................................................1
Sobre su historia y creador.......................................................................... 4
¿Qué son los diagramas de flujo?....................................................................6
Constantes…………………………………………………………………7
Variables…………………………………………………………………..8
Acumuladores...……………………………………………………………9
Contadores..................................................................................................10
Identificadores……………………………………………………………11
Función de los comandos ..............................................................................12
Según……………………………………..………………………………12
Mientras......................................................................................................13
Repetir……………………………………………………………………14
Para……………………………………………………………………….15
Función……………………………………………………………………16
Conclusión.....................................................................................................17
Webgrafía ...................................................................................................... 18
Anexos............................................................................................................19

3. 1
(Imagen 1). PSEINTseint.PNG. [Figura]. Recuperado de: https://temarioanacleto2.es.tl/PSeint.htm
1
¿Qué es Pseint?
Es una software con licencia libre GPL (por sus siglas en inglés: General
Public License) diseñado para ayudar a los estudiantes que hacen sus
primeros pinitos en el mundo de la programación ya que les permite
desarrollar el aprendizaje de los conceptos fundamentales del pensamiento
algorítmico computacional mediante un simple e intuitivo pseudo-lenguaje
en español que minimiza las dificultades propias del lenguaje de
programación real y la complejidad de aprender y pensar en otro idioma,
como pasa con la mayoría de programas que están en inglés (C++, C#, Java,
JavaScript, MatLab, Pascal, PHP, Python, entre otros).
Imagen 1
Pseint proporciona un entorno de trabajo con numerosas ayudas y recursos
didácticos además de un editor de diagramas de flujo donde se pueden
visualizar los algoritmos que se van construyendo. En otras palabras, con esta
herramienta nos podemos instruir en conceptos básicos como el uso de
estructuras de control, expresiones, variables y demás, sin tener que lidiar con
las particularidades de la sintaxis de un lenguaje real.

4. 4
(Imagen 2). psint.jpeg. [Figura]. Recuperado de: https://diocesanos.es/blogs/equipotic/2020/01/10/pseint-un-
interprete-de-pseudocodigo-para-aprender-fundamentos-de-programacion/
4
(Imagen 2). psint.jpeg. [Figura]. Recuperado de: https://diocesanos.es/blogs/equipotic/2020/01/10/pseint-un-
interprete-de-pseudocodigo-para-aprender-fundamentos-de-programacion/
2
Por la manera en la que este software está dispuesto podemos establecer que su
objetivo es facilitar la tarea de escribir algoritmos.
Imagen 2
Algunas de sus características son:
➢ El pseudocódigo es configurable.
➢ Permite generar y editar diagramas de flujo.
➢ Permite la edición simultánea de múltiples algoritmos por medio de
pestañas.
➢ Puede interpretar los algoritmos escritos.
➢ Permite la conversión de este código a diferentes lenguajes de
programación.
➢ Ofrece un sistema de ayuda integrada acerca del pseudocódigo y uso del
programa (ayudas para la escritura, auto completado, plantillas de
comandos, coloreado de sintaxis, intervalos inteligentes, entre otros).
➢ Es multiplataforma (compatible con Windows, Linux, MAC).

5. (Imagen 3). año-bisiesto-en-pseint.jpg. [Figura]. Recuperado de:
https://pseudocodigoejemplos.com/ano-bisiesto-en-pseint/
3
PSeInt de PSeudo Intérprete es uno de los software más populares de su tipo,
ampliamente utilizado en universidades de Latinoamérica y España.
Utiliza las convenciones estructurales de un lenguaje de programación real,
pero está diseñado para la lectura humana y tiene independencia de cualquier
otro lenguaje de programación. El pseudocódigo omite detalles que no son
esenciales para la comprensión humana del algoritmo, como declaraciones de
variables y código específico del sistema. Se complementa, donde sea
necesario, con descripciones detalladas en lenguaje natural, o con notación
matemática compacta. El pseudo código es usado en la planificación del
desarrollo de programas informáticos, para esbozar la estructura del programa
antes de realizar la efectiva codificación.
Imagen 3
No existe una sintaxis estándar para el pseudocódigo, aunque los ocho
IDE's que manejan pseudocódigo tengan su sintaxis propia. Aunque sea
parecido, el pseudocódigo no debe confundirse con los programas
esqueleto que incluyen código ficticio, que pueden ser compilados sin
errores. Los diagramas de flujo y UML pueden ser considerados como
una alternativa gráfica al pseudocódigo.

6. 6
(Imagen 4). pablo-novara-2_vga.JPG. [Fotografía]. Recuperado de:
https://www.unl.edu.ar/noticias/news/view/premian_a_docente_de_la_fich_por_un_desarrollo_de_software_libre_1
4
Sobre su historia y creador
El software comenzó a desarrollarse en octubre de 2003 por Pablo Novara
utilizando Borland C++ Builder porque esta era la herramienta que
recomendaba la cátedra (debido a la facilidad que brinda para el desarrollo de
interfaces visuales).
Pablo comenzó con una prueba de concepto siendo este su primer proyecto a
desarrollar con C++. A esta inexperiencia con el lenguaje se le atribuyen
algunos errores de diseño y muchas ineficiencias en la implementación que con
el tiempo corrigió. Al ser un software para uso exclusivamente didáctico, no
tenía grandes problemas de rendimiento ya que los datos a interpretar no eran
algoritmos de miles de líneas sumamente complejos, por lo que pudo tomarse
ciertas libertades en la implementación.
No sólo se preocupó de la interpretación sino también por señalar los errores de
uno código incorrecto. La versión original presentada el 29 de diciembre del
mismo año, tenía cientos de errores latentes, sólo corría bajo Windows y se
limitaba a interpretar el algoritmo o marcar sus errores de sintaxis.
Imagen 4

7. 5
A continuación, el desarrollo de este proyecto contado desde la perspectiva
misma del creador:
“Uno de los primeros pasos fue crear el proyecto en SourceForge y publicar así
el software bajo la Licencia Pública General (GPL). El siguiente paso fue
comenzar a portarlo al sistema operativo GNU/Linux. El intérprete
propiamente dicho estaba escrito mayormente en ANSI/ISO C++ por lo que no
presentó mayores dificultades, pero la interfaz gráfica debió desarrollarse desde
cero, eligiéndose para tal fin la libreríaGTK+ por estar presente en la mayoría
de las distribuciones de Linux y tener yo alguna experiencia en la utilización de
la misma. Finalmente, el día de la presentación del CD, viajé con algunos de
los responsables del mismo a Buenos Aires, y conocí personalmente a Patricia
Chechele, una de las testers oficiales de la recopilación y profesora de
informática, quien además de demostrar gran simpatía por el intérprete, más
tarde aportaría numerosos reportes de bugs y sugerencias de gran utilidad.
Luego de esto, sobrevino una etapa de corrección de errores sin grandes
avances, hasta que en mayo de 2006 comencé a desempeñarme como ayudante
de cátedra de Fundamentos de Programación y Programación Orientada a
Objetos en la UNL, comenzando primero como pasante, y luego, en agosto del
mismo año, asumiendo el cargo interino luego de concursar por el mismo. Esta
posición me permitió observar a los alumnos utilizando el software, encontrar y
corregir errores, y realizar ciertas observaciones que derivaron en la
implementación de las características de Ayuda Rápida y Diagrama de Flujo.
Finalmente, en octubre de 2006, presenté el trabajo Desarrollo de un Software
Intérprete de Pseudocódigo para la Enseñanza de Fundamentos de
Programación en el 1er Encuentro de Jóvenes Investigadores de Universidades
de Santa Fe”.

8. 6
(Imagen 5). 1.png. [Figura]. Recuperado de: https://eportafolioprogra.blogspot.com/2015/09/
6
(Imagen 5). 1.png. [Figura]. Recuperado de: https://eportafolioprogra.blogspot.com/2015/09/
6
¿Qué son los Diagramas de flujo?
Son diagramas que describen un proceso o un algoritmo, representando de
manera más detallada el paso a paso que involucra un determinado proceso
desde su inicio hasta su fin. Los diagramas de flujo son múltiples y diversos y
pueden abordar muchos temas distintos de formas muy diferentes. En cualquier
caso, el aspecto en común entre ellos es la presencia de un vínculo entre los
conceptos y una relación entre las ideas.
Esta herramienta permite la comprensión de los algoritmos ya que el estudiante
puede visualizar el algoritmo que acaba de construir mediante el diagrama de
flujo que el software genera por defecto a partir de lo que haya escrito, o bien,
puede ver cómo es la estructura algorítmica del diagrama de flujo que acaba de
realizar.
Imagen 5

9. 7
7
(Imagen 6 y 7). Constantes en PseInt. [Figura]. Recuperadas de
https://www.youtube.com/watch?v=LFGmC_S-7d4
Ahora veamos algunos conceptos básicos:
Constantes
Es un valor que no se puede modificar durante la ejecución de un programa,
únicamente puede ser leído, por que permanece sin cambios durante todo el
desarrollo del algoritmo. Por ejemplo: el numero Pi, el IVA, la fecha de
cumpleaños de alguien, su cédula (número de identificación) etc.
Una constante corresponde a una área reservada en la memoria principal del
ordenador, donde el programa almacena valores fijos. Veamos un ejemplo
donde Pi está como constante:
Imagen 6
Imagen 7

10. 8
Variables
Elementos cuyo valor puede cambiar durante la ejecución del algoritmo.
Al igual que las constantes, las variables están en un área reservada en la
memoria principal del ordenador. En las variables numéricas, puede contener
un número real o entero.
Dicho de otra manera, una variable es un objeto en el que su contenido puede
variar durante el proceso de ejecución del algoritmo, se identifican por un
nombre y su tipo de valores que puede contener para realizar un uso correcto.
Por ejemplo: acumulación de una suma, realizar una cuenta, etc.
Vamos a ver un simple ejemplo donde manipularemos tres variables.
1
2
3
4
5
Inicio
A<-5
B<-3
C<-A+B
Fin
Si mostráramos el resultado de C, sería 8, ya que sumamos el valor de A que
vale 5 y el valor de B que vale 3.
Una variable también puede guardar cadenas de texto (se indica encerrando el
texto entre comillas), booleanos o un valor que el usuario teclee. ¿Pero qué es
un booleano? Es un tipo de dato que solo puede almacenar dos valores, true o
false, son muy usados para poner condiciones en estructuras de control, como
interruptores. Algo muy recomendable a la hora de programar es llamar a las
variables por un nombre significativo sobre lo que contenga para mejorar su
legibilidad. Por ejemplo, si queremos almacenar un día del mes, esa variable se
puede llamar día o si queremos almacenar el total de un producto, podemos
usar precio_final. Es recomendable no dejar espacios en blanco e inicializar
las variables que no tiene que ser introducidas por el usuario, también ser
inicializada en 0.

11. 9
(Imagen 8). Contadores y Acumuladores en PseInt. [Figura]. Recuperado de
https://www.youtube.com/watch?v=EMvidaEOrkc
Acumuladores
Es una variable que aumenta sobre sí misma un conjunto de valores, de esta
manera se pueda obtener la suma de todos ellos en una sola variable.
Acumulador = Acumulador + Variable
Son utilizados para acumular resultados parciales de cálculos con una misma
operación. Consta de dos procesos:
Inicialización, debe ser inicializado con un valor neutro según el tipo de
operación que realicemos, si es una suma se inicializará en 0 y si es un
producto se inicializará en 1.
Acumulación, realiza la acumulación con estas expresiones según el tipo de
operación:
acumulador <- acumulador+variable o acumulador <- acumulador*variable
Imagen 8
Los acumuladores de diferencian de los contadores porque aumentan en una
cantidad variable, mientras que el contador aumenta de uno en uno.

12. 10
10
(Imagen 9). laVariableContadorPseintExec.jpg. [Figura]. Recuperado de https://tutorias.co/ciclo-
para-pseint-la-variable-contador/
Contadores
Un contador es una variable cuyo valor se incrementa o disminuye en una
cantidad constante cada vez que se produce un determinado suceso o
acción.
Contador = contador + constante
Sirven para contar cualquier suceso o acción interna que se necesite dentro
de un programa. Se desarrolla en dos fases:
Inicialización, se inicia en 0 si realiza una cuenta natural o desde un valor
inicial, si queremos realizar otro tipo de cuenta.
Incremento, aumenta el valor de la variable en 1 si es una cuenta natural o
con otro valor, si se desea realizar otro tipo de cuenta. La expresión que se
utiliza para la variable es:
contador <- contador + constante
No debemos olvidar que “contador” es el nombre que le hemos dado a una
variable, la constante puede ser 1 o cualquier número que se desee. Este es
un ejemplo de ciclo para la variable contador:
Imagen 9

13. 8
(Imagen 10). ComandosPseint.PNG. [Figura]. Recuperado de
https://temarioanacleto2.es.tl/PSeint.htm
11
Identificadores
Son los nombres que se les da a los elementos utilizados para solucionar
un problema y para lograr diferenciar unos de otros. Al asignar nombres a
variables, constantes, procedimiento o programa.
La escritura de un identificador tiene reglas, las cuales deben aplicarse
siempre en el momento de crear alguno de los elementos descritos.
Actualmente se recomienda utilizar el convenio Camelize según el cual,
cuando un identificador está formado por dos o más palabras en lugar de
utilizar el guion bajo (_), se debe iniciar cada palabra con letra mayúscula.
Tampoco se debe usa la (ñ) o la tilde (´) ya que son caracteres no legibles y
difíciles de traducir en algunos programas. También es muy recomendable
que los identificadores sean claros y correspondan a la información que
tendrán asignada.
Estos identificadores van de la mano con las palabras reservadas o acciones
secuenciales:
Nos permite mostrar en pantalla algún tipo de dato, o varios
separados por una coma (,) y esos datos deben estar entre
comillas, así: Escribir "hola mundo"
Nos permite recibir valores por teclado y guardarlos en
variables, así: Leer a; //recibe el valor y lo almacena en a
Nos permite guardar un valor en una variable, así:
c <-2; por lo tanto c=2 (c tiene el valor dos), que es lo
mismo decir c tiene el valor 2
También encontramos la acción selectiva o interrogativa
Imagen 10

14. 12
(Imagen 11). pseint05a.png. [Figura]. Recuperado de
https://www.aprendeaprogramar.com/cursos/verApartado.php?id=2005
12
Función de los comandos
Estas son las acciones repetitivas o interactivas:
Según
El comando Según nos sirve para cuando se elija una variable en una acción
programada dependientes de aquella. Nos permite evaluar la propiedad de una
variable, y después de comparar una a una las salidas con la evaluación,
realizar la acción determinada. Se usa de esta manera:
Segun num_dia_sem Hacer
1: Escribir "Lunes";
2: Escribir "Martes";
3: Escribir "Miércoles";
4: Escribir "Jueves";
5: Escribir "Viernes";
6: Escribir "Sábado";
7: Escribir "Domingo";
De Otro Modo:
Escribir "No es un día de la semana";
FinSegun
Imagen 11

15. (Imagen 12 y 13). Pseint 2020 | Ciclos. [Figura]. Recuperado de
https://www.youtube.com/watch?v=Mabj-CYJ6GQ
13
Mientras
El comando Mientras nos sirve para repetir un proceso
infinitas veces hasta que la condición programada deje de
cumplirse, (hasta que el valor usado en la condición indique lo contrario).
Esto nos permite realizar una cierta acción determinada mediante la
condición del Mientras.
El ciclo mientras se utiliza cuando no se conoce cuántas veces se va a
repetir un proceso, ya que está dado en función de un dato dentro del
programa. A continuación la estructura de los ciclos mientras:
Imagen 12
Imagen 13

16. 9
(Imagen 14 y 15). bucle repetir - pseint. [Figura]. Recuperado de
https://www.youtube.com/watch?v=jW3BMbDgEwA
14
Repetir
El comando Repetir como su nombre lo indica nos sirve
para volver a repetir una acción en un determinado ciclo.
Repite una series de acciones hasta que se de cierta condición. Dicha
acción la determina el operador =, que hace que salga del bucle.
Imagen 14
Imagen 15

17. 15
(Imagen 16 y 17). Pseint 2020 | Ciclos | Ciclo Para en Pseint. [Figura]. Recuperado de
https://www.youtube.com/watch?v=UF4NUilOB9M
15
Para
El comando nos sirve para repetir un proceso en una
determinada cantidad de veces hasta llegar a un número
de referencia el cual determina el fin de este proceso.
Presenta un cierto rango de valores, y para ellos realiza una
determinada acción.
Esta es la estructura del ciclo para:
Imagen 16
Imagen 17

18. 16
16
(Imagen 18). ejer11.png. [Figura]. Recuperado de https://victomanolo.wordpress.com/ejercicios-con-
funciones-en-pseint/
Función
Esta nos sirve para crear subprocesos, algoritmos o funciones aparte,
que pueden ser llamadas en cualquier momento sin tener que hacer la
secuencia de acciones en el proceso de algoritmo principal.
Permite añadir Funciones/SubProcesos al programa.
Aquí podemos ver un ejemplo de uso:
“SubProcesos que no devuelven valor, solo realizan una tarea
específica”
SubProceso ImprimirResultado(x)
Escribir "El resultado es: ",x;
FinSubProceso
SuProcesos que devuelven valores
SubProceso x <- LeerDato(cosa)
Definir x Como Entero;
Escribir "Ingrese ", cosa,": ";
Leer x;
FinSubProceso
Imagen 18

19. 17
Conclusión
Después de haber realizado este interesante trabajo informativo, como
grupo podemos concluir que el software Pseint es una de las más útiles
herramientas en lo que a educación en programación respecta ya que cuenta
con un entorno amigable y el pseudo-lenguaje sobre el que está basado
ciertamente facilita mucho el entendimiento de conceptos que pueden
llegar a ser un poco abstractos para las personas que se inician en la
programación.
Si observamos su entorno gráfico, (que vendría a ser nuestra área de
trabajo) notamos que esta herramienta cuenta con un amplio menú de
ayudas casi paso a paso de las que podemos hacer uso de manera intuitiva,
por lo que en cierta forma se siente como si el software nos asistiera
personalmente durante el proceso de sintaxis del algoritmo que estemos
desarrollando, evitando errores que en un lenguaje de programación
pasarían de largo. Además de ayudarnos en la sintaxis, esta herramienta va
un paso más allá con los diagramas de flujo que expresan el logaritmo de
manera gráfica, lo que nos permite interrelacionar los conceptos de la
compleja algoritmia computacional con procesos simples del día a día.
Por lo anteriormente expuesto, pseint nos parece una herramienta muy
completa que además es gratuita, por lo que cualquier persona que
mínimamente tenga un computador y acceso a internet puede comenzar a
aprender. Es una herramienta tan intuitiva que permite alcanzar
conocimientos de base siendo autodidacta.

20. 18
Webgrafía
https://tutorias.co/ciclo-para-pseint-la-variable-contador/
https://sites.google.com/site/portafolio4bb2/5-estructura-de-un-pseudocodigo-
en-pseint
https://temarioanacleto2.es.tl/PSeint.htm
http://www.discoduroderoer.es/variables-y-constantes-en-pseudocodigo/
https://www.nextu.com/blog/como-funciona-la-mente-de-un-programador-de-
software/
http://www.discoduroderoer.es/asignacion-en-pseudocodigo/
http://www.discoduroderoer.es/variables-y-constantes-en-pseudocodigo/
http://www.discoduroderoer.es/operadores-pseudocodigo/
http://www.discoduroderoer.es/operacion-de-entrada-y-salida-en-
pseudocodigo/

21. 19
/
Anexos
Evidencias del informe realizado en equipo:

22. 20
Links del blog de cada uno de los Integrantes:
Dana Sofía Morales Rico:
https://dannasofiamorales.blogspot.com/
Haddy Andrés Ortiz Pedroza:
https://678tecnologia678.blogspot.com/2018/04/tecnologia678.html?m=1
Ana Sofía Ramírez Prieto:
https://anaramirez71.blogspot.com
Laura Sofía Sepúlveda Murillo:
https://tic20220.blogspot.com/