Cómo depurar en PSeInt: ejecutar paso a paso y ver variables (2026)

Tu programa se ejecuta sin errores… pero el resultado está mal. La suma da otro número, el bucle se repite una vez de más, la condición nunca se cumple. Bienvenido al error más frustrante de la programación: el error lógico. El programa hace exactamente lo que le pediste, no lo que querías pedirle. Para cazarlo, PSeInt incluye una herramienta perfecta para estudiantes: la ejecución paso a paso, que te deja avanzar instrucción por instrucción mientras observas qué le pasa a cada variable.

Cuándo necesitas depurar paso a paso

Usa esta técnica cuando:

  • El programa corre sin mensajes de error, pero el resultado no es el esperado.
  • Un bucle se repite demasiadas veces (o nunca termina).
  • Una condición Si toma siempre la misma rama, incluso cuando debería tomar la otra.
  • Sospechas que una variable cambia de valor en un punto que no controlas.

Si en cambio tu programa ni siquiera arranca y muestra un mensaje de error, primero revisa la lista de errores comunes en PSeInt: probablemente sea un problema de sintaxis, no de lógica.

El botón «Ejecutar paso a paso»

En la barra de herramientas de PSeInt, junto al botón normal de Ejecutar, encontrarás el botón «Ejecutar paso a paso». Es la puerta de entrada al modo de depuración. Úsalo siempre desde la barra de herramientas: así no dependes de recordar combinaciones de teclas que pueden variar según la versión o el sistema operativo.

💡 Idea clave: la ejecución normal es como ver una película a velocidad normal; la ejecución paso a paso es como verla fotograma por fotograma. Nada cambia en tu programa: solo tú lo observas más despacio.

Cómo ejecutar tu algoritmo paso a paso

  1. Abre tu algoritmo en PSeInt.
  2. Pulsa el botón «Ejecutar paso a paso» de la barra de herramientas.
  3. El programa se detiene en la primera instrucción ejecutable y la resalta.
  4. Cada vez que avances un paso, PSeInt ejecuta una sola instrucción y se detiene en la siguiente, resaltándola.
  5. Si tu programa pide datos con Leer, la ejecución se pausará para que los ingreses, igual que en una ejecución normal.
  6. Continúa avanzando hasta que termine el programa o hasta que encuentres el problema.

Pruébalo con este ejemplo que contiene un error lógico deliberado:

Algoritmo SumaConError
    Definir i, suma Como Entero
    suma <- 0
    Para i <- 1 Hasta 5 Con Paso 1 Hacer
        suma <- suma + i
    FinPara
    Escribir "La suma de 1 a 5 es: ", suma
FinAlgoritmo

(Pista: este ejemplo en realidad está bien… el error aparecerá cuando lo modifiques tú en los 100 ejercicios resueltos de PSeInt y algo no cuadre.)

El panel de variables: tu lupa de detective

Mientras avanzas paso a paso, PSeInt muestra un panel de variables con el valor actual de cada una. Esta es la parte más poderosa de la depuración: en cada paso, mira cómo cambian los valores y pregúntate si son los que esperabas.

El método del detective:

  1. Avanza paso a paso hasta justo antes de la zona sospechosa.
  2. Anota mentalmente qué valor debería tener cada variable.
  3. Ejecuta el siguiente paso y compara: ¿el valor real coincide con el esperado?
  4. En el primer paso donde no coincidan, ahí está tu error: la instrucción que acabas de ejecutar es la culpable.

Estrategia de depuración en 4 pasos

Cuando el panel de variables te señale la instrucción culpable, no la cambies a ciegas:

  1. Reproduce: asegúrate de poder repetir el error con los mismos datos de entrada.
  2. Acota: usa la ejecución paso a paso para localizar la primera instrucción donde el valor se desvía.
  3. Comprende: lee esa instrucción con calma. ¿La condición está al revés? ¿Usaste la variable equivocada? ¿El bucle empieza o termina un número antes o después?
  4. Corrige y verifica: cambia solo esa instrucción y vuelve a ejecutar el programa completo para confirmar que el resultado ya es correcto y que no rompiste otra cosa.

Errores típicos que se cazan así

  • Variable no inicializada: usas una variable antes de darle un valor; en el panel verás un valor extraño o cero donde esperabas otra cosa.
  • Condición invertida: escribiste Si x > 10 cuando querías Si x < 10; el programa siempre toma la rama contraria.
  • Error de "uno más, uno menos": el bucle Para llega hasta 10 cuando debía llegar hasta 9 (o al revés); se ve clarísimo avanzando paso a paso por las últimas iteraciones.
  • Asignación en lugar de comparación: revisa la sintaxis de PSeInt para no confundir <- (asignar) con = (comparar).

Preguntas frecuentes

¿La ejecución paso a paso cambia el resultado de mi programa?

No. Solo cambia la velocidad a la que lo observas: el programa ejecuta exactamente las mismas instrucciones y produce el mismo resultado. Es una herramienta de observación, no modifica tu algoritmo.

¿Puedo saltarme partes del programa que ya sé que están bien?

Sí. Si el error está al final de un algoritmo largo, puedes ejecutar normalmente hasta cerca de la zona sospechosa y luego continuar paso a paso desde ahí. También puedes reestructurar temporalmente tu código para probar una sección aislada.

¿Qué hago si el error está en los datos que ingreso?

Entonces no es un error del programa sino de la prueba. Repite la ejecución paso a paso ingresando datos distintos y anota con qué valores falla y con cuáles no: ese patrón te dirá si el problema está en la lógica o en tus datos de prueba. Revisa también los errores comunes relacionados con la entrada de datos.

¿La ejecución paso a paso sirve dentro de subprocesos y funciones?

Sí. Cuando la ejecución llega a una llamada a subproceso o función, el modo paso a paso entra dentro de él y puedes observar sus variables locales igual que las del programa principal. Es muy útil para verificar que los parámetros se pasan correctamente.

Publicaciones Similares