¿Cuál es la respuesta de Haskell a Node.js?

Creo que la comunidad de Erlang no tiene envidia de Node.js, ya que lo hace sin bloqueo de E / S de forma nativa y tiene formas de escalar fácilmente las implementaciones a más de un procesador (algo que ni siquiera está integrado en Node.js). Más detalles en http://journal.dedasys.com/2010/04/29/erlang-vs-node-js y Node.js o Erlang

¿Qué hay de Haskell? ¿Puede Haskell proporcionar algunos de los beneficios de Node.js, es decir, una solución limpia para evitar el bloqueo de E / S sin recurrir a la programación de subprocesos múltiples?

Hay muchas cosas que son atractivas con Node.js

1. Eventos: sin manipulación de subprocesos, el programador solo proporciona devoluciones de llamada (como en el marco Snap)
2. Se garantiza que las devoluciones de llamada se ejecuten en un solo hilo: no es posible la condición de carrera.
3. Agradable y simple API compatible con UNIX. Bonificación: Excelente soporte HTTP. DNS también disponible.
4. Cada E / S es por defecto asíncrona. Esto hace que sea más fácil evitar las cerraduras. Sin embargo, el procesamiento excesivo de la CPU en una devolución de llamada afectará a otras conexiones (en este caso, la tarea debería dividirse en subtareas más pequeñas y reprogramarse).
5. Mismo idioma para el lado del cliente y del lado del servidor. (Sin embargo, no veo demasiado valor en este caso. JQuery y Node.js comparten el modelo de programación de eventos, pero el resto es muy diferente. Simplemente no puedo ver cómo compartir código entre el lado del servidor y el lado del cliente Ser útil en la práctica.)
6. Todo esto empaquetado en un solo producto.

De acuerdo, después de haber visto un poco de la presentación de node.js a la que @gawi me señaló, puedo decir un poco más sobre cómo Haskell se compara con node.js. En la presentación, Ryan describe algunos de los beneficios de Green Threads, pero luego continúa diciendo que no encuentra que la falta de abstracción de hilo sea una desventaja. No estoy de acuerdo con su posición, particularmente en el contexto de Haskell: creo que las abstracciones que proporcionan los hilos son esenciales para hacer que el código del servidor sea más fácil de corregir y más robusto. En particular:

• El uso de un subproceso por conexión le permite escribir código que expresa la comunicación con un solo cliente, en lugar de escribir código que trata con todos los clientes al mismo tiempo. Piénselo de esta manera: un servidor que maneja múltiples clientes con hilos se ve casi igual que uno que maneja un solo cliente; La principal diferencia es que hay un forklugar en el primero. Si el protocolo que está implementando es del todo complejo, administrar la máquina de estado para varios clientes simultáneamente es bastante complicado, mientras que los hilos le permiten simplemente escribir la comunicación con un solo cliente. El código es más fácil de entender y más fácil de entender y mantener.

• las devoluciones de llamada en un solo subproceso del sistema operativo es multitarea cooperativa, a diferencia de la multitarea preventiva, que es lo que obtienes con los subprocesos. La principal desventaja con la multitarea cooperativa es que el programador es responsable de asegurarse de que no haya inanición. Pierde modularidad: comete un error en un solo lugar y puede arruinar todo el sistema. Esto es realmente algo de lo que no debe preocuparse, y la prevención es la solución simple. Además, la comunicación entre devoluciones de llamada no es posible (sería un punto muerto).

• la concurrencia no es difícil en Haskell, porque la mayoría del código es puro y, por lo tanto, es seguro para subprocesos por construcción. Hay simples primitivas de comunicación. Es mucho más difícil dispararse en el pie con concurrencia en Haskell que en un idioma con efectos secundarios sin restricciones.

¿Puede Haskell proporcionar algunos de los beneficios de Node.js, es decir, una solución limpia para evitar el bloqueo de E / S sin recurrir a la programación de subprocesos múltiples?

Sí, de hecho, los eventos y los hilos están unificados en Haskell.

• Puede programar en subprocesos ligeros explícitos (por ejemplo, millones de subprocesos en una sola computadora portátil).
• O; puede programar en un estilo asíncrono basado en eventos, basado en notificaciones de eventos escalables.

Los hilos se implementan realmente en términos de eventos y se ejecutan en múltiples núcleos, con migración de subprocesos sin interrupciones, con rendimiento documentado y aplicaciones.

Por ejemplo para

• macizamente orquestación de trabajo concurrente
• colecciones concurrentes en 32 o 48 núcleos
• soporte de herramientas para perfilar y depurar programas multiproceso / multi-evento .
• alto rendimiento Servidores web de basados ​​en eventos .
• usuarios interesantes: como el comercio de alta frecuencia .

Colecciones concurrentes nbody en 32 núcleos

En Haskell tienes tanto eventos como hilos, y como todos los eventos están bajo el capó.

Lea el documento que describe la implementación.

En primer lugar, no creo que node.js esté haciendo lo correcto exponiendo todas esas devoluciones de llamada. Terminas escribiendo tu programa en CPS (estilo de paso de continuación) y creo que debería ser el trabajo del compilador hacer esa transformación.

Eventos: sin manipulación de subprocesos, el programador solo proporciona devoluciones de llamada (como en el marco Snap)

Con esto en mente, puede escribir usando un estilo asíncrono si lo desea, pero al hacerlo, se perdería la escritura en un estilo sincrónico eficiente, con un hilo por solicitud. Haskell es ridículamente eficiente en el código síncrono, especialmente en comparación con otros idiomas. Son todos los eventos debajo.

Se garantiza que las devoluciones de llamada se ejecuten en un solo hilo: no es posible la condición de carrera.

Aún podría tener una condición de carrera en node.js, pero es más difícil.

Cada solicitud está en su propio hilo. Cuando escribes código que tiene que comunicarse con otros hilos, es muy sencillo hacerlo seguro gracias a las primitivas de concurrencia de Haskell.

Agradable y simple API compatible con UNIX. Bonificación: Excelente soporte HTTP. DNS también disponible.

Echa un vistazo a los ataques y compruébalo por ti mismo.

Cada E / S es por defecto asíncrona (sin embargo, esto puede ser molesto a veces). Esto hace que sea más fácil evitar las cerraduras. Sin embargo, el procesamiento excesivo de la CPU en una devolución de llamada afectará a otras conexiones (en este caso, la tarea debería dividirse en subtareas más pequeñas y reprogramarse).

No tiene tales problemas, ghc distribuirá su trabajo entre los hilos reales del sistema operativo.

Mismo idioma para el lado del cliente y del lado del servidor. (Sin embargo, no veo demasiado valor en este caso. JQuery y Node.js comparten el modelo de programación de eventos, pero el resto es muy diferente. Simplemente no puedo ver cómo compartir código entre el lado del servidor y el lado del cliente podría Ser útil en la práctica.)

Haskell no puede ganar aquí ... ¿verdad? Piense de nuevo, http://www.haskell.org/haskellwiki/Haskell_in_web_browser .

Todo esto empaquetado en un solo producto.

Descarga ghc, enciende cabal. Hay un paquete para cada necesidad.

Personalmente, veo Node.js y la programación con devoluciones de llamada como algo innecesariamente de bajo nivel y un poco antinatural. ¿Por qué programar con devoluciones de llamada cuando un buen tiempo de ejecución como el que se encuentra en GHC puede manejar las devoluciones de llamada por usted y hacerlo de manera bastante eficiente?

Mientras tanto, el tiempo de ejecución de GHC ha mejorado enormemente: ahora presenta un "nuevo nuevo administrador de E / S" llamado MIO donde "M" significa multinúcleo, creo. Se basa en la base del administrador de E / S existente y su objetivo principal es superar la causa de la degradación del rendimiento de más de 4 núcleos. Los números de rendimiento proporcionados en este documento son bastante impresionantes. Verse a sí mismo:

