Como aprender a programar desde 0 (parte 6)


Cómo aprender a programar y no morir en el intento – Parte 6

Continuando con nuestra interminable reconocida y solicitada saga orientada a quienes se empiezan a adentrar al mundo de la programación, hoy les traemos una nueva edición, realmente la última que veremos sobre Pseudo lenguajes y además las últimas consideraciones previas a la entrada a los lenguajes reales.

Cómo aprender a programar y no morir en el intento – Parte 6

Contenidos:

  1. Funciones.
  2. Ultimas consideraciones sobre Pseudo-código.
  3. Entrando a un lenguaje real.
  4. Más sobre los paradigmas de programación.
Como pueden apreciar, hay harto que cubrir, así que vamos directo a eso:

1.- Funciones.

El último tema que cubriremos sobre programación en pseudo-código propiamente tal, será el de las funciones, el cual es un elemento de suma importancia tanto para estas etapas tempranas como para cuando nos adentremos aun más en la programación.
Intentaremos simplificar este tema lo que más podamos. De cualquier forma, a pesar de la complejidad que puede presentar, no se preocupen si no lo entienden a la perfección en un comienzo, ya que a medida que vayamos viendo los ejemplos y en otros contenidos más avanzados iremos comprendiendo bien este tema.
Hasta ahora, cada vez que escribíamos un programa y dentro de el necesitábamos tener procedimientos de cálculo o manipulación de datos, los escribíamos línea por línea estructuradamente dentro del principal de nuestro programa, algo así:
Definición de variable / asignación de valor
Operación 1
Operación 2
Operación 3
Asignación de resultados
Si las operaciones anteriores las necesitamos utilizar más de una vez o para distintas variables, adicionalmente podíamos añadirlas dentro de un ciclo, si el tipo de variables nos lo permiten, o bien repetir las operaciones dentro del programa las veces que sean necesarias.
Ahora, si la operación es de una sola línea, como una operación matemática por sí sola, no presenta mayores complejidades ni costos repetirla todas las veces que sean necesarias. Sin embargo, cuando hablamos ya de un proceso que contiene varias operaciones, y por ende varias líneas de código, es cuando el tema se vuelve mucho más complejo y engorroso, ya que nuestros programas empiezan a aumentar de tamaño y será mucho más costoso (computacionalmente hablando) ejecutarlos.
Para esto es que se definen las Funciones, las cuales, como su nombre lo indica, ofrecen la funcionalidad de agrupar y ejecutar una serie de operaciones, tanto por si solas como dependiendo de ciertos parámetros que les entreguemos, y a la vez dándonos la opción de retornarnos un valor que puede ser constante o variable dependiendo de los resultados de las operaciones y cálculos internos de la función.
La programación está compuesta fundamentalmente de funciones, y hasta ahora, a través de los contenidos y ejemplos, hemos utilizado una serie de ellas. Por ejemplo, la parte principal que declaramos en cada programa que hacemos es una función, es la que contiene los contenidos principales del programa que escribimos, valga la redundancia. A esa función no le entregamos ningún tipo de parámetros y no nos retorna nada. Otras funciones que hemos utilizado hasta ahora son las iteraciones condicionales (Si, Si no), los ciclos (mientras, para, haga mientras) y otras como leer, mostrar, etc.
¿Qué ventajas presentan las funciones?
Principalmente orden, comodidad y economía. El uso de funciones nos permite no tener que repetir operaciones según el número de veces que las vayamos a necesitar y en vez de eso solo definirlas una vez y llamarlas cuando sea necesario. Eso también implicará que nuestro programa sea mucho más liviano al momento de ejecutarse. Existen una serie de otras ventanas que iremos descubriendo más adelante.
Las funciones se escriben fuera de la función principal (normalmente por orden, se escriben después) y se definen de acuerdo a la siguiente estructura:
tipo     nombre_función(parámetro 1, parámetro 2, etc.)
{
operación 1;
operación 2;
sentencia 1;
sentencia 2;
retorno de variable;
}
Donde:
  1. Tipo: Detalla el tipo de valores que devuelve la función. Estos tipos pueden ser los mismos que los de las variables, los cuales han sido especificados en los números anteriores de esta saga. Sin embargo, no hay que confundirse, ya que por el hecho de que una función sea de un determinado tipo, no significa que dentro de las operaciones no puedan declararse y usarse variables de otros tipos, solo debemos fijarnos que las variables que retornamos si lo sean. Se debe definir un tipo para la función obligatoriamente.
  2. Nombre de la función: Es un nombre único, tal como si estuviésemos definiendo una nueva variable. El nombre de la función puede ser cualquiera, pero es recomendable, por orden, darle un nombre adecuado. Por ejemplo si definimos una función que encuentre el número máximo entre una serie de valores, es recomendable nombrar a esa función como numero_maximo. De esa forma, siempre podremos ver que hace cada parte de nuestro programa rápidamente cuando lo estemos revisando.
  3. Parámetros: Tal como hemos definido en distintas partes de esta saga de tutoriales, los parámetros que recibe una función son los que utilizará para operar dentro de ella y devolver resultados. Normalmente las operaciones declaradas en una función son procedimientos estándar que varían dependiendo de los valores que manejamos. En una función podemos recibir múltiples parámetros y estos pueden ser de distintos tipos, solo debemos asegurarnos de escribir primero el tipo y luego el nombre de ese parámetro, tal como si definiéramos variables. Estos nombres no pueden repetirse dentro de la función.
  4. Operaciones y sentencias: Básicamente podemos hacer lo mismo que hacemos dentro de nuestros programas, ya sea usar operadores matemáticos, iteraciones condicionales, ciclos, mostrar, leer, etc. Todo está permitido.
  5. Valor a retornar: Esto es opcional, una función puede o no retornar un valor, ya que muchas veces el resultado podemos mostrarlo directamente en pantalla con la función mostrar. Si decidimos devolver un valor, lo hacemos mediante la sentencia retornar junto al valor o variable que enviemos. Solo debemos recordar que el valor o variable retornado tiene que coincidir con el tipo de la función.
Con toda la definición ya más clara, veremos un ejemplo de declaración y uso de funciones:
Ejemplo: Realizaremos un programa en donde crearemos una función que defina que número es mayor entre 2 entregados como parámetros. Los comentarios, como siempre, en negrita, cursiva y entre /* y */:
Inicio/* Damos inicio al programa */
Numero num1, num2, mayor;
/* Declaramos 3 variables de tipo Número: num1 y num2 que serán 2 números que el usuario ingresará por teclado, y mayor, que será donde se almacenará el número mayor después de que la función nos devuelva el resultado */
principal ( )
{
/* Declaramos la función principal del programa */
mostrar(“Por favor ingrese el número 1: “);
leer(%numero, &num1);
mostrar(“Por favor ahora ingrese el número 2: “);
leer(%numero, &num2);

/* Mediante mostrar y leer, recibimos por teclado los 2 números ingresados por el usuario */
mayor=numero_mayor(num1, num2);/* A la variable mayor, le asignamos el resultado de llamar a la función numero_mayor, especificada luego de la función principal, pasándole como parámetros las variables num1 y num2 */
mostrar(“El número mayor de los que ingreso es: %numero”, mayor);/* Nuestra variable mayor ya recibió el resultado de la función, así que lo desplegamos */
}
numero numero_mayor(numero valor1, numero valor2)
{
/* Declaramos una función de tipo numero, llamada numero_mayor y que recibe como parámetro 2 variables de tipo numero, llamadas valor1 y valor2, que corresponden a los num1 y num2 enviados desde arriba */
Si(valor1 > valor2)
{
retornar valor1;
}
Si no
{
retornar valor2;
}
/* Mediante una iteración condiciional, hacemos una comparación entre los 2 números y retornamos el mayor de los 2 para que se le asigne a la variable mayor y se muestre por pantalla al usuario. */
}
Fin
Con este simple ejemplo hemos podido apreciar un poco el funcionamiento y uso de las funciones en la programación. Hay un importante concepto que hemos utilizado ahora, pero que detallaremos más en profundidad cuando estemos hablando de lenguajes reales, que es el paso de parámetros desde una función a otra (lo que hicimos cuando llamamos a la función y lo que esta recibe por el otro lado). Por ahora no vale la pena entrar en esos detalles, pero ya los veremos más completamente.
Con las funciones sucede lo mismo, esta pasada que le hemos dado ahora es bastante superficial, pero iremos cubriendo otros aspectos y descubriendo sus usos completos y más complejos a medida que vayamos programando más y más. Por ahora es una buena técnica ir combinando los otros contenidos que hemos visto en los capítulos anteriores con esto e ir practicando. Por ahora, al siguiente tema.

2.- Últimas consideraciones sobre el Pseudo-código:

En estos momentos que estamos llegando al final de nuestra cobertura sobre el pseudo-código o pseudo-lenguaje, es bueno repasar algunas consideraciones antes de adentrarnos al lenguaje real en el que decidamos programar, por ejemplo:
1.- Recordemos que el pseudo-lenguaje no es un lenguaje de programación real, y por ende, lo que hemos cubierto hasta acá no lo encontrarán en libros o puede que aparezca de forma distinta. No se preocupen, el objetivo nunca ha sido ni será que nos convirtamos en expertos de pseudo-código, si no que entendamos como se desarrollan los procedimientos en la programación y como plantearnos soluciones a los problemas mediante el entendimiento de la estructura de los programas.
2.- El pseudo-código, a pesar de no ser un lenguaje real, utiliza un paradigma estructurado y por la forma y palabras que normalmente se uilizan, se asemeja bastante al lenguaje C, por lo que es la opción natural para seguir. Veremos más de esto en el próximo punto.
3.- Lamentablemente, al no tratarse de un lenguaje real, no existe ningún software que podamos utilizar para programar y así ver nuestros errores para poder solucionarlos. Esto por un lado es bueno, ya que agudiza nuestra forma para leer el código y detectar errores, algo que nos servirá de sobremanera más adelante.
4.- Es recomendable que repasemos e intentemos entender de la mejor forma todos los puntos explicados en esta y pasadas ediciones de esta saga. Si bien hemos cubierto una pequeña parte de todo lo que comprende la programación, hasta ahora hemos visto las bases fundamentales para entender los lenguajes reales y todo el resto de aplicaciones dentro de la programación, por lo que entender de la mejor manera estas bases será esencial para que la enseñanza no se complique más adelante.

3.- Entrando a un lenguaje real:

Ahora que hemos de alguna forma “terminado” con el pseudo-lenguaje ha llegado un momento importante: Decidir el lenguaje de programación que empezaremos a aprender.
Esta decisión no es sencilla, y depende de varios factores, entre ellos el paradigma de programación, la facilidad del lenguaje, la extensibilidad y funcionalidades, actualización con los tiempos e incluso preferencia personal entre muchas otras razones.
Al momento de elegir debemos tomar esas consideraciones, aunque también fijarnos en otras como la documentación disponible, grupos de usuarios y todo lo que nos pueda apoyar a que el aprendizaje sea más sencillo.
Como experiencia personal, y el camino que seguiremos en esta saga de tutoriales, una de las mejores opciones para continuar es el lenguaje C, esto debido a lo similar que es al pseudo-código que hemos visto y porque ambos comparten el mismo paradigma estructurado, con lo que la transición se hace mucho más sencilla y así es posible pasar a otros lenguajes con mayor facilidad en el futuro. Así que prepárense, que para allá vamos.

4.- Más sobre los paradigmas de programación:

Tal como veíamos en este tutorial, actualmente existen 4 paradigmas comunes de programación, como son (ojo que son definiciones básicas, para que nos hagamos la idea de cada uno):
  1. Paradigma estructurado: Es el paradigma que hemos estado viendo hasta ahora con el pseudo-lenguaje y que luego veremos con C. Este paradigma, como su nombre lo indica, expresa una declaración y funcionamiento estructurado para sus programas, en donde desde arriba a abajo en una misma “plantilla de programa” debe estar el inicio, la declaración de las variables del programa y las funciones (la principal y otras funciones). Todo definido desde su inicio a su final. Además, los lenguajes estructurados se enfocan principalmente en el tratamiento de datos, recibiéndolos, operando con ellos y mostrando resultados. No tienen más profundidad que eso.
  2. Paradigma orientado a objeto: A diferencia del estructurado, en este paradigma, todo se trata como un objeto, cada uno de ellos con atributos, tal como si habláramos de objetos del mundo real. Los lenguajes de POO (programación orientada a objetos), operan mediante distintas clases, que son plantillas que determinan el comportamiento de un objeto. Pueden haber clases donde se determine un objeto, sus atributos y los métodos (parecido a las funciones) que se aplican a ellos y otras clases donde solo se encuentre el método principal (como la función principal). Este es un paradigma mucho más complejo que no queremos detallar por ahora para no confundirnos, porque el paso desde un lenguaje estructurado a uno POO complica al principio, pero no se preocupen, ya lo veremos.
  3. Paradigma orientado a eventos: En este paradigma se habla de lenguajes que dentro de un programa, presentan una serie de acciones que están “siempre listas” y se encuentran en espera para dispararse de acuerdo a un evento que ocurra (normalmente ejecutado por un usuario). Por ejemplo, tenemos programas como Word o Excel, que en sus menús y botones cuentan con múltiples mini-programas listos para ejecutarse cuando el usuario presione el botón o seleccione el menú. Por ahora no adentraremos más en esto, por las mismas razones el caso anterior.
  4. Paradigma orientado a aspectos: Este es un paradigma que actualmente se encuentra bajo investigación, por lo que no hay gran información disponible. Decidimos mencionarlo más por anécdota que por cubrirlo propiamente tal. Quizás cuando estemos en números futuros de esta saga podamos ir adelantando más información.
Con esto podemos tener un poco más claro por qué existen distintos lenguajes de programación y que los diferencia, es principalmente su paradigma.
Para casos de esta saga, por las razones antes descritas, seguiremos con el lenguaje C, el cual nos servirá de base para todo el aprendizaje que tendremos que hacer.
Fin

Cuestionario:

0 comentarios:

Publicar un comentario

 
Design by Free WordPress Themes | Bloggerized by Lasantha - Premium Blogger Themes | Bluehost Review