domingo, 15 de mayo de 2016

C++ unique_ptr

En esta nueva serie de C++, voy a cubrir algunos tópicos que me han resultado útiles en el último año. Los primeros artículos serán acerca de la creación de objetos y manejo de memoria. Uno de las principales mejoras en C++11 son unique_ptr's y shared_ptr's para facilitar el manejo de memoria. Para los ejemplos que estaré presentando, creé la clase MiClase, que imprime mensajes para ayudar a visualizar que partes de la clase son invocadas. Nuestro primer ejemplo muestra como un unique_ptr se encarga de llamar el destructor, a diferencia de un apuntador normal, donde tenemos que recordar llamar a delete para evitar posibles fugas de memoria.

domingo, 25 de octubre de 2015

Cómo aprender a resolver problemas en programación: Recomendaciones

  1. Introducción
  2. Recomendaciones

¿Cómo podemos empezar a aprender a resolver problemas de programación? En este post me gustaría analizar algunas de las estrategias propuestas en el capítulo 1 del libro Think Like a Programmer. An Introduction to Creative Problem Solving y cómo cada una de estas estrategias sí me han ayudado a mejorar mi habilidad para resolver problemas de programación.

Antes de intentar escribir código para cualquier problema de programación, es importante saber que existen algunas recomendaciones para ordenar nuestros pensamientos y posteriormente poner manos a la obra. Si organizamos nuestro entendimiento de lo que el problema está pidiendo, es mucho más fácil llegar a una primera solución, y aunque ésta sea una solución parcial o muy rudimentaria, es crucial entender que este es un muy buen primer paso y que con práctica, podremos ser capaces de saltarnos algunos pasos intermedios. Pero por ahora, lo más esencial es detenernos un poco y analizar qué se está pidiendo.

