INFORME FUNDAMENTOS DE PROGRAMACIÓN en PSEINT

0
INFORME DE TECNOLOGÍA
PERIODO II.
Equipo:
Fiory Castro.
Sara pinto.
Stefania Osorio.
Mariana Armero.
Grado: 10-6, institución educativa liceo departamental,
de Santiago de Cali
Docente: Guillermo Mondragon
14 de Junio del 2025

1
TABLAS DE CONTENIDOS
CONCEPTOS...........................................................................................................................2
Constantes......................................................................................................................... 2
Variables.............................................................................................................................3
Acumuladores:................................................................................................................... 5
Contadores:........................................................................................................................7
Identificadores:...................................................................................................................8
¿Qué es y cómo funciona Pseint?..................................................................................... 9
MAPA CONCEPTUAL.............................................................................................................9
CONCLUSIONES.................................................................................................................. 10
EVIDENCIAS......................................................................................................................... 12
LINKS.................................................................................................................................... 14

2
CONCEPTOS.
Constantes
Una constante es un nombre simbólico dado a un valor fijo en el que no se puede
realizar cambios ni alteraciones después de que se haya definido. En el código, las constantes
se utilizan para representar cualquier valor que no se deba mostrar; por ejemplo,como el valor
de π (pi) o el número de días en una semana.
Los diferentes lenguajes de programación pueden tener diferentes prácticas para
definir las constantes, pero en la mayoría de los casos, se hace con una palabra clave especial.
Por ejemplo.
● En C y C++ usamos la palabra clave const:
const int MAX_AGE = 100;
● En Java, se usa final:
final int MAX_AGE = 100;
● En Python, aunque no existe una palabra clave para constantes, por
convención se usan nombres en mayúsculas:
MAX_AGE = 100
(Aunque en Python no impide modificar el valor, la convención de usar mayúsculas
indica que esa variable no debe cambiar)
ventajas
● Claridad y mantenimiento del código: Usar constantes mejora la legibilidad
del código, ya que el nombre de la constante describe claramente el valor que representa. Por
ejemplo, en lugar de escribir repetidamente el número 100, puedes usar la constante
MAX_AGE.
● Seguridad y confiabilidad: Al no permitir que el valor de la constante
cambie, reduces el riesgo de errores accidentales en el código.
● Optimización del rendimiento: Algunos compiladores pueden optimizar el
uso de constantes en su código, ya que el valor no cambia durante la ejecución.

3
usos comunes
● Valores matemáticos fijos: Como π (pi), la base de los logaritmos naturales
(e), o la gravedad.
● Tamaños fijos: Como el número de días en una semana (7), el número de
horas en un día (24), etc.
● Configuraciones: Muchas veces las constantes se usan para definir
parámetros de configuración que no deberían cambiar, como las rutas de archivos o los
límites de ciertas operaciones.
Ejemplo:
Supongamos que estás programando una aplicación que calcula el área de un círculo.
El valor de π es constante, por lo que sería ideal usar una constante en lugar de escribir el
valor directamente en cada cálculo.
En pyntho:
PI = 3.14159
del area_circulo(radio):
return PI * radio * radio
print(area_circulo(5)) # Salida: 78.53975
Variables
Una variable es un espacio de memoria donde se almacena un valor que puede
cambiar. El valor de la variable puede ser actualizado en cualquier momento durante la
ejecución del programa, a diferencia de las constantes, que no pueden ser modificadas.
Para usar una variable, debes darle un nombre y asignarle un valor inicial.
Dependiendo del lenguaje de programación, la sintaxis puede variar ligeramente. Aquí tienes
ejemplos en diferentes lenguajes
● En C/C++:
int edad = 25;
edad = 26; // Se puede modificar
● En Java

