Aprender a programar: 10. Clases, bloques y procs

Parece que he pasado bastante tiempo inactivo en el blog, pero hoy vengo con buenas noticias: ¡están listas las ultimas partes de «Aprende a programar»!

• El capítulo 10 muestra como se definen las clases en Ruby, algunos detalles útiles para trabajar con el tiempo por medio de la clase Time, y el funcionamiento de los diccionarios (hashes).
• El capítulo 11 trata sobre una característica de Ruby que permite resolver problemas de formas muy interesantes: los bloques y procs, conjuntos de instrucciones que son tratados como objetos.

Al final del tutorial, Chris incluye tres grandes fuentes de referencia para resolver dudas sobre Ruby, las cuales he complementado con algunas fuentes en español para quienes así lo prefieran.

Puedes pasar directamente al tutorial con el siguiente enlace. (Y puedes descargar el tutorial desde el menú Archivo → Descargar como...).

Aprende a programar

Ahora que la traducción está prácticamente terminada, pienso en que me ha sido una grata experiencia en conjunto. Las horas empleadas en buscar como adecuar un termino o frase del inglés al español para que se escuche natural sin perder el sentido y agregando notas cuando fue necesario, el tedioso proceso de dar un buen formato tratando de cuidar la legibilidad a la vez que la estética, el repetitiva actividad de revisar ortografía y gramática, y la mentalmente agotadora tarea de adaptar los ejemplos para el habla hispana (en cierto punto terminé odiando a la RAE), todo ello culminando en un sentimiento de satisfacción por haber completado el proyecto.

Quedan unos pequeños detalles que pulir, pero corresponden principalmente al repositorio del proyecto (agregar enlaces, notas) y queda como posibilidad, para una futura versión, pasarlo a formato docbook o markdown, lo que facilitaría el ser portado por medio de alguna aplicación a otros formatos.

Si alguien gusta colaborar, puede hacerlo mediante el repositorio del proyecto.

Ya por último, si conocen a alguien interesado a aprender a programar y quieren evitar que sufra de entrada con la sintaxis de Java, C#, etc., compartan con esa persona el enlace al tutorial. Seguramente le será de utilidad.

Aprende a programar: 9. Como crear tus propios métodos

¡Él capítulo 9 está listo! «Escribiendo tus propios métodos» ha tomado más tiempo del que esperaba debido a la gran cantidad de edición y pruebas que se tuvieron que hacer código del programa que escribe números en su versión de texto en español (el programa original del tutorial los escribe en inglés, cuyas reglas para escribir números son mucho más sencillas y tiene menos casos especiales), además que los programas de ejemplo son bastante largos, pero al final he quedado satisfecho con el resultado.

Realizar las soluciones a los programas propuestos con las limitaciones de las técnicas vistas es un buen ejercicio, pero lo pospondré para seguir trabajando en la traducción de los últimos capítulos.

Espero que quien siga el tutorial disfrute con el contenido del capítulo, encuentre retadores los ejercicios que ahí se encuentran, y continúe con interés para adentrarse en el manejo de clases y bloques de los capítulos siguientes.

Como de costumbre, la versión más reciente la puedes encontrar en el siguiente enlace:

Aprende a programar

La terrible exclamación, o, resultados inesperados de métodos con ! en Ruby

Ésta es una traducción del artículo «The Big Bad Bang, or, The OTHER Gotcha with Ruby's Bang Methods», escrito originalmente por David Aronson en Attack of the Codosaurus!, y es publicado bajo su permiso.

---

     Algunas personas me han preguntado el por qué ciertos métodos de Ruby terminan con un signo de exclamación (!), comúnmente conocido como bang en los círculos de programación. Los ejemplos incluyen upcase! (para obtener una versión completamente en mayúsculas de una cadena de caracteres) y uniq! (para obtener los elementos únicos dentro de un arreglo). Para acortar la explicación, el bang significa que debes usar ese método con precaución.

     Esto es debido a que usualmente el método modifica el objeto que recibe y luego lo devuelve (proceso destructivo), en lugar de devolver sólo una copia modificada del objeto. (En Rails y otros frameworks similares, puede indicar que el método arrojará una excepción si algo sale mal. Pero, nos enfocaremos en los métodos básicos de Ruby.) Les mostraré otra razón en un momento, pero por ahora, vamos a examinar el comportamiento usual y esperado.

     Por ejemplo:

cadena = 'foo'
p cadena.upcase # > FOO
p cadena        # > foo

     Obtenemos FOO y después foo. Cuando upcase devolvió la versión en mayúsculas, no modificó la cadena.

     Por otro lado, si agregamos un bang, así:

cadena = 'foo'
p cadena.upcase! # > FOO
p cadena         # > FOO

     ¡Obtenemos FOO y otra vez FOO! En otras palabras, upcase! devolvió la versión en mayúsculas, justo como la versión sin bang, ¡pero también modifico la cadena!

     De forma similar, si usamos uniq:

arreglo = [1, 3, 3, 7]
p arreglo.uniq # > [1, 3, 7]
p arreglo      # > [1, 3, 3, 7]

     Obtenemos [1, 3, 7] y [1, 3, 3, 7], mostrando que la versión sin bang devolvió los valores únicos dentro del arreglo, pero no lo modificó, mientras que si agregamos un bang:

arreglo = [1, 3, 3, 7]
p arreglo.uniq! # > [1, 3, 7]
p arreglo       # > [1, 3, 7]

     Obtenemos [1, 3, 7] y [1, 3, 7] de nuevo, mostrando que el arreglo fue modificado ésta vez.

     Hasta ahora todo bien. ¡Pero espera! ¡Aún hay más! Hay un comportamiento inesperado aguardando ser encontrado...

No esperes que las versiones con bang de los métodos devuelvan el mismo valor que las versiones sin bang. (Aunque ese valor parezca ser la razón de ser de ambas funciones.)

     En los casos antes mencionados, ese es el punto. Pero observemos lo que pasa si la variable ya tiene el valor que necesitamos –en otras palabras, si la cadena ya está en mayúsculas, o el arreglo ya cuenta sólo con valores únicos.

     Si usamos:

cadena = 'FOO'
p cadena.upcase! # > nil
p cadena         # > FOO

     Como esperamos de la cadena, al ya contener el valor que necesitamos, no fue modificada. Pero observa el valor devuelto por cadena.upcase! –¡es nil!

     Veamos que pasa en el caso numérico:

arreglo = [1, 3, 7]
p arreglo.uniq! # > nil
p arreglo       # > [1, 3, 7]

     Justo como en el caso anterior, el arreglo no sufrió cambios, ¡pero el valor devuelto por arreglo.uniq! es nil! ¿Cómo es eso posible?

     De forma resumida, los métodos básicos en Ruby que incluyen el bang, con frecuencia devuelven nil si no se realizó ningún cambio. El problema es que esto no pasa de una forma consistente, por lo tanto, cuando utilices un método que incluye bang con el que no estés familiarizado, asegurate de leer el manual.

Aprende a programar: Capítulos 0 a 8 revisados

     ¡Uffff! Después de varios días de arduo trabajo (que incluyeron sus respectivos y merecidos descansos), he concluido la revisión del material traducido del tutorial «Learn to Program» hasta el momento.

     Además de corregir algunos errores gramaticales y ortográficos, se han hecho las siguientes mejoras:

• Se agregaron enlaces a la mayoría de los códigos de ejemplo para ser probados directamente desde el navegador, sin la necesidad de instalar Ruby. (Gracias a repl.it).
• Se proba el código de todos los programa de ejemplo para asegurar que todos ellos puedan ejecutarse.
• Se incluyeron enlaces a código de ejemplos de soluciones a cada uno de los ejercicios propuestos. (Para quien pueda llegar a necesitar una guía).
• Se reorganizo el proyecto en GitHub para que tenga una estructura coherente y facilite la colaboración.

Como siempre, el material más reciente se encuentra en el documento:

Aprende a programar

«Aprende a programar» ahora en GitHub

¡Saludos, lectores!

     El blog ha tenido poco movimiento debido al proceso de adaptación a mi nueva rutina de trabajo (tome un trabajo eventual como recepcionista-auditor nocturno) y de «adecuación física» (me encuentro a medio proceso de llegar a mi peso ideal a través de cambios en mi alimentación y ejercicio constante), pero he permanecido con el propósito de completar mi preparación en el área de desarrollo de software.

     Por supuesto, eso incluye el continuar con mis proyectos, entre los cuales se incluye la traducción de «Lear to Program». Aunque el proceso de traducción ha tenido poca actividad, he continuado haciendo pequeñas mejoras al revisar el texto con atención: corrigiendo errores, agregando notas, adecuando el estilo y cambiando palabras para hacer más claro el sentido donde me ha parecido adecuado.

     He tenido que iniciar una revisión general a causa de que al estar trabajando en la traducción del capítulo 7, encontré que no había probado los ejemplos de código que habían sido modificados en el proceso. Y en mi convicción de entregar un trabajo de calidad a las personas con la intención de aprender sobre Ruby, me he vuelto un poco sobre mis pasos. No espero que la revisión tome mucho tiempo, así que seguramente para Agosto ya la habré terminado. Y durante ese mismo mes, quiero terminar el proceso de traducción de los capítulos 7 y 8.

     Probablemente uno de los cambios más interesantes es que he movido el trabajo a la plataforma de Github, lo que permitirá que otras personas puedan participar en el proyecto con relativa facilidad por medio del sistema de control de versiones Git en el siguiente enlace:

Aprende a programar

Aprende a programar: 8. Arreglos e iteradores

     Es turno de aprender a manejar un nuevo tipo de objeto: ¡los arreglos! Aunque son sólo listas que guardan referencias a otros objetos, nos permiten manipular grandes cantidades de información relacionada y aplicar sobre ella tareas repetitivas de una forma sencilla.

     Aún más, los arreglos en Ruby cuentan con métodos especiales que nos permiten movernos entre sus elementos sin tener que estar al pendiente de la posición en donde nos encontramos (cómo lo haríamos en C o Java).

     Puedes continuar leyendo al respecto en...

Aprende a programar

Aprende a programar: 7. El control del flujo de un programa

     ¡Por fin está listo el sexto capítulo de Aprende a programar! Tomo un poco de tiempo debido al formato extra que lleva el código para ilustrar las palabras clave usadas en control del flujo de un programa. Ésta sección revisa los temas de operadores lógicos, ramificación e iteración. Con ellos es posible construir casi cualquier tipo de programa, así que es muy importante entenderlos. Al final, hay un par de ejercicios bastante divertidos.

     Interesante, ¿no es así? Invierte un poco de tiempo y continua en

Aprende a programar