Introducción a la Programación – 1

Hemos visto en publicaciones anteriores lo que significa crear un programa informático (puedes leerlo en este post si no lo has leído aún), y a grandes rasgos hemos abordado también el concepto de algoritmo (link aquí). En este primer tutorial de Introducción a la Programación, profundizaremos aún más estos conceptos, y entre este primer tutorial y el siguiente aprenderemos a diseñar un algoritmo para crear un programa similar a una calculadora con operaciones básicas (suma, resta, multiplicación y división entre dos números). En resumen, los temas que vamos a tratar en este post son los siguientes:

1. Un programa es como una caja negra
2. Algoritmo y Seudocódigo
3. Estructuras de repetición y decisión
3.1. Condicionales
4. Ejercicio

alojamiento wordpress

1. Un programa es como una caja negra

Cuando utilizamos un programa, lo que solemos hacer por lo general es ingresar datos en el programa (ya sea mediante teclado, mouse o algún otro dispositivo denominado periférico), presionar algún botón de la interfaz de usuario que nos ofrece el programa (si no hay botones ni ventanas y hay una ventana de comandos, simplemente presionamos la tecla enter), y luego esperar a que el programa procese los datos que nosotros le ingresamos y muestre finalmente el resultado del proceso (si se trata de un cálculo, nos muestra el resultado del cálculo, y si no, nos muestra un mensaje de éxito o de error en caso de que haya habido un error en el sistema).

Si se analiza bien este proceso, podemos ver que hay tres etapas bien diferenciadas: 1) el ingreso de datos por parte del usuario; 2) el procesamiento de los datos por parte del programa (el cual puede ser instantáneo o demorar segundos, minutos, quizás hasta horas!); 3) y por último, el programa arroja los resultados de ese proceso (si se realizó con éxito o hubo un error). Desde el punto de vista del usuario que utiliza el programa, sólo importan estas 3 cosas, ya que al usuario no le interesa saber cómo es que la máquina realiza el procesamiento de los datos (a menos que se trate de una persona curiosa), ni cómo está hecho el programa. Sólo le importan los datos que él ingresa, lo que demora en retornar el resultado y el resultado en sí mismo (o datos de salida del programa). Es por eso que se suele decir que el programa es como una caja negra, dado que es como si fuera una caja en donde por un lado se ingresan datos de entrada, y por el otro sale la información procesada por el programa. Lo que hay dentro de la caja no le incumbe al usuario. La siguiente Figura 1 ilustra lo que acabamos de explicar:

Introducción a la Programación - Tutorial 1 - Figura 1

Figura 1.

En esta figura se muestran las operaciones que realiza el programa para leer y procesar los datos de entrada, y para imprimir o mostrar el resultado de la operación en la salida del programa. Esto es simplemente para entender a nivel de código cómo es la separación que se suele llevar a cabo de estas etapas. A lo largo de los tutoriales, nos vamos a centrar en escribir programas que se utilizan mediante una terminal de línea de comandos, ingresando datos mediante el teclado y obteniendo resultados luego del procesamiento. No vamos a crear programas que tengan interfaces de usuario con ventanas y botones, aunque en futuros cursos podríamos incluir tutoriales para programar y definir interfaces de usuario, pero de momento esto no está dentro del alcance de este curso. Se entiende que es más sencillo comenzar a aprender programación desde cero implementando programas que se utilizan por línea de comandos, ya que permite enfocarse solamente en los aspectos funcionales del programa, y no en los aspectos visuales o estéticos.

Volviendo a la Figura 1, se observa que el usuario escribe mediante línea de comandos los datos que quiere que el programa procese. El programa lee entonces estos datos que ingresa el usuario mediante un comando llamado leer(), luego los datos son procesados mediante un comando denominado procesar() y finalmente, los resultados se imprimen en la ventana de comandos por intermedio de la operación imprimir().

Estos comandos no pertenecen a ningún lenguaje de programación, simplemente es un lenguaje inventado para explicar cómo serían las instrucciones que a grandes rasgos ejecutaría la máquina en un programa de este estilo.

Para sintetizar esta sección, hemos visto que un programa tiene tres etapas claramente diferenciadas si se lo analiza desde el punto de vista de la interacción con el usuario: los datos de entrada (los ingresa el usuario mediante los periféricos); el procesamiento de los datos (lo lleva a cabo la máquina, ejecutando instrucciones como pueden ser leer(), procesar(), etc.); y por último, la impresión de los datos de salida (que puede ser el resultado de la operación, o la impresión de un mensaje de éxito o error). En la próxima sección comenzaremos a desarrollar en qué consiste el procedimiento de crear un algoritmo, y especificarlo con un seudocódigo, como un paso previo a la escritura del código del programa en un lenguaje concreto.

2. Algoritmo y Seudocódigo

Como habíamos visto en este post, un programa es un conjunto de instrucciones u órdenes, escritas en un lenguaje de programación. Más adelante, en futuros tutoriales, aprenderás a escribir estas instrucciones en un lenguaje de programación específico, pero de momento nos centraremos en explicar las ideas básicas que serán necesarias para poder encarar esa tarea.

Por otra parte, y como se vió en un post anterior, un algoritmo es una secuencia ordenada de pasos, o un procedimiento a seguir para poder resolver un problema, y habíamos explicado además, que un algoritmo puede transformarse en un programa informático, en tanto sea posible convertir esa secuencia ordenada de pasos en un conjunto de instrucciones escritas en un lenguaje de programación.

Hasta ahora todo parece muy claro. Pero cabría preguntarse, ¿ Cómo se diseña un algoritmo ? ¿ Cómo se crea uno ? Por lo general, los algoritmos se suelen especificar mediante algo que se denomina Seudocódigo, que es un borrador en el cuál se escribe el procedimiento del algoritmo (puede ser utilizando papel y lápiz, o en un archivo de texto, da lo mismo en donde se escriba) en un lenguaje que es cercano al lenguaje de programación, pero pensado para que sea más legible por un humano, es decir, es como escribir cómo van a ser las instrucciones que tendrá el algoritmo antes de transformarlo en código de un lenguaje de programación. Es un paso previo a la escritura del código en la máquina.

Algo importante para mencionar: en un seudocodigo se especifican las acciones que debe realizar la maquina, no lo que el usuario debe hacer. El usuario solamente ingresa datos, presiona enter, y espera a que el programa haga lo suyo. En cambio, el seudocodigo debe detallar qué es lo que debe hacer la máquina para procesar los datos, no lo que debe hacer el usuario. Aquí viene un ejemplo para aclarar las cosas:

Supongamos que queremos escribir un algoritmo para crear un programa sencillo que permite sumar dos números que el usuario ingresa en la pantalla (mediante el teclado), y mostrar el resultado de la suma al usuario. Si fuésemos a diseñar un algoritmo para esto, la lista de pasos a seguir para este algoritmo sería la siguiente:

Paso 1) Leer el primer número que el usuario ingresa. (sumando 1)
Paso 2) Leer el segundo número que el usuario ingresa. (sumando 2)
Paso 3) Efectuar la suma entre ambos números.
Paso 4) Mostrar el resultado de la suma en la pantalla.

Así de simple. El programa que resuelva nuestro problema debería poder ejecutar estas 4 instrucciones, y en ese orden indicado. Sin embargo, una máquina no comprende el idioma español, y por ese mismo motivo es que se necesita convertir este algoritmo a un código escrito en un lenguaje de programación, para que la máquina comprenda y ejecute. Un primer paso para esto, es convertir esta lista en un seudocódigo. Para esto, lo que hacemos es escribir estas 4 acciones como si fuesen comandos a ejecutarse, con pocas palabras, y utilizando una forma de escribir similar a como se hace en un lenguaje de programación (pero no necesariamente respetando las reglas de ningún lenguaje). Observen cómo quedaría este algoritmo si lo convirtiéramos en seudocódigo:

Paso 1) leer(numero_1)
Paso 2) leer(numero_2)
Paso 3) resultado = sumar(numero_1, numero_2)
Paso 4) imprimir(resultado)

Si no se entiende a la primera, a no desesperarse. Aquí viene la explicación: en el punto número (1), se convirtió la oración leer el primer número que el usuario ingresa simplemente en el comando leer(numero_1). El número que el usuario ingresa se simboliza con el texto numero_1, mientras que la acción de leer la entrada del usuario se convirtió ahora en un comando llamado simplemente leer (como el que se mostró en la Figura 1), y en donde el número que se lee se escribe entre paréntesis. Lo que hicimos aquí fue simplificar la escritura, además de tratar de acercarnos más a cómo se escriben las órdenes en un lenguaje típico. Es solamente eso. Recuerden que aún no estamos siguiendo las reglas de ningún lenguaje por el momento. El lenguaje que se utiliza es un lenguaje falso (de ahí proviene la palabra seudocódigo, ya que pseudo significa falso).
Mientras tanto, en el paso número (2), se realiza la misma acción que en el (1) pero con el segundo número que el usuario ingresa, por lo que lo único que cambia en este caso, es el nombre numero_1 por numero_2. Son identificadores que sirven para distinguir entre un número y el otro.
En el paso número (3), lo que se intenta decir con esa igualdad es: El resultado de la operación es igual a ejecutar la suma entre los números identificados como numero_1 y numero_2. Más adelante veremos que tanto numero_1, como numero_2 y resultado, en el contexto de un lenguaje de programación, se llaman variables, y tienen un uso concreto. Pero de momento no conviene explicar esto. Simplemente hay que quedarse con la idea de que son identificadores de ciertos números que el usuario ingresa.
Finalmente, en el cuarto y último paso, se ejecuta un comando llamado imprimir(resultado), que no hace otra cosa que mostrar en la pantalla (la línea de comandos en nuestro caso) el número que representa el resultado de la suma entre los números que el usuario ingresó (si el usuario ingresó los números 4 y 5, entonces el resultado que se muestra en pantalla es el número 9).

¿ Se entiende la idea ? Recuerda que ante cualquier duda puedes comentar al final del post.

A continuación, vamos a presentar las estructuras básicas que forman parte de un lenguaje de programación y que por ende sirven de ayuda para escribir mejor el seudocódigo de un algoritmo.

3. Las estructuras de repetición y decisión

3.1. Condicionales

Permítanme ahora modificar un poco este ejercicio: supongamos que en lugar de hacer un algoritmo para un programa que simplemente sume dos números, intentemos hacer otro que solamente ejecute la suma si los números son mayores que cero, es decir, si no se admiten números negativos. En caso de que alguno sea negativo, se deberá mostrar en pantalla un mensaje que diga Lo siento. No hemos podido ejecutar la suma. Los números que se ingresan no deben ser negativos.

En esta situación, tendremos dos escenarios posibles: el caso feliz, y el caso triste. El caso feliz sería que el usuario ingresara dos números positivos, en cuyo caso la suma sería exitosamente ejecutada, y el resultado sería mostrado en pantalla sin problemas (este es el mismo caso del ejemplo anterior), mientras que el caso triste sería que el usuario ingresara un número negativo y otro positivo (o mayor o igual que 0), o incluso los dos números negativos. En ese escenario, se deberá mostrar el mensaje de error en la pantalla. Aquí claramente existe una condición que debe cumplirse para que la suma sea efectuada.

Para resolver esto, será necesario recurrir a un tipo de sentencia en programación que se denomina estructura de decisión, o instrucción condicional. ¿ Qué es esto ? Es una orden que indica que, si se cumple una determinada condición, entonces se debe ejecutar una orden determinada, y si la condición no se cumple, entonces se debe hacer otra cosa. ¿ Cuál es la condición en este ejemplo ? Que ambos números sean mayores que cero. Si se cumple esa condición, entonces se debe realizar la suma y mostrar su resultado, y si no se cumple, entonces se debe mostrar un mensaje de error. El algoritmo que resuelva este problema deberá reflejar este comportamiento. Si anotáramos la lista de pasos a seguir para este algoritmo (en lenguaje natural), quedaría de esta manera:

Paso 1) Leer el primer número.

Paso 2) Leer el segundo número.

Paso 3) Si alguno de los números leídos es menor que cero, entonces:

Paso 3.1) Imprimir en pantalla el mensaje “Lo siento. No hemos podido ejecutar la suma. Los números que se ingresan no deben ser negativos.”

Paso 4) Si no:

Paso 4.1) Efectuar la suma.

Paso 4.2) Mostrar el resultado de la suma en pantalla.

Paso 5) Fin.

Lo que cambia con respecto al ejemplo anterior, es la aparición de la instrucción condicional en el Paso número (3). Típicamente en un lenguaje de programación, se suelen escribir los condicionales con una estructura de la forma if (condición a cumplirse) then (if significa Si en inglés, mientras que then significa entonces), por lo que aquí escribimos el condicional en español para que sea más natural y se entienda a las primeras de cambio. Este paso 3 dice que si alguno de los números que el usuario ingresó es negativo, entonces se debe ejecutar lo que aparece numerado como Paso (3.1), que es la impresión en pantalla del mensaje de error. Es importante recalcar que el Paso (3.1) NO se ejecuta si la condición del Paso 3 NO se cumple. Esa es la gracia de la instrucción condicional.

Si no se cumple la condición del Paso (3), entonces se salta directamente al Paso (4), en donde aparece la instrucción Si no (que en inglés significa Else). Esta sentencia lo que dice es que, si no se cumple la condición anterior, entonces se ejecutan las órdenes que están numeradas como (4.x) (es decir, la 4.1 y la 4.2). Estas dos instrucciones ejecutan la suma, y muestran el resultado de la suma en pantalla, que es lo que corresponde hacer en el caso en que ambos números sean positivos (es decir, justamente en el caso en el que la condición del paso (3) no se cumple).

alojamiento wordpress

Pues bien, ya tenemos la lista de pasos a seguir en lenguaje natural de nuestro algoritmo, lo que nos falta hacer es el pasaje del algoritmo al seudocódigo, el cual quedaría escrito de la siguiente manera:

Paso 1) leer(numero_1)

Paso 2) leer(numero_2)

Paso 3) Si (numero_1 < 0) o (numero_2 < 0) entonces:

Paso 3.1) imprimir(“Lo siento. No hemos podido ejecutar la suma. Los números que se ingresan no deben ser negativos.”)

Paso 4) Si no:

Paso 4.1) resultado = sumar(numero_1, numero_2)

Paso 4.2) imprimir(resultado)

Paso 5) Fin.

El seudocódigo en este caso es bastante similar al seudocódigo del ejercicio anterior, con la diferencia de que se agregan las sentencias condicionales Si … entonces, y Si no. Otro detalle es la forma en la que se expresa la condición que debe cumplirse, ya que la expresión (numero_1 < 0) o (numero_2 < 0) es nada más y nada menos que un o lógico, lo que quiere decir que para que la condición en su totalidad se cumpla, debe cumplirse al menos una de las dos sub-expresiones que están entre paréntesis (es decir, si el numero_1 es negativo o el numero_2 es negativo, entonces se cumple la condición de que al menos uno de ellos es negativo). Más adelante en futuros tutoriales hablaremos con mayor profundidad de las diferentes expresiones lógicas que existen para expresar condiciones que deben cumplirse.

En el siguiente tutorial continuaremos con las estructuras de repetición y decisión, y hablaremos acerca de los bucles, para finalmente diseñar un algoritmo que nos sirva para programar una calculadora con operaciones básicas entre dos números, ejercicio que nos servirá para aplicar todos los conceptos aprendidos en estos tutoriales.

En la sección siguiente, dejaremos un ejercicio para que practiques lo aprendido en la lección de este post. Si tienes alguna duda, deja un comentario al final. Si resuelves el ejercicio y quieres una corrección, envíame un correo a pablo@carbasoft.com. Contestaré en cuanto pueda. Si quieres suscribirte al Newsletter de Carbasoft, puedes hacerlo mediante el formulario que se encuentra al final de esta entrada (debajo de la sección Ejercicio).

4. Ejercicio

Diseña un algoritmo (redactando la lista de pasos a seguir en lenguaje natural, y en seudocódigo) para un programa que calcule el área de un triángulo de la siguiente manera:

  1. El usuario debe ingresar dos números que corresponden a las medidas de la base y la altura del triángulo.
  2. Si alguno de los números es negativo, el programa debe mostrar un mensaje de error en pantalla indicando que los datos son erróneos.
  3. Si ambos números son positivos, entonces el programa deberá calcular el área del triángulo y mostrar el resultado en pantalla.

Se cuenta con los siguientes comandos para utilizar:

  1. leer() que permite leer los datos que el usuario ingresa.
  2. imprimir() que permite mostrar en pantalla el resultado de la operación (o un mensaje de error).
  3. multiplicar() que permite calcular el producto de dos números (por ej., para calcular el producto 3*2 se utilizaría el comando multiplicar(3, 2)).
  4. dividir() que permite calcular la división entre dos números (3/2 se escribiría como dividir(3, 2)).

Nota: Recuerde que el área de un triángulo es igual a  (base x altura)/2.

Espero que este post, que forma parte del conjunto de tutoriales de Introducción a la Programación, haya sido de tu agrado, y que las diferentes ideas y conceptos expresados en el mismo se hayan entendido. De más está decir que ante cualquier duda, consulta, crítica o aporte que consideres necesario brindar, puedes dejar un comentario al final del post. Tu grano de arena ayudará a mejorar el sitio.

 


 

Suscríbete al Newsletter de Carbasoft:

Si te gustó esta estrada del blog, puedes ayudarme a mantener el sitio mediante PayPal:



También puedes darle Me gusta a la página de Carbasoft en Facebook: