Personal tools

Es/Por que Haskell importa

From HaskellWiki

Revision as of 21:34, 2 November 2006 by Miguel (Talk | contribs)

Jump to: navigation, search

Contents

1 Por qué Haskell importa

Traducción de Why Haskell matters.

1.1 ¿Qué son los lenguajes de programación funcionales?

Los lenguajes de programación como C/C++/Java/Python se llaman imperativos porque consisten en una secuencia de acciones. El programador explícitamente le dice a la computadora cómo realizar una tarea, paso a paso. Los lenguajes de programación funcionales trabajan de forma diferente. En lugar de realizar acciones en secuencia, evalúan expresiones.

1.1.1 El nivel de Abstracción

Hay dos áreas que son fundamentales al programar una computadora - manejo de recursos y secuenciación. El manejo de recursos (alojar registros y memoria) ha sido objeto de mucha abstracción: la mayoría de los lenguajes nuevos (imperativos y funcionales) han implementado recolección de basura para eliminar el manejo de recursos del problema, dejando al programador concentrarse en el algoritmo en lugar de la tarea mecánica del alojamiento de memoria.

La secuenciación también tuvo algo de abstracción, aunque no al mismo nivel. Los lenguajes imperativos lo han hecho introduciendo nuevas palabras claves y librerías estándar. Por ejemplo, la mayoría de los lenguajes imperativos tienen sintaxis especial para construir varios bucles ligeramente diferentes, ya no tienes que hacer todas las tareas de manejar estos bucles tú mismo.

Pero los lenguajes imperativos están basados en la noción de secuenciación - no pueden escapar de ella completamente. La única forma de elevar el nivel de abstracción en el área de secuenciación para un lenguaje imperativo es introduciendo más palabras clave o funciones estándar, abarrotando el lenguaje.

Esta relación cercana entre lenguajes imperativos y la tarea de secuenciar comandos para que el procesador ejecute significa que los lenguajes imperativos nunca podŕan elevarse más allá de la tarea de secuenciar, y como tales nunca pueden llegar al mismo nivel de abstracción que los lenguajes funcionales.

En Haskell, la secuenciación es eliminada. Sólo se preocupa por lo que el programa calcula, no cuándo o cómo se calcula. Esto hace de Haskell un lenguaje más flexible y fácil de usar. Haskell tiende a ser parte de la solución a un problema, y no parte del problema en sí.

1.1.2 Funciones y Efectos Laterales en Lenguajes Funcionales

Las funciones tienen un rol importante en los lenguajes de programación funcional. Las funciones se consideran valores, como Int o String. Una función puede devolver otra función, puede tomar otra función como parámetro y puede ser construida componiendo funciones. Esto ofrece una "cola" más fuerte para combinar los módulos de tu programa. Una función que evalúa alguna expresión puede formar parte de la computación como un argumento, por ejemplo; haciendo así más modular a la función. También puedes tener que una función contruye otra función. Por ejemplo, se puede definir una función "diferenciar" que diferenciará una función numéricamente dada. Entonces, si tienes una función "f", puedes definir "f' = differentiate f", y usarla como lo harías en un contexto matemático. Estos tipos de funciones se llaman funciones de orden superior.

Aquí hay un pequeño ejemplo en Haskell de una función numOf que cuenta el número de elementos en una lista que satisface cierta propiedad.

numOf p xs = length (filter p xs)

Después discutiremos la sintaxis de Haskell, pero lo que esta línea dice es "Para obtener el resultado, filtra la lista xs con la prueba p y computa el largo del resultado". Ahora p es una función que toma un elemento y devuelve True (verdadero) o False (falso) determinando si el elemento pasa o no la prueba. numOf es una función de orden superios, parte de su funcionalidad es tomada como un argumento. Se debe notar que filter es también una función de orden superior, toma una "función de prueba" como argumento. Juguemos con esta función y definamos algunas funciones más especializadas a partir de ella.

numOfEven xs = numOf even xs