4
int edad = 25;
● En Python:
edad = 25
edad = 26 # Se puede modificar
● En JavaScript:
let edad = 25;
Características
● Nombre: Cada variable tiene un nombre único que se utiliza para referenciarla
en el código. Es importante elegir nombres descriptivos que hagan entender qué valor
almacena (por ejemplo, edad para la edad de una persona).
● Tipo de datos: Las variables pueden almacenar diferentes tipos de datos,
como números enteros (int), decimales (float), cadenas de texto (String), booleanos
(boolean), entre otros. El tipo de dato define qué tipo de valor puede almacenar la variable.
● Valor mutable: Lo más importante sobre las variables es que su valor puede
cambiar durante la ejecución del programa. Puedes asignarles un nuevo valor en cualquier
momento.
Ventajas
● Flexibilidad: Las variables permiten almacenar información que puede
cambiar, como la entrada de un usuario o el resultado de un cálculo.
● Reutilización: Almacenar valores en variables permite usar esos valores en
diferentes partes del programa sin tener que escribir el valor directamente cada vez.
● Interactividad: Las variables permiten que el programa sea interactivo,
recibiendo y procesando datos de manera dinámica (por ejemplo, un programa que pida al
usuario su edad y la almacene en una variable).
Ejemplo

5
Supongamos que quieres crear un programa para calcular el área de un círculo, pero
esta vez usarás una variable para el radio (ya que el radio puede cambiar en diferentes
cálculos).
En Python:
PI = 3.14159 # Constante, no cambia
radio = 5 # Variable, el valor puede cambiar
def area_circulo(radio):
return PI * radio * radio
print(area_circulo(radio)) # Salida: 78.53975
radio = 7 # Ahora cambiamos el valor de la variable 'radio'
print(area_circulo(radio)) # Salida: 153.93804
En este caso, la variable radio puede cambiar, y eso afecta el cálculo del área.
Mientras tanto, la constante PI permanece igual.
Acumuladores:
Un acumulador es una variable que se utiliza para almacenar la suma de una serie de
valores, típicamente en el contexto de un bucle o iteración. El acumulador se inicializa a un
valor inicial, que generalmente es 0 para sumas, y luego se incrementa con cada nuevo valor
que se procesa.
El papel del acumulador en programación:
● Acumulación de datos:
Los acumuladores son útiles para obtener un total o una suma de varios valores dentro
de un programa.
● Bucle repetitivo:
Se utilizan comúnmente dentro de bucles (como for o while) para sumar o acumular
valores en cada iteración del bucle.
● Ejemplos de uso:

6
-Calcular la suma de elementos en un arreglo.
-Sumar los ingresos de un día de ventas.
-Determinar el promedio de un conjunto de números.
● Inicialización:
Es crucial inicializar el acumulador antes de empezar a utilizarlo en un bucle.
● Incremento:
En cada iteración del bucle, el acumulador se incrementa con el valor actual que se
está sumando.
● Resultado final:
Una vez que el bucle termina, el acumulador contiene el resultado final de la suma.
Ejemplo en pseudocódigo:
Supongamos que queremos sumar los números de 1 a 5.
// Inicializar el acumulador
acumulador = 0;
// Bucle for para iterar de 1 a 5
para (i = 1; i <= 5; i++)
{
// Sumar el valor actual al acumulador
acumulador = acumulador + i;
}
// El acumulador contiene la suma (15)
// Mostrar el resultado

7
mostrar(acumulador)
Contadores:
Los contadores son variables que se incrementan o decrementan en un valor fijo,
generalmente para llevar un registro del número de veces que se ejecuta un bloque de código
o para contar eventos. Se utilizan comúnmente en bucles (como for o while) para controlar el
número de iteraciones.
● ¿Cómo funcionan los contadores?:
1. Inicialización:
Un contador se declara y se inicializa a un valor inicial, típicamente 0 o 1.
2. Incremento o Decremento:
Se incrementa o decrementa en un valor constante cada vez que ocurre un evento o se
ejecuta una parte del código.
3. Uso:
Se utiliza para controlar la ejecución de un bucle o para llevar un registro de sucesos.
● Diferencia entre contador y acumulador:
Un acumulador también es una variable, pero a diferencia del contador, el valor que
se suma o resta puede ser variable (no necesariamente constante). Por ejemplo, se puede
utilizar para sumar una serie de valores diferentes que se van obteniendo a lo largo de la
ejecución del programa.
● Ejemplo en JavaScript:
let contador = 0; // Inicialización
for (let i = 0; i < 5; i++) {
console.log("Contador: " + contador);
contador++; // Incremento
}

8
Identificadores:
Un identificador es un nombre que se utiliza para referirse a elementos como
variables, funciones, clases, etc., dentro de un programa. Estos nombres permiten al
programador acceder y manipular estos elementos en el código. Los identificadores deben
seguir ciertas reglas, como empezar con una letra o guion bajo, y pueden contener letras,
números y guiones bajos.
● Ejemplos de identificadores:
-Variables: edad, nombre, precio_total
-Funciones: calcular_area, imprimir_datos
-Clases: Usuario, Producto
-Constantes: MAX_INT, PI
● Reglas para la creación de identificadores:
-Primer carácter: Debe ser una letra (mayúscula o minúscula) o un guion bajo (_). No
puede ser un número.
-Caracteres siguientes: Pueden ser letras, números o guiones bajos.
-Distinción entre mayúsculas y minúsculas: La mayoría de los lenguajes de
programación distinguen entre mayúsculas y minúsculas en los identificadores (ej. variable es
diferente de Variable).
-Palabras reservadas: No se pueden utilizar palabras reservadas del lenguaje (ej. if,
for, while en la mayoría de los lenguajes).
-Longitud: Algunos lenguajes tienen límites en la longitud de los identificadores.
-Sin espacios: Los identificadores no deben contener espacios en blanco.
● Importancia de los identificadores:
-Organización: Permiten a los programadores organizar y estructurar el código de
manera lógica.
-Legibilidad: Nombres descriptivos facilitan la comprensión del código.
-Mantenibilidad: Código con identificadores claros es más fácil de mantener y
modificar.
● Ejemplo:

9
suma_total = 0
numero_de_estudiantes = 25
calcular_promedio()

10
¿Qué es y cómo funciona Pseint?

es un programa que se utiliza para aprender los conceptos básicos de programación.
Su nombre significa “Pseudo Intérprete” y trabaja con algo llamado “seudocódigo”,
que es una forma fácil de escribir instrucciones para resolver problemas, usando un lenguaje
parecido al español.
se usa principalmente para pensar y planear un algoritmo, es decir, los pasos que debe
seguir una solución antes de programarla en un lenguaje real como Java

¿Cómo se usa?
En PSeInt se escriben los pasos del programa con instrucciones simples como leer, escribir,
si...entonces, o mientras...hacer
Abrir el programa
Al iniciar PSeInt, aparece una ventana en blanco donde puedes escribir tu algoritmo.
Escribir el seudocódigo
Usas instrucciones básicas como:
○ Leer → para pedir datos al usuario.
○ Escribir → para mostrar resultados en pantalla.
○ Definir → para declarar las variables.
○ Si, Mientras, Para → para hacer decisiones y repeticiones.
Guardar tu archivo
Puedes guardar tu trabajo para seguirlo luego. Se guarda con la extensión .psc.
Ejecutar el programa
Al dar clic en "Ejecutar" o "Depurar", PSeInt va mostrando paso a paso lo que
haría el programa. Esto te ayuda a ver si está funcionando bien o si hay errores.
Corregir errores
Si algo está mal escrito o falta algo, el programa te lo dice y puedes corregirlo.

11
Luego se puede ejecutar para ver si el algoritmo funciona correctamente
Proceso
este código pide dos notas, las suma, saca el promedio y muestra el resultado

12
MAPA CONCEPTUAL.
Definiciones - azul cielo
ejemplos - recuadros blancos

