dacap.com.ar

UI de un instalador

2013-02-28T00:00:00-03:00

Intenté instalar Fedora 18. Estos son los problemas en la primera pantalla de la instalación. (Demás está decir que tuve ganas de dejar la instalación acá mismo.)

La primera pantalla (ver screenshot) muestra la selección de lenguaje. Una lista con todos los lenguajes, y por defecto seleccionado inglés (fair enough). Selecciono español con el mouse. No hay problemas por ahora.

Debajo de la lista hay un texto box y un check box. No entiendo muy bien para qué sirve el text box, y el checkbox dice “Fijar la distribución de teclado predeterminado para el idioma seleccionado.” (mensaje totalmente incomprensible). Generalmente cuando instalo un sistema operativo pienso “seguro voy a tener que configurar el teclado”. Por experiencia previa en Windows siempre hay dos cosas que configurar: idioma y teclado, después lo demás viene cocinado (o por lo menos es lo mínimo que espero).

Escribo algo en el text box y resulta ser que actúa como filtro del lenguaje, como para buscar el lenguaje según escribimos. Esto tiene tres fallas (sí, tres fallas en una misma pantalla):

El text box sirve para filtrar una lista que está encima de él, no por debajo, ¿para qué filtrar una lista que ya seleccioné con el mouse? generalmente los campos de búsqueda muestran los resultados abajo, no arriba, inclusive una lupa dentro del text box no vendría nada mal, por lo menos para saber que sirve para buscar,
Al escribir el lenguaje, puse “spanish”, pero no aparece nada, hay que escribir “español” (extraño, ya que en el listado se muestra una columna con el nombre del idioma en inglés),
Al intentar escribir “español” aparece “espa;ol”, porque todavía no pude configurar el teclado.

En conclusión: tengo un text box que sirve para filtrar según el nombre del idioma, pero necesito colocar caracteres unicode que todavía no puedo ingresar porque no configuré el teclado, o sea, el text box no sirve absolutamente para nada. ¡¿Quién demonios diseñó esta pantalla?!

Y todavía falta el check box, que dicho sea de paso lo presioné pensando que servía para configurar el teclado. Pero después de clickear en “Continuar” comprendí el mensaje: “Fijar el teclado predeterminado”. “Fijar predeterminado”. “Set/use default”. Entonces dije “Ah claro no, no, no, yo quiero especificar mi teclado, no quiero uno por defecto”, y luego no pude volver a la pantalla anterior (no hay botón “Volver”). Tuve que salir de la instalación y comenzar de nuevo.

A veces me preguntan “¿qué tiene de malo Linux?”. Use Debian por más de 5 años (por línea de comandos, porque el GUI nunca me terminó de cerrar), y ya hace muchísimo tiempo volví a Windows, ¿por qué? por esta mentalidad endemoniada y retorcida que está detrás del diseño de cada simple pantalla, ventana, diálogo, botón.

Si sos un programador, el entorno de Linux te puede beneficiar porque tiene las herramientas justas para programar, de fácil acceso e instalación, scripts, etc. Pero al tiempo que empieces a usar la interfaz gráfica, te va a dañar el cerebro. Vas a comenzar a creer que esas pantallas están bien diseñadas, y por lo tanto, terminarás siendo un peor programador.

¿Capacidad ilimitada o brain overflow?

2012-12-02T00:00:00-03:00

¿Qué nos ofrece Internet? ¿Qué le podemos dar? ¿Qué somos? ¿Somos lo que consumimos? Y si hoy hay un desborde de información, ¿no estaremos engordando de información? ¿no necesitamos ponernos a dieta?

Antes de la aparición de las redes sociales era un poco más complicado publicar contenido en Internet, lo cual hacía que haya menos vías de comunicación, menos canales de información, menos distracciones, y menos gente publicando material. Ahora, el “problema” es que cualquiera puede publicar –y republicar– lo que sea. No sólo tenemos un exceso de información, sino que tenemos duplicación de información en exceso.

¿Qué pasa cuando vemos una imagen? ¿O cuando escuchamos una música? ¿O leemos algo? ¿Dónde van a parar dentro nuestro? Internamente, no tenemos idea de cómo se almacenan esas imágenes en el cerebro, pero sí podemos afirmar que: si vemos algo nuevamente, con seguridad somos capaces de aseverar que ya lo vimos con anterioridad. Estamos seguros que esas imágenes están “guardadas” en nuestra mente. No podemos recordarlas con exactitud –o tal vez no recordamos nada– pero cuando la vemos nuevamente algo se activa, algo dentro nuestro que nos dice “esto ya lo vi”.

Y aquí introduzco la parte más interesante: todo esto que nosotros vemos, esta marea de información que nos inunda, millones de imágenes que día a día siguen entrando en nuestras cabezas, ¿realmente nos sobrepasa? ¿o tenemos una capacidad ilimitada de decir “esto ya lo vi”?

Y es una de las dos respuestas: o tenemos una capacidad infinita de recordar cosas, o nuestro cerebro, llegado su momento de la vida, no da más, sufre un brain overflow¹, donde: 1) lo que vemos con nuestros ojos ya no entra en la cabeza –no asimilamos más–, o 2) el cerebro va descartando –olvidando– las imágenes más antiguas. Claro que existe una tercera opción: 3) nos quedamos inmediatamente ciegos y sordos.

Haciendo alusión a un stack overflow, que de manera simplificada es cuando una aplicación corriendo en una computadora se queda sin memoria para continuar, y la única resolución posible es matarla.
↩

Eternos

2012-12-01T00:00:00-03:00

“¿Dónde puedo publicarlo?”, “Necesito un blog”, “Necesito otro blog”. No, no necesito ningún blog. O al menos, no necesito otro. A veces pienso que el contenido que genero va a mejorar por cambiar de lugar. La realidad me demuestra que esto nunca sucede.

La mayoría de gente no necesita un blog. La mayoría de gente no tiene nada importante para compartir, o que decirnos. Yo no tengo nada importante para ofrecerles. Y aún así, escribo esto. O mejor dicho, lo estoy escribiendo –sí, con papel y lápiz, o papel y microfibra en este caso–.

Y mientras escribo, pienso, “¿qué pasaría si todos los servidores se apagaran? ¿qué perderíamos? ¿qué parte como sociedad nos faltaría? ¿qué sociedad pasaríamos a ser? ¿o a volver a ser? El impacto no sería tanto. Sería más a nivel personal, si es que teníamos cosas “ahí afuera” en Internet. Y cuando digo “cosas” me refiero a material que nos costó esfuerzo creativo realizarlo.

Por eso, estoy pensando que sería muy triste –para uno– perder su blog. Perder todo eso que escribió. A nadie más le importaría. Pero sí, cada una de esas almas perdería un poco de sí mismas, de eso que crearon y ahora no está más. Para la gente que nunca creó, la angustia sería nula. Como hacer zapping en el TV, o pasar a otro libro. “¿Ahora qué dan?” se escucharía a continuación del apagón.

Tal vez los servidores nunca exploten. Tal vez la nube llegó para quedarse. Igual, el mejor consejo que se me ocurre es: si realmente tienes algo que vale la pena compartir, escríbelo, dibújalo, grábalo, hazlo partitura. Porque en el futuro, es muy probable que sea lo único que tengamos para recordarnos que fuimos jóvenes, y soñamos, y un día nos sentamos, y escribimos en una hoja, pensando que seríamos eternos.

Aclaración: Esto fue escrito bajo el título “Nada que decir”, en papel, el día 14 de noviembre del 2012 a las 19:30 hs.

Ayer leí esto lo cual va un poco con este estilo de escribir en papel.

Excepciones desde un destructor

2012-08-20T00:00:00-03:00

Hace tres días, en C++Next publicaron un artículo sobre tirar excepciones en los destructores. Hasta el mismo Herb Sutter anda por los comentarios.

Para los que no saben, los destructores no deberían tirar excepciones. Y si la clase se usa en los contenedores de la STL, las excepciones en los destructores están completamente prohibidas. Por lo tanto, ya existe un consenso general en donde tirar excepciones desde un destructor es sólo una fuente de problemas.

Así, ¿qué trae de nuevo el artículo? Bueno, aunque el artículo es interesante y lo recomiendo leer, básicamente no llega a nada. A tener en cuenta:

Si tiramos una excepciones en un destructor, la excepción se propaga como en cualquier otra función. Se siguen llamando los destructores de los subobjetos (variables miembro) y se libera la memoria utilizada por el objeto. La excepción se propaga hasta algún catch. Aquí todo funciona bien, no quedan objetos zombies ni memory leaks.
Cuando ocurre una excepción, se destruyen los objetos que estaban en su ámbito y en todos los ámbitos hasta llegar al catch (este proceso se llama stack unwinding). ¿Qué ocurre si en medio de esos objetos que se están destruyendo ocurre otra excepción? Veamos el siguiente ejemplo:
```
class A { ... }

class B {
public:
  ~B() { throw 2; }
}

int main() {
  try {
    A a;
    B b;
    throw 1;   // Comienza el stack unwinding, los destructores
               // se llamarán en orden: ~B y luego ~A, pero ~B tira
               // otra excepción
  }
  catch (...) { }
}
```
La pregunta prevalece: ¿qué pasa en este caso donde ~B tira una excepción en su destrucción? ¿qué excepción continúa? ¿la primera o la segunda que generó el destructor?

El artículo propone pensar sobre este tema y que tal vez podríamos descartar la segunda excepción. El estándar propone resolverlo con un terminate (ver §15.2 párrafo 3). Sencillamente, no se puede tirar otra excepción en medio del stack unwinding.

De los comentarios de Herb Sutter podemos sacar varios puntos muy concisos:

Una excepción es un error dentro de una función, y un error ocurre cuando las postcondiciones de la función no se pueden cumplir.
La postcondición de un destructor es que el objeto estará destruido al salir del destructor.
La vida del objeto termina al momento que entramos en el destructor, es decir, la postcondición se cumplirá de cualquier modo. No podemos -en medio de un destructor- decir “eh, ok, esperen, este objeto no se puede destruir, cancelen todo, vayan para atrás”. Esto no es posible, al salir del destructor, la memoria ya será liberada.
Entonces, ¿por qué no tirar excepciones en un destructor? Porque no existe posibilidad de reintento o cancelación de la operación. Una vez que entramos al destructor el objeto será liberado de la memoria de cualquier modo.
Podemos llegar a usar una función b.close() en el caso que necesitemos atrapar excepciones en la liberación de recursos. El destructor podría simplemente llamar a this->close() y hacer un catch de todas las excepciones para evitar que se propaguen.
Él aclara que hubiera preferido destructores con noexcept en C++11: Un modificador de funciones que especifica que el compilador debe chequear que al destructor realmente no se le escapan excepciones.

Para divertirse un poco más con todo esto, recomiendo leer:

Ítem 16 “Writing Exception-Safe Code” en Exceptional C++ de Herb Sutter.
Ítem 51 “Destructors, deallocation, and swap never fail” en C++ Coding Standards de Herb Sutter y Andrei Alexandrescu.

Sobre el tiempo

2012-08-02T00:00:00-03:00

Muchas veces decimos “perdí el tiempo en tal cosa” o “invertí el tiempo en tal otra”. Estas expresiones dan a entender dos puntos: 1) que el tiempo tiene un valor, y 2) que nuestra vida, a medida que transcurre, va consumiendo ese tiempo, y vamos devaluándolo. Es como que, si pasamos tiempo fuera de algo “constructivo” (a nivel económico), le hacemos daño o quitamos valor a alguien -o a algo- superior a nosotros.

Esa es la visión comercial del tiempo, y es la visión que la sociedad actual tiene acerca del tiempo. Creo que deberíamos comenzar a “invertir” más tiempo en pensar sobre el tiempo mismo.

Personalmente, sospecho que el tiempo no se pierde, ni se gana, ni se invierte, ni desaparece. El tiempo simplemente pasa, y nosotros estamos en algún lugar, sencillamente pasando el tiempo. No hay nada ni nadie superior a quien le estemos fallando si usamos nuestro tiempo en cosas que no son vistas como “productivas” por los ojos de la sociedad actual.

Ver una película, escuchar una música, estar tirado en la cama, usar Internet, ver televisión, escuchar la radio, leer una novela, poesía, jugar, o sentarse en la vereda, no es una pérdida de tiempo. Es una “inversión” del tiempo en nosotros mismos, y ese tiempo simplemente debe pasar, para llenarnos.

Tal vez no nos damos cuenta que el tiempo es necesario que lo pasemos. Que no existe inversión alguna, ni pérdida. Sólo es eso, pasar el tiempo.

La gran unificación de la programación

2012-07-18T00:00:00-03:00

Imaginemos un mundo donde no exista código duplicado, nada. Sólo un gran repositorio con “pedazos de lógica” Eso significa que la más insignificante porción de lógica, por ejemplo, calcular el mínimo entre dos números, existe una única vez codificada en un lenguaje de programación universal al cual todos podemos acceder. Ejemplo en pseudo-código:

importá "el código para calcular un mínimo entre dos valores"
         y dejalo en una función que se llame "min"
definí la variable a = min(3, 2)
devolvé a

Así nunca nadie debería codificar nunca jamás cómo se calcula el mínimo de dos valores. Inclusive nuestro pequeño programa se podría dejar en el repositorio como “el calculador del mínimo entre 3 y 2”. (Completamente inútil, pero podríamos dejarlo, e inclusive, debería estar ahí, porque yo ya lo escribí aquí.)

¿Cuál es el problema? Las interfaces. Por ejemplo ¿Qué requisito necesita nuestro “código para calcular un mínimo”? ¿Usará el operador < para comparar los argumentos? ¿O el >? ¿Y si usamos nuestro propio tipo de dato? ¿Podemos calcular el mínimo entre dos archivos, o documentos, o personas, o naranjas? ¿Qué devuelve min, una copia de los argumentos o una referencia? Si devuelve una copia ¿cómo crea la copia? ¿qué es una referencia?

Los templates de C++ resuelven muchas de estas preguntas (y los “conceptos” intentaban ser esta especificación de esta interfaz). Pero C++ sólo anda en C++. Lo que aquí me pongo a imaginar es un lenguaje universal, que puede ser importado y convertido a cualquier otro lenguaje y luego interpretado o compilado a lo que sea. Es decir, un repositorio de pseudo-código para resolver cualquier tipo de cuestiones.

Ejemplos: Quiero un calculador de la sucesión de Fibonacci, PUM! ahí lo tenes para Fortran. Quiero una implementación de un radio button para Java, PAM! Ahí lo tenes. Quiero un Tetris andando con highscore y todo en… sí, en C mandamelo, SALE CON FRITAS!

¿Existirá algún día la cero duplicación de código?

Publicado originalmente aquí.

La utopía de Nietzsche

2012-07-07T00:00:00-03:00

Hace ya unos años atrás leía el siguiente aforismo de Friedrich Nietzsche de Humano, demasiado humano:

462.- Mí utopía. En un mejor orden social, habrán de atribuirse las tareas pesadas y los trabajos arduos de la vida a aquél que menos sufra, es decir, al más insensible, e ir subiendo así gradualmente hasta el hombre más sensible a las formas más nobles y sublimes de dolor, a quien una vida aliviada al extremo no impedirá, entonces, que siga sufriendo.

Un mundo donde todos sufren por igual.

Tipos para todo

2012-07-03T00:00:00-03:00

Consejos para desarrolladores: Si un programa tiene que manejar una entidad, por más mínima que sea, no subestimes el poder que tiene crear un tipo de dato para esa entidad. Por ejemplo: un DNI (Documento Nacional de Identidad) se pueden representar con un string o un entero de 64 bits, pero tal vez sea mejor usar un tipo de dato propio (ej: una clase); una coordenada X podría ser un entero, o realmente una clase CoordenadaX (o un simple typedef de C++ como para comenzar).

¿Ventajas? En lenguajes de tipado estático, podemos obtener muchísimas validaciones en tiempo de compilación. Por ejemplo, validaciones del tipo “aquí espero un DNI, no espero cualquier entero”; o validaciones de unidades como “aquí espero gramos, no un double cualquiera”.

No me extrañaría ver en un futuro que Java y C# adopten los sufijos personalizables de C++11. Estos sufijos permiten hacer más sencillo definir literales de nuestro propios tipos. Ejemplos:

DNI algunDni = 14304890_dni;
CoordenadaX posicion = 32_x;
Width ancho = 320_width;
Gramos peso = 10_kg + 500_g;
Bits datosCrudos = 10010_bits;

Sí, todas son posibles expresiones de C++11 definiendo los tipos de datos correctos y sobrecargando el operator"". (Vale la pena ver la implementación del _bits en esta respuesta de StackOverflow.)

Tools for web development

2012-06-23T00:00:00-03:00

This is a set of tools, projects, libraries, frameworks, etc. to create web applications that I recommend you to check out. I’ll be modifying this list if I found more and more libraries. Feel free to recommend one in the comments section below.

Application logic at client side

jQuery: jQuery gives you an easy and portable way to query for DOM elements, create AJAX requests, create animation, etc. It’s like the de facto framework to extend JavaScript. There are others like script.aculo.us, mootools, etc.
Handlebars.js: Templating engine at client side. You can render JSON objects to HTML.

Style, HTML organization, and UI helpers

Twitter Bootstrap: All your website style should be based on this. Forget your way to layout HTML elements and CSS style, this is the right way to do it.
less: A dynamic stylesheet language. Useful to avoid duplicating colors/styles all over a CSS file.
jQuery UI: UI widgets and extensions to build really interactive pages with JavaScript and jQuery.
jQuery UI Layout: A way to organize your page like a desktop app with docking panes. Example
fancybox: A library to show screenshots with fancy transitions (depends on jQuery).

Data visualization

SlickGrid: A super customizable open source JavaScript grid to display a lot of data. You’ll need JavaScript knowledge to customize this grid, but it feels really good when you found a bug and you can fix it (also you can send pull requests to the author). Grooveshark uses this grid.
dygraphs: Create zoomable charts.

WebFonts & Icons

The League of Moveable Type: Open web fonts.
Font Awesome: A web font where each glyph is an icon.
Black & White Icons

Entrando a otro mundo

2012-05-09T00:00:00-03:00

Forward declarations de enumerados

2012-04-10T00:00:00-03:00

Continuando las discusiones con los forward declarations, podemos destacar un pequeño tipo de dato que nunca tuvo esta capacidad, por lo menos no hasta C++11: Los enumerados.

Los enum siempre fueron un problema en la definición de APIs. Actualmente, si queremos usar un enumerado en una función o como miembro de una clase, debemos tener su definición completa con anterioridad, inclusive el listado de valores posibles que puede tomar el enumerado.

Esto es muy sencillo de ver en el siguiente ejemplo. Imaginemos que nuestro programa se comunica con el usuario por medio de una GUI (ventanas, botones, controles de todo tipo). Cada control puede recibir mensajes desde el sistema operativo, por ejemplo, si el usuario clickea un botón, tiene sentido que recibamos el mensaje BotonMousePresionado.

Aquí un enumerado con el listado de posibles mensajes que podemos recibir (imaginemos esto en un archivo tipo_mensaje.h):

enum TipoMensaje {
  AbrirVentana,
  CerrarVentana,
  BotonMousePresionado,
  TeclaPresionada
};

En el caso de que declaremos una clase que utiliza el enumerado, necesitamos de la definición de TipoMensaje completa:

#include "tipo_mensaje.h"   // Necesitamos la definición del enumerado

class Mensaje {
  TipoMensaje mensaje;
public:
  // ...
};

Inclusive aunque no utilicemos los valores posibles del enumerado, no hay forma de desacoplarlo. Esto se debe a que según el estándar de C++, la cantidad de memoria usada por un enumerado depende de la implementación del compilador y del rango de valores permitidos del enumerado. Ejemplo: Un compilador podría decidir usar un char en vez de un int para representar nuestro TipoMensaje.

¿Cuál es la desventaja?
Debido a que el compilador decide, según reglas internas y los valores posibles del enum, qué tipo de dato usar para representarlo, cada vez que agreguemos un nuevo valor al enumerado debemos recompilar todos los archivos que lo estaban referenciando.

¿Cómo podemos solucionarlo?
C++11 introduce el concepto de los “enumerados fuertemente tipados” (strongly typed enumerations). Con lo cual podemos decidir qué tamaño específico tiene el enumerado.

Si conocemos con anterioridad cuántos valores queremos codificar en nuestro enum, podemos especificar la cantidad de memoria requerida por el mismo. Podemos definir un enumerado que ocupe sólo 8 bits:

enum TipoMensaje : char {
  AbrirVentana,
  CerrarVentana,
  BotonMousePresionado,
  TeclaPresionada
}

Y si necesitamos referenciarlo:

enum TipoMensaje : char;    // Forward declaration

class Mensaje {
  TipoMensaje mensaje;
public:
  // ...
};

¿Por qué se llaman “enumerados fuertemente tipados”?
Ese es otro tema que lo dejo para un próximo post.

Referencias: N2347 (pdf)

Reformat XML on Emacs

2012-04-09T00:00:00-03:00

You can reformat XML code adding the following code in your .emacs:

(require 'sgml-mode)

(defun reformat-xml ()
  (interactive)
  (save-excursion
    (sgml-pretty-print (point-min) (point-max))
    (indent-region (point-min) (point-max))))

And executing reformat-xml in your XML buffer then.

Paréntesis en una URL

2012-04-08T00:00:00-03:00

Ya van dos veces que tengo que buscar cómo se codifican los paréntesis en una URL. Aquí dejo esto como futura referencia:

El paréntesis de apertura ( se puede escribir como %28
El paréntesis de cierre ) se puede escribir %29

Ejemplo: Un link a http://en.wikipedia.org/wiki/Tee_(command) se puede escribir como http://en.wikipedia.org/wiki/Tee_%28command%29.

Game concepts

2012-04-05T00:00:00-03:00

These are several (maybe unimplementable) game concepts that I’ll be releasing in my Twitter account and adding them here frequently:

Avoid to bite your tongue. tweet
Social Network Tycoon, you’ve to create and maintain your own social network, destroying the competition. tweet
Prepare as many mates as you can before it became washed out. tweet
Drink as much beer as you can without getting drunk. tweet
You are a book and you must find your writer… because you’ve a typo. tweet

Una cosa por vez

2012-04-04T00:00:00-03:00

Hoy leí el siguiente artículo: The Magic of Doing One Thing at a Time (La Magia de Hacer Una Cosa a la Vez). Más allá de los consejos específicos para un manager o individuos en la empresa, quiero resumir los puntos importantes en general para cualquier ser humano.

Prácticamente, si te sentis abrumado por millones de tareas en el trabajo e información que te llega de todos lados, podes tomar las siguientes estrategias para aumentar tu productividad, o mejor dicho, volverla a su estado natural antes de que este mundo enfermo llegara:

No juegues a la multi-tarea. No hagas malabares con todo. Dedicate a resolver una tarea por vez y bien.
Pequeños tiempos muertos también ayuda. No intentes “rellenar” esos tiempos haciendo otras pequeñas tareas.
Si tenes un teléfono “inteligente”, apagalo el mayor tiempo posible (o quemalo y comprate un celular normal).
No esperes respuesta inmediata de todos. Así tampoco interrumpís el trabajo de los demás.
Hace la cosa más importante al inicio de la mañana, a la primera hora (sin interrupciones ni distracciones).

Lenguaje

2012-03-23T00:00:00-03:00

¿Cómo elijo que una página este en inglés o español?

Este sitio contiene páginas que están en español y otras que están en inglés. Generalmente no podrá encontrar la misma página traducida en ambos lenguajes. Y en esta etapa de mi vida, muy difícilmente me dedicaré a traducir todo lo que escribo.

Dependiendo de lo que quiero transmitir, una página estará en un lenguaje u otro. Si quiero publicar una aplicación o un juego, probablemente lo haga en inglés. Si en cambio quiero transmitir una idea, lo haré en mi lengua materna, español.

¿Por qué?

Prefiero no traducir nada. No soy tan bueno escribiendo inglés como me gustaría y todavía tengo que aprender a escribir en español.

Si vale la pena transmitir una idea compleja correctamente, utilizaré español, en caso contrario, utilizaré inglés. Inclusive, le recomiendo hacer lo mismo. Se disfruta más escribiendo y leyendo en la lengua de uno antes que en la ajena, es más sencillo expresar ideas y es probable que contenga menos errores.

Y como punto adicional: prefiero comunicarme y discutir con gente que entienda mi lengua.

iosfwd

2012-02-24T00:00:00-03:00

La librería estándar de C++ ofrece un archivo de cabecera de forward declarations de las clases de entrada y salida a flujos de bytes (iostreams):

#include <iosfwd>

De esta forma podemos utilizar los tipos ostream, istream, etc. sin necesidad de traer la definición de todas las clases de entrada y salida. Generalmente deberíamos utilizar el <iosfwd> en nuestro .h cuando no hagamos un mayor uso que sólo referenciarlas. Un ejemplo:

#ifndef EMPLEADO_IO_H
#define EMPLEADO_IO_H

#include <iosfwd> // forward declaration de ostream

class Empleado;    // forward declaration de nuestro tipo

// Aquí no necesitamos conocer el tamaño ni de Empleado,
// ni de ostream, podemos compilar sólo con sus forward
// declarations.
void write_empleado_en_formato_binario(const Empleado&, ostream&);

#endif

Regla: Siempre intenta usar las forward declarations antes que incluir los archivos de cabecera que definen las clases, los cuales suelen mostrar detalles de implementación que son propensos a cambiar. Siguiendo esta regla mejoraremos el tiempo de compilación y la cantidad de archivos a compilar al realizar una modificación en un .h.

Para más información, ver la sección 27.3 Forward declarations [iostream.forward] del último borrador público del estándar de C++

Año nuevo

2011-12-23T00:00:00-03:00

Bueno, este año fue poco productivo en este blog. El próximo no prometo mucho más, pero espero mejorar. Dejo un par de links que agregué en la sidebar:

Pre-defined C/C++ Compiler Macros: Si alguna vez tenemos que detectar la versión de un compilador o en qué plataformas estamos, estas macros pueden ayudarnos a escribir código portable.
C++ Reference Wiki: Una wiki con referencia sobre C++ y C++11

Los próximos años pueden llegar a ser los mejores años de C++. Con clang avanzando sobre gcc, es probable que aparezcan herramientas muy importantes para ayudar a programar en C++. Aquí les dejo un video:

¡Feliz año nuevo!

Ecos de la nada

2011-12-12T00:00:00-03:00

Como el recuerdo melancólico
de un amor que nunca fue,
los ecos retumban.
Y el sonido percibido,
es un silencio atroz.

Una sociedad que no fue

2011-11-30T00:00:00-03:00

No existe el dinero. No existen ricos, ni pobres. Todos trabajan, aprenden y juegan. Todos ayudan a todos. Algunos trabajan en cosas que les gusta. Otros trabajan obligados realizando tareas que nadie desea. No existen los sueldos. Se comercia con tiempo. A peores trabajos mayor el tiempo para aprender y jugar. Cualquiera puede escribir, componer, leer, escuchar, o ver una película. Todos pueden cumplir sus sueños, pero un tiempo lo tenes que donar.

No existe la publicidad, ni dos productos que sirvan para el mismo fin. Los bienes materiales sirven sólo para lo que fueron creados, con el diseño que produzca el menor impacto ambiental. La comida es la mejor para la salud. Se consume todo lo que se fabrica. Se fabrica sólo lo que se necesita.

Código C++ moderno

2011-09-21T00:00:00-03:00

Una excelente charla de Herb Sutter (en inglés) introduciendo algunas de las novedades del nuevo estándar C++11 y sobre cómo escribir código en C++ aprovechando todo el conocimiento acumulado en estos años (si nunca leíste C++ Coding Standards de Herb Sutter y Andrei Alexandrescu, compralo):

http://channel9.msdn.com/Events/BUILD/BUILD2011/TOOL-835T

Los puntos tratados que no podes dejar pasar por alto:

El nuevo significado de la palabra auto para inferir tipos automáticamente.
La nueva sintaxis de lambdas para definir functors en línea y usarlos en algoritmos estándares (ej: for_each()).
Exception safety y heap lifetime con smart pointers, los cuales ya tenemos varios posts en este mismo blog sobre el concepto de smart pointers y RAII.
Nuevos contenedores de tipo hash table.
Move semantics que evita la creación y destrucción de objetos temporales innecesarias (ej: al retornar por valor).
Varios pequeños nuevos coding standards de C++11: funciones begin()/end(), override explícito, idioma pimpl con unique_ptr<>, etc.

En futuros posts voy a dedicar algo de tiempo en introducir estos temas y explicar por qué nacieron cada una de estas modificaciones en el nuevo estándar de C++.

El Hombre De Múltiples Caras

2011-09-12T00:00:00-03:00

Change volume with mouse wheel over task bar

2011-08-01T00:00:00-03:00

Yeah, you can change the volume just moving the mouse wheel over task bar using AutoHotkey and the following little script:

#If MouseIsOver("ahk_class Shell_TrayWnd") WheelUp::Send {Volume_Up} WheelDown::Send {Volume_Down} MouseIsOver(WinTitle) { MouseGetPos,,, Win return WinExist(WinTitle . " ahk_id " . Win) }

Assault Rigs y Herbie Hancock

2011-07-10T00:00:00-03:00

Hace ya unos cuantos años atrás (tal vez más de 10), cuando junto con mis hermanos adquirimos una PlayStation, la consola traía un CD de demo ¹ con varios juegos. Entre esos había uno de tanques con una música algo especial. Luego nunca más me acordé del nombre del juego, y la músico quedó perdida en mi inconsciente.

Da la casualidad que ayer escuché Hang Up Your Hang Ups de Herbie Hancock. E inmediatamente recordé la música. Busqué el nombre del CD demo, encontré el listado de juegos y ahí estaba, el Assault Rigs:

La lista de músicos de Assault Rigs:

Andrew Crowley
Stuart Duffield
Matt Furniss

Buscar por “CD Sampler Pack Vol2” aquí.
↩

Víctima de la modernidad

2011-06-29T00:00:00-03:00

Somos rehenes de un mundo que no hicimos. Sufrimos insomnio por una pesadilla que no soñamos. Somos partícipes de una historia que nadie recuerda. Somos guionistas de un papel protagónico que nadie actúa. Somos engranajes en un plan de unos pocos cerebros siniestros. Somos un eslabón de una cadena trunca. Somos el eco que ya no se escucha. Somos la imagen de un ruido perdido.

Somos víctimas de un mundo moderno que sólo fábrica para un futuro en el que no estamos.

One Leg

2011-05-10T00:00:00-03:00

Short music with a couple of guitars.

Google Chrome - Always on top

2011-03-27T00:00:00-03:00

OK, Google Chrome needs an “Always on top” option for Windows (indeed Windows needs that option for all applications).

Installing AutoHotKey and running this AutoHotKey script, you will be able to put any window on top (with 80% of opacity) pressing just WinKey+O key when you’ve the window active. Here is the script just for reference:

#o:: WinSet, Alwaysontop, , A WinGet, ExStyle, ExStyle, A if (ExStyle & 0x8) ; 0x8 is WS_EX_TOPMOST { WinSet, Transparent, 204, A } else { WinSet, Transparent, 255, A } return

Notes:

You can change #o:: in the first line with other key if you want (e.g. #g:: will be WinKey+G key instead of WinKey+O)
You can change 204 with other level of opacity (0 is completely transparent, 255 is completely opaque)

References:

Slow Walk

2011-03-21T00:00:00-03:00

Hace mucho que no cuelgo una música, vamos con algo simple:

Sucesión de 12 compases clásica de blues en mi tonalidad preferida del piano (la más fácil), Do mayor. La improvisación del punteo con escala pentatónica de Do mayor.

Cola de prioridades (STL priority_queue)

2011-03-08T00:00:00-03:00

La cola de prioridades es una estructura de datos que se puede visualizar como una bolsa, donde podemos ir metiendo elementos uno atrás del otro, pero sólo los podemos retirar según un criterio de prioridad. Por ejemplo, en el caso de un ladrón obsesivo-compulsivo, podría robar un banco cargando bolsas de dinero sin ningún criterio, y al vaciarla podría retirar los billetes según su valor (primero los de $100, luego los de $50, etc.).

Otro ejemplo, imaginemos que tenemos un barco:

#include <queue>
#include <list>

using namespace std;

class Barco {
public:
  void subirPasajero(const Pasajero& pasajero);
  void abandonarBarco(list<Pasajero>& pasajerosEnOrden);

private:
  priority_queue<Pasajero> pasajeros_;
};

La función subirPasajero() debe agregar un pasajero al barco, y abandonarBarco() debe sacar todos los pasajeros del barco y colocarlos (por orden de prioridad) en la lista que se recibe como argumento:

void Barco::subirPasajero(const Pasajero& pasajero)
{
  pasajeros_.push(pasajero);
}

void Barco::abandonarBarco(list<Pasajero>& pasajerosEnOrden)
{
  while (!pasajeros_.empty()) {
    pasajerosEnOrden.push_back(pasajeros_.top());
    pasajeros_.pop();
  }
}

Tenga en cuenta que la función miembro pop() de las colas en C++ (queue, priority_queue, etc.) no retornan el valor extraído. Esto es así para evitar crear copias de los objetos dentro de la cola. De este modo la función top() devuelve una referencia al elemento mismo que se encuentra en la cola, y pop() lo remueve sin devolver nada. Así nos evitamos de crear copias temporales de la instancia removida.

Para poder usar la priority_queue sobre un tipo de dato propio (como Pasajero), debemos ofrecer una implementación del operator<() para comparar distintas instancias de nuestro tipo de dato (este operador se utiliza para saber qué elemento debe salir último de la cola, es decir, el menor elemento tiene menor prioridad):

enum Prioridad { Capitan, Hombre, Mujer, Ninio };

class Pasajero {
public:
  Pasajero(Prioridad p) : prioridad_(p) { }

  bool operator<(const Pasajero& otro) const {
    return prioridad_ < otro.prioridad_;
  }

  Prioridad prioridad() const { return prioridad_; }

private:
  Prioridad prioridad_;
};

De este modo, el capitán tiene prioridad 0 y es tomado en cuenta como el de menor prioridad para abandonar el barco. Los pasajeros que mayor prioridad tienen de abandonar el barco son las mujeres y los niños. En este caso podrían tener igual prioridad, no tendría mucho sentido salvar a todos los niños sin sus respectivas madres.

Ahora podemos crear un ejemplo:

#include <iostream>

using namespace std;

int main()
{
  Barco titanic;
  titanic.subirPasajero(Pasajero(Capitan));
  titanic.subirPasajero(Pasajero(Mujer));
  titanic.subirPasajero(Pasajero(Hombre));
  titanic.subirPasajero(Pasajero(Mujer));
  titanic.subirPasajero(Pasajero(Ninio));
  titanic.subirPasajero(Pasajero(Hombre));
  titanic.subirPasajero(Pasajero(Ninio));
  // ...

  list<Pasajero> pasajeros;
  titanic.abandonarBarco(pasajeros);
  
  for (list<Pasajero>::iterator it = pasajeros.begin(),
         end = pasajeros.end(); it != end; ++it) {
    cout << it->prioridad() << "\n";
  }
  
  return 0;
}

El anterior ejemplo imprime:

Lo que significa que, sin importar el orden en el cual agregamos los pasajeros, primero extraemos los niños, luego las mujeres, los hombres, y finalmente el capitán.

Más información:
http://www.cplusplus.com/reference/stl/priority_queue/
http://en.wikipedia.org/wiki/Priority_queue

Ingenieros en Sistemas de Información

2011-03-06T00:00:00-03:00

La carrera de Ingeniería en Sistemas de Información está llena de casos (brain washers) donde te dicen una y otra vez que “el ingeniero no debe programar”. OK, para poner las cosas claras: El ingeniero en sistemas que no programó nunca, o no piensa programar nunca, ni piensa tocar una línea de código, es en pocas palabras alguien que no sirve absolutamente para nada.

Puedo enumerar algunos caminos que un Ingeniero en Sistemas de Información quisiera tomar para esquivar la programación: diseñador, arquitecto, investigación, project manager, testing, calidad. Pero igualmente no vale la pena ser exhaustivos, ya que todos tienen la misma respuesta: Si nunca programaste, nunca vas a poder hacer otra cosa bien.

Por ejemplo, no concibo a la figura de un diseñador que nunca programó. Siendo el diseñador alguien que “fabrica” las bases para los programadores, ¿cómo puede entender alguien qué es bueno para los programadores si nunca programó? Lo mismo se aplica a la arquitectura del sistema que van a usar los programadores a lo largo de todo el desarrollo. A un project manager que se encarga de manejar programadores. A los testers que se encargan de probar código de programadores. La calidad que intenta arreglar y optimizar todo el proceso que deben seguir los programadores. En todo esto el punto clave es: Si nunca fui programador ¿puedo comprenderlos y mejorar su desarrollo o su forma de trabajo? La respuesta es no.

El único fin de la Ingeniería en Sistema de Información es hacer un sistema o mantener un sistema heredado, y la única forma de hacerlo es comunicándose con la computadora programando. Por lo tanto, los programadores son la pieza fundamental. Sin programación, no hay sistema. En consecuencia, deberías comenzar a respetar a los programadores.

Consejo: Si estás estudiando Ingeniería en Sistemas de Información, aprende a programar. Si no te gusta programar, no importa, el mundo sigue andando con gente que estudió y trabaja de algo que no le gusta, tal vez a costa del sufrimiento de otros.

Intros

2010-12-30T00:00:00-03:00

La primera intro (u "opening") que me sorprendió en mi vida fue la de Tekken para arcade en una pantalla gigante:

Te ponía la piel de gallina.

Después la intro de Tekken 2 para PlayStation que era para caerse de la silla, con una breve introducción a cada personaje y una música increíble:

Tekken 3 de Arcade:

Tekken 3 de PlayStation (nivel cinematográfico, aunque es notorio que los modelos 3D y la animación todavía no estaban tan avanzadas para ese entonces):

Igualmente, la intro que más se gravo en mi cabeza es la de Twisted Metal 2. Con menores recursos que las otras (animación 2D, imágenes estáticas que se rotan y desplazan, como una animación de Flash) pero con una voz de fondo espectacular, Welcome to Twisted Metal:

También vale la pena ver los finales de Twisted Metal 2, no tienen desperdicio.

Follow

2010-12-03T00:00:00-03:00

Una importante aclaración sobre el botón “Follow” (Seguir) de Twitter, principalmente para los políticos que lo usan: A veces, este botón no significa algo bueno. Es decir, que un político tenga 100.000 seguidores no significa nada. El “Follow” no equivale a un “Lo voy a seguir” en repuesta a “Síganme, no los voy a defraudar”. El “Follow” significa “¡Síganlo, que no se escape!”.

Sueños

2010-11-17T00:00:00-03:00

Nunca te vayas a dormir después de usar la computadora. La computadora roba sueños. Si te preguntas por qué ya no sueñas más, es porque usas la computadora antes de dormir. 30 o 60 minutos antes lee un cacho de novela o libro de filosofía. No funciona si lees libros técnicos.

Simulador Político

2010-09-30T00:00:00-03:00

Así como existen simuladores de vuelo para entrenar pilotos, debería existir un simulador para aspirantes a político. La idea sería meterlos dentro de una máquina y hasta que no dejan de destruir naciones, no se los saca al mundo real.

Iostream - Redireccionar clog para "loguear" en un archivo

2010-09-18T00:00:00-03:00

La iostream es la librería de entrada y salida de C++. Existen algunos streams estándares de salida: std::cout, std::cerr y std::clog. El primero apunta a la consola, y los dos últimos... también. Las diferencias son estas:

cout apunta a la salida estándar STDOUT (texto de resultado esperado de un programa);
cerr y clog apuntan a STDERR (salida de errores y cualquier otra porquería).

Aunque a primera vista todo el texto se envía a la consola, uno puede redireccionar la salida a otros lados. Por ejemplo, imaginemos que tenemos el siguiente programa test.exe:

#include <iostream>

using namespace std;

int main()
{
  cout << "A\n";
  cerr << "B\n";
  clog << "C\n";
  return 0;
}

Al ejecutarlo, obtenemos por pantalla las tres líneas:

test.exe [ENTER]
A
B
C

Pero resulta interesante saber que podemos redireccionar el STDOUT a un archivo y el STDERR a otro. Ejemplo:

test.exe 1>stdout.txt 2>stderr.txt

¿Qué demonios es 1 y 2? Los archivos tienen un descriptor que los identifica, 1 es para la STDOUT, y 2 para STDERR. El signo mayor (>) significa que "quiero redireccionar toda la salida de texto que vaya para este descriptor a este archivo". En el anterior ejemplo logramos obtener dos archivos distintos, stdout.txt que contiene una línea (A), y stderr.txt que contiene dos líneas (B y C).

Generalmente, los logs van a un archivo, no a la pantalla. Aunque por defecto clog mande todo a STDERR, resulta útil redireccionar este stream a un archivo propio (por ejemplo, test.log). De esta forma, podemos hacer uso de clog para "loguear" todo lo que nuestro programa hace.

¿Cómo se redirecciona clog? Básicamente los streams de C++ tienen un streambuf asociado, y éste es el realmente encargado de leer y escribir datos (en la pantalla, en un archivo, en un string en memoria, etc.). Por lo tanto, si creamos un fstream y le colocamos su propio streambuf a clog, podemos usar clog como un "alias" del fstream original (clog va a estar compartiendo el mismo streambuf que el fstream). El código resultante es bastante sencillo:

#include <iostream>
#include <fstream>

using namespace std;

int main()
{
  // Creamos un archivo de salida para logging.
  ofstream test_log;
  test_log.open("test.log");

  // Obtenemos el streambuf actual de clog (esto
  // lo usaremos luego para restaurar el streambuf
  // a su valor original, por si las moscas).
  streambuf* old_rdbuf = clog.rdbuf();

  // Reemplazamos el streambuf de clog con el del archivo.
  // Ahora ambos streams utilizarán el mismo streambuf (es
  // decir, escriben en el archivo test.log).
  clog.rdbuf(test_log.rdbuf());

  // Hacemos lo mismo que el ejemplo original.
  cout << "A\n";
  cerr << "B\n";
  clog << "C\n";
  
  // Restauramos el viejo streambuf de clog.
  clog.rdbuf(old_rdbuf);

  // Cerramos el archivo.
  test_log.close();
  return 0;
}

Y listo, ahora podemos hacer lo mismo que antes:

test.exe 1>stdout.txt 2>stderr.txt

Con lo cual obtenemos tres archivos:

stdout.txt con la línea A.
stderr.txt con la línea B.
test.log con la línea C.

Compartidor

2010-09-15T00:00:00-03:00

Detrás del éxito de las redes sociales como Facebook o Twitter, se esconde uno de los sentimientos más primitivos del ser humano: El compartir algo que nos gusta. Lamentablemente, en vez de contemplar y aprovechar al máximo nuestras propias vivencias y emociones, intentamos rellenar el alma de las demás personas. Así podemos identificar a un nuevo ser que emerge de la Internet con total majestuosidad: el compartidor.

El compartidor no es sólo el tipo que comparte, es el tipo que en su interior, muy en lo profundo de su ser, cree que todo lo que ve, escucha, huele y siente, puede ser transmitido a otros. Potenciado a base de redes sociales, el sentimiento crece en un éxtasis total al ser compartido lo antes posible con todos los amigos. Con la telefonía móvil a su favor, destruye sus sentimientos al mismo tiempo que teclea su próximo mensaje a compartir.

Claro que, como siempre me gusta darle un giro inesperado a las cosas, no puedo despedirme sin compartir:

Fuerza de gravedad

2010-09-07T00:00:00-03:00

El desarrollo de páginas web, y la evolución del universo de la Internet, tuvo una gran fuerza en su contra que hizo, entre otras cosas, que una cantidad inimaginable de personas alrededor del mundo no puedan plasmar sus ideas y creatividad sobre uno de los soportes más ricos conocidos hoy en día: el hipertexto y la multimedia (dos palabras prehistóricas). Dicha fuerza se la conoce como Internet Explorer.

Miembros virtuales

2010-08-30T00:00:00-03:00

Una función miembro virtual tiene la característica de poder ser sobrecargada por subclases para agregar un comportamiento propio. Pero existen dos lugares en donde las funciones virtuales toman un comportamiento especial: en los constructores y los destructores.

Veamos el siguiente ejemplo:

#include <iostream>

using namespace std;

class Lugar {
public:
  Lugar() {                     // El lugar es creado
    creacion();                 // Llamamos a la función virtual
  }
  virtual ~Lugar() {            // El lugar es destruido
    destruccion();              // Llamamos a la función virtual
  }
protected:
  virtual void creacion()    { }
  virtual void destruccion() { }
};

class Universo : public Lugar {
protected:
  void creacion()    { cout << "Big Bang\n"; }
  void destruccion() { cout << "Big Crunch\n"; }
};

int main()
{
  Universo i_am_god;  // ¿Qué imprime este programa?
  return 0;
}

La idea de todo método virtual es poder proporcionar puntos de extensión a las clases derivadas. En este caso, ¿Lugar::creacion funciona como punto de extensión para clases derivadas? La respuesta es: no. El anterior programa no imprime nada.

Aunque creamos una instancia de Universo, ni el método Universo::creacion ni Universo::destruccion se llamaron. ¿A qué se debe esto? Imaginemos que al crear un Universo, primero debemos crear un Lugar en su totalidad, para luego comenzar a crear el universo. Es por eso que si llamamos a creacion mientras estamos construyendo el Lugar, no podemos alcanzar el método Universo::creacion ya que el Universo todavía no comenzó a ser construido (no tiene un Lugar completamente construido donde existir).

La secuencia correcta es:

Alojamos un cacho de memoria suficiente como para que entre el universo.
Algo así como hacer un: this = malloc(sizeof(Universo)) en C.
Construimos el Lugar usando la memoria recién obtenida como puntero this.
Luego construimos el Universo.
Y recién ahí somos capaces de llamar a Universo::creacion y asegurarnos que estaremos usando el método especializado de la subclase.

¿Puedo llamar a creacion dentro del constructor de Universo? La respuesta es sí, todo es posible. ¿Es correcto? Mmmhh, depende, si alguien hace una subclase de Universo y sobreescribe creacion, nuevamente estará en el mismo problema que estamos mostrando aquí.

¿Por qué en el destructor de Lugar no llama a Universo::destruccion? Porque el Universo ya está destruido (¿cruncheado?) para cuando llegamos al destructor del Lugar.

¿Cómo lo soluciono? Usar puntos de extensión en los constructores y destructores presentan más problemas que ventajas. La solución es no usarlos. Solución (obvia):

#include <iostream>

using namespace std;

class Lugar {
public:
  Lugar() { }
  virtual ~Lugar() { }
};

class Universo : public Lugar {
public:
  Universo()  { cout << "Big Bang\n"; }
  ~Universo() { cout << "Big Crunch\n"; }
};

int main()
{
  Universo i_am_god;
  return 0;
}

En un próximo post voy a dar un ejemplo más complejo donde esto no sirve.

¿Y qué sucede si llamo una función miembro abstracta en el constructor o destructor? Es el desastre total. Completamente ilegal. Imposible. Una violación absoluta a la razón y el sentido común. Imagine este código:

#include <iostream>

using namespace std;

class Lugar {
public:
  Lugar() { creacion(); }        // Ja llamo a creacion()
protected:
  virtual void creacion() = 0;   // Jaja y no lo defino ;)
};

class Universo : public Lugar {
protected:
  void creacion() { }            // Jajaja sólo puede llamarme a mí!
};

int main()
{
  Universo i_am_god_x2;
  return 0;
}

Al compilar este código con gcc obtenemos un warning porque estamos llamando un método abstractor en el constructor, y un error de enlace al crear el ejecutable ya que Lugar::creacion no está definido:

test.cpp: In constructor 'Lugar::Lugar()':
test.cpp:7:22: warning: abstract virtual 'virtual void Lugar::creacion()' called from constructor
C:\temp\ccstr9Hr.o:test.cpp:(.text$_ZN5LugarC2Ev[Lugar::Lugar()]+0x16): undefined reference to `Lugar::creacion()'
collect2: ld returned 1 exit status

Aunque dijimos explícitamente que Lugar::creacion() es abstracto (=0), eso no significa que no debamos definirlo en este caso tan particular.

Referencias:
Sutter, Herb & Alexandrescu, Andrei (2004). Item 49: Avoid calling virtual functions in constructors and destructors. C++ Coding Standards: 101 Rules, Guidelines, and Best Practices. Boston, MA: Addison-Wesley Professional, (ISBN 0321113586).

Ridículo

2010-08-22T00:00:00-03:00

A veces la gente pide cosas completamente imposibles. Esta issue de Chromium me hizo reír. El tipo tenía problemas descargando archivos con su versión de Chrome, reporta la issue, pero al mismo tiempo dice: “But please don’t ask me to change another version”…

O sea ¿Tenes un problema con el software que usas pero no querés ni hacer el mínimo esfuerzo de actualizarlo? ¿¡Inclusive si eso significa hacer un simple doble-click?!

Las respuestas a la issue son geniales.

TODO (a hacer)

2010-08-05T00:00:00-03:00

Supongo que todos (los geeks) suelen tener un txt con una lista de “cosas a hacer” (un “to do”). Hoy me di cuenta que, con justa razón, tengo las tareas “a hacer” a un paso de la papelera.

¿Será que nunca termino de hacer todo lo que me gustaría hacer?

Botones

2010-08-03T00:00:00-03:00

Veamos los siguientes requerimientos. Tenemos tres clases de botones:

Button: El botón común que al presionarlo ejecuta un comando (OK, Cancel, Yes, No, Close, Kill Process, etc.)
Check-box: Una caja para poner un tilde.
Radio-button: Un conjunto de botones redondos para seleccionar una opción entre varias.

Cada clase de botón puede verse y actuar como otra clase al mismo tiempo. Por ejemplo: un check-box puede verse como un button pero actuar como check-box, o tres buttons pueden actuar como radio-buttons pero verse como buttons.

Además, existen algunas propiedades específicas:

Los botones que se ven como buttons pueden tener cuatro valores que indican la redondez de cada una de las cuatro esquinas. Recuerde que un check-box o un radio-button puede lucir como un button.
El comportamiento de los radio-buttons necesita de un grupo que los reuna (por ejemplo, un ID que indica que varios radio-buttons pertenecen al mismo grupo). Recuerde que un button o un check-box puede actuar como un radio-button.

¿Cómo resolvería este problema con objetos? Esto es un excelente candidato para aplicar MVC.

Chistes

2010-07-31T00:00:00-03:00

Los eventos de la vida no son aleatorios. Son una hermosa y perfecta sucesión de chistes que se van desencadenando a medida que crecemos.

Blogs

2010-07-31T00:00:00-03:00

En el futuro, los diarios, las páginas web, los blogs, los microblogs, SMS y todo medio de comunicación escrito, será reemplazado por una alternativa más económica y efectiva: El yoctoblogging. Todo podrá ser dicho con monosílabos: soy, yo, fui, bien, sí, pis, más, mal, gas, ¿vos?, ¿y?…

El tiempo libre será tan poco que sólo tendremos lo suficiente como para escribir (y leer) este tipo de mensajes.

Tentación

2010-07-27T00:00:00-03:00

A veces siento que me mira y me habla… y escucho “vení, haceme click, dale ;) … tengo un montón de cosas para ofrecerte”

Al final, siempre me defrauda.

Apuntes y creatividad

2010-07-27T00:00:00-03:00

Consejo: Si vas a enseñar una materia en la facultad o un curso, ¿por qué no agregarle un poco de creatividad al asunto? En vez de usar los mismos ejemplos del libro de referencia, a veces es bueno inventar otros (inclusive, evitar usar una escaneada del libro puede ser una buena idea).

Interfaces gráficas interesantes para diseñar

2010-07-26T00:00:00-03:00

Esta es una lista de interfaces gráficas interesantes para resolver:

Una interfaz gráfica que pueda ser usada inmediatamente por cualquiera que nunca haya visto una computadora.
Un lenguaje de scripting que me permita hacer cualquier cosa en el sistema operativo, sin necesidad de escribir una línea de código. Por ejemplo, una interfaz para configurar una red de pipes y filtros, donde por las tuberías puede pasar cualquier tipo de dato (texto, datos binarios crudos, imágenes, audio, logs, planillas de excel, bases de dato, páginas web, mails, código fuente, etc.) y los filtros los pueden transformar en cualquier cosa.
Una interfaz que permita hacer control de versiones con Git con varios repositorios remotos de forma totalmente gráfica, sólo con el mouse. Comandos complejos como rebase podrían ser un simple drag and drop. Debería poder tener una visión de cada repositorio como una pequeña computadora a la que le puedo hacer pull y push (por branch). Etc.
Un editor de texto como Microsoft Word o OpenOffice.org Writer que produzca documentos de tan buena calidad como LaTeX.

Sólo ideas. ¿Para proyectos open source? ¿para proyectos comerciales?

Alcance

2010-07-26T00:00:00-03:00

Estaba comiendo en un bar. Levanto la vista y miro el televisor. Un tipo pidiendo limosna a un periodista. El periodista lo mira y le dice: “Señor, yo estoy para mostrarle al mundo sus miserias”. El tipo pega la vuelta y sigue comiendo basura. Yo sigo comiendo. Un pibe se acerca y me pide limosna. Lo miro, le doy una moneda, y pienso: “Que poco puedo cambiar este mundo”. Sigo comiendo.

Cuentos

2010-07-25T00:00:00-03:00

Un día un tipo se levantó de la cama y se puso a escribir un cuento. Para la noche ya lo había terminado. El cuento era tan bueno que no podía creerlo. Lo leyó una y otra vez, era increíble.

Nunca más vieron al tipo.

Con el cerebro

2010-07-25T00:00:00-03:00

Llegará el día que programaremos con el cerebro. Los atajos de teclado no servirán de nada. Simplemente miro una ubicación, pienso en qué quiero escribir y… BAM! ahí van apareciendo las letras por arte de magia.

Eso es un editor de texto.

Descargar MinGW con gcc 4.5 automáticamente

2010-06-06T00:00:00-03:00

Este post se podría llamar:

¿Cómo instalar MinGW?
¿Cómo instalar y usar gcc 4.5 en Windows?
¿Cómo compilar programas de C o C++ en Windows?
O también, ¿puedo portar MinGW en un pendrive?

Cualquiera de los casos se responde con el siguiente archivo: MinGW-Downloader.zip.

Los pasos a seguir son los siguientes:

Cree una carpeta donde descomprimir MinGW-Downloader.zip (por ejemplo, C:\Compilers, o C:\GNU, lo importante es que la carpeta no contenga espacios!)
Descomprima MinGW-Downloader.zip en esa carpeta
Ejecute el archivo C:\Compilers\MinGW-Downloader\MinGW-4.5-Downloader.bat
Espere…
Una vez finalizado deberá ver algunos mensajes en la pantalla diciéndole si tuvo éxito (SUCCESS), inclusive el script intenta compilar un programa en C y otro en C++.
Listo, ya tiene MinGW con gcc 4.5 disponible en su máquina.

Puede usar el script Run-cmd-with-MinGW-4.5.bat para ejecutar la línea de comandos de Windows y tener el compilador disponible (gcc, g++, etc.) en la variable PATH. Lo importante es que el proceso de descarga no modifica ninguna variable de entorno suya (PATH), por lo tanto, podría borrar la carpeta C:\Compilers y empezar desde cero siempre que así lo desee.

Puede mover la carpeta C:\Compilers\MinGW-Downloader\MinGW-4.5 a C:\MinGW-4.5 y borrar C:\Compilers\MinGW-Downloader completamente. Si quiere tener el compilador disponible desde cualquier aplicación (por ejemplo, desde un editor de texto o IDE), podría agregar la ruta C:\MinGW-4.5\bin a su PATH.

Cabe destacar que la carpeta MinGW-4.5 (C:\Compilers\MinGW-Downloader\MinGW-4.5) y el archivo Run-cmd-with-MinGW-4.5.bat los puede mover donde usted desee (por ejemplo, llevarlos en un pen drive), sólo tenga en cuenta que para hacer esto los dos tienen que estar en el mismo directorio (e.j. C:\MinGW-4.5 y C:\Run-cmd-with-MinGW-4.5.bat).

Shared Pointers de C++0x

2010-05-29T00:00:00-03:00

En C usted puede hacer esto:

#include <stdlib.h>

struct Persona { };

int main()
{
  Persona* a = malloc(sizeof(Persona));
  free(a);
  return 0;
}

Un ejemplo equivalente en C++:

class Persona { };

int main()
{
  Persona* a = new Persona();
  delete a;
  return 0;
}

Por cada malloc existe un free (al menos que use reallocs), y por cada new existe un delete (y por cada new[] un delete[]).

¿Existe una forma por la cual C++ se "entere" que ya no quiero usar un puntero? La respuesta es: No, no existe. C++ no tiene un garbage collector. Pero existen clases que pueden ayudarnos, como el viejo y tan poco querido auto_ptr, o los mejorados unique_ptr, shared_ptr y weak_ptr del nuevo estándar de C++0x (o el TR1).

Un shared pointer es una clase que se encarga de guardar un puntero a un objeto (o tipo de dato), y cuenta la cantidad de referencias que se están haciendo a dicho objeto (es decir, la cantidad de shared pointers que apuntan al mismo objeto). El último shared pointer que se destruya (cuando las referencias llegan a cero), será el encargado de borrar el objeto apuntado (mediante un simple delete).

Un ejemplo:

#include <iostream>
#include <memory>  // Aquí debería estar shared_ptr<> (GCC 4.4)

using namespace std;

class Persona {
  int n;

public:
  Persona(int n) : n(n) {
    cout << "Nace la persona " << n << "\n";
  }

  ~Persona() { 
    cout << "Muere la persona " << n << "\n";
  }

  static shared_ptr<Persona> Crear(int n) { 
    return shared_ptr<Persona>(new Persona(n));
  }
};

int main()
{
  shared_ptr<Persona> a(new Persona(1));
  shared_ptr<Persona> b = Persona::Crear(2);
  shared_ptr<Persona> c;

  cout << "--- Aquí ambas personas existen ---\n";

  c = a; // Aquí c apunta a la persona 1
  b = c; // Ahora b apuntará a la persona 1 (la persona 2 muere porque
         // ya no existen referencias a ella)

  cout << "--- Aquí la persona 2 ya no existe ---\n";
  
  return 0;
}        // Aquí muere la persona 1 (a, b, c apuntaban a ella)

La salida del anterior programa es esta:

Nace la persona 1
Nace la persona 2
--- Aquí ambas personas existen ---
Muere la persona 2
--- Aquí la persona 2 ya no existe ---
Muere la persona 1

Como puede ver, en el anterior programa se llama sólo dos veces a "new Persona" y dos veces al destructor ~Persona. No debemos preocuparnos por usar "delete", el shared_ptr<> hace todo por nosotros.

¿Cómo hago para que la clase shared_ptr funcione en VS2008 SP1 Express? Debe definir _HAS_TR1 antes de incluir el archivo <memory>. Ejemplo:

#ifdef _MSC_VER      // Si estamos usando el compilador de Microsoft
  #define _HAS_TR1 1 // Esto hará que se incluyan las clases del TR1 (std::tr1)
#endif

#include <iostream>
#include <memory>

using namespace std;
#ifdef _MSC_VER
  using namespace std::tr1; // para tener shared_ptr<> disponible
#endif

// Resto del ejemplo...

C++0x Final Committee Draft (FCD)

2010-03-31T00:00:00-03:00

Ya está disponible el documento N3092, Programming Languages — C++, Final Committee Draft. Este documento es el que más podría corresponder al nuevo estándar ISO de C++ (lo que viene de acá a uno o dos años pueden ser correcciones menores):

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3092.pdf

Más información acá.

Improving your applications by statistics

2010-03-03T00:00:00-03:00

If you developed an application and published it in a website, you can use things like google-analytics data to adjust your application. E.g. If everybody is accessing your website with 32-bits, 24-bits and 16-bits screen resolutions, you can discard all considerations about 8-bits modes in your application.

Things you should add to your application:

A way to get usage data from your users. E.g. where they do click, how they call commands (menus, keyboard, toolbars, ribbons, etc.). In this way you could focus improvement in the more common methods to run commands.
A way to count how many times a command was used. Maybe there are commands that are rarely used, these commands could be more deeper in menus hierarchies and without keyboard shortcut.
A way to known systems where your application is running. E.g. operating system, version, screen resolution, etc. Improve usability in the most used platform.
A way to known how many computers are running a specific version of your application. If a version is not used anymore, you can stop supporting it (E.g. Adding patches for a version that nobody uses).

All this must be done carefully, with proper check-boxes like “Do you want to send anonymous data about your usage to improve customer experience?” in installers, splash screens, etc.

There are some frameworks to do this kind of work. Anyway you basically need:

An HTTP server to accept packages from users (e.g. through POST requests). Each request should be processed by a script (in PHP, ASP, etc.) which should convert the received package into database model.
A way to differentiate users (you could SHA1 some string like “local user name + pc host name + app name version”). Here I don’t know if the IP could be a good way idea (NAT problems, etc.).
A way to make HTTP requests from your application (firewall + proxy problems) of all collected usage data of the user (identified by the SHA1).
A mini-program to process all the database and print some useful reports.

Emacs: How to open the current buffer with associated application?

2010-03-02T00:00:00-03:00

The following function tries to run the application associated with the current buffer file type (e.g. if you use this function in an .html file, the file will be opened with your default web browser):

(defun open-current-file-with-associated-app ()
  (interactive)
  (shell-command (concat "cmd /c \"start " (buffer-file-name) "\"")))

Emacs: How to locate the current buffer in Windows Explorer?

2010-03-02T00:00:00-03:00

You can use the following function to open the Windows Explorer in the directory of the current buffer:

(defun locate-current-file-in-explorer ()
  (interactive)
  (cond
   ;; In buffers with file name
   ((buffer-file-name)
    (shell-command (concat "start explorer /e,/select,\"" (replace-regexp-in-string "/" "\\\\" (buffer-file-name)) "\"")))
   ;; In dired mode
   ((eq major-mode 'dired-mode)
    (shell-command (concat "start explorer /e,\"" (replace-regexp-in-string "/" "\\\\" (dired-current-directory)) "\"")))
   ;; In eshell mode
   ((eq major-mode 'eshell-mode)
    (shell-command (concat "start explorer /e,\"" (replace-regexp-in-string "/" "\\\\" (eshell/pwd)) "\"")))
   ;; Use default-directory as last resource
   (t
    (shell-command (concat "start explorer /e,\"" (replace-regexp-in-string "/" "\\\\" default-directory) "\"")))))

How it works?

If you are visiting a buffer associated to a file (with buffer-file-name), the Windows Explorer is opened to focus the file in its directory.
If you are in dired mode (browsing a directory inside Emacs with dired-mode), it will open that directory in Windows Explorer.
If you are in eshell-mode, the current working directory will be opened in Windows Explorer.
As last chance it will open the Windows Explorer in the default directory (where you start emacs). E.g. This can happen if you use this function in scratch buffer (which is a buffer without an associated file).

STL string, parseando un número de versión

2010-01-27T00:00:00-03:00

En esta ocasión vamos a ver cómo usar la clase std::string para convertir una cadena de caracteres (como "1.2.3") en una clase "Version" que tenga una interfaz simple de utilizar (por ejemplo, que permita comparar versiones).

Los pasos son simples:

tenemos como entrada una cadena de caracteres,
dividimos la cadena según el caracter '.' (punto),
convertimos cada parte a entero,
guardamos cada número entero de forma ordenada en un vector.

El punto 2 es en el cual nos vamos a enfocar más. El código mostrado aquí es a modo de ejemplo, y está lejos de ser el más óptimo.

Antes de comenzar ¿Podemos usar strcmp para comparar dos versiones? No, no podemos. Ejemplo: strcmp("1.9", "1.10") > 0, cuando en realidad la versión 1.9 es menor a 1.10.

Imaginemos que tenemos una cadena:

std::string ver = "1.10.2.3";

La clase std::string tiene la función miembro find, la cual podemos usar para buscar casi cualquier cosa dentro de la cadena. ¿Qué debemos buscar? Los puntos, sabiendo donde está cada punto, podemos ir recortando la cadena en sus distintas partes ("1", "10", "2", y "3"). Buscamos la ubicación del primer punto:

size_t i = ver.find('.');

if (i != std::string::npos)
  std::printf("El punto fue encontrado en la posición %d\n", i);
else
  std::printf("No hay punto en la cadena\n");

Ejecutando el código anterior, deberíamos obtener el mensaje:

El punto fue encontrado en la posición 1

¿Qué es size_t? Es como el tipo "unsigned int", el tipo de dato retornado por el operador sizeof() y utilizado como índice en las funciones de std::string.

¿Qué es std::string::npos? Es el máximo valor posible de un size_t y se utiliza para indicar (en este caso) que la función find falló (no encontró el punto).

Una vez que tenemos la posición del punto, podemos obtener la porción de texto que contiene la primer cifra, para eso usamos la función miembro substr:

std::string primer_cifra = ver.substr(0, i);

Esto significa: che vos, función substr, devolveme el pedazo de cadena de caracteres que va desde el índice 0, y tiene una longitud de i-caracteres.

El proceso puede ser repetido tantas veces como queramos para seguir obteniendo cifras. Por ejemplo, para la siguiente cifra debemos buscar (find) el siguiente punto, pero comenzando desde el que encontramos hace un rato:

i++;     // ir a la posición siguiente del punto '.'
size_t j = ver.find('.', i);

¿Qué es (o hace) el segundo argumento de find? Le indica a la función desde donde debe comenzar a buscar. La primera vez que usamos find este argumento no se especificó, porque por omisión toma el valor 0, es decir, buscar desde el inicio de la cadena.

¿Por qué i++? Porque si comenzáramos a buscar un punto desde i, nos devolvería la misma posición i (porque justamente, en i, está el primer punto que encontramos). Entonces debemos avanzar una posición.

Ahora, debemos recortar la segunda cifra:

std::string segunda_cifra = ver.substr(i, j-i);

La segunda cifra, comienza desde i y tiene una longitud igual a j-i. Para comprender esto, vea la siguiente figura:

De esta forma, ver.substr(i, j-i) nos devuelve la cadena "10". La versión completa del algoritmo puede quedar algo así:

#include <vector>  // Por std::vector
#include <string>  // Por std::string
#include <cstdlib> // Por std::strtol
#include <cstdio>  // Por std::printf

int main()
{
  std::string ver = "1.10.2.3";

  // Vector con cada cifra.
  // Luego del procesamiento esto debería ser = { 1, 10, 2, 3 }
  std::vector<int> cifras;

  size_t i = 0;   // Comenzamos desde i=0
  size_t j = 0;

  // Repetir hasta no llegar al final de la cadena
  while (j != std::string::npos) {
    // Buscar próximo punto
    j = ver.find('.', i);

    std::string cifra;

    // Si se encontró un punto
    if (j != std::string::npos) {
      // Recortamos desde i hasta j
      cifra = ver.substr(i, j-i);

      // El nuevo comienzo para buscar puntos será "j+1"
      i = j+1;
    }
    // Si no se encontró un punto
    else {
      // Recortamos desde "i" hasta el final de la cadena
      cifra = ver.substr(i);
    }

    // Obtener el valor entero de la cifra
    int cifra_int = std::strtol(cifra.c_str(), NULL, 10);

    // Agregar la cifra al vector
    cifras.push_back(cifra_int);
  }

  for (size_t i=0; i<cifras.size(); ++i)
    printf("cifras[%d] = %d\n", i, cifras[i]);

  return 0;
}

La salida del anterior programa es:

cifras[0] = 1
cifras[1] = 10
cifras[2] = 2
cifras[3] = 3

Con este código, podríamos implementar una clase "Version" con la siguiente interfaz:

class Version
{
public:
  Version(const char*);
  Version(const std::string&);

  bool operator==(const Version& u) const;
  bool operator<(const Version& u) const;
  // ...
};

En un próximo post voy a colocar una posible implementación de la clase "Version".

Punteros por ámbito (scoped pointers)

2009-11-06T00:00:00-03:00

C++ no tiene un recolector de basura, aunque C++0x le va tomando el gustito, tenemos algunas opciones para liberarnos de liberar memoria, valga la redundancia.

Imaginemos un código como el siguiente:

#include <cstdio>

using namespace std;

class A {
public:
  A()         { printf("A\n");    }
  ~A()        { printf("~A\n");   }
  void hola() { printf("hola\n"); }
};

int main()
{
  A* a = new A;
  a->hola();
  return 0;
}

El anterior programa, por más minimalista que parezca, tiene un memory leak. Aunque los recursos suelen ser liberados por el mismo sistema operativo al finalizar el programa, si el proceso se ejecuta por mucho tiempo (e.j. un servicio que se ejecuta por días, semanas o meses dentro de un servidor), los recursos se van agotando poco a poco hasta que la computadora queda hecha una pasa.

Para arreglar el leak, deberíamos escribir:

int main()
{
  A* a = new A;
  a->hola();
  delete a;
  return 0;
}

¿Cómo hacemos para liberar memoria sin llamar delete nosotros mismos? Podemos crear una clase utilitaria que haga el trabajo por nosotros en su destructor. Por ejemplo, en el siguiente código veremos que el delete es llamado en el destructor de PunteroA:

class PunteroA {
  A* ptr;
public:
  PunteroA(A* p) { ptr = p; }
  ~PunteroA()    { delete ptr; }
};

int main()
{
  PunteroA a(new A);
  a->hola();          // error, "a" no es un puntero ni sobrecarga operator->
  return 0;
}

El anterior programa nos dará un error de compilación ya que el tipo PunteroA no soporta el operador flecha. Debemos agregarlo en la definición de la clase PunteroA:

class PunteroA {
  A* ptr;
public:
  PunteroA(A* p)  { ptr = p; }
  ~PunteroA()     { delete ptr; }
  A* operator->() { return ptr; }
};

int main()
{
  PunteroA a(new A);
  a->hola();        // ahora sí, PunteroA::operator->() nos devuelve
                    // el verdadero puntero A* y A::hola() finalmente
                    // es llamado
  return 0;
}

¿Cómo obtengo el A* desde un PunteroA? Debemos definir el operador de conversión hacia A*:

class PunteroA {
  A* ptr;
public:
  PunteroA(A* p)  { ptr = p; }
  ~PunteroA()     { delete ptr; }
  A* operator->() { return ptr; }
  operator A*()   { return ptr; }
};

Así podemos usar un PunteroA en funciones que reciban un A*. Ejemplo:

void func(A* a) { ... }

int main()
{
  PunteroA a(new A);
  func(a);
  return 0;
}

Generalizando: Podemos generalizar nuestro PunteroA para cualquier tipo de dato:

template<class T>
class ScopedPointer {
  T* ptr;
public:
  ScopedPointer(T* p) { ptr = p; }
  ~ScopedPointer()    { delete ptr; }
  
  operator T*()       { return ptr; }
  T* operator->()     { return ptr; }
};

Así podemos usar el mismo ScopedPointer para liberar instancias de cualquier clase:

int main()
{
  ScopedPointer<A> a(new A);
  ScopedPointer<B> b(new B);
  a->hola();
  return 0;
}

¿Y si quiero liberar otro tipo de recurso? Si el recurso no es memoria, y es liberado con otra función en vez de delete, podemos generalizar nuestro ScopedPointer con un nuevo parámetro de template llamado Destroyer:

struct DefaultDestroyer {
  template<class T>
  static void free(T* ptr) { delete ptr; }
};

template<class T, class Destroyer = DefaultDestroyer>
class ScopedPointer {
  T* ptr;
public:
  ScopedPointer(T* p) { ptr = p; }
  ~ScopedPointer()    { Destroyer::free(ptr); }
  
  operator T*()       { return ptr; }
  T* operator->()     { return ptr; }
};

En este caso, el destructor ~ScopedPointer llama a la función estática Destroyer::free. Esta función básicamente puede hacer lo que nosotros queramos. Podría ser útil para liberar ficheros o cualquier otro tipo de recurso:

struct FileDestroyer {
  static void free(FILE* ptr) { fclose(ptr); }
};

int main()
{
  ScopedPointer<FILE, FileDestroyer> file(fopen("hola.txt", "rt"));
  char buf[256];
  fread(buf, 1, 256, file);
}

¿No existen punteros de este tipo ya implementados? Boost tiene su propio scoped_ptr. También existen punteros más avanzados que cuentan referencias, como los smart pointers.

Interfaces vs. Conceptos

2009-10-18T00:00:00-03:00

¿Qué son los conceptos? Vamos a ver con un simple ejemplo, cómo podemos hacer una equivalencia entre las conocidas interfaces y los conceptos.

Imaginen esta "interfaz" (clase abstracta):

class IPortero {
public:
  virtual IPortero() { }
  virtual void ir_a_piso(int piso) = 0;
  virtual int piso_destino() = 0;
};

Tenemos otra clase Ascensor que podemos "personalizar" con nuestro propio portero, así nuestra implementación de portero puede hacer lo que se le de la gana:

class Ascensor {
  IPortero* m_portero;
public:
  Ascensor(IPortero* portero) {
    m_portero = portero;
  }
  void apretaron_boton_en_piso(int piso) {
    m_portero->ir_a_piso(piso);
    mover_ascensor(m_portero->piso_destino());
  }
  void mover_ascensor(int piso) { ... }
};

Con programación genérica, podemos reformular la interfaz convirtiéndola en un "concepto" y la clase Ascensor en una clase plantilla:

template<class TipoPortero>
class Ascensor {
  TipoPortero m_portero;
public:
  Ascensor() { }
  void apretaron_boton_en_piso(int piso) {
    m_portero.ir_a_piso(piso);
    mover_ascensor(m_portero.piso_destino());
  }
  void mover_ascensor(int piso) { ... }
};

La pregunta es, ¿qué demonios es TipoPortero?. La respuesta es sencilla: TipoPortero puede ser cualquier tipo de dato que cumpla los siguientes requisitos:

Tenga un constructor por omisión (que se pueda construir un nuevo TipoPortero sin argumentos, o sea, TipoPortero()).
Tenga una función miembro TipoPortero::ir_a_piso(int), la cual recibe un "int" (o cualquier tipo de dato que se pueda construir desde un "int" implícitamente).
Y otra función miembro TipoPortero::piso_destino() que devuelve un entero.

¿Cómo especificamos la "interfaz" o los "requerimientos" de un concepto? Sencillamente no se puede, C++0x iba a soportar esto, pero ya no. Hoy en día la mejor respuesta es usar algunos comentarios en la clase Ascensor que especifiquen qué espera en sus parámetros de template. En este aspecto se podría decir que IPortero es mejor porque especifica explícitamente lo que el portero tiene que hacer (funciones a implementar, etc.).

¿Qué ventaja tiene el concepto con respecto a las interfaces? La clase genérica Ascensor ahora tiene el mismo portero adentro suyo (no un puntero a la interfaz). Las llamadas a las funciones miembro ir_a_piso y piso_destino son llamadas directas (no tienen el overhead de una llamada a una función virtual).

Clases que "desaparecen" luego de compilar

2009-10-17T00:00:00-03:00

La magia de C++ es que, una vez compilado el código, algunas clases pueden desaparecer por completo (principalmente las que se usan en stack). O sea, aunque las clases abstraen al programador de los detalles de implementación, al final, el código termina siendo tan óptimo como si la clase no fuera utilizada en un principio.

Un ejemplo. Teniendo la siguiente clase Acumulador:

#include <cstdio>

class Acumulador {
  int v;
public:
  Acumulador()         { v = 0;                   }
  ~Acumulador()        { std::printf("%d\n", v);  }
  void acumular(int x) { v += x;                  }
};

Un código como el siguiente:

{
  Acumulador acum;
  acum.acumular(2);
  acum.acumular(4);
  acum.acumular(10);
}

Al compilarlo (optimizándolo), el código equivale a exactamente esto:

{
  int v = 0;
  v += 2;
  v += 4;
  v += 10;
  std::printf("%d\n", v);
}

La clase Acumulador ya no existe. Obtenemos el código más óptimo posible: sin llamadas a la función "acumular", ni ningún byte extra de memoria (Acumulador ocupa lo mismo de memoria que ocupa un "int").

Este ejemplo no ayuda a ver grandes ventajas, pero si el constructor y el destructor hacen tareas complicadas, y las funciones miembros también, el resultado puede llevarnos a dos puntos:

Nos abstrae de la complejidad de la implementación (e.j. para qué quiero saber cómo se acumula si sólo quiero acumular)
Obtenemos código tan óptimo como si no hubiéramos usado la abstracción (e.j. las operaciones se acercan al hardware tanto como sea posible).

SourceForge habla de Allegro Sprite Editor

2009-10-13T00:00:00-03:00

Hoy salió un artículo sobre Allegro Sprite Editor en la SourceForge Community.

Las viejas home pages

2009-10-07T00:00:00-03:00

(Una nota que nadie nunca leerá)

Viendo mi página hoy en día, siento que ya es una reliquia. Hace muchísimo que las páginas personales dejaron de existir como eran antes. Ahora son todos blogs, feeds, artículos, noticias, etc. Las viejas páginas personales (con secciones, site-map, etc.) ya son una antigüedad.

A lo largo de los años fui quitando más y más texto de mi página, hasta dejarla pelada completamente. Hoy en día son sólo links, apuntando a otros sitios para bajarse cosas útiles (¿?). Algún que otro párrafo explicando algo, pero inclusive sospecho que esos párrafos nunca serán leídos.

En fin, las viejas páginas personales fueron devoradas por la “fast-food” de la información en Internet.

Google Wave

2009-09-19T00:00:00-03:00

Una de las mejores cosas que vi:

Editado 2012-04-05: Ja, me causa gracia hoy en día como una de las mejores cosas que pense ver, la cerraron.

Modernización de Emacs

2009-08-26T00:00:00-03:00

Un artículo de Xah Lee que habla sobre cómo mejorar Emacs. Por fin alguien que piensa en la usabilidad en el software libre.

Y su proyecto para llevarlo a cabo: ErgoEmacs.

Lo que quieras hacer

2009-07-23T00:00:00-03:00

Tema Lo que quieras hacer de Riff

Te dicen que nunca hiciste algo bien,
que no fuiste lo que debías ser;
no saben que acaso no quisiste ser,
como ellos decían estaba bien.

Según pasa el tiempo te das cuenta que
todo fue distinto a lo que iba a ser,
sólo queda ahora seguir adelante,
seguir adelante y no retroceder.

Tuya, es toda tu vida
para hacer lo que tu quieras hacer,
tuya, y no sólo mía
porque yo ya no te puedo ni ver.

C++0x no va a tener "conceptos"

2009-07-23T00:00:00-03:00

En la última reunión del ISO C++ Standards Committee decidieron quitar los "conceptos" del próximo estándar de C++ (que en realidad, en vez de C++0x va a ser C++1x y chirola). Un artículo de Bjarne Stroustrup habla al respecto:

[...] Básicamente, los "conceptos" tenían como meta hacer de la programación genérica algo más accesible a la mayoría de los programadores, pero esa meta ha sido para mí (Stroustrup) seriamente comprometida: En vez de hacer la programación genérica más accesible, los "conceptos" se fueron convirtiendo en otra herramienta más en las manos de los expertos (únicamente).
[...]
Para resumir y de alguna forma simplificar, he afirmado que:
Los "conceptos" como están actualmente definidos son muy difíciles de utilizar, lo que los llevará al desuso, dando la posibilidad a un desuso de los templates mismos y a la adopción completa de C++0x.
Un pequeño conjunto de simplificaciones [BS2009] pueden dejar a los "conceptos" lo suficientemente aceptables como para salir acorde a las fechas planificadas para C++0x o con sólo un retraso menor.
[...]

STL vector en vez de los clásicos buffers de C

2009-07-12T00:00:00-03:00

Algunas veces tenemos que crear buffers temporales. Por ejemplo, la función sprintf necesita de un buffer para poder dejar la cadena resultante. Ejemplo:

char buf[256];
sprintf(buf, "%d", 12345);
// usar "buf"...

Si queremos mantener el buffer en heap:

char* buf = malloc(256);
sprintf(buf, "%d", 12345);
// usar "buf"...
free(buf);

En C++ podríamos hacer uso de los operadores new[]/delete[]:

char* buf = new char[256];
sprintf(buf, "%d", 12345);
// usar "buf"...
delete[] buf;

Pero es aconsejable evitar la creación de arreglos con new[], y en su lugar hacer uso de std::vector:

std::vector<char> buf(256);
sprintf(&buf[0], "%d", 12345);
// usar "&buf[0]" en vez de "buf"...

El resultado: tenemos un buffer en el heap que se libera automáticamente (~std::vector) al salir del ámbito de la función que lo utiliza.

Conscientemente, todo todo, lo podrás lograr

2009-04-06T00:00:00-03:00

Tema Conscientemente, todo todo, lo podrás lograr de Billy Bond y La Pesada Del Rock and Roll

En tu mente, en tu mente vivirán.
Los deseos, los deseos de cambiar.
Concientemente todo todo lo podrás lograr.

No te quedes, no te quedes muy atrás.
Si no sigues, no tendrás con quien hablar.
Concientemente todo, todo lo podrás lograr.

Vamos chicos, vamos chicos a cambiar.
Vamos loco, vamos loco a cambiar.
Concientemente todo todo lo podrás lograr.

No te quedes siempre en el mismo lugar.
Vamos chico, vamos loco a cambiar.
Concientemente, todo todo, lo podrás lograr.

STL for each

2009-03-21T00:00:00-03:00

Para recorrer un arreglo de C, podemos utilizar punteros. Comenzamos apuntando al primer elemento y frenamos una vez procesado el último elemento:

#include <stdio.h>

int main()
{
  int array[] = { 5, 3, 4, 9, 1 };
  int array_size = sizeof(array) / sizeof(int); // cantidad de elementos de "array"
  int *array_begin = array;                     // comienzo del array
  int *array_end = array+array_size;            // final del array (+un elemento)
  int *it;                                      // el iterator

  for (it = array_begin;  it != array_end;  ++it) {
    printf("%d\n", *it);
  }
  return 0;
}

Hay que tener en cuenta que array_end es igual a &array[5]. Sabiendo que sólo podemos acceder a los elementos desde array[0] a array[4], decimos que array[5] está más allá del último elemento del arreglo, es decir, &array[5] es la posición de memoria que ya no es parte del mismo arreglo (de ahí it != array_end significa “mientras nos encontremos dentro del arreglo”).

¿Cómo recorrer un contenedor de la STL? La idea es similar, sólo que en vez de usar punteros utilizamos iteradores, y observe como la sintaxis del for es exactamente la misma. (Nota: en este caso utilizamos un vector.)

#include <iostream>
#include <vector>

using namespace std;

int main()
{
  vector<int> array;
  array.push_back(5);
  array.push_back(3);
  array.push_back(4);
  array.push_back(9);
  array.push_back(1);

  vector<int>::iterator it;

  for (it = array.begin();  it != array.end();  ++it) {
    cout << *it << endl;
  }
  return 0;
}

¿Cómo recorrer un contenedor STL con el algoritmo for_each? (Nota: Lo siguiente también se puede hacer con copy y ostream_iterator.)

#include <cstdio>
#include <vector>
#include <algorithm>

using namespace std;

void print_element(int a) { cout << *it << endl; }

int main()
{
  vector<int> array;
  array.push_back(5);
  array.push_back(3);
  array.push_back(4);
  array.push_back(9);
  array.push_back(1);

  for_each(array.begin(), array.end(), print_element);
  return 0;
}

La función pasada como tercer parámetro a for_each es llamada por cada elemento del arreglo:

template<typename InputIterator, typename Function>
Function for_each(InputIterator first, InputIterator last, Function f)
{
  for (; first != last; ++first)
    f(*first);
  return f;
}

¿Por qué for_each devuelve la función? Principalmente porque la función f podría no ser una función! Podría ser un functor (objeto función), es decir, una instancia de una clase que tiene sobrecargado el operator() (llamada a función). Pero este tema se merece su propio post.

¿Se puede usar el algoritmo for_each para los arreglos de C? Sí.

#include <cstdio>
#include <algorithm>

using namespace std;

void print_element(int a) { printf("%d\n", a); }

int main()
{
  int array[] = { 5, 3, 4, 9, 1 };
  int array_size = sizeof(array) / sizeof(int); // cantidad de elementos de "array"
  int *array_begin = array;                     // comienzo del array
  int *array_end = array+array_size;            // final del array (un elemento más)

  for_each(array_begin, array_end, print_element);
  return 0;
}

STL generate

2008-12-08T00:00:00-03:00

Si usted tiene una función que genera números/valores/instancias (ej: un generador de números aleatorios, o identificadores) puede usar el algoritmo generate de la STL para crear una secuencia de objetos. Por ejemplo, para generar 100 números (pseudo)aleatorios de 0 a 1:

#include <algorithm>
#include <vector>

double uniform_random()
{
  return (rand() % 10001) / 10000.0;
}

int main()
{
  std::vector<double> v(100);
  std::generate(v.begin(), v.end(), uniform_random);
  return 0;
}

El algoritmo generate recibe dos iteradores (inicio y fin), y llama a la función especificada para cada una de las posiciones que recorre:

template<typename ForwardIterator, typename Generator>
void generate(ForwardIterator first, ForwardIterator last,
              Generator gen)
{
  for (; first != last; ++first)
    *first = gen();
}

Los algoritmos de la STL son genéricos porque utilizan la aritmética de punteros. Los iteradores sobrecargan los operadores para poder ser utilizados como punteros. Así un algoritmo puede ser utilizado con los contenedores de la STL (vector) o con los viejos y tan queridos arreglos (y punteros) de C:

#include <algorithm>

double uniform_random()
{
  return (rand() % 10001) / 10000.0;
}

int main()
{
  double v[100];
  std::generate(v, v+100, uniform_random);
  return 0;
}

¿Preincrementar o postincrementar?

2008-08-19T00:00:00-03:00

Hace mucho que quería escribir un post tan inútil como este. La duda que siempre me pasaba por la cabeza era la siguiente: ¿Será exactamente el mismo código ensamblador el que genera el compilador cuando utilizamos el preincremento o el postincremento (sin utilizar el valor de retorno)? Tenía la seguridad de que así debía ser (una optimización tan básica no podía ser dejada de lado), pero me faltaban las pruebas (en ensamblador) para verificarlo.

Recordando un poco, el preincremento

int a = 0;
int b = ++a;

hace a=1 y b=1, mientras que el postincremento

int a = 0;
int b = a++;

hace a=1 y b=0, esto significa que b obtuvo el valor de a anterior al incremento.

Aquí estamos utilizando el valor de retorno del operador incremento. El código ensamblador es distinto para cada caso. Vamos a echarle una mirada (antes le recomiendo ver este excelente artículo para comprender más sobre el stack y las convenciones de llamadas). En el preincremento el código ensamblador (generado por GCC 3.4.5 para i386) es:

subl  $8, %esp          // reservamos 8 bytes en el stack (para variables locales)
movl  $0, -4(%ebp)      // a   = 0
leal  -4(%ebp), %eax    // eax = &a
incl  (%eax)            // *eax= (*eax) + 1
movl  -4(%ebp), %eax    // eax = a
movl  %eax, -8(%ebp)    // b   = eax

En el postincremento

subl  $8, %esp          // reservamos 8 bytes en el stack
movl  $0, -4(%ebp)      // a   = 0
movl  -4(%ebp), %edx    // edx = a
leal  -4(%ebp), %eax    // eax = &a
incl  (%eax)            // *eax= (*eax) + 1
movl  %edx, -8(%ebp)    // b   = edx

donde se ve que el registro edx se utiliza para guardar el valor que tenía a antes del incremento para luego asignárselo a b.

Pero la pregunta original es, ¿qué pasa si no usamos el valor de retorno? ¿el código de ++i o i++ es igual? Debería serlo, y de hecho, lo es. Pero como veremos más abajo, esto sólo se cumple si utilizamos tipos de datos built-in (int, double, long, etc.). Miremos el siguiente código:

void func() { }
void pre () { for (int c=0; c<8; ++c) { func(); } }
void post() { for (int c=0; c<8; c++) { func(); } }
int main()
{
  pre();
  post();
  return 0;
}

Básico, un for pero con las dos variantes posible de incremento. El código generado para ambos casos (tanto para la función pre como post) es el siguiente:


  pushl %ebp              // guardar el viejo puntero a la base del stack
  movl  %esp, %ebp        // establecer la nueva base del stack
  subl  $4, %esp          // guardar 4 bytes en el stack (para variables locales)
  movl  $0, -4(%ebp)      // c = 0
L3:
  cmpl  $7, -4(%ebp)
  jg    L2                // si c > 7 entonces ir a L2
  call  _func             // llamar a la función func()
  leal  -4(%ebp), %eax    // eax = &c
  incl  (%eax)            // *eax= (*eax) + 1
  jmp   L3                // repetir yendo a L3
L2:
  leave                   // restaurar la base del stack (popl %ebp)
  ret                     // retornar al punto de llamada

Realmente es indiferente usar cualquiera de los dos tipos de incremento, salvo, en los tipos definidos por el usuario. C++ ofrece un soporte para tipos de usuario igual a los built-in (bueno, no del todo, pero lo están solucionando). Nos da la posibilidad de sobrecargar los operadores de nuestros propios tipos (clases). Por ejemplo:

class tipo {
  int x;
public:
  tipo(int y) : x(y) { }
  tipo(const tipo& y) : x(y.x) { }
  // preincremento
  tipo& operator++() {
    ++x;
    return *this;
  }
  // postincremento
  tipo operator++(int) {
    tipo tmp(*this);
    ++x;
    return tmp;
  }
  bool operator<(int y) const { return x < y; }
};

void func() { }
void pre()  { for (tipo c=0; c<8; ++c) { func(); } }
void post() { for (tipo c=0; c<8; c++) { func(); } }

int main()
{
  post();
  return 0;
}

No colocaré el código ensamblador por desbordar belleza, pero el código generado en este caso es distinto: cada incremento llama a la función correspondiente a su operador. Esto es debido a que ambas implementaciones varían considerablemente. Por ejemplo, el postincremento necesita de una instancia extra de tipo para poder devolver el anterior valor de this, en cambio, el preincremento devuelve una referencia al mismo this (sin necesidad de hacer una copia).

Como dato curioso, algo interesante ocurre al utilizar las optimizaciones del GCC. Si compilamos este último programa con el parámetro -O3, vamos a ver que todas las funciones correspondientes a la clase tipo desaparecen, y todo el código resultantes es inline, dando como resultado un código tan óptimo como si hubiéramos utilizado un int en vez de nuestra clase tipo.

¿Cómo obtengo el código ensamblador desde un archivo C/C++?
Con el compilador gcc, hay que utilizar el parámetro -S:

g++ -S -o archivo.s -c archivo.cpp

En archivo.s queda el código ensamblador (sintaxis AT&T).

Excepciones, RAII y auto_ptr

2008-06-24T00:00:00-03:00

Una de las mejores formas de realizar un control de errores es por medio de excepciones. Lamentablemente, si no se toman las precauciones adecuadas, se pueden obtener leaks de algunos recursos. Por ejemplo, imagine el siguiente caso:

int main()
{
  try {
    char *ptr = new char[256];
    double *matrix = new double[100000*100000]; // 74 Gigabytes
    // ...
    delete matrix;
    delete ptr;
  } catch (const std::bad_alloc& e) {
    std::cout << "No hay memoria suficiente" << std::endl;
  }
  return 0;
}

Aquí, con el segundo new una excepción bad_alloc es lanzada. El problema es que la memoria asignada con el primer new nadie la libera. Esto es un memory leak. Una opción para solucionarlo es mediante un bloque finally "a la Java":

int main()
{
  char *ptr = NULL;
  double *matrix = NULL;
  try {
    ptr = new char[256];
    matrix = new double[100000*100000];
    // ...
    delete matrix;
    delete ptr;
  } catch (...) { // finally
    if (matrix) delete matrix;
    if (ptr) delete ptr;
  }
  return 0;
}

Claro que esto no hace al manejo de errores una tarea transparente.

En C++ se puede utilizar la técnica RAII (la adquisición de recursos está en la inicialización), lo que ayuda a evitar leaks. La idea básica detrás de esto es que los constructores obtengan recursos, y los destructores los liberen. Al ocurrir una excepción, se van llamando los destructores de los objetos creados.

Para solucionar nuestro problema, podemos utilizar la clase auto_ptr que se encuentra en <memory>. Un auto_ptr guarda un puntero que es liberado automáticamente en el destructor.

int main()
{
  try {
    std::auto_ptr<char> ptr(new char[256]);
    std::auto_ptr<double> matrix(new double[100000*100000]);
    // ...
  } catch (const std::bad_alloc& e) {
    std::cout << "No hay memoria suficiente" << std::endl;
  }
  return 0;
}

Los deletes no son necesarios. Al salir del ámbito del bloque try, ya sea normalmente o por excepción, se llamará al destructor de los auto_ptrs creados, así no se incurre en ningún tipo de leak.

Advertencia: Los auto_ptr deben ser utilizados sabiendo cuál es su verdadero funcionamiento: La copia de un auto_ptr a otro no los deja equivalentes. La última copia se queda con el puntero, los demás lo van perdiendo, y el delete lo invoca el último auto_ptr destruido. Por ejemplo:

{
  std::auto_ptr<Persona> otra_persona;
  {
    std::auto_ptr<Persona> una_persona(new Persona);
    otra_persona = una_persona;
    // ahora "una_persona" apunta a NULL
  }
} // aquí la persona es destruida

Pregunta: ¿Por qué no usar objetos alojados en el stack en vez del heap para evitar los leaks? Porque el stack es mucho más pequeño. Por ejemplo, el siguiente código provoca un SIGSEGV ya que el arreglo no entra en el stack:

double matrix[1000000];

Pero sí entra en el heap:

double *matrix = new double[1000000]; // 7.6 Megabytes

Compilando archivos

2008-05-10T00:00:00-03:00

Suponiendo que conoce qué es un archivo de código fuente, código objeto, un ejecutable .exe, y el código máquina; voy a pasar a explicar algunos comandos del GCC para compilar.

Retomando la idea del anterior post, imagínese que creamos un archivo timemark.h para darle un poco de portabilidad a todo este asunto de medir el desempeño de una rutina. Las declaraciones de timemark.h pueden ser usadas para crear un pequeño programa ejemplo1.c que sea independiente de la plataforma (por lo menos entre Windows y GNU/Linux).

Vamos a probar algunas operaciones sobre la línea de comandos para ver cómo compilar este archivo. Inicialmente, la opción más sencilla es utilizar directamente "gcc ejemplo1.c", esto nos da como resultado el archivo "a.exe" o "a.out". Veamos (teniendo timemark.h y ejemplo1.c en un directorio C:\ejemplo1):

C:\ejemplo1>gcc ejemplo1.c
C:/Temp/ccMjdaaa.o:ejemplo1.c:(.text+0x31): undefined reference to `get_timemark'
C:/Temp/ccMjdaaa.o:ejemplo1.c:(.text+0x3c): undefined reference to `get_timemark'
C:/Temp/ccMjdaaa.o:ejemplo1.c:(.text+0x4e): undefined reference to `timemark_diff'
collect2: ld returned 1 exit status

Como podrá ver, recibimos un error por las funciones no definidas get_timermark y timemark_diff. Esto se debe a que utilizando solamente "gcc ejemplo1.c", se intenta enlazar el código de ese único archivo en el ejecutable. Tenemos algunas opciones intermedias antes de crear el .exe final. Por ejemplo, podemos crear un archivo que contenga el código objeto ya compilado (pero únicamente del archivo en cuestión ejemplo1.c):

C:\ejemplo1>gcc -o ejemplo1.o -c ejemplo1.c

Así obtenemos el ejemplo1.o (código objeto). En este caso no recibimos errores ya que ejemplo1.o hace referencias a las funciones get_timermark y timemark_diff, pero no necesita su implementación específica. Cuando creamos el ejecutable final (.exe) es cuando realmente necesitamos el código de todas las funciones invocadas.

El archivo que falta es timemark.c. Del mismo modo, podemos compilarlo con el comando:

C:\ejemplo1>gcc -o timemark.o -c timemark.c

Ahora resta unir ambos archivos objetos en un único ejecutable, con un único punto de acceso (main):

C:\ejemplo1>gcc -o ejemplo.exe ejemplo1.o timemark.o

Y listo. Por ahora, lo aprendido son estos dos comandos:

gcc -o archivo.o -c archivo.c
gcc -o archivo.exe archivo1.o archivo2.o archivo3.o ...

El primero compila el código fuente para generar un archivo objeto, y el segundo comando reune (enlaza, linkea) el grupo de archivos objetos en un ejecutable único.

De todas formas, es bastante tedioso escribir estos comandos cada vez que queremos compilar. Para resolver el problema podemos utilizar los llamados Makefiles. Claro, lo más interesante queda para un futuro post.

Medir el tiempo de una rutina

2008-03-01T00:00:00-03:00

¿Alguna vez se preocupó por la velocidad con la que corre su programa? ¿No? Entonces usted es un candidato perfecto para jugar al Java. En caso contrario, voy a explicarle un pequeño código que utilizaremos en próximas entregas para medir el tiempo de ejecución de determinadas rutinas.

Ya lo dijo alguien: "La optimización prematura es la raíz de todos los males". No hay nada más cierto, aunque también es verdad que hacer algo simple de la peor forma posible, es la causa de otros grandes males. Con esto quiero decir que debería intentar hacer las cosas de la forma más simple y más óptima que usted conozca (dándole mayor importancia a la simplicidad del código); luego se preocupa por "darle velocidad" a la rutina que provoca el cuello de botella (en próximos posts veremos cómo usar gprof para detectarlo).

La forma de calcular el tiempo de CPU que toma una función es muy simple:

tomamos el valor del reloj antes de realizar la llamada (t_ini),
llamamos a la rutina en cuestión, y
tomamos nuevamente el valor del reloj (t_fin).

La diferencia entre t_fin - t_ini nos da el total de tiempo que tomó: 1) hacer la llamada a la rutina, 2) que esta haga su trabajo, 3) que devuelva el resultado.

Ahora hay algunos pequeños detalles de implementación. Por ejemplo, ¿qué función usar para tomar el tiempo del reloj? Y más importante, ¿qué precisión obtenemos con dicha función?

Para tomar el tiempo podemos usar la rutina clock(), que devuelve el tiempo aproximado de CPU que transcurrió desde que nuestro programa fue iniciado, dicho tiempo representado en un valor de tipo clock_t: un valor entero que indica una cantidad de "tics" de reloj.

La precisión que tenemos con dicha rutina es de CLOCKS_PER_SEC (tics de reloj por segundo), lo que significa que por cada segundo que pasa, la función clock() nos devolverá CLOCKS_PER_SEC unidades más que el valor anterior. En MinGW, CLOCKS_PER_SEC es igual a 1000, pero es mejor no fiarse de esto, ya que en otras plataformas dicho valor varía. Inclusive, según POSIX, la constante CLOCKS_PER_SEC debería ser 1000000.

Veamos algo de código:

#include <stdio.h>
#include <time.h>

int main(int argc, char *argv[])
{
  clock_t t_ini, t_fin;
  double secs;

  t_ini = clock();
  /* ...hacer algo... */
  t_fin = clock();

  secs = (double)(t_fin - t_ini) / CLOCKS_PER_SEC;
  printf("%.16g milisegundos\n", secs * 1000.0);
  return 0;
}

Con esto podemos medir cuántos milisegundos demoró "hacer algo". Todo parece muy bonito hasta que nos damos cuenta de dos grandes problemas:

Tomar una medida única y aislada es igual que tomar un número completamente aleatorio y mostrarlo (no es una muestra representativa). Es mejor repetir las mediciones unas cuantas veces (y hablo del orden de las 100, o 100000, o 1e32 veces), y luego sacar un promedio de todo.
La función clock() no llega a tener una precisión ni de 10 milisegundos (aunque CLOCS_PER_SEC sea 1000 o más).

Una vez dicho esto, el código de arriba no sirve ni para limpiarse los trastes... Así que tenemos que buscar una función con mayor precisión, y además, promediar varias muestras.

Existen otras alternativas como la función gettimeofday, pero bajo Windows sufre del mismo problema de precisión que clock(). Igualmente en Linux funciona perfectamente, así que vale la pena tener en cuenta este código:

#include <stdio.h>
#include <time.h>
#include <sys/time.h>

/* retorna "a - b" en segundos */
double timeval_diff(struct timeval *a, struct timeval *b)
{
  return
    (double)(a->tv_sec + (double)a->tv_usec/1000000) -
    (double)(b->tv_sec + (double)b->tv_usec/1000000);
}

int main(int argc, char *argv[])
{
  struct timeval t_ini, t_fin;
  double secs;

  gettimeofday(&t_ini, NULL);
  /* ...hacer algo... */
  gettimeofday(&t_fin, NULL);

  secs = timeval_diff(&t_fin, &t_ini);
  printf("%.16g milliseconds\n", secs * 1000.0);
  return 0;
}

Como puede ver la estructura timeval contiene dos campos, segundos y microsegundos transcurridos (tv_sec y tv_usec respectivamente), por lo tanto ofrece una precisión de microsegundos. De todas formas, como decía esto en Windows no sirve y la razón es sencilla, en la misma MSDN explican que el temporizador del sistema corre aproximadamente a unos 10 milisegundos, por lo tanto, cualquier función que lo utilice nos estará dando la misma asquerosa precisión (inclusive al utilizar GetSystemTimeAsFileTime y FILETIME). Por lo tanto la solución es utilizar lo que se conoce en el mundo de Windows como el "contador de rendimiento de alta resolución" (high-resolution performance counter):

#include <stdio.h>
#include <windows.h>

/* retorna "a - b" en segundos */
double performancecounter_diff(LARGE_INTEGER *a, LARGE_INTEGER *b)
{
  LARGE_INTEGER freq;
  QueryPerformanceFrequency(&freq);
  return (double)(a->QuadPart - b->QuadPart) / (double)freq.QuadPart;
}

int main(int argc, char *argv[])
{
  LARGE_INTEGER t_ini, t_fin;
  double secs;

  QueryPerformanceCounter(&t_ini);
  /* ...hacer algo... */
  QueryPerformanceCounter(&t_fin);

  secs = performancecounter_diff(&t_fin, &t_ini);
  printf("%.16g milliseconds\n", secs * 1000.0);
  return 0;
}