Aquí definimos la función numOfEven que cuenta la cantidad de elementos pares en una lista. Notemos que no es necesario declarar explícitamente xs como un parámetro. Podríamos haber escrito numOfEven = numOf even. De hecho una definición muy clara. Pero por el momento, declararemos explícitamente los parámetros.

Ahora definamos una función que cuenta el número de elementos que son mayores o iguales a 5 :

numOfGE5 xs = numOf (>=5) xs

Aquí la función de prueba es simplemente ">=5" que se la pasamos a numOf para obtener la funcionalidad que necesitamos.

Ahora debieras ver que la modularidad de la programación funcional nos permite definir funciones genéricas donde parte de la funcionalidad se pasa como argumento, que luego podremos usar para definir nombres para cualquier función especializada. Este pequeño ejemplo es en cierta manera trivial, no debería ser muy difícil reescribir las definiciones de la funciones de más arriba, pero para funciones más complejas esto es muy práctico. Tu puedes, por ejemplo, escribir una función para recorrer un árbol binario auto-balanceado y tomar parte de la funcionalidad como parámetro (por ejemplo, la función de comparación). Esto te permitiría recorrer un árbol sobre cualquier tipo de datos, simplemente proveyendo la función de comparación que necesites. De esta manera puedes dedicar más esfuerzo en asegurarte que la función general es correcta, y después todas las funciones especializadas serán también correctas. Sin mencionar que no tendrás que copiar y pegar código en tu proyecto. Este concepto también es factible en lenguajes imperativos. En algunos lenguajes orientados a objetos uno tiene que proveer un "Objeto comparador" para árboles y otras estructuras de datos. La diferencia es que la forma à la Haskell es mucho más intuitiva y elegante (crear un tipo distinto sólo para comparar otros tipos y después pasar un objeto de este tipo no es una forma elegante de hacerlo), y por ello es más probable que sea usado frecuentemente (y no solo en bibliotecas estándares).

Un concepto central en los lenguajes funcionales es que el resultado de una función está determinada por su entrada, y sólo por su entrada. ¡No hay efectos laterales! Esto también se extiende a las variables - las variables en Haskell no varían. Esto puede sonar extraño si tu estas acostumbrado a la programación imperativa (donde la mayor parte del código consiste en cambiar el "contenido" de una variable), pero es realmente muy natural. Una variable en Haskell es un nombre al que se le da un valor; y no, como en los lenguajes imperartivos, una abstracción de algún concepto de bajo nivel como una celda de memoria . Cuando se piensa a las variables como atajos para valores (justo como en matemáticas), tiene sentido que no se permitan las modificaciones de las variables. Tu no esperarías que "4 = 5" sea una asignación válida en ningún lenguaje de programación; por lo tanto, es extraño que "x = 4; x = 5" esté permitido. Esto es díficil de captar para programadores muy acostumbrados a lenguajes imperativos, pero no es tan extraño como parece a primera vista. Por ello, cuando empieces a pensar cosas como "Esto es demasiado rebuscado, me vuelvo a C++!", trata de obligarte a continuar aprendiendo Haskell - estarás contento de haberlo hecho.

Eliminar efectos laterales de la ecuación permite que las expresiones sean evaluadas en cualquier orden. Una función puede devolver siempre el mismo resultado si recibe la misma entrada - sin excepciones. Este determinismo elimina toda una clase de errores encontrados en programas imperativos. De hecho, uno podría argumentar que la mayoría de los errores en sistemas grandes pueden ser atribuidos a efectos laterales - si no causados directamente por ellos, entonces causados por un diseño que se basa en efectos laterales. Esto significa que los programas funcionales tienden a tener muchos menos errores que los imperativos.

1.1.3 Conclusión