Algunas recomendaciones que he encontrado muy útiles en este primer paso de analizar un problema son las siguientes:

  1. Dividir el problema: Algunos problemas contienen muchos pasos o bien, es necesario hacer diferentes operaciones para encontrar la solución. Una buena estrategia es leer el problema más de una vez para poder identificar las diferentes partes en las que puede estar dividido. Dividir un problema nos permite hacer varias operaciones sencillas que combinadas, realizan una tarea compleja. Por ejemplo, supongamos que queremos contar el número de veces que un grupo de palabras aparece en un archivo de texto. Este problema lo podemos dividir en: leer el archivo, tokenizar el texto que contiene el archivo (es decir, desarrollar código que sea capaz de separar el texto del archivo en palabras individuales), leer palabra por palabra el texto del archivo, identificar si alguna palabra pertenece al grupo de palabras que queremos contar, llevar la cuenta de cuando una palabra de nuestro grupo aparece en el texto del archivo, repetir la cuenta para cada palabra de nuestro grupo de palabras y retornar nuestro resultado utilizando alguna estructura de datos. Si nos enfocamos en uno solo de estos pasos a la vez, resolver este problema es mucho más sencillo.
  2. Identificar las partes del problema que se nos hacen fáciles de resolver: Es posible que cuando estamos resolviendo un problema, existan ciertas partes que nos parecen más sencillas de resolver o con las que tenemos más experiencia. Esto es parecido a cuando resolvemos un examen: algunas preguntas son más sencillas que otras. En el libro Abre tu mente a los números: Cómo sobresalir en Ciencias aunque seas de Letras, aprendí que existe más de una manera de atacar las partes fáciles y difíciles de algo que queremos resolver. Volviendo al ejemplo del examen, algunas personas se sienten cómodas atacando las preguntas fáciles primero y dejando las difíciles para después. Pero otra estrategia que puede resultar exitosa de acuerdo con la autora es la siguiente: atacar lo más difícil primero y en cuanto comencemos a notar que estamos atorados, dirigir nuestra atención hacia preguntas o pasos fáciles y volver al problema difícil una vez que hayamos resuelto los fáciles. La idea detrás de esta técnica es que nuestro cerebro funciona en dos modos: en el primero se enfoca intensamente en una tarea y en el segundo procesa información de manera difusa (es decir, sin enfocarse particularmente en una idea). El modo difuso nos ayuda a seguir resolviendo el problema difícil mientras estamos resolviendo los problemas fáciles y es gracias a este modo de "pensar" que muchas veces recordamos información súbitamente o nos damos cuenta repentinamente de algún error que estábamos cometiendo.
  3. Reconocer o tratar de hacer analogías del problema a resolver: Con el paso del tiempo y con experiencia, reconocer problemas parecidos y recordar cómo los resolvimos se convierte en algo muy natural. En nuestro camino a adquirir esa experiencia es importante que podamos identificar si un problema se parece a algún otro o si podemos hacer alguna analogía. Las analogías nos ayudan a entender mejor el problema y en ocasiones nos pueden auxiliar a visualizarlo mejor. Una buena analogía es un excelente recurso que en un futuro cercano nos permite recordar más fácilmente aquéllo que aprendemos. Por ejemplo, en el problema de contar cuántas veces un grupo de palabras aparece en el texto de un archivo podemos visualizar una línea de producción en donde las palabras pasan frente a nosotros y nosotros tenemos que colocarlas en sus cajas correspondientes. Cada vez que clasificamos una de las palabras en las que estamos interesados, utilizamos un marcador para anotar cuántas palabras hay hasta el momento en cada caja tachando el valor anterior y escribiendo el nuevo valor que se incrementa en 1 unidad.
  4. Experimentar: El autor de Think Like a Programmer. An Introduction to Creative Problem Solving, deja muy claro que experimentar no significa solamente tomar piezas de código y comenzar a ver si alguna funciona de manera aleatoria. Experimentar se refiere a tratar de utilizar nuevo código de forma que parezca lógica y de acuerdo con nuestra (poca o mucha) experiencia. Supongamos que estamos tratando de generar algún tipo de gráfico y sabemos que existe una librería que puede contener la funcionalidad que estamos buscando. Para confirmar si podemos utilizar alguna función de la librería, podemos leer la documentación y hacer ejemplos simples para observar qué es lo que pasa. Si el resultado de estos experimentos es lo que nosotros necesitamos, entonces podemos utilizar esta librería para resolver nuestro problema de generar algún gráfico. Incluso en circunstancias en las que no necesitamos utilizar ninguna librería (como cuando estamos aprendiendo a utilizar un lenguaje de programación), experimentar haciendo pequeños ejemplos y observando el resultado es algo muy valioso que nos ayuda a entender realmente qué está pasando.
  5. Reducir la complejidad del problema: Imaginemos que estamos tratando de construir un programa para jugar al "gato" o "tic-tac-toe" en 3 dimensiones. Para poder resolverlo, es necesario que podamos manipular un arreglo en 3 dimensiones, sin embargo, quizá para familiarizarnos mejor con la forma de resolver este problema, es mejor enfocarnos en cómo resolveríamos el clásico juego en 2 dimensiones y posteriormente extender nuestra solución para tomar en cuenta un arreglo de 3 dimensiones.
  6. Evitar frustrarte: Esta es quizá solamente una recomendación, pero no por eso deja de ser valioso recordar que debemos respirar profundamente y no rendirnos. Si de verdad estás atorado resolviendo un problema, pide ayuda a alguien con más experiencia pero no te desesperes ni pienses que la programación no es para ti. Es muy válido pedir ayuda e incluso, es muy importante saber cuándo pedir ayuda y a quién.

Si bien estas no son las únicas estrategias para comenzar a resolver un problema, son las que más me han parecido útiles en mi camino a mejorar la manera en la que ataco los problemas de programación. Sin embargo, ninguna técnica puede reemplazar el hacer ejercicios. Es por esta razón que al terminar de leer este post, lo primero que debes hacer es resolver varios ejercicios. En el libro Think Like a Programmer el autor recomienda utilizar acertijos para practicar las recomendaciones que acabamos de analizar brevemente.

Las siguientes ligas contienen acertijos en español de varios tipos que pueden ayudarte a comenzar a utilizar estas estrategias. Trata de resolver aquéllos que no conozcas utilizando distintas formas de atacar el problema. Mientras más intentes, mejor:

http://www.parapensar.com/acertijos.html

http://www.elconfidencial.com/alma-corazon-vida/2014-07-28/10-acertijos-clasicos-que-pondran-a-prueba-tu-capacidad-logica_166413/

Si conoces otros sitios que contienen buenos acertijos, compártelos en los comentarios.

domingo, 11 de octubre de 2015