En este caso, imagine que QueryPerformanceCounter es como clock() y QueryPerformanceFrequency es como CLOCKS_PER_SEC. Es decir, la primera función nos da el valor del contador, y la segunda su frecuencia (en ciclos por segundo, hertz). Cabe aclarar que un LARGE_INTEGER es una forma de representar un entero de 64 bits por medio de una unión (union).

Como tarea al lector, si es que existe alguno, le queda hacer una versión "portable" (entre Windows y Linux) para medir el rendimiento (con unos cuantos #ifdef WIN32 y #endif sería suficiente).

18 de Marzo del 2008: acá transcribo una macro que me pasó el amigo Carlos Becker para medir el tiempo de una rutina en Linux mediante clock_gettime:

#define TIME_THIS(X)                                         \
  {                                                          \
    struct timespec ts1, ts2;                                \
    clock_gettime( CLOCK_REALTIME, &ts1 );                   \
    X;                                                       \
    clock_gettime( CLOCK_REALTIME, &ts2 );                   \
    printf( #X " demora: %f\n",                              \
      (float) ( 1.0*(1.0*ts2.tv_nsec - ts1.tv_nsec*1.0)*1e-9 \
      + 1.0*ts2.tv_sec - 1.0*ts1.tv_sec ) );                 \
  }

/* podemos usarla así */
{
  double x, y, z;
  x = 2.0;
  y = 4.0;
  TIME_THIS(z = sqrt(x*x + y*y));
}

Lo que da como resultado:

z = sqrt(x*x + y*y) demora: 0.015164

Conseguir un compilador

2008-02-17T00:00:00-03:00

Editado 21 de mayo 2011: Este post se encuentra aquí sólo a fines históricos, ahora usted puede usar el instalador automático de MinGW.

Editado 9 de septiembre 2010: Aunque este post contiene información útil de cómo instalar MinGW con gcc 3.4, tal vez prefiera antes probar este nuevo post sobre cómo descargar MinGW con gcc 4.5 de forma automática.

En este blog vamos a hablar sobre los lenguajes de programación C y C++, y cómo usar software GNU para hacer aplicaciones. También voy a tratar de investigar algo de ensamblador.

De todas formas, para evitar hacer un primer post completamente inútil "de presentación", voy a pasar a explicarles cómo pueden instalar un compilador gratuito en Windows desde cero, y hacer un pequeño programa "Hola Mundo" sin pensar mucho (eso sí, van a tener que leer un poco). El proceso para Linux es más sencillo, ya que el compilador suele venir instalado por defecto en la mayoría de las distribuciones.

Primero, algunas definiciones importantes:

MinGW: Un conjunto de programas y bibliotecas que permiten crear aplicaciones para Windows.
GCC: El compilador. Transforma código escrito en C/C++ a un archivo ejecutable (.exe). En realidad hace miles de maravillas más, pero por ahora nos vamos a quedar con esta definición.
MSYS: Es un conjunto mínimo de programas para poder ejecutar scripts "a la" Unix. Además incluye una terminal que emula un pequeño entorno GNU/Linux.
Emacs: La madre de los editores de texto. Alguna vez dije que era una porquería o muy complicado, y que conviene usar editores como el RHIDE o Setedit. Bueno, la cosa es que con "un poco" de práctica uno comprende el poder de esta herramienta.
make: Un programa que puede compilar muchos archivos y linkearlos en un ejecutable de forma automatizada (siempre y cuando le escribamos un archivo con las órdenes adecuadas). Generalmente los programadores están acostumbrados a utilizar un IDE (como el DevC++) que maneje el proyecto, calcule las dependencias entre archivos, compile todo lo necesario, linkee, ejecute y depure. Si bien esto es cómodo, espero poder enseñarles a automatizar la compilación y liberarlos de un determinado IDE para compilar los programas.
cmd.exe: Es la línea de comandos de Windows. Si nunca lo utilizó, es hora que se ponga a usarlo. Para iniciar la línea de comandos debe ir al menú "Inicio/Ejecutar..." e introducir "cmd". ¿Cómo se usa? Bueno, empiece a buscar...

Ahora nos dedicaremos a instalar el MinGW, para eso debe comenzar a bajarse los siguientes archivos (si no sabe cómo descomprimir un archivo .tar.gz...):

mingw-runtime-3.13.tar.gz: Los archivos de cabecera y bibliotecas estándares (stdio.h, math.h, libc, libm, etc.)
w32api-3.10.tar.gz: Archivos de cabecera del API de Win32
gcc-core-3.4.5-20060117-1.tar.gz: El preprocesador de C y el compilador de C
gcc-g++-3.4.5-20060117-1.tar.gz: El compilador de C++ y los archivos de cabecera de C++
binutils-2.17.50-20060824-1.tar.gz: Varios programas utilitarios que sirve para diferentes propósitos (ej: quitar símbolos de depuración con strip, convertir direcciones a líneas de código fuente con addr2line, procesar la información de rendimiento con gprof, crear librerías con ar, compilar los archivos de recursos de Windows con windres, etc.).
mingw32-make-3.81-2.tar.gz: La utilidad make
gdb-5.2.1-1.exe: El depurador de código

Una vez que consiga todos estos archivos, debe crear una carpeta C:\MinGW (le recomiendo esa ubicación) y descomprimir todo ahí mismo. Para instalar el depurador (gdb) deberá ejecutar el instalador, seguir los pasos, y colocar como carpeta de instalación "C:\MinGW".

Una vez instalado todo, usted ya está en condiciones para compilar código en C o C++. Antes verifique que en dicha carpeta tiene una estructura de directorios como la siguiente:

C:\MinGW
  bin\
  doc\
  include\
  info\
  lib\
  libexec\
  man\
  mingw32\

Si así es, significa que todo salió bien (bueno, tampoco descomprimir unos archivos es algo tan complicado).

Para estar seguros que el compilador funcione, vamos a crear el programa de prueba por excelencia, el "Hola Mundo". Abra el bloc de notas (Inicio/Ejecutar/notepad) y escriba en un archivo el siguiente código:

#include <stdio.h>

int main(int argc, char *argv[])
{
  printf("Hola Mundo\n");
  return 0;
}

Guarde el archivo como "C:\MinGW\hola.c". Ahora abra la línea de comandos cmd.exe, y ahí mismo ejecute los siguientes comandos:

cd C:\MinGW
set PATH=C:\MinGW\bin;%PATH%
gcc hola.c

Verá que el archivo "a.exe" se crea en el directorio C:\MinGW. Si ejecuta el programa a.exe visualizará en la salida de la consola el mensaje más estúpido jamás escrito: "Hola Mundo"

C:\MinGW>a.exe
Hola Mundo

A continuación le paso a explicar qué hicimos en esta ráfaga de pasos:

"cd C:\MinGW" es para ubicarnos en el directorio donde se encuentra el archivo o proyecto que queremos compilar (si no sabía esto, es porque todavía no estuvo buscando cómo usar cmd.exe...).
"set PATH=C:\MinGW\bin;%PATH%" es un conjunto de varias cosas: "PATH" es una variable de entorno que indica cuáles son los directorios donde podemos encontrar archivos ejecutables (archivos ejecutables como gcc.exe, cpp.exe, etc.); "set" es un comando del shell para cambiar el valor de una variable de entorno; y "%PATH%" devuelve el valor de dicha variable de entorno. Por lo tanto, lo único que estamos haciendo aquí es agregar una nueva ruta (C:\MinGW\bin) a PATH para que el shell encuentre los archivos ejecutables que a nosotros nos interesa (el preprocesador, compilador, etc.). Si desea ver dónde busca el shell los archivos ejecutables actualmente, puede usar el siguiente comando: "echo %PATH%"
"gcc hola.c" compila el programa "hola.c" y deja el resultado (linkea o linkedita) en un archivo llamado "a.exe" (o "a.out" en Linux). En otros posts veremos cómo podemos especificar un nombre distinto a este archivo de salida.

De todo lo visto, lo más molesto es la configuración de la variable de entorno, es decir, si pensamos compilar varias veces, cada vez que abramos un shell (cmd.exe) deberemos hacer un "set PATH=C:\MinGW\bin;%PATH%". Para evitar este paso tenemos dos opciones:

Si tiene accesos de Administrador, puede hacer click derecho sobre "Mi PC", "Propiedades", "Opciones Avanzadas", "Variables de Entorno" y modificar la variable PATH agregándole el valor "C:\MinGW\bin" (recuerde no tocar las demás rutas, además de agregar un ";" para separar las distintas rutas entre sí).
En otro caso, puede crearse un archivo de comandos por lotes mi-mingw.bat para iniciar el shell adecuadamente con el PATH ya configurado. Por ejemplo, un mi-mingw.bat posible podría ser:
```
set PATH=C:\MinGW\bin;%PATH%
start cmd.exe
```
Este archivo podemos dejarlo en el Escritorio y cada vez que tengamos ganas de compilar, con un simple doble click ya podemos empezar. Inclusive, en vez de iniciar "start cmd.exe" podríamos iniciar algún IDE o editor de texto como Emacs. Pero eso para otro post.

Bueno, por hoy me cansé. Cualquier problema o pregunta que tengan, los comentarios están abiertos (y bien moderados :)