Como los lenguajes funcionales son más intuitivos y ofrecen más formas y formás más fáciles de hacer las cosas, los programas funcionales tienden a ser más cortos (usualmente entre 2 y 10 veces). La semántica está más cercana al problema que en una versión imperativa, lo que facilita la verificación de la corrección de una función. Más aun, Haskell no permite efectos laterales, esto lleva a tener menos errores. De esta manera, los programas en Haskell son más fáciles de escribir, más robustos y más fáciles de mantener.

1.2 Qué puede ofrecer Haskell al programador?

Haskell es un lenguaje moderno de propósito general desarrollado para incorporar el conocimiento colectivo de la comunidad de programación funcional en un lenguaje elegante, poderoso y general.

1.2.1 Pureza

A diferencia de otros lenguajes de programación funcional Haskell es puro. No permite ningún efecto lateral. Este es probablemente la característica más importante de Haskell. Ya hemos discutido brevemente los beneficios de la programación pura, libre de efectos laterales - y no hay mucho más que podamos decir sobre eso. Necesitas experimentarlo tu mismo.


1.2.2 Pereza

Otra característica de Haskell es que es perezoso (hablando técnicamente, esto es "no-estricto"). Esto significa que no se evalúa nada hasta tanto deba ser evaluado. Uno puede, por ejemplo, definir una lista infinita de primos sin caer en una recursión infinita. Sólo los elementos de esta lista que sean realmente usados serán computados. Esto permite algunas soluciones muy elegantes para muchos problemas. Un patrón típico de resolución de un problema sería definir una lista de todas las posibles soluciones y luego filtrar las ilegales. La lista resultante tendrá sólo soluciones legales. La evaluación perezosa hace esta operación muy limpia. Si solo se necesita una solución, simplemente se puede tomar el primer elemento de la lista resultante - la evaluación perezosa nos asegurará que nada más es evaluado innecesariamente.

1.2.3 Tipado fuerte

Más aun Haskell es fuertemente tipado, esto significa lo que dice. Es imposible convertir sin darse cuenta un Double a un Int, o seguir un puntero nulo. Esto también lleva a tener menos errores. Puede ser doloroso en los raros casos en que uno necesita convertir un Int a un Double explícitamente antes de hacer alguna operación, pero en la práctica eso no sucede muy a menudo como para convertirse en una molestia. De hecho, forzar cada conversión explícitamente puede ayudar a resaltar problemas en el código. En otros lenguajes donde estas conversiones son invisibles, los problemas surgen frecuentemente cuando el compilador trata un double como un entero o, aun peor, un entero como un puntero.

A diferencia de otros lenguajes fuertemente tipados, en Haskell los tipos son inferidos automáticamente. Esto significa que rara vez tendrás que declarar los tipos de tus funciones, excepto como forma de documentación. Haskell mirará cómo usas las variables y se dará cuenta de eso qué tipo debería tener la variable - después se hará un chequeo de tipos de todo para asegurarse que todos los tipos coinciden. Python tiene la noción de "duck typing", que significa "si camina y habla como un pato, entonces es un pato!". Se puede argumentar que Haskell tiene una forma mejor de "duck typing". Si un valor camina y habla como un pato, entonces será considerado un pato a través de la inferencia de tipos; pero, a diferencia de Python, el compilador también atrapará los errores si después intenta comportarse como un mono! Tu obtienes los beneficios de tipado fuerte (se capturan errores en tiempo de compilación, en vez de en tiempo de ejecución) sin las molestias que acarrea esto en otros lenguajes. Más aun, Haskell siempre inferirá el tipo más general para una variable. Por lo tanto, si tu escribes una función de ordenamiento sin una declaración de tipos, Haskell se asegurará que la función acepte cualquier valor que pueda ser odenado.