Con Mio, los servidores HTTP realistas en Haskell escalan a 20 núcleos de CPU, logrando un rendimiento máximo hasta un factor de 6.5x en comparación con los mismos servidores que usan versiones anteriores de GHC. La latencia de los servidores Haskell también se mejora: [...] bajo una carga moderada, reduce el tiempo de respuesta esperado en 5.7x en comparación con versiones anteriores de GHC

Y:

También mostramos que con Mio, McNettle (un controlador SDN escrito en Haskell) puede escalar efectivamente a más de 40 núcleos, alcanzar un rendimiento completo de más de 20 millones de nuevas solicitudes por segundo en una sola máquina y, por lo tanto, convertirse en el más rápido de todos los controladores SDN existentes .

Mio ha llegado a la versión GHC 7.8.1. Personalmente, veo esto como un gran paso adelante en el rendimiento de Haskell. Sería muy interesante comparar el rendimiento de las aplicaciones web existentes compilado por la versión anterior de GHC y 7.8.1.

Los eventos de mi humilde opinión son buenos, pero la programación por medio de devoluciones de llamada no lo es.

La mayoría de los problemas que hacen especial la codificación y depuración de aplicaciones web proviene de lo que las hace escalables y flexibles. Lo más importante, la naturaleza sin estado de HTTP. Esto mejora la navegabilidad, pero impone una inversión de control donde el elemento IO (el servidor web en este caso) llama a diferentes controladores en el código de la aplicación. Este modelo de evento -o modelo de devolución de llamada, dicho con mayor precisión- es una pesadilla, ya que las devoluciones de llamada no comparten ámbitos variables y se pierde una vista intuitiva de la navegación. Es muy difícil evitar todos los posibles cambios de estado cuando el usuario navega de un lado a otro, entre otros problemas.

Se puede decir que los problemas son similares a la programación de GUI donde el modelo de evento funciona bien, pero las GUI no tienen navegación ni botón de retroceso. Eso multiplica las transiciones de estado posibles en las aplicaciones web. El resultado del intento de resolver este problema son marcos pesados ​​con configuraciones complicadas y muchos identificadores mágicos omnipresentes sin cuestionar la raíz del problema: el modelo de devolución de llamada y su falta inherente de compartir ámbitos variables, y ninguna secuencia, por lo que la secuencia tiene que ser construido vinculando identificadores.

Existen marcos basados ​​en secuencia como ocsigen (ocaml) seaside (smalltalk) WASH (descontinuado, Haskell) y mflow (Haskell) que resuelven el problema de la gestión del estado mientras mantienen la navegabilidad y la REST-plenitud. Dentro de estos marcos, el programador puede expresar la navegación como una secuencia imperativa donde el programa envía páginas y espera respuestas en un solo hilo, las variables están dentro del alcance y el botón Atrás funciona automáticamente. Esto inherentemente produce un código más corto, más seguro y más legible donde la navegación es claramente visible para el programador. (advertencia justa: soy el desarrollador de mflow)

La pregunta es bastante ridícula porque 1) Haskell ya ha resuelto este problema de una manera mucho mejor y 2) más o menos de la misma manera que Erlang lo ha hecho. Aquí está el punto de referencia contra el nodo: http://www.yesodweb.com/blog/2011/03/preliminary-warp-cross-language-benchmarks

Dale a Haskell 4 núcleos y puede hacer 100k solicitudes (simples) por segundo en una sola aplicación. Node no puede hacer tantos, y no puede escalar una sola aplicación a través de los núcleos. Y no tiene que hacer nada para cosechar esto porque el tiempo de ejecución de Haskell no bloquea. El único otro lenguaje (relativamente común) que tiene IO sin bloqueo integrado en el tiempo de ejecución es Erlang.

Al igual que nodejs ha dejado de liberar, el Marco web Snap Haskell también ha dejado de liberar .