13
CONCLUSIONES
- Fiory Castro Carvajal
Durante esta actividad logré comprender los conceptos fundamentales de la
programación, como acumuladores, contadores e identificadores. Realizar esta investigación
me permitió entender cómo funcionan dentro de un algoritmo.
En el trabajo grupal fortalecí mis habilidades de comunicación. supimos organizarnos
para dividir las tareas de forma equilibrada y practicamos el respeto por las opiniones de los
demás. Sin embargo, en una próxima ocasión, me gustaría que planifiquemos mejor los
tiempos desde el inicio, para que todos podamos trabajar con calma y evitar que alguien se
sienta presionado al final. Creo que una mejor gestión del tiempo puede mejorar aún más el
trabajo en equipo que ya venimos construyendo.
Mariana Armero Daza
A lo largo de esta actividad, comprendí conceptos fundamentales de programación
como variables, acumuladores, contadores e identificadores. La investigación me permitió
aplicar estos elementos en algoritmos, consolidando mi entendimiento del proceso de
desarrollo.
En el trabajo grupal, mejoré mi capacidad de comunicación y colaboración. Logramos
organizarnos eficientemente, distribuir tareas equitativamente y respetar todas las
perspectivas. Destaco la importancia de la escucha activa y la integración de ideas diversas.
Identifiqué que una mejor planificación de tiempos desde el inicio evitaría presiones en
etapas finales. Implementar hitos claros y revisiones periódicas optimizaría nuestra dinámica
futura.
1. Asimilación técnica: Comprensión aplicada de conceptos abstractos.

14
2. Sinergia grupal:Distribución justa de responsabilidades y ambiente colaborativo.
3. Autocrítica constructiva: Detección proactiva de oportunidades de mejora (gestión
temporal)
Sugerencia para próximos proyectos:
Implementar una matriz de responsabilidades con fechas límite intermedias para equilibrar
cargas de trabajo y prevenir acumulación de tareas
- Stefania Osorio Agudelo
Esta experiencia no solo me permitió comprender mejor los fundamentos de la
programación,(como el uso de acumuladores, contadores, identificadores y variables) sino
también crecer en lo personal y como equipo. La investigación técnica nos dio herramientas
clave para construir algoritmos con mayor claridad, mientras que el trabajo colaborativo
fortaleció nuestras habilidades de comunicación y respeto por las ideas del otro.
Aunque se logró una buena organización grupal, aún hay aspectos por mejorar, especialmente
en la planificación del tiempo. Hay distribuir mejor las tareas desde el inicio y establecer
momentos de revisión puede marcar una gran diferencia en el resultado final y en el bienestar
de cada integrante. En próximos proyectos, aplicar esta reflexión implementando
herramientas concretas como matrices de responsabilidades y plazos intermedios.
En resumen, más allá de los conocimientos técnicos adquiridos, esta actividad me dejó una
enseñanza valiosa sobre el valor de trabajar en equipo con empatía, compromiso y visión
compartida.

- Sara Pinto Córdoba

15
comprender mejor los fundamentos de la programación, especialmente a través de
herramientas como PSeInt y el uso práctico de conceptos clave como constantes, variables,
acumuladores, contadores e identificadores
exploramos cómo se construyen algoritmos básicos y cómo se representa un problema de
manera ordenada antes de pasarlo a un lenguaje formal de programación.
también conocimos la importancia de las instrucciones claras y lógicas al momento de
resolver tareas usando tecnología

18
LINKS
FIORY CASTRO CARVAJAL: https://fiorycastronovenoseis.blogspot.com/
SARA PINTO CORDOBA : https://minintendoconsola.blogspot.com/
STEFANIA OSORIO AGUDELO: https://tecnologiastef13.blogspot.com/
MARIANA ARMERO:https://mariarmero1109.blogspot.com/

INFORME FUNDAMENTOS DE PROGRAMACIÓN en PSEINT

Más contenido relacionado

Similar a INFORME FUNDAMENTOS DE PROGRAMACIÓN en PSEINT (20)

Último (20)

INFORME FUNDAMENTOS DE PROGRAMACIÓN en PSEINT