Compara esto con cómo lo harías en algún lenguaje orientado a objetos. Para tener polimorfismo, tendrías que usar alguna clase base, y después declarar tus variables como instancias de subclases de esa clase. Eso significa un montón de trabajo extra y declaraciones ridículamente complicadas sólo para declarar la existencia de una variable. Más aun, tendrías que realizar muchas conversiones de tipo a través de conversiones ("casts") explícitos - lo cual no es definitivamente una solución elegante. Si tu quieres escribir una función polimórfica en estos lenguajes orientados a objetos, probablemente declararías los parámetros como objetos de una clase base global (como "Object" en Java), que escencialmente permite le permite al programador pasarle cualquier cosa a la función, aun objetos que lógicamente no pueden ser pasados a la función. El resultado es que la mayoría de las funciones que escribes en esos lenguajes no son generales, sólo funcionan con un solo tipo de datos. Estás también corriendo el control de errores de tiempo de compilación a tiempo de ejecución. En sistemas grandes donde alguna funcionalidad se usa raramente, estos errores pueden no ser vistos hasta que causan un error fatal en el peor momento posible.

Haskell provee una form elegante, concisa y segura de escribir programas. Los programas no se colgarán inesperadamente, ni producirán basura extraña como salida.

1.2.4 Elegancia

Otra propiedad de Haskell que es muy importante para el programador, aun cuando no signifique mucho en términos de estabilidad o performance, es la elegancia. Para decirlo sencillamente: las cosas funcionan como tu te lo imaginas.

Para destacar la elegancia de Haskell repasaremos un pequeño ejemplo. Elejimos QuickSort porque es un algoritmo simple y realmente útil. Miraremos dos versiones - una escrita en C++, un lenguaje imperativo, y una escrita en Haskell. Ambas versiones sólo usan la funcionalidad disponible para el programador sin importar módulos extras (de otra forma podríamos simplemente invocar a la función "sort" de la biblioteca estándar de cada lenguaje y estaríamos hechos!). Entonces, vamos a usar las primitivas estándar de secuencias de cada lenguaje (una "lista" en Haskell y un "array" en C++). Ambas versiones deben ser polimórficas (lo que es hecho automáticamente por Haskell, y con templates en C++). Ambas versiones deben usar el mismo algoritmo recursivo. Por favor nota que esto no tiene la intención de ser una comparación definitiva entre los lenguajes. Sólo se quiere mostrar la elegancia de Haskell, la versión C++ sólo se incluye a los fines de la comparación (y podría haber sido codificada de otra manera si usaramos la Standard Template Library, por ejemplo).

template <typename T>
void qsort (T *result, T *list, int n)
{
    if (n == 0) return;
    T *smallerList, *largerList;
    smallerList = new T[n];
    largerList = new T[n];      
    T pivot = list[0];
    int numSmaller=0, numLarger=0;      
    for (int i = 1; i < n; i++)
        if (list[i] < pivot)
            smallerList[numSmaller++] = list[i];
        else 
            largerList[numLarger++] = list[i];
    
    qsort(smallerList,smallerList,numSmaller); 
    qsort(largerList,largerList,numLarger);
    
    int pos = 0;        
    for ( int i = 0; i < numSmaller; i++)
        result[pos++] = smallerList[i];
    
    result[pos++] = pivot;
    
    for ( int i = 0; i < numLarger; i++)
        result[pos++] = largerList[i];
    
    delete [] smallerList;
    delete [] largerList;
};

No explicaremos este código, sólo notemos cúan complejo y difícil es entenderlo en una mirada, principalmente porque el programador tiene que lidiar con detalles de bajo nivel que no tienen nada que ver con la tarea a resolver. Ahora veamos la versión de QuickSort en Haskell, que luce como sigue:

 qsort []     = []
 qsort (x:xs) = qsort less ++ [x] ++ qsort more
     where less = filter (<x)  xs
           more = filter (>=x) xs

Desglosemos este código en detalle, ya que usa mucha sintaxis de Haskell que puedes no conocer.

La función se llama qsort y toma una lista como su parámetro. Definimos una función en Haskell así: nombrefuncion a b c = expr, donde nombrefuncion es el nombre de la función, a, b, y c son los parámetros y expr es la expresión a ser evaluada (usualmente usando los parámetros). Las funciones se llaman simplemente escribiendo su nombre primero y luego su(s) parámetro(s). Haskell no usa paréntesis para la aplicación funcional. Las funciones simplemente tienen más precedencia que cualquier otra cosa, entonces "f 5 * 2", por ejemplo, aplicaría f a 5 y luego lo multiplicaría por 2; si quisieramos que la multiplicación ocurriera antes de la aplicación entonces usaríamos paréntesis como en "f (5*2)".

Volvamos al QuickSort. primero vemos que tenemos dos definiciones para la función. Esto se llama ajuste de patrones (pattern matching) y brevemente podemos decir que probará el argumento pasado a la función con los patrones desde arriba hacia abajo, usando el primero que se ajuste.

La primera definición se ajusta a [] que en Haskell es la lista vacía (una lista de 1, 2 y 3 es [1,2,3] así que tiene sentido que la lista vacía sean sólo dos corchetes). Así que cuando tratamos de ordenar la lista vacía, el resultado será una lista vacía. ¿Suena razonable, no?

El segundo patrón de definición se ajusta a una lista con al menos un elemento. Lo hace usando (x:xs) como su argumento. El operador "cons" es (:) y simplemente pone un elemento en frente de una lista, así 0 : [1,2,3] devuelve [0,1,2,3]. El ajuste de patrones contra (x:xs) se cumple con una lista con cabeza x y cola xs (que puede o no ser la lista vacía). En otras palabras, (x:xs) es una lista de al menos un elemento.

Así que como necesitaremos usar la cabeza de la lista después, podemos extraerla muy elegantemente mediante el ajuste de patrones. Puedes pensarlo como nombrar el contenido de la lista. Esto se puede hacer para cualquier construcción de datos, no sólo una lista. Es posible ajustar patrones con un nombre de variable arbitrario y luego usar la función head para obtener la cabeza de la lista.

Ahora si tenemos una lista no vacía, la lista ordenada se produce ordenando todos los elementos menores a x y poniéndolos en frente de x, y luego ordenando todos los elementos mayores a x y poniéndolos al final. Hacemos esto usando el operador de concatenación de listas ++. Nótese que x no es una lista así que el operador ++ no funcionará sobre ella, por lo que hacemos una lista unitaria al ponerla entre corchetes.

Así, la función se lee "Para ordenar la lista, ubica la cabeza entre la lista ordenada de todos los elementos menores a ella y la lista ordenada de todos los elementos mayores a ella". Esta frase podría bien ser la descripción original del algoritmo. Esto es muy común en Haskell. Una definición de función usualmente se asemeja mucho a la descripción informal de la función. Por esto es que decimos que Haskell tiene una brecha semántica menor que otros lenguajes.

Pero espera, ¡no hemos terminado todavía! ¿Cómo es que las listas less y more se calculan? Bueno, recuerda que no nos importa la secuenciación en Haskell, así que las hemos definido debajo de la función usando notación where (que permite usar los parámetros de la funcion en sus definiciones). Usamos la función del preludio estándar filter. No explicaremos demasiado esta parte, pero la línea less = filter (<x) xs usará filter (<x) xs para filtrar la lista xs. Puedes ver que realmente pasamos la función que se usará para filtrar la lista a filter, un ejemplo de funciones de alto orden.

La función (<x) debe leerse "la función 'menor a x'" y devolverá True si el elemento que se le pasa es menor que x (nótese qué fácil fue construir una función al vuelo, ponemos la expresión "<x", "menor a x", entre paréntesis y la mandamos a la función - ¡las funciones en realidad son sólo otro valor!).

Todos los elementos que pasan la prueba son la salida de filter y terminan en less. De la misma manera, (>=x) se usa para filtrar la lista por todos los elementos mayores o iguales a x.

Ahora que te han explicado la sintaxis, lee la definición de la función de nuevo. Nota qué poco tiempo toma lograr entender lo que la función hace. Las definiciones de funciones en Haskell explican lo que computan, no cómo lo hacen.

Si ya te has olvidado de la sintaxis esbozada arriba, ¡no te preocupes! La cubriremos de forma más completa y minuciosa en los tutoriales. Lo importante de este ejemplo es que el código Haskell es elegante e intuitivo.

1.2.5 Haskell y los errores

Hemos dicho varias veces que muchas características de Haskell ayudan a disminuir la ocurrencia de errores; recapitulemos esas características.

Los programas en Haskell tienen menos errores porque Haskell es:

  • Puro. No hay efectos laterales.
  • Fuertemente tipado. No puede haber uso dudoso de tipos. Y no hay core dumps!
  • Conciso. Los programas más cortos facilitan mirar una función y "captarla" de una sóla vez, convenciendote que es correcta.
  • Alto nivel. Los programas de Haskell casi siempre se escriben exactamente igual que la descripción del algoritmo. Lo que facilita verificar que la función haga lo que el algoritmo dice. Al codificar en un nivel de abstracción superior, dejando los detalles para el compilador, se deja menos espacios para que se deslicen errores.
  • Memoria administrada. No hay que preocuparse por los punteros, el Garbage Collector se ocupa de ellos. El programador puede preocuparse de la implementación del algoritmo, no de administración de memoria.
  • Modular. Haskell ofrece más "pegamento" y más fuerte para componer programas a partir de módulos ya desarrollados. De esta manera, los programas Haskell pueden ser más modulares. Frecuentemente se puede probar que el uso de funciones modulares es correcto por inducción. Combinar dos funciones que se probaron correctas dará un resultado correcto (asumiendo que la combinación es correcta).

Aun más, la mayoría de las personas concuerdan en que uno piensa diferente al resolver problemas en un lenguaje funcional. Uno subdivide el problema en funciones más y más pequeñas y luego uno escribe esas funciones pequeñas (y "garantizadas-de-corrección-casi-siempre"), que son compuestas de varias maneras para obtener el resultado final. ¡Simplemente no hay espacio para errores!

1.3 Haskell vs POO

El gran beneficio de la programación orientada a objetos (POO) no es que uno pueda agrupar los datos con las funciones que actúan sobre ellos en un objeto, el beneficio es que permite un buen encapsulamiento de datos (separando la interfaz de la implementación) y polimorfismo (permitiendo que un conjunto de tipo de datos se comporte de la misma manera). Sin embargo:

¡Encapsulamiento de datos y polimorfismo no son exclusivos de POO!

Haskell tiene herramientas para abstraer datos. No podemos meternos en ello sin haber visto el sistema de módulos y cómo funcionan los tipos abstractos de datos (TAD) en Haskell, algo que está bastante más allá del alcance de este ensayo. Por ello, haremos una corta descripción de cómo funcionan los TADs y el polimorfismo en Haskell.

El encapsulamiento en Haskell se logra declarando cada tipo de datos en un módulo independiente, y de este módulo sólo se exporta la interfaz. Internamente puede haber muchas funciones que manipulan los datos reales, pero la interfaz es lo único visible desde fuera del módulo. Notemos que el tipo de datos y las funciones que actúan sobre él no están agrupadas en un "objeto", sino que están (típicamente) agrupadas en el mismo módulo; de esta manera uno puede elegir exportar sólo ciertas funciones (y no los constructores para el tipo de datos), logrando así que estas funciones sean la única forma de manipular el tipo de datos - quedando "escondida" la implementación tras la interfaz.

El polimorfismo se logra usando lo que se llama clases de tipo. Si tu tienes conocimientos previos de C++ o Java, puedes asociar las clases con algo parecido a un template para construir un objeto, pero eso no es lo que son las clases en Haskell. Una clase de tipo es realmente eso a lo que suena. Es un conjunto de reglas para determinar si una instancia de un tipo es una instancia de la clase. Haskell separa la instanciación de la clase de la construcción del tipo de datos. Uno puede declarar un tipo "Porsche" como una instancia de la clase de tipo "Auto", digamos. Todas las funciones que pueden ser aplicadas a cualquier otro miembro de la clase de tipo Auto podrán ser aplicadas a un Porsche. Una clase que está incluida en Haskell es la clase de tipo Show, y un tipo puede ser instanciado en esa clase dando una función show, que convierta una instancia de ese tipo en un String. Consecuentemente, las instancias de casi todos los tipos de Haskell pueden ser mostradas en la pantalla aplicando la función show para convertirlos en un String, y usando después la acción de E/S correspondiente (hay más sobre E/S en los tutoriales).

Notemos cuán similar es esto con la noción de objeto en POO cuando se considera el aspecto del polimorfismo. El sistema de Haskell es más intuitivo para manejar el polimorfismo. Uno no necesita preocuparse en heredar en el orden correcto o asegurarse que la herencia tiene sentido. Una clase es simplemente una clase, y los tipos que son instancias de esta clase no tienen que compartir una relación de herencias padre-hijo. Si un tipo de datos cumple con los requisitos de una clase, entonces puede ser instanciada en esa clase. Simple, no? ¿Recuerdas el ejemplo de QuickSort? ¿Recuerdas que habíamos dicho que era polimórfico? El secreto detrás del polimorfismo en qsort es que está definida para trabajar sobre listas de cualquier tipo que pertenezca a la clase Ord (por "Ordenado"). Ord tiene definida un conjunto de funciones, entre ellas "<" y ">" que son suficientes para nuestras necesidades, porque sólo necesitamos saber si un elemento es mayor que x o no. Por ello si fueramos a definir las funciones que requiere Ord para nuestro tipo Porsche (sería suficiente implementar <= y ==, Haskell construiría el resto a partir de ellas) en una instanciación de la clase Ord, podríamos usar qsort para ordenar listas de Porsche (aun cuando no tenga sentido ordenar Porsches). Notemos que nunca dijimos nada sobre las clases a las que debían pertenecer los elementos de la lista, Haskell inferirá esto automáticamente viendo las funciones que hemos usado (en el ejemplo de qsort, solo "<" y ">=" son relevantes).

Para resumir: Haskell incluye mecanismos para encapsulamiento de datos que igualan o pasan a aquellos de los lenguajes orientados a objetos. Lo único que Haskell no provee es una forma de agrupar funciones y datos en un objeto (aparte de construir un tipo de datos que incluya una función, recuerda que las funciones son datos!). Sin embargo, esto es un problema menor: para aplicar una función a un objeto, escribiremos "func obj a b c" en vez de algo como "obj.func a b c".

1.4 Modularidad

Un concepto central en la informática es la modularidad. Una analogía popular es esta: digamos que tu quieres construir una silla de madera. Si tu construyes las partes por separado y luego las pegas, la tarea se resuelve fácilmente. Pero si tu tienes que tallar la silla entera a partir de un pedazo sólido de madera, te puede resultar un poco más difícil. John Hughes tiene algo para decir sobre el tema en este artículo: Why Functional Programming Matters (Por qué es importante la programación funcional)

"Los lenguajes que intenten mejorar la productividad deben permitir la programación modular. Pero nuevas reglas de alcance y mecanismos para compilación separada no son suficientes - modularidad significa más que módulos. Nuestra capacidad para descomponer problemas en partes depende directamente de nuestra capacidad para unir las soluciones. Para ayudar a la programación modular, un lenguaje deber proveer buena cola.

Los lenguajes de programación funcional proveen dos nuevos tipos de colas: funciones de alto orden y evaluación perezosa."

1.5 The Speed of Haskell

Let me first state clearly that the following only applies to the general case in which speed isn't absolutely critical, where you can accept a few percent longer execution time for the benefit of reducing development time greatly. There are cases when speed is the primary concern, and then the following section will not apply to the same extent.

Now, some C++ programmers might claim that the C++ version of QuickSort above is probably a bit faster than the Haskell version. And this might be true. For most applications, though, the difference in speed is so small that it's utterly irrelevant. For instance, take a look at the Computer Language Shootout, where Haskell compares favorably to most of the so called "fast" languages. Now, these benchmarks don't prove all that much about real-world performance, but they do show that Haskell isn't as slow as some people think. At the time of writing it's in 2nd position, only slightly behind C (with C++ fairly far behind).

Almost all programs in use today have a fairly even spread of processing time among its functions. The most notable exceptions are applications like MPEG encoders, and artificial benchmarks, which spend a large portion of their execution time within a small portion of the code. If you really need speed at all costs, consider using C instead of Haskell.

There's an old rule in computer programming called the "80/20 rule". It states that 80% of the time is spent in 20% of the code. The consequence of this is that any given function in your system will likely be of minimal importance when it comes to optimizations for speed. There may be only a handful of functions important enough to optimize. These important functions could be written in C (using the excellent foreign function interface in Haskell). The role of C could, and probably will, take over the role of assembler programming - you use it for the really time-critical bits of your system, but not for the whole system itself.

We should continue to move to higher levels of abstraction, just like we've done before. We should trade application speed for increased productivity, stability and maintainability. Programmer time is almost always more expensive than CPU time. We aren't writing applications in assembler anymore for the same reason we shouldn't be writing applications in C anymore.

Finally remember that algorithmic optimization can give much better results than code optimization. For theoretical examples when factors such as development times and stability doesn't matter, then sure C is often faster than Haskell. But in the real world development times do matter, this isn't the case. If you can develop your Haskell application in one tenth the time it would take to develop it in C (from experience, this is not at all uncommon) you will have lots of time to profile and implement new algorithims. So in the "real world" where we don't have infinite amounts of time to program our applications, Haskell programs can often be much faster than C programs.


1.6 Epilogue

So if Haskell is so great, how come it isn't "mainstream"? Well, one reason is that the operating system is probably written in C or some other imperative language, so if your application mainly interacts with the internals of the OS, you may have an easier time using imperative languages. Another reason for the lack of Haskell, and other functional languages, in mainstream use is that programming languages are rarely thought of as tools (even though they are). To most people their favorite programming language is much more like religion - it just seems unlikely that any other language exists that can get the job done better and faster. There is a paper by Paul Graham called Beating the Averages describing his experience using Lisp, another functional language, for an upstart company. In it he uses an analogy which he calls "The Blub Paradox". It goes a little something like this: If a programmer's favorite language is Blub, which is positioned somewhere in the middle of the "power spectrum", he can most often only identify languages that are lower down in the spectrum. He can look at COBOL and say "How can anyone get anything done in that language, it doesn't have feature x", x being a feature in Blub. However, this Blub programmer has a harder time looking the other way in the spectrum. If he examines languages that are higher up in the power spectrum, they will just seem "weird" because the Blub programmer is "thinking in Blub" and can not possibly see the uses for various features of more powerful languages. It goes without saying that this inductively leads to the conclusion that to be able to compare all languages you'll need to position yourself at the top of the power spectrum. It is my belief that functional languages, almost by definition, are closer to the top of the power spectrum than imperative ones. So languages can actually limit a programmers frame of thought. If all you've ever programmed is Blub, you may not see the limitations of Blub - you may only do that by switching to another level which is more powerful.

One of the reasons the mainstream doesn't use Haskell is because people feel that "their" language does "everything they need". And of course it does, because they are thinking in Blub! Languages aren't just technology, it's a way of thinking. And if you're not thinking in Haskell, it is very hard to see the use of Haskell - even if Haskell would allow you to write better applications in a shorter amount of time!

Hopefully this article has helped you break out of the Blub paradox. Even though you may not yet "think in Haskell", it is my hope that you are at least aware of any limitations in your frame of thought imposed by your current "favorite" language, and that you now have more motivation to expand it by learning something new. If you are committed to learn a functional language, to get a better view of the power spectrum, then Haskell is an excellent candidate.