2 - Diagramación y codificación en Ruby

El tutorial está ideado para ser desarrollado por una persona que no conoce nada de programación y se utilice el lenguaje de programación Ruby como primer lenguaje.

El objetivo fundamental de este tutorial es permitir que el estudiante pueda resolver problemas de distinta índole (matemáticos, administrativos, contables etc.) empleando como herramienta la computadora.

Hay que tener en cuenta que para llegar a ser programador se debe recorrer un largo camino donde cada tema es fundamental para conceptos futuros. Es importante no dejar temas sin entender y relacionar.

La programación a diferencia de otras materias como podría ser la historia requiere un estudio metódico y ordenado (en historia se puede estudiar la edad media sin tener grandes conocimientos de la edad antigua)

Es bueno tenerse paciencia cuando los problemas no se resuelven por completo, pero es de fundamental importancia dedicar tiempo al análisis individual de los problemas.

¿Qué es un programa?

Programa: Conjunto de instrucciones que entiende una computadora para realizar una actividad.
Todo programa tiene un objetivo bien definido: un procesador de texto es un programa que permite cargar, modificar e imprimir textos, un programa de ajedrez permite jugar al ajedrez contra el ordenador u otro contrincante humano.
La actividad fundamental del programador es resolver problemas empleando el ordenador como herramienta fundamental.

Para la resolución de un problema hay que plantear un algoritmo.
Algoritmo: Son los pasos a seguir para resolver un problema.

Diagrama de flujo

Un diagrama de flujo es la representación gráfica de un ALGORITMO.

Los símbolos gráficos a utilizar para el planteo de diagramas de flujo son:

Estos son los elementos esenciales que intervienen en el desarrollo de un diagrama de flujo.

Planteo de un problema utilizando diagramas de flujo.

Para plantear un diagrama de flujo debemos tener muy en claro el problema a resolver.
Ejemplo : Calcular el sueldo mensual de un operario conociendo la cantidad de horas trabajadas y el pago por hora.

Podemos identificar:

Datos conocidos:
Horas trabajadas en el mes.
Pago por hora.

Proceso:
Cálculo del sueldo multiplicando la cantidad de horas por el pago por hora.

Información resultante:
Sueldo mensual.

Si hacemos un análisis todo problema está constituido por:
- Datos conocidos: Datos con los que se cuenta al plantear el problema.
- Proceso: Operaciones a realizar con los datos conocidos.
- Información resultante: Es la información que resuelve el problema.

Esta forma de expresar un problema identificando sus datos conocidos, procesos e información resultante puede llegar a ser engorrosa para problemas complejos donde hay muchos datos conocidos y procesos. Es por eso que resulta mucho más efectivo representar los pasos para la resolución del problema mediante un diagrama de flujo.

Resulta mucho más fácil entender un gráfico que un texto.
El diagrama de flujo nos identifica claramente los datos de entrada, operaciones y datos de salida.
En el ejemplo tenemos dos datos de entrada: horas_trabajadas y costo_hora, a las entradas las representamos con un paralelogramo y hacemos un paralelogramo por cada dato de entrada.
La operación se representa con un rectángulo, debemos hacer un rectángulo por cada operación. A la salida la representamos con la hoja rota.

El diagrama de flujo nos da una idea del orden de ejecución de las actividades en el tiempo. Primero cargamos los datos de entrada, luego hacemos las operaciones necesarias y por último mostramos los resultados.

Ahora debemos codificar el diagrama de flujo utilizando las instrucciones del lenguaje Ruby.
La codificación del diagrama de flujo la haremos dentro del archivo ejercicio002.rb que creamos con nuestro editor favorito

El programa completo para el calculo del sueldo de un operario conociendo la cantidad de horas trabajadas y el costo por hora es (copiemos estas líneas en el editor):

puts "Ingrese las horas trabajadas por el empleado"
horas_trabajadas = gets.to_i
puts "Ingrese el pago por hora"
costo_hora = gets.to_f
sueldo = horas_trabajadas * costo_hora
puts "El sueldo total del operario es "
puts sueldo

Para ejecutar el programa debemos ir a la línea de comandos y escribir ruby y el nombre del archivo que acabamos de codificar:

Tener en cuenta que debemos ingresar el caracter "." en lugar del caracter "," si ingresamos un costo por hora con decimales.

Conceptos que deben quedar claros:

1. Por el momento haremos todo el algoritmo dentro de un archivo con extensión *.rb.

2. Si observamos el diagrama de flujos vemos que utilizamos tres variables: (horas_rabajadas, costo_hora, sueldo), en Ruby la variable se define de que tipo es cuando se carga un valor. La cantidad de horas normalmente será un valor entero (ej. 100 - 150 - 230 etc.), pero el costo de la hora es muy común que sea un valor real (ej. 5.35 - 7.50 etc.) y como el sueldo resulta de multiplicar las horas trabajadas por el costo por hora el mismo deberá ser real.
   

   Para cargar por teclado datos utilizamos el método gets y a partir de estos datos llamando al método to_i se convierten a un tipo entero y es almacenado en la variable horas_trabajadas:
   

   horas_trabajadas = gets.to_i
   

   Como queremos cargar un valor flotante en la variable costo_hora debemos llamar a gets y seguidamente a to_f (to_f convierte a tipo de dato float):

   costo_hora = gets.to_f
   

   Los nombres de las variables, por ejemplo: horas_trabajadas, deben comenzar en minúscula y en caso de estar constituida por dos palabras se las separe por el caracter '_'(un nombre de variable no puede tener espacios en blanco, empezar con un número, ni tampoco utilizar caracteres especiales)
   Debemos buscar siempre nombres de variables que nos indiquen que almacenan (no es conveniente llamar a nombres de variables con letras individuales salvo en casos puntuales que veremos más adelante)

3. Para mostrar mensajes en la pantalla utilizamos el método puts:
   

   puts "Ingrese las horas trabajadas por el empleado"
   

   Con esta sintaxis todo lo que se encuentra contenido entre comillas aparecerá exactamente en la pantalla.
   Si necesitamos mostrar el contenido de una variable debemos disponer la variable sin comillas::
   

   puts sueldo
   

4. Para hacer la entrada de datos por teclado en Ruby debemos utilizar el método gets y mediante los métodos to_i o to_f indicamos que el dato ingresado es un entero o un flotante:

   horas_trabajadas = gets.to_i
   

5. Las operaciones que indicamos en el diagrama de flujo mediante la figura rectángulo la codificamos tal cual:
   

   sueldo = horas_trabajadas * costo_hora
   

Podemos ver una relación entre las instrucciones que debemos utilizar para cada símbolo del diagrama de flujo:

No representamos con símbolos los mensajes a mostrar previo a la carga de datos por teclado:

puts "Ingrese las horas trabajadas por el empleado"