Cómo aprender a programar y no morir en el intento – Parte 2
Con las Fiestas Patrias ya quedando atrás, y luego de una tonelada algunos tutoriales de cocina que les dejamos en estos días, volvemos un poco más a la normalidad en Como Lo Hago, y que mejor que trayéndoles la segunda parte de esta saga de tutoriales que hemos estado preparando para aquellos que quieren adentrarse en el mundo de la programación.
Bueno sin más preambulo les digo, que como siempre, todo el detalle está después del salto.
Cómo aprender a programar y no morir en el intento – Parte 2
Contenidos:
Tal como lo prometimos en el tutorial anterior, hoy veremos los siguientes temas:
- Áreas de memoria alias “Como almacena un computador la información”.
- Introducción al Pseudo-Código.
- Haciendo nuestro primer programa.
¿Listos?, ¿Fueron a buscar bebida?, yo no he ido, así que esperenme -> !.
1.-Áreas de memoria.
Quizás para gente más experimentada en el tema de la programación, pueda parecer algo repentino entrar a esto tan luego, pero hay una razón de fondo que es empezar a relacionarnos con el concepto de las variables de cierta forma.
Pero bueno, ¿Qué son las áreas de memoria?. Para contestar esta pregunta, nos haremos otra, ¿Cómo almacena la información una máquina/equipo/computador?.
Básicamente lo hace de 2 formas, o mediante el uso de 2 tipos de memoria: la volátil y la no volátil.
La memoria volátil es toda aquella que una vez que apagamos el computador se vacía (Ej: Memoria RAM). Tiene la ventaja de ser de mayor acceso (lectura/escritura) y obviamente la desventaja de que su almacenamiento no es“permanente”.
Por su lado la memoria no volátil es justamente lo contrario a la anterior, ya que una vez que almacenamos información ahí, quedará hasta que decidamos borrarla o “alguien” lo decida por nosotros. Ejemplos de memoria no volátil son los almacenamientos magnéticos (discos duros) o los ópticos (CD, DVD, etc).
En la programación se utilizan ambos tipos de memoria. Por un lado se utiliza la memoria volátil para el trabajo convariables (explicaremos eso en detalle) y por otro lado la memoria no volátil cuando estamos trabajando con archivos o en otras situaciones que iremos viendo a medida que ocurran.
En una representación gráfica, la memoria volátil que utiliza la programación (RAM), sería algo como esto, guardando las proporciones:
Cada cuadradito representa un área de memoria, el cual posee una dirección expresada en valores hexadecimales (algo por ejemplo como FA2246) la cual se llama dirección de memoria, y es utilizada cuando se quiere acceder a los datos almacenados en ese “cuadradito”.
¿Se acuerdan esa vez que les dijimos que explicaríamos las variables en detalle?, que tiempos aquellos ¿no?, bueno el momento es ahora.
Las variables
Esta definición no intenta ser técnica ni mucho menos. Solo pretendemos que el concepto quede claro para que lo intentamos lograr.
Una variable es un “enlace contenedor” de y a un dato. ¿Por qué enlace contenedor?, porque una variable esta relacionada a una dirección de memoria, por ende enlace, y contiene un valor correspondiente a un dato que podemos recibir o tomar de otro lado (usuario, otra variable, el resultado de una operación, etc), ergo contenedor. Esta definición se irá haciendo más clara a medida que vayamos avanzando.
Las variables tienen ciertas características, como son:
Nombre: Corresponde al identificador de la variable. Los nombres de variables dentro de un programa deben ser únicos, no empezar con un número, no contener símbolos y respetar las palabras reservadas dentro de un lenguaje de programación (Por ej: En Java, la palabra new es reservada, por lo que no se puede nombrar una variable así).
Tipo: Corresponde al tipo de datos que podrán almacenarse en la variable. Si bien en lenguajes como PHP no es necesario definir el tipo, la mayoría de los otros lenguajes lo piden. Los tipos más comunes son:
- Int: Corresponde a números enteros (correspondiente al universo Z de las matemáticas). El rango que abarca (valores máximos y mínimos que se les puede dar) varía del lenguaje en uso. Existen 2 variaciones comunes como son el short int o short y el long int o long. Varían en el rango.
- Float: Corresponde a valores de punto flotante (números decimales correspondientes al universo Q de las matemáticas). En algunos lenguajes se puede utilizar como double, short double o long double. Su rango difiere del lenguaje a utilizar.
- Char: Corresponde a valores de caractéres alfanuméricos (
- Boolean: Corresponden a valores de tipo lógico. Almacenan sólo 2 posibles valores: true o false.
- String: Corresponde a una cadena de caractéres, por ejemplo una palabra o frase. Su rango depende de cada lenguaje.
Además debemos tener presente que las variables pueden cambiar su valor a lo largo del programa (a no ser que sean definidas como constantes, ya veremos eso más adelante) y existen observaciones sobre las operaciones que ejecutamos sobre ellas. Estos puntos los detallaremos más adelante.
Dejando esa definición un poco más clara, volvemos al tema de las áreas de memoria.
Cuando creamos una variable, o bien la definimos, el equipo le asigna automáticamente un área de memoria en la cual almacenará su valor. En caso de sobrepasar el área asignada, se le asignará una nueva área de memoria, y así sucesivamente.
Esta sección de las áreas de memoria irá quedando cada vez más clara según vayamos avanzando.
2.- Introducción al Pseudo-Código
El Pseudo-Código, como su nombre lo indica, es una especie de “lenguaje de programación” utilizado para introducir a los futuros programadores a la estructura de la realización de programas.
En él, se utilizan todos los recursos de un lenguaje de programación normal, a pesar de que los nombres y conceptos puedan variar dependiendo de quien lo enseñe, y se busca principalmente practicar un poco la lógica que posteriormente debemos implementar.
Lo principal que se debe entender, es que a pesar de establecer algunas reglas sobre como se operará con el pseudo-código, los únicos errores que se pueden cometer son de lógica y no como expresamos las distintas funcionalidades del programa, así que hay que irse sintiendo lo suficientemente libres para experimentar.
Antes de entrar de lleno a este tema, es bueno detenernos y explicar un poco el tema de los paradigmas de programación.
Paradigmas de programación
En la programación existen una serie de paradigmas que se refieren principalmente al enfoque que le daremos a un problema para solucionarlo o bien “la forma en que veremos las cosas”. Los paradigmas más comunes son:
- Paradigma de programación estructurada.
- Paradigma de programación orientada a objetos.
- Paradigma de programación orientada a eventos.
- Paradigma de programación orientada a aspectos.
Para las primeras etapas de estas guías nos enfocaremos en el paradigma estructurado. A medida que vayamos avanzando nos interiorizaremos más en esto.
Volviendo al tema del Pseudo-código, y habiendo establecido el punto de los paradigmas, veamos el formato clásico y básico de un programa:
Inicio
Definición/declaración de variables
Cuerpo del programa
Fin
A medida que vayamos haciendo programas más complejos veremos como este formato se va a ampliando. Una explicación de las partes:
- Inicio: Se refiere al comienzo del programa.
- Definición/declaración de variables: Aquí indicamos todas las variables que utilizaremos para la realización de nuestro programa, junto con su tipo y en algunos casos, su valor inicial.
- Cuerpo del programa: Aquí irá el desarrollo de nuestro programa, indicando información que recolectaremos, operaciones y salidas (entrega de información).
- Fin: Se refiere al fin del programa.
Cumpliendo esos pasos básicos, podemos empezar a hacer nuestros primeros programas. Así que a tomar una hoja de papel, un lápiz y una goma, porque de seguro deberemos borrar más de alguna cosa por ahí.
3.- Haciendo nuestro primer programa
Para hacer nuestro “bautizo oficial” en el mundo de la programación, partiremos por realizar el ejercicio más clásico que aparece en todos los libros de programación de aquí a la eternidad, el famoso “Hola mundo”.
En este programa lo que haremos será simplemente mostrar un mensaje en pantalla que diga “Hola Mundo”. El código a continuación, y los comentarios van en negritas, cursiva y entremedio de /* y */.
Ejercicio 1: Hola Mundo
Inicio
/* Establecemos el inicio del programa */
Principal( )
/* Definimos la función “Principal” que es donde irá el cuerpo del programa. Ya adentraremos el tema de las funciones */
mostrar “Hola Mundo”;
/* Utilizamos la sentencia “mostrar” para enviar un mensaje que se despliegue en pantalla y entre comillas la frase que mostraremos, en este caso “Hola Mundo”. Luego de la sentencia ponemos un punto y coma para indicar el fin de esta, algo que utilizaremos mucho cuando estemos programando en algún lenguaje, ya que eso le indica al entorno de programación que es el fin de la sentencia */
Fin
/* Finalizamos el programa */
Y así de simple. Hemos hecho nuestro primer programa enviando un mensaje “Hola Mundo” que se mostrará en la pantalla. Para este programa, como solo mostramos un mensaje, podrán ver que no hicimos uso de variables, por eso nos saltamos la parte de la definición de ellas. En posteriores ejercicios haremos uso de eso.
----------------------------------------------------------------------------------------------------------------------------------
0 comentarios:
Publicar un comentario