Cómo sincronizar Blogger y una página de Facebook automáticamente

Hasta hace poco tiempo, había estado usando RSS graffiti para publicar autómaticamente en la página de Facebook de este blog un resumen de cualquier post nuevo aquí en Blogger. Esta herramienta era muy conveniente y durante muchos meses nunca tuve que preocuparme por la sincronización entre este blog y su página de Facebook. Sin embargo, RSS graffiti dejó de funcionar en Abril de este año (2015) y sin darme cuenta, los posts que creé después de Abril nunca aparecieron en la página de Facebook.
Ahora bien, la búsqueda de otra herramienta parecida a RSS graffiti me llevó a conocer otro sitio que parece ser bastante útil: If This Then That (IFTTT). En este sitio es posible crear "recetas" que conectan diferentes aplicaciones para hacer prácticamente todo tipo de tareas. En este post me gustaría explicar paso a paso cómo es que usé IFTTT para sincronizar nuevamente este blog con su página en Facebook.
Los siguientes pasos están basados en la explicación que aparece en el blog Technology And Life:
  1. Si no lo has hecho, abre la página de IFTTT dando click aquí
  2. Regístrate haciendo click en el botón de "Sign up". IFTTT requiere la creación de una cuenta mediante un correo electrónico y un password (esta cuenta es totalmente gratuita):
  3. Abre el correo electrónico que proveíste en el paso anterior y confírmalo dando click en la liga que IFTTT envía después de haberte registrado:
  4. Una vez que confirmaste tu cuenta, da click en la opción "My Recipes" (observa la imagen que sigue):
  5. Existen dos tipos de "recetas": IF y DO. Para conectar Blogger y Facebook Pages vamos a crear una receta de tipo IF. Selecciona la pestaña de recetas tipo IF y da click en el botón "Create a Recipe":
  6. Observa cómo aparece la frase "ifthisthenthat" (figura de abajo). Da click en la palabra "this" que aparece resaltada en azul cielo:
  7. A continuación, selecciona Blogger de entre las aplicaciones que IFTTT muestra (si no aparece entre ellas, puedes buscarla en el cuadro de texto que dice "Search Channels"). La primera vez que se selecciona un canal o app, podrás seleccionar qué tipo de información de tu perfil quieres compartir con IFTTT:
  8. Después de seleccionar Blogger como nuestra primera aplicación, tenemos que seleccionar el tipo de acción que se va a llevar a cabo cada vez que un nuevo post es publicado en nuestro blog. De entre las dos opciones mostradas abajo, selecciona la izquierda ("Any new post") para activar nuestra receta cada vez que cualquier nuevo post se publique:
  9. Presiona el botón azul para crear la acción que disparará la receta:
  10. Nuestra nueva receta refleja lo que acabamos de hacer y es momento de seleccionar la segunda aplicación que queremos conectar (en este caso Facebook pages). Da click en la palabra "that" que está resaltada en azul:
  11. Selecciona la segunda aplicación de entre las opciones, actívala si es que no la has usado antes y ajusta la información que quieras compartir. En este caso la segunda aplicación será Facebook pages (que aparece como un canal por separado con respecto a Facebook):
  12. Elige la acción que quieres que ocurra en este segundo canal. En este caso, para crear un post en la página de Facebook, elige la opción de enmedio:
  13. Elige los campos (IFTTT les llama "ingredientes") que quieras que aparezcan en el post. Esto se logra dando click en las cajas de texto y después dando click en el ícono que aparece a la derecha. El primer campo requiere la URL del blog post y ya está puesto automáticamente. En el segundo (y más grande) cuadro de texto, puedes elegir diferentes "ingredientes" para la liga del blog en la página de Facebook. En este caso, yo simplemente elegí compartir el título del post:
  14. Por último, crea la receta presionando el botón azul:
  15. La interpretación de la receta es la siguiente: Si se ha creado un nuevo post en tu blog, entonces crea un post en tu página de Facebook seleccionada que contiene un link a ese nuevo post del blog. Para probar esta nueva receta, crea un nuevo post y córrela presionando en el botón "Check now":

El resultado (en la página de Facebook de este blog) de crear la receta anterior es el siguiente:

Si no estás satisfecho con la apariencia del post en la página de Facebook, tienes que borrar el post en tu blog y volver a crear uno nuevo, aplicar los cambios que desees a la receta en IFTTT y correr la receta como se menciona en el último paso.

De acuerdo con el blog Technology And Life, la receta se corre automáticamente cada 15 minutos y solamente se ejecuta si encuentra un post nuevo en el blog.

IFTTT es una herramienta muy interesante y dentro de la página puedes encontrar cientos de otras recetas para conectar diferentes aplicaciones o ejecutar distintas acciones. Vale la pena explorarlo a fondo. Aprender a utilizar esta herramienta puede resultar en ahorros de tiempo y esfuerzo para manejar nuestras aplicaciones.

domingo, 30 de agosto de 2015

Cómo aprender a resolver problemas en programación: Introducción

  1. Cómo aprender a resolver problemas en programación: Introducción

Durante la última mitad de mis estudios en la universidad me dediqué casi exclusivamente a trabajar con hardware y dejé un poco de lado la programación. Después de graduarme descubrí que había perdido bastante práctica y decidí comenzar a resolver problemas utilizando C++. Aunque C++ es el lenguaje que utilicé en mi último proyecto, éste no requirió del uso de programación demasiado extensivo y cuando decidí regresar a utilizar la programación me sucedió algo muy curioso: era capaz de entender lo que un problema me estaba pidiendo e inclusive, era capaz de seguir la solución propuesta por algún autor o programador pero al intentar construir mi propia solución me encontré con gran dificultad para poder comenzar a escribirla.

Para tratar de solucionar esta situación realicé una búsqueda en Google y para mi sorpresa, encontré un libro que describía exactamente qué estaba pasando: Think Like a Programmer. An Introduction to Creative Problem Solving. Mi problema no era la falta de conocimiento acerca del uso del lenguaje de programación sino la falta de práctica en cómo resolver problemas.

Desarrollar una técnica para resolver problemas eficiente y elegantemente cuesta tiempo, esfuerzo y paciencia. Aunque esta es una habilidad fundamental para todo buen programador, desafortunadamente no se enseña de manera sistemática en la escuela y en muchas ocasiones, el programador comienza realmente a aprender cuando ya se encuentra trabjando en la industria. Sin embargo, resolver problemas de programación es un arte y al no contar con una forma organizada para desarrollar este arte, muchos programadores capaces e inteligentes pueden llegar a frustrarse y pensar erróneamente que no poseen las habilidades necesarias para ser buenos programadores. En esta serie de posts me gustaría hablar acerca de cómo aprender a resolver problemas con el propósito de ayudar a todos aquellos que han vivido una situación similar a la mía: la falta de práctica para resolver un problema. En especial, me gustaría discutir acerca de lo que me fue más útil después de haber comprado y estudiado el libro que acabo de mencionar.

De la misma forma en que el autor propone ejercicios después de cada capítulo, estaré dejando ejercicios que considero útiles para todo aquél que quiera aprender o mejorar su técnica de resolución de problemas. Tal y como el autor del libro lo menciona al final de cada capítulo: de nada sirve leer los conceptos si no se practican. Por lo tanto, si de verdad quieres aprender a resolver problemas entonces resuelve lo más que puedas de los ejercicios: mientras más resuelvas, mejor.

domingo, 25 de enero de 2015

Soundex

Breve implementación del algoritmo soundex. Soundex es un algoritmo fonético, es decir, se utiliza para indexar palabras de acuerdo con su pronunciación. La mayoría de estos algoritmos se desarrollaron para ser ocupados en el idioma inglés. A diferencia del español en el que prácticamente todas las palabras se escriben de la manera en la que suenan, en el inglés existen varias formas de escribir una palabra. Por ejemplo, el apellido Smyth and el apellido Smith se pronuncian exactamente de la misma forma pero su escritura es diferente. En este caso, nos vamos a enfocar en el uso de Soundex con apellidos.

Las reglas del soundex son las siguientes:

Guía de codificación de Soundex
Número Letra que representa
1 B, F, P, V
2 C, G, J, K, Q, S, X, Z
3 D, T
4 L
5 M, N
6 R

Para las letras A, E, I, O, U, H, W , Y se utiliza el cero (0) o bien, se ignoran completamente (ejemplo: Lee se codifica como L-000).

  1. Cada apellido codificado con soundex consiste en una letra seguida por tres números, por ejemplo, el apellido Smith se codifica como S-530
  2. Si el apellido tiene letras repetidas (como por ejemplo Higgins), la letra repetida se cuenta una sola vez: H-252 (H es la primera letra, la "i" se ignora, la "g" se toma en cuenta una sola vez, la segunda "i" se ignora y los dos últimos dígitos corresponden a la "n" y "s" respectivamente)
  3. En los apellidos que tienen letras que se codifican con el mismo número y se encuentran juntas, estas letras se toman en cuenta como un solo caracter. Por ejemplo, Jackson se codifica como J-250 (J, 2 para la "c", la "k" se ignora, la "s" también se ignora, la "o" se ignora, 5 para la "n" y finalmente, se completa con 0 para cumplir con la primera regla)
  4. Si el apellido tiene prefijos como Van, Con, De, Di, La, o Le, entonces el apellido se puede codificar de dos formas: tomando en cuenta el prefijo o ignorándolo. Por ejemplo, VanDeusen se puede codificar como V-532 (V, 5 para la "n", 3 para la "d", la "e" y la "u" se ignoran, 2 para la "s" y la última "n" se ignora para no romper la primera regla) o como D-250 (D, la "e" y la "u" se ignoran, 2 para la "s", la "e" se ignora, 5 para la última "n" y se completa con 0 para cumplir con la primera regla)
  5. Si una vocal se encuentra en medio de dos consonantes que se codifican con el mismo número, se toma en cuenta la consonante que se encuentra a la derecha de la vocal. Por ejemplo, Tymczak se codifica como T-522 (T, la "y" se ignora, 5 para la "m", la "c" se ignora, la "z" se ignora, la "a" se ignora y solamente se escribe 2 para la "k")
  6. Si "H" o "W" se encuentran enmedio de dos letras que se codifican con el mismo número, entonces se ignora la consonante de la derecha. Por ejemplo, Ashcraft se codifica como A-261 (A, 2 por la "s", la "h" se ignora, la "c" se ignora, 6 por la "r", 1 por la "f" y la "t" se ignora)

Para saber más acerca de Soundex, visita: The Soundex Indexing System.

La implementación es la siguiente:

sábado, 27 de diciembre de 2014

C++11 Sincronizacion de Hilos

El primer ejemplo muestra posibles errores que resultan cuando se modifica una variable compartida desde diferentes hilos sin ninguna protección. El programa laza dos hilos, los cuales ejecutan la misma función, la cual realiza 1000 incrementos unitarios a la variable compartida; idealmente el resultado debe ser 2,000.

Una posible salida de este programa es:
$ ./thread_race
305: 1375
417: 1937
419: 1208
534: 1393
619: 1037
655: 1934
688: 1805
699: 1457
Una forma de arreglar este programa es usar un mutex para proteger el acceso a esta variable. Además estamos midiendo el tiempo de ejecución.

Esta es una posible ejecución:
$ ./thread_mutex
tiempo= 1499 ms
Usar un mutex es la forma más directa de resolver este problema; sin embargo, en este caso, dado que sólo estamos compartiendo una variable entera, es posible usar una variable atómica, lo cual permite una ejecución correcta y más eficiente que usando un mutex.

Este es un ejemplo de ejecutar este código:
$ ./thread_atomic
tiempo= 560 ms
Saludos!

lunes, 22 de diciembre de 2014

C++ accumulate

Este es un pequeño tip que se me hizo interesante. Veamos el siguiente codigo:

Imprime lo siguiente:
resultado= 987459712
resultado= 5000000050000000

El segundo resultado es el correcto.

Cuando usamos, por ejemplo, contenedores de la STL, tenemos que especificar el tipo del elemento que queremos, por ejemplo: vector<double>. Pero en el caso de los algoritmos de la STL, por default se basan en los argumentos. En el caso anterior, el compilador deduce para el primer accumulate que queremos un tipo entero para guardar el resultado final, lo cual causa un overflow cuando se suman todos los elementos.

Para el segundo accumulate, gracias a que usamos 0L, el compilador deduce correctamente que queremos usar un long para guardar el resultado de la suma.

Esto es mas aparente cuando vemos en la referencia que esta función usa el tercer parámetro para deducir que tipo usar para acumular el resultado final.

Saludos.