Mostrando entradas con la etiqueta lenguajes. Mostrar todas las entradas
Mostrando entradas con la etiqueta lenguajes. Mostrar todas las entradas

jueves, 3 de agosto de 2017

Cómo escribir tu propio intérprete (o compilador)

Interpreter Book

Suelo escuchar varios podcast mientras me muevo por Buenos Aires u otras ciudades en mi trabajo. Uno de los que sigo desde hace años es el de Scott Hanselman, que es quizá una de las personas que más me impactó dentro de lo que se conoce como la "comunidad Microsoft".

Scott, más allá de seguir trabajando para Microsoft en el grupo de ASP.NET y herramientas de Azure, es un tipo inquieto que mantiene varios podcasts e iniciativas, y sobre todo valoro su constante esfuerzo por lograr una industria más inclusiva, recibiendo a a gente de toda edad, raza, identidad u orientación sexual, religión o ideario.

Pero basta de elogios al amigo Scott. El tema que me atrajo especialmente en éste último podcast fue que entrevistaba a Thorsten Ball, quien auto-publicó el libro "Writing An Interpreter In Go", que trata básicamente de eso: recorre todos los pasos de escritura de un intérprete. En su caso del lenguaje Monkey que él diseñó para el libro mismo, y que es bastante similar a JavaScript o un montón de otros lenguajes de la familia de las llaves {}.

Más allá de que es un tema interesante, me gustó que la manera en que lo hace es utilizando lo más básico de Go, sin más que la librería standard, construyendo desde cero el parser y el lexer, y sin usar ninguna librería particular. Y por supuesto, utilizando TDD.

Es un libro que recorre en mayor detalle el camino constante del Maestro Ángel Java López, que como puede verse en su cuenta de GitHub escribe este tipo de intérpretes o compiladores todo el tiempo.

¿Por qué escribir un intérprete a esta altura? Básicamente porque las capacidades y el entendimiento de sus partes nos ayudan a ser mejores programadores en general, como llegado cierto punto un buen automovilista tiene que aprender de mecánica, o un rocker necesita aprender sobre ingeniería de sonido.

jueves, 13 de julio de 2017

Codewars: jugar, practicar, codear

codewarsHace unos días recordé este sitio que conocí hace unos años, al verlo mencionado en un tweet de mi amigo el Maestro.

A raíz de esa mención volví a visitarlo y me alegró ver cuánto progreso mientras yo no estaba mirando.

Codewars es básicamente un sitio de práctica. Está basado en la idea de Code Katas, pero extendido a formas adicionales como el Kumite (una especie de competencia entre desarrolladores), y todo en un entorno colaborativo donde los participantes mismos son quienes agregan y refinan los ejercicios, también votando y comentando tanto los planteos como las distintas soluciones.

Entre las características que más me gustaron es que hay:

  • Diferentes niveles de dificultad
  • Tags que agrupan los ejercicios por temas, niveles, foco
  • Alto nivel de gamification: los participantes tenemos Kyu (niveles), Honor (puntos acumulados), seguidores, clanes y medallas entre muchas otras característica que generan una comunidad vibrante
  • Foros y comentarios bien integrados
  • Un gran contenido gratuito soportado por publicidad, pero que está bien integrada y es relevante (son siempre productos o servicios de desarrollo y los avisos no son molestos), más una oferta paga económica y que más allá de ofrecer unas pocas características avanzadas para quienes realmente le dedican mucho tiempo, es casi una membresía a un club de amigos.
  • Y sobre todo, la chance de aprender y/o practicar en una variedad enorme de lenguajes:
    (en este momento) C, Clojure, CoffeeScript, C++, Crystal, C#, Dart, Elixir, F#, Go, Haskell, Java, JavaScript, Lua, Objective-C, OCaml, PHP, Python, Ruby, Rust, Shell, SQL, Swift, Typescript, y otros que todavía no tienen Katas, pero están en proceso, como: CSS3, D, Erlang, Groovy, Julia, Kotlin, Liso, Perl, R, Racket, Sass y Scala.

Para los que ya saben que soy un enfermo de los lenguajes de programación, se dan cuenta que esto es un picnic para mi.

Recién retomé, y usualmente esto es para mi un equivalente a mirar series o jugar videojuegos: un pasatiempo estimulante. Los que quieran pueden encontrarme en Codewars y eventualmente podemos hacer un Kumite.

lunes, 4 de noviembre de 2013

Imperdible: cócteles para programadores

Todos los años se festeja el Día del Programador, el día número 256 del año. Esta vez pasó el 13 de septiembre, y para festejarlo, un colega ruso publicó una serie de cócteles para programadores, publicada en GitHub, traducida a varios lenguajes, incluido el español, y con varias fotos muy buenas, algunas de las que reproduzco a continuación para abrirles el apetito (o la sed, en este caso).

Gracias a los amigos de Surculus Fructum por el dato.

Debajo, los cócteles para Ruby, Python y Assembler, respectivamente. En el post hay varios más, incluyendo las recetas. ¡Salud!

Ruby Python Assembler

martes, 22 de octubre de 2013

Libros gratuitos de programación

Libros Gratis de Programación

Revisando las estadísticas de este blog, veo que los posts más populares han sido históricamente los que se refieren a libros gratuitos, así que en un arranque de populismo, decidí agregar uno más.  :)   Al fin y al cabo, si son tan populares, espero que sea porque a los lectores les sirve contar con esos recursos.

Hay una lista ENORME de libros de programación gratuitos en inglés, que se actualiza periódicamente, y de manera colaborativa, y puede verse en:

Quienes quieran colaborar, pueden hacerlo a través de este proyecto en GitHub.

Para quienes prefieren el español hay un recurso bueno y legal que tiene varios libros para leer directamente en línea, de temas genéricos como HTML, CSS, JS, Bootstrap y GIT.

lunes, 23 de septiembre de 2013

¡Opa! ¿Y este framework?

Opa Up and Running

El framework Opa para JavaScript es más que un framework. En realidad, es un lenguaje + una librería, pero con un objetivo bastante ambicioso: Opa intenta cubrir con mismo lenguaje el desarrollo del lado cliente, servidor y el acceso a base de datos.

Según la introducción del proyecto en su repositorio de GitHub (traduzco):

Opa es un framework avanzado para JavaScript, compuesto de dos partes:

  • Un compilador para el lenguaje Opa, que presenta una sintaxis de estilo JavaScript pero con muchas mejoras;
  • Una librería JavaScript, que se usa en tiempo de ejecución.

Siguiendo la tradición de recorrer "Raros lenguajes nuevos", lo que más me interesó de Opa es el lenguaje mismo, y ese objetivo ambicioso, así que veamos algunas características:

Opa es open source (la librería con licencia MIT y el compilador GPL 3) y se autodefine como un lenguaje "full stack" ya que cubre todas las capas, y promete soportar aplicaciones seguras y escalables.

Las aplicaciones terminan ejecutándose sobre Node.js y usan MongoDB para el manejo de datos.

Soporta nativamente HTML5 y CSS y trata de automatizar la comunicación cliente/servidor con Ajax/Comet, y brinda un modelo de programación orientado a eventos y no-bloqueante (básicamente, respeta el modelo JS, pero subiendo el grado de abstracción).

Una de las promesas más atractivas de Opa es que se puede programar sin pensar (a priori) en la distinción entre cliente y servidor. El compilador analiza y distribuye el código, haciéndose cargo de toda la comunicación. Posteriormente, sin embargo, uno puede optimizar algunas situaciones utilizando los modificadores client y server.

Veamos el clásico "Hola, Mundo" en Opa:

Server.start(
   Server.http,
   { title: "Hola, Mundo"
   , page: function() {<h1>¡Hola, Mundo!</h1> }
   }
)

El programa se corre (habiendo instalado el compilador y las herramientas, obviamente) con el comando: opa hola.opa -- y la aplicación puede navegarse en http://localhost:8080

Algo interesante de Opa es que a pesar de compilar a JS (algo ya recurrente) es un lenguaje de tipos estrictos, aunque no hace falta declararlos porque se utiliza inferencia. Sin embargo, el compilador informa de cualquier tipo de violación y es bastante inteligente al sugerir incluso las opciones para solucionarlas.

Veamos un ejemplo más, con acceso a datos. Este ejemplo de los tutoriales cuenta clics y los almacena en una tabla:

import stdlib.themes.bootstrap

database int /counter = 0;

function action(_) {
    /counter++;
    #msg = <div>Thank you, user number {/counter}!</div>
}

function page() {
    <h1 id="msg">Hello</h1>
    <a class="btn" onclick={action}>Click me</a>
}

Server.start(
    Server.http,
    { ~page, title: "Database Demo" }
)

Como puede notarse en el ejemplo de arriba, el HTML queda completamente embebido como parte del lenguaje, sin necesidad de usar comillas para los literales, que además soportan interpolación sencilla. 

Obviamente, como Opa está basado en Node, también es posible usarlo en Linux, FreeBSD, OS X y Windows, y estando disponibles todos los fuentes, es posible compilarlo en otras plataformas también.

También tiene instrucciones para desplegar fácilmente aplicaciones en plataformas como Heroku, Cloud Foundry y otras, y existen packs para varios editores como SublimeText, Emacs, Vim, Eclipse, GEdit y otros.

Esto es una brevísima introducción porque realmente hay mucho por investigar en este interesante lenguaje. Si alguien profundiza, me encantaría que me cuente. Lo mismo haré por mi lado.

Y casi me olvido: como pueden ver en la ilustración más arriba, hay un libro publicado por O'Reilly.

sábado, 21 de septiembre de 2013

Charlemos de tecnología, ¿ta?

Surculus Fructum

Arrancó un promisorio podcast de tecnología en español, de los amigos uruguayos PoTe y Cuervo, bastante conocidos en la comunidad Ruby rioplatense.

Más allá de Ruby, porque son inquietos como la mayoría de los que andan por este blog, se juntan cada tanto a hablar de tecnología, y grabar un podcast sobre un tema o dos, y prometen invitados.

No se pierdan Surculus Fructum, el podcast. Ahí en el sitio pueden suscribirse mediante feed o iTunes, bajar el audio en varios formatos o escucharlo en la página, pero les dejo el primer episodio acá nomás para que si quieren escuchen un ratito y me crean que está bueno.

Destacable, también aunque esperable de esta gente, el hecho de que el sitio es una pinturita de HTML5 y con un diseño muuuuy minimalista y prolijo.

A prestar orejas:

lunes, 23 de julio de 2012

Buildpacks: Heroku para todos y todas

Buildpacks

Heroku, una de las plataformas como servicio (PaaS) más exitosas e innovadoras, es desde hace tiempo una plataforma políglota, soportando oficialmente Ruby (el lenguaje con que se inició), pero también Node.js, Clojure, Java, Python y Scala.

Pero en realidad eso no es todo. Actualmente soportan una variedad enorme de lenguajes, a través del mecanismo que generaron para soportar cualquiera, llamado Buildpacks. Aunque Heroku desarrolla activamente los buildpacks mencionados más arriba, la comunidad puede (y de hecho lo ha hecho) desarrollar otros para soportar todo tipo de lenguajes o entornos, como puede verse en este listado, que incluye algunos como Common Lisp, Emacs, Erlang, Go, Jekyll, JRuby, Lua, Perl, PhantomJS y otros.

¿Cómo funcionan los buildpacks? La última versión de la plataforma base de Heroku (llamada Cedar) provee un entorno de ejecución virtualizado que básicamente es una abstracción de los servidores, con los servicios de red, el sistema de administración y monitoreo, y claro, GIT. Sobre esto, para soportar cualquier lenguaje, debe haber un buildpack que utiliza GIT hooks para dispararse al recibir actualizaciones sobre un repositorio, como muestra el siguiente diagrama de ejemplo:

Heroku Buildpacks

Así, al hacer git push heroku master, se puede notar que después de recibir la actualización completa del repositorio, se dispara el buildpack correspondiente a la aplicación, según se indicó al ejecutar el comando heroku create, o posteriormente con la variable de entorno BUILDPACK_URL.

Construir buildpacks no es demasiado complejo. Se pueden incluir en ellos binarios u otras dependencias necesarias por sobre la plataforma, y para comenzar basta con crear un fork del ejemplo Hello Buildpack (no podía llamarse de otra manera), leer la documentación del API, y eventualmente participar en el foro junto a otros colegas.

Finalmente, los buildpacks pueden utilizarse fuera de Heroku, como en el caso de otros proveedores que ya los soportan, o utilizando Mason, en cualquier tipo de entorno.

viernes, 29 de junio de 2012

JetBrains + Nemerle = una dupla poderosa (+ video)

La gente de JetBrains, los cerebros a propulsión detrás de IntelliJ IDEA, ReSharper y toda una familia de IDEs especializadas, anunció recientemente la contratación del núcleo del equipo de desarrollo de Nemerle, uno de esos "raros lenguajes nuevos", completamente abierto, que revisé en este blog un año atrás.

Como explican en el anuncio, la incorporación se decidió en reconocimiento al increíble trabajo de Nemerle en la implementación del lenguaje y sus características de meta-programación, inferencia de tipos, etc. El foco del equipo estará por o tanto en el proyecto N2, un framework para desarrollo de lenguajes, un área a la que JetBrains se dedica muy especialmente y con evidente éxito.

Para que se den una idea sobre lo que genera esta gente, les dejo un video fresquito de una sesión sobre este lenguaje presentada por Igor Tkachev, del equipo de desarrollo, durante la reciente Norwegian Developers Conference en Oslo, a principios de junio (dura menos de media hora y está en inglés).

Da la impresión que el contacto y la posibilidad de fusión surgió a partir de esta época, así que puede ser un video para la historia (al menos para el equipo de Nemerle y JetBrains).

lunes, 26 de diciembre de 2011

Raros lenguajes nuevos: Dart (+ video)

Dart

Hace ya varios meses comenzó a circular el rumor de que Google estaba trabajando en un nuevo lenguaje. Entre los rumores se mencionaba un nombre: Dash, y un par de personas, conocidos para los que siguen las novedades en cuanto a lenguajes y máquinas virtuales: Gilad Bracha y Lars Bak.

En la conferencia GOTO, en Aarhus, Dinamarca, durante octubre de este año, se descorrió el velo y se presentó el nuevo lenguaje, con nombre definitivo similar al inicial: DART.

Efectivamente los autores detrás son Bracha y Bak. Bracha se ha autodenominado Teólogo Computacional Emérito, y conocido por ser coautor de la Especificación del Lenguaje Java y creador de los lenguajes StrongTalk (un entorno de Smalltalk, en realidad, creado antes de entrar en Sun) y más recientemente, Newspeak. Lars Bak es un reconocido en máquinas virtuales, habiendo liderado en Sun proyectos como HotSpot y Java ME, el entorno de ejecución de Self y más recientemente V8, el motor de ejecución de JavaScript abierto que forma parte de Google Chrome.

Google mantiene dos proyectos en paralelo respecto a la evolución de JavaScript: por un lado sigue apoyando fuertemente el desarrollo de EcmaScript (el verdadero nombre de JavaScript) para resolver algunos de los problemas de diseño que acarrea a lo largo de los años. Por otro lado, reconociendo que este es un camino que tomará muchísimos años y será complejo implementar algunas soluciones, mantiene también a Dart como una alternativa posible.

Dart es un lenguaje con muchas características conocidas, que no sorprende demasiado, pero con una base muy fuerte en su motor de ejecución, y mantiene la capacidad de ejecutarse nativamente dentro del navegador, algo que todavía no está completamente soportado ni en Chrome, pero si experimentalmente en una versión particular de Chromium (el proyecto abierto) siguiendo instrucciones particulares para compilarla.

Las características principales de Dart como lenguaje son:

  • Tipos estáticos opcionales (si no se declaran son dinámicos)
  • Herencia simple basada en clases con interfaces
  • Genéricos
  • Sintaxis muy similar a JS
  • Interpolación de strings
  • Lambdas
  • Modelo de aislamiento similar a Erlang (cada Isolate es un conceptualmente un proceso sin nada compartido, comunicándose por pase de mensajes, pudiendo correr en paralelo)

Las opciones de ejecución son realmente tres:

  • Compilar de Dart a JavaScript (la única opción que permite generar y ejecutar aplicaciones hoy en día)
  • Ejecutar el código Dart en su propia máquina virtual (aun no soportada realmente en ningún navegador, pero si en las herramientas Dart)
  • Crear una imagen (se trata de una imagen del heap de una aplicación que puede empaquetarse y reactivarse instantáneamente, similar a una imagen de Smalltalk).

Para utilizar Dart es necesario descargar y utilizar un conjunto de herramientas empaquetadas como un plugin de Eclipse, o para probar el lenguaje en un contexto más básico se puede utilizar Dartboard, un pequeño editor en linea con las herramientas detrás, en el servidor. En la imagen debajo pueden ver DartEditor corriendo en mi computadora:

Dart Editor

Para los más interesados, dejo un video y presentación de Gilad Bracha mismo en InfoQ (en inglés). Lamentablemente la gente de InfoQ no permite embeber el video de manera directa, pero es en parte porque ellos brindan una experiencia muy buena al sincronizar el video del presentador junto a las diapositivas en cuadros separados.

viernes, 23 de diciembre de 2011

Código en colores: temas para programar

Hace tiempo que no publicaba nada, ocupado con muchos temas laborales y personales, pero estoy organizándome nuevamente y vuelvo a la carga. Ojalá pueda ir subiendo la frecuencia y llegar de nuevo al ritmo diario dentro de poco.

Tomorrow Night theme

Todos los que programamos tenemos una serie de hábitos que son bastante personales y que nos ayudan a mantener el foco y la comodidad en la tarea. Muchas veces no podemos elegir de manera directa cosas como el lenguaje, la plataforma o ciertas herramientas, pero en la mayoría de los casos si podemos personalizar sus configuraciones.

Una de las personalizaciones más comunes y variables son los colores de nuestros editores o IDEs. Algunos preferimos fondos oscuros, otros claros, a veces tonos medios. En mi caso prefiero los primeros, y siempre estoy buscando variantes de "temas" de colores que pueda usar en diferentes ambientes. No es una búsqueda activa, sino que en general me llama la atención cuando alguien menciona nuevos temas en algún blog o artículo, y cuando puedo le dedico unos minutos a mirarlos.

Esta mañana mientras leía otra cosa llegué de causalidad a la página de temas en la Wiki de TextMate, uno de los editores que uso frecuentemente, y echando una mirada me llamó la atención un tema mencionado como 2morrow Night (muestra a la derecha).

Lo interesante es que siguiendo el link de descarga en GitHub descubrí que Chris Kempson, el autor, se tomó el trabajo de brindar este mismo tema (y sus variantes) en muchísimas plataformas, como BBEdit, Coda, Eclipse, Expresso, GEdit, Emacs, editores de JetBrains, la terminal de OS X, Visual Studio y muchos otros. Una labor obsesiva e invaluable. Empecé a bajar algunos de ellos, y después me di cuenta que era más fácil tenerlos todos, así que fui a mi consola y:

> git clone https://github.com/ChrisKempson/Tomorrow-Theme.git
Cloning into Tomorrow-Theme...
remote: Counting objects: 445, done.
remote: Compressing objects: 100% (228/228), done.
remote: Total 445 (delta 225), reused 425 (delta 208)
Receiving objects: 100% (445/445), 940.89 KiB | 332 KiB/s, done.
Resolving deltas: 100% (225/225), done.

…y en 10 segundos tenía todos a mi alcance. Me sigue maravillando la cantidad de cosas que quedan cada vez más a nuestro alcance desde GitHub u otros recursos en la nube.

Como dije, Chris se tomó el trabajo en serio y todas las variantes por plataforma están en el formato correcto, con lo que al hacer doble clic sobre los archivos, en la mayoría de los casos, el editor los agrega directamente (en mi caso, TextMate y Terminal lo hicieron, en Vim lo abre y hay que ejecutarlo, ya que es un script completo).

Si les gusta probar temas, pueden tomar esto como mi regalo de navidad.

Si no, aprovecho igualmente para desearle felicidades a todos los lectores.

 

lunes, 8 de agosto de 2011

LangDay 2012: planeando una conferencia sobre lenguajes

imageEl grupo ErlAr, que reune a usuarios de Erlang en Argentina, está intentando organizar para el año próximo una conferencia sobre lenguajes de programación, con foco principal en los lenguajes “no principales”. Esto quiere decir concentrarse en aquellos que no son los más populares en la industria local, como C/C++, Java, C# o Visual Basic, sino en los lenguajes que tienen pequeñas pero pujantes comunidades de seguidores, como Python, Ruby, Erlang (claro) y otros menos conocidos, algunos experimentales, incluso.

Esta idea no puede ser menos atractiva para mi, que soy un apasionado del tema, y para quienes disfruten de la serie “raros lenguajes nuevos” que mantengo en este blog.

El proyecto, que por ahora se llama Lang Day 2012, tiene las siguientes características, según el sitio borrador:

Objetivo

Brindar un evento de uno o dos días que permita a los asistentes obtener una idea sobre lenguajes de programación emergentes la cual le permita comparar:

  • Paradigma dominante del lenguaje
  • Tipado
  • Características principales
  • Fortalezas/Debilidades
  • Filosofía
  • Estado actual/Planes futuros
  • Estado de documentación/comunidad
  • Casos de éxito
  • etc. (agregar otros de ser necesario)

Formato

El evento intentara organizar las charlas de manera que los asistentes puedan asistir a las charlas introductorias de todos los lenguajes y luego decidan en cuales quieren profundizar.

Por esto el track de introducción será en una sola sala donde las charlas introductorias se realizaran una tras otra con una duración de 45 minutos.

Luego el track avanzado se realizará en 2 salas por lo cual el asistente deberá decidir en cuales lenguajes desea profundizar.

Por ultimo se realizará antes de la charla de cierre una serie de lightning talks con duración de 15 minutos que permita presentar de una manera mas superficial lenguajes menos conocidos o no tan maduros

Lenguajes Principales

Estos lenguajes son los que se desea presentar en profundidad en charla introductoria y avanzada de encontrarse presentadores:

  • Python
  • Ruby
  • Erlang
  • Scala
  • F#
  • Go
  • Haskell

quizas:

  • Clojure

    Lenguajes Secundarios

    Estos lenguajes son los que pueden presentarse en una lightning talk:

    • efene
    • LayerD
    • coffescript + node.js
    • etc

    Calendario

    • Charla de apertura (de 30 a 60 minutos)
    • Charlas introductorias (sala única, 45 a 60 minutos)
    • Charlas avanzadas (salas múltiples, 45 a 60 minutos)
    • Lightning Talks (sala única) (entre 15 y 20 minutos cada una)
    • Charla de Cierre (entre 15 y 30 minutos)

    Charla de apertura

    La charla de apertura además de dar información sobre el evento debería informar sobre la utilidad de aprender nuevos lenguajes, y presentar una breve introducción a conceptos básicos que puedan ser utilizados durante las charlas como:

    • Tipado Estático, Dinámico, Progresivo, de pato, Fuerte vs Débil
    • Paradigma funcional, orientado a objetos y estructurado
    • Side effects, Single Assignment

      Para estar al tanto del avance del evento, pueden seguir la cuenta de Twitter @LangDayAr, y los interesados pueden completar esta encuesta sobre detalles que les gustaría como asistentes, o anotarse en este otro formulario si tienen interés en presentar sobre alguno de los temas.

      lunes, 25 de julio de 2011

      Google App Engine completó el soporte para Go

      La semana pasada el equipo de Google App Engine, la plataforma como servicio para ejecutar aplicaciones en la nube, anunció soporte para Go, uno de esos raros lenguajes nuevos, en este caso generado por el mismo Google, en lugar de surgir del ambiente académico o la comunidad de código abierto.

      Esto hace que Go, diseñado para ser un lenguaje de sistema de un nivel apenas superior a C++, eliminando los típicos problemas de manejo de memoria y aportando características específicas para situaciones de alta concurrencia y paralelismo.

      Go es un lenguaje “de llaves”, en la tradición familiar de C, pero sin necesidad de puntos y comas, al menos (las lleva pero el compilador se encarga de ponerlas solo). Veamos el clásico Hola, Mundo:

      package main

      import "fmt"

      func main() {
      fmt.Println("Hello, 世界")
      }

      Una de las características más interesantes de Go, y una de las que lo hace especialmente interesante para aplicaciones en la nube, es su implementación de co-rutinas, o funciones que pueden ejecutarse en paralelo, utilizando, casualmente, la sentencia “go”, pero además permite definir “canales” para mantener la comunicación entre procesos. Para los interesados que aún no lo hayan hecho, hay un buen tutorial de Go con muchos ejemplos.


      Quienes quieran probar Go en Google App Engine, pueden comenzar con las instrucciones en Google Code.

      jueves, 7 de julio de 2011

      Raros lenguajes nuevos: CoffeeKup (más y más cafeína)

      CoffeeKup

      El matemático Alfréd Rényi decía que "un matemático es una máquina que convierte café en teoremas", frase que usualmente se le atribuye a su compatriota y colega Paul Erdös, quien solía repetirla.

      Los programadores somos de alguna manera aparatos para convertir cafeína en algoritmos, lo que se hace explícito en la tradición de Java, JavaScript y el reciente CoffeeScript, todos inspirados en este alcaloide de venta libre.

      Siguiendo la tradición cafetera, Maurice Machado ha colaborado con un reciente experimento notable basado en Node.js y CoffeeScript. Como breve recordatorio, CoffeeScript es una sintaxis simplificada de JavaScript, con un estilo más sucinto, bastante similar a Ruby, que se está haciendo tan popular que ya viene integrado en la distribución de Ruby on Rails 3.1, por ejemplo.

      Lo que Maurice generó con CoffeeKup es un lenguaje específico de dominio (DSL) sobre CoffeeScript para generar el marcado completo de la página. Esto es, en lugar de escribir HTML, podemos escribir directamente toda la estructura de la página en CoffeeScript.

      Veamos el ejemplo clásico de http://coffeekup.org/:

      doctype 5
      html ->
        head ->
          meta charset: 'utf-8'
          title "#{@title or 'Untitled'} | My awesome website"
          meta(name: 'description', content: @desc) if @desc?
          link rel: 'stylesheet', href: '/stylesheets/app.css'
          style '''
            body {font-family: sans-serif}
            header, nav, section, footer {display: block}
          '''
          script src: '/javascripts/jquery.js'
          coffeescript ->
            $().ready ->
              alert 'Alerts are so annoying...'
        body ->
          header ->
            h1 @title or 'Untitled'
            nav ->
              ul ->
                (li -> a href: '/', -> 'Home') unless @path is '/'
                li -> a href: '/chunky', -> 'Bacon!'
                switch @user.role
                  when 'owner', 'admin'
                    li -> a href: '/admin', -> 'Secret Stuff'
                  when 'vip'
                    li -> a href: '/vip', -> 'Exclusive Stuff'
                  else
                    li -> a href: '/commoners', -> 'Just Stuff'
          section ->
            h2 "Let's count to #{@max}:"
            p i for i in [1..@max]
          footer ->
            p shoutify('bye')

      Como puede verse, se declara la estructura jerárquica de la página (cabecera y cuerpo), con sus atributos internos, y pueden anidarse los elementos como párrafos, divs, listas, y demás. Y claro, puede embeberse código en cualquier lado. No hay una diferencia directa entre la plantilla y el código.

      Parece una postura muy radical, pero me parece un espacio sumamente interesante a investigar. Los experimentos de Maurice estén disponibles en GitHub y no terminan en CoffeeKup. Hay otros relacionados, como Zappa y CoffeeScript-Bespin.

       

      viernes, 1 de julio de 2011

      Video: Programando de a pares con Mariano Koldobsky

      Mariano Koldobsky

      Mi invitado esta vez es Mariano Koldobsky, un experimentado trabajador al que conozco desde hace años, a raíz de conocernos en una empresa en que él trabajaba y yo daba consultoría, y reencontrarnos más tarde en la comunidad ágil.

      Tiempo después logramos trabajar juntos por un tiempo, hasta hace poco cuando Mariano empezó a trabajar para bvision, que tienen oficinas cerca de su casa en La Plata, capital de la provincia de Buenos Aires.

      Con Mariano compartimos la pasión por la programación, la electrónica y recuerdos de nuestra generación, ya que somos los dos bastante veteranos. Pero casualmente esas dos primeras aficiones nos llevaron a elegir como tema de nuestra sesión un ejercicio de programación y cableado, utilizando una placa Arduino, que es una plataforma de hardware abierto, ideal para realizar prototipos e implementaciones sencillas y caseras de dispositivos de control.

      Como verán en el video, la placa se conecta por USB (anteriormente por puerto serie) y se programa en un lenguaje de programación propio (una especie de Processing, pero basado en C++ en lugar de Java).

      Algo interesante de Arduino es que es la plataforma que tomó de base Google para desarrollar su propio Android Open Accessory Development Kit, con lo que conocerla ahora puede significar algo más que un mero pasatiempo.

      El video dura un poco menos de 15 minutos, y espero que les resulte tan divertido como a nosotros grabarlo. ¡Al menos por una vez van a ver algo más que código!

       

      jueves, 30 de junio de 2011

      Raros lenguajes nuevos: Cobra (video)

      Cobra - multiplataforma

      (gracias a José Romaniello por descubrirme este interesantísimo lenguaje)

      Cobra es un lenguaje multi-plataforma y multi-paradigma que combina una cantidad de características sumamente interesantes.

      Es obra de Charles Esterbrook, y su autor describe sus principios de diseño de la siguiente manera:

      1. Programación rápida y expresiva
      2. Rápida ejecución
      3. Tipado estático y dinámico
      4. Calidad soportada a nivel del lenguaje

      Por supuesto que suena ambicioso y vendedor, pero en principio, es bastante realista. Veamos cómo se soporta cada cosa:

      Programación rápida y expresiva

      Cobra tiene una sintaxis basada en Python (sobre todo) y Ruby, lo que lo hace mucho más legible que los lenguajes "con llaves y punto y coma". Entre otras cosas, en Cobra los bloques se determinan por indentación, las listas y diccionarios se pueden declarar como literales, hay comandos como print y assert de uso sencillo y poderoso, la manera de iterar y dividir listas es simple, y mucho más.

      Un ejemplo rápido de la sintaxis, con la definición de una clase:

      class Person
         """
         Declaración de una clase. Este comentario documenta la clase misma
         """
      
         var _name as String  # Declara variables de instancia (no estáticas)
         var _age as int
      
         cue init(name as String, age as int) # Inicializador (constructor)
            base.init
            _name = name
            _age = age
      
         def sayHello # Métodos
            # Los corchetes interpolan valores en las strings
            print 'Hello. My name is [_name] and I am [_age].'
      
         def divide(i as int, j as int) as int
            """ Este comentario documenta este método """
            assert j > 0 # Si el divisor 
            return i / j

       

      Rápida ejecución

      Esto es logrado a través del uso de tipos estáticos con inferencia permanente, sin perder las capacidades dinámicas para los casos necesarios.

      La implementación actual de Cobra utiliza la Infraestructura Comun de Lenguajes (CLI) de .NET/Mono, por lo que el compilador genera código intermedio (IL) que a su vez es es llevado a código nativo por el motor de ejecución de .NET/Mono como en otros lenguajes.

       

      Tipado estático y dinámico

      La mayor parte de la resolución es estática y en tiempo de compilación, mientras que siempre que haga falta puede utilizarse resolución dinámica en tiempo de ejecución, basada en Reflection de .NET y apoyándose en técnicas específicas de optimización.

      Veamos un ejemplo sencillo de una misma función declarada estáticamente:

      def add(a as decimal, b as decimal) as decimal
         return a + b
      

      ... o dinámicamente:

      def add(a, b) as dynamic
         return a + b
      

      En la práctica, no son la misma función, ya que la primera opera solamente con números decimales, y la segunda con cualquier tipo que soporte la operación suma.

      Obviamente la primer función es más rápida, ya que se verifica y compila, y no requiere más recursos que los operandos de un largo conocido (decimal), mientras que la segunda, al resolverse dinámicamente, es verificada en tiempo de ejecución y requieres más recursos para la conversión de parámetros, etc.

      Por otro lado, contar con ambas variantes es lo ideal, ya que podemos aprovechar el contrato estricto de los tipos estáticos para gran parte de la aplicación, pero con la flexibilidad de los dinámicos para las porciones que son más variables, o para facilitar el prototipado.

      Nótese que el soporte a tipos dinámicos de Cobra, comparado con el de C# o VB (a partir de .NET 4), es sintácticamente más sencillo, mucho más integrado a nivel del lenguaje.

      Calidad soportada a nivel del lenguaje

      Cobra soporta contratos de código (algo proveniente de Eiffel que .NET 4 soporta parcialmente), pruebas unitarias, comentarios para documentación y verificación de valores nulos en tiempo de compilación, todo como parte de su sintaxis.

      Veamos como las pruebas unitarias quedan embebidas directamente como parte de un método:

      class Utils
         shared
            def countChars(s as String, c as char) as int
               """
               Returns the number of instances of c in s.
               """
               test
                  assert Utils.countChars('', c'x') == 0
                  assert Utils.countChars('x', c'x') == 1
                  assert Utils.countChars('X', c'x') == 0  # case sensitive
                  assert Utils.countChars(' ! ! ', c'!') == 2
               body
                  count = 0
                  for ch in s
                     if c == ch
                        count += 1
                  return count

      Las aserciones, además, pueden usarse en cualquier parte del código, y arrojan una excepción con información útil para depuración si no se cumplen (no son un IF).

      Los contratos embebidos en el código permiten especificar pre y post-condiciones a los métodos, garantizando la consistencia antes de entrar y después de retornar el valor final. Por ejemplo:

      class Customer
      
         var _contacts as List<of Contact>
         get contacts from var
      
         def addContact(contact as Contact)
            require # Arroja excepción si algo no se cumple ANTES de entrar
               contact not in .contacts
               contact.name
               contact.customer is nil
            ensure # Arroja excepción si algo no se cumple DESPUES de salir
               contact.customer == this
               .contacts.count = old .contacts.count + 1
            body
               contact.customer = this
               _contacts.add(contact)

      Y otra característica muy buena de seguridad es que los parámetros o tipos que pueden recibir nil (llamado como en Smalltalk o LISP), son los que se declaran como tales, agregando al sufijo "?" al tipo, como en:

      def bar(s as String?)
         if s  # Es igual que preguntar "if s is not nil"
            print Utils.countChars(s, c'x')

       

      Cobra está escrito en Cobra

      Una característica más que quiero remarcar es que este lenguaje está escrito sobre si mismo. Por supuesto hay una parte del compilador escrita para la plataforma nativa (C# en este caso), pero el resto está escrito en Cobra mismo, lo que hace que el lenguaje tenga un nivel de depuración y prueba mayor que otros que se construyen generalmente sobre lenguajes de más bajo nivel. Esto está sucediendo en otros lenguajes a posteriori, como en el caso de PyPy o Rubinius, pero en Cobra fue un principio de diseño.

      Personalmente me parece uno de los lenguajes "experimentales" más interesantes y completos que he visto en los últimos tiempos, en parte porque se apoya en una plataforma que ya ofrece muchos servicios, y en parte por algunas de sus características maduras que y las herramientas con que ya cuenta (compilador, ejecutor de pruebas unitarias, generador de documentación, coloreador de sintaxis, etc).

      Y también cuenta con soporte parcial en algunas IDEs y editores:

      Visual Cobra es un complemento para Visual Studio que reconoce y colorea la sintaxis.

      Naja es una IDE completa escrita en Cobra que ademas del coloreo de sintaxis tiene soporte para lista de tareas basada en comentarios, soporte para proyectos y un diseñador de formularios que genera código Cobra.

      Y si uno prefiere un editor de texto hay muchos para los cuales hay complementos para soportar la sintaxis, incluyendo gedit, Notepad++, UltraEdit, Vim y TextMate (el que estoy usando yo), y mucho más para elegir según la plataforma que cada uno usa. Y para cualquier otro caso existe un detalle de las palabras clave y modificadores, de manera que en cualquier editor se puede partir del soporte para Python y cambiar estas listas.

       

      Finalmente, dejo este video de la presentación de Esterbrook en el Lang .NET Symposium 2008. Aunque la implementación del lenguaje maduró bastante desde entonces, muchos de los principios siguen igual.

       

      jueves, 16 de junio de 2011

      Rubinius 2.0 - versión preliminar para desarrolladores

      Rubinius

      Rubinius es una implementación de Ruby que tiene la característica principal de estar escrito mayormente en Ruby.

      La máquina virtual está escrita en C++ y utiliza LLVM para convertir el bytecode en el código nativo del procesador destino, pero el compilador de los bytecodes y la gran mayoría de las bibliotecas están escritas en Ruby. Este nucleo utiliza un recolector de basura muy optimizado y permite extensibilidad en C que soporta las mismas extensiones en este lenguaje que utiliza el intérprete estándar de Matz (conocido como MRI).

      El siguiente diagrama muestra la distribución de componentes de Rubinius:

      Componentes

      Uno de los desafíos de Rubinius siempre fue medir el nivel de compatibilidad contra la implementación de Matz, por lo que tempranamente empezaron a trabajar en RubySpec, una serie de pruebas que funcionan como la especificación del lenguaje, ya que éste no tenía una originalmente y por sus propias características de meta-programación, es especialmente complejo de validar.

      Básicamente, Rubinius, hasta su última versión estable, soporta Rails, Rake, RSpec, Nokogiri, Mongrel y prácticamente todas las bibliotecas y frameworks hasta Ruby 1.8.x.

      La novedad es que el equipo acaba de liberar la versión preliminar 2.0, que fundamentalmente soporta Ruby 1.8.7 y 1.9.2, y funciona bajo Windows, pero además utiliza un nuevo mecanismo de threading realista que aprovecha los múltiples núcleos de los procesadores modernos.

      Adicionalmente, el equipo migró el repositorio a GitHub. Para los interesados en el desarrollo de lenguajes, vale la pena al menos pegarle una mirada.

       

       

      martes, 14 de junio de 2011

      Raros lenguajes nuevos: Nemerle

      Nemerle

      Uno de los principios de diseño del framework .NET, o más específicamente del CLI (Common Language Infrastructure) es, como su nombre lo indica, permitir implementar fácilmente una variedad importante de lenguajes.

      El CLI es una pieza estandarizada ante ECMA como un estándar abierto, y es lo que ha permitido la creación de implementaciones abiertas de .NET como Rotor y Mono.

      Pero también ha permitido la implementación de muchos lenguages (más allá de Microsoft) que comparten todo el ecosistema de herramientas y bibliotecas disponibles.

      Nemerle es uno de estos casos. Desarrollado en la Universidad de Wroclaw, Polonia, se trata de un lenguaje de tipos estáticos, casi un superset de C#, que soporta estilos de programación funcional y orientada a objetos, metaprogramación, lenguajes específicos de dominio y mucho más. Al estar basado en el CLI genéricamente, funciona en .NET y en Mono por igual.

      Siendo un superset, es posible compilar (con un par de toques en el archivo .csproj) fuentes C# en Nemerle.

      Dos de las características más distintivas de Nemerle son la inferencia de tipos y el uso de macros.

      Veamos algunos ejemplos de código, con inferencia de tipos:

      def d = Dictionary ();
      d.Add ("Code and Beyond", 42);
      foreach (s in args) {
        ...
      }

      Notese que no hace falta inicializar los tipos del diccionario, que son declarados y chequeados a partir del primer uso.

      En el caso de las macros, pueden escribirse cosas como:

      ExecuteReaderLoop ("SELECT nombre, apellido FROM personas WHERE nombre = $miNombre", dbcon,
      {
        System.Console.WriteLine ("Persona: {0} {1}", nombre, apellido) 
      });

      que enmascaran la creación del SqlCommand y el SqlReader, la clásica iteración y la obtención de las strings para los dos campos leídos, pero es importante ver que es mucho más que una función de una biblioteca, ya que en este caso se está interpretando la string conteniendo la sentencia SQL y generando el código chequeado correspondiente.

      Nemerle también tiene interpolación de strings más eficiente que en C#, ya que se ejecuta en tiempo de compilación, como en:

      $"Me llamo $Nombre y tengo $Edad años."

      donde las variables reemplazadas son chequeadas por el compilador, a diferencia de utilizar String.Format, donde se realizan en tiempo de ejecución.

      Es muy interesante además la sencillez para definir Macros, que no tienen nada que ver con las de C, y son descendientes directas de las macros de LISP. Veamos este caso que define un bucle hacia atrás:

      macro ReverseFor (i, begin, body) 
      syntax ("atras", "(", i, ";", begin, ")", body)
      {
        <[ for ($i = $begin; $i >= 0; $i--) $body ]>
      }

      que se usaría de esta manera:

      atras (i ; n) print (i);

      Más información sobre Nemerle en la wiki del lenguaje, y los más interesados pueden encontrar el repositorio en Google Code.

      miércoles, 4 de mayo de 2011

      CoffeeScript: el libro (más un video)

      El libro de CoffeeScriptYa hablé antes en este blog sobre CoffeeScript y las ediciones de Pragmatic Programmers, y hoy quería combinar ambas cosas comentando el nuevo libro de Trevor Burnham que ya está disponible en Beta, y comencé a leer ayer.

      Por supuesto, el libro está en inglés, y no está terminado, pero me parece otro indicio, junto con la decisión de incluir CoffeeScript por omisión en Rails, del auge que está tomando este dialecto simplificado para JavaScript.

      Pero vamos al libro. En el prologo, Jeremy Ashkenas, el creador de CoffeeScript, explica entre otras cosas (la traducción es mía):

      ..."Afortunadamente para nosotros, el JavaScrit de hoy disfruta de un merecido renacimiento. Gracias al incansable esfuerzo de los implementadores de los navegadores, es actualmente el más rápido de los lenguajes dinámicos populares; está presente en todos lados, desde servidores hasta Photoshop; y es el único lenguaje que se puede usar para programar desde todos los ángulos de la web.

      CoffeeScript es un pequeño lenguaje que apunta a brindar fácil acceso a las partes buenas de JavaScript: las funciones de primer clase, los objetos como hash, incluso la poco comprendida cadena de herencia por prototipos. Si hacemos bien nuestro trabajo, ustedes terminarán escribiendo un tercio del código para escribir el mismo JavaScript que hubiesen escrito de otra forma. CoffeeScript pone un alto valor a la legibilidad del código y a eliminar mucho del ruido sintáctico.Al mismo tiempo, hay una correspondencia prácticamente uno-a-uno entre CoffeeScript y JavaScript, lo que significa que no hay degradación de rendimiento -de hecho, muchas biblitoecas JavaScript terminan corriendo más rápido después de ser migradas a CoffeeScript debido a algunas optimizaciones que el compilador puede realizar."

      El prólogo termina elogiando al autor del libro por sus colaboración con CoffeeScript desde los primeros días, lo que asegura que el tema está tratado desde un profundo conocedor.

      El juego del 5x5

      El libro recorre el lenguaje y compilador en detalle, incluyendo instalación y ejecución, integración en otros ambientes e interoperabilidad con bibliotecas populares como jQuery. Y a medida que recorre los diversos capítulos, utiliza como ejemplo la construcción de un juego sencillo para dos jugadores, llamado 5x5, del que puede verse la interfaz a la derecha.

      Comparto el índice general para que se den una idea del alcance:

      • Prólogo y Agradecimientos
      • Prefacio (historia, audiencia y organización del libro, proyecto de ejemplo y comunidad)
      • Comenzando (instalación, editores, ejecución y depuración)
      • Funciones, alcance y contexto
      • Colecciones e Iteraciones
      • Módulos y clases
      • Interactividad web con jQuery
      • Aplicaciones del lado del servidor con Node.js
      • Respuestas a los ejercicios
      • Maneras de ejecutar CoffeeScript (consolas web, dentro de una aplicación web, en Rails, via middleware, en Node.js, usando Middleman, en scripts del sistema operativo)
      • Cartillas
      • Bibliografía

       

      Para terminar, dejo un video de Ashkenas presentando (en inglés) CoffeScript en la JSConf de hace un año. Es interesante ver la presentación de parte del propio padre de la criatura, pero tengan en cuenta que los doce meses transcurridos han cambiado la situación (para mejor) y ampliado las características del compilador.

       

      lunes, 14 de marzo de 2011

      Probar Haskell en tu navegador

      Real World HaskellSiguiendo el camino que inicio _why con TryRuby.org, Chris Done creo TryHaskell.org, una página donde encontramos una consola interactiva para probar Haskell, el lenguaje puramente funcional por excelencia.

      Esta consola es del tipo REPL (read, evaluate, print loop) y permite ingresar comandos y expresiones. Como en Haskell la declaración de funciones es una expresión (utilizando let) se pueden crear y ejecutar funciones dentro del entorno.

      Por supuesto, como en el caso de TryRuby, se puede seguir un tutorial que va guiando al asistente secuencialmente a través de las expresiones más sencillas, manipulación de strings, manejo de listas, declaración de símbolos, etc.

      La consola interpreta y muestra los resultados parciales e informa si hay situaciones de error, como puede verse debajo.

      Consola de Haskell

       

      Adicionalmente a los ejemplos que la misma página va proponiendo, hay también un link al libro "Real World Haskell", de Bryan O'Sullivan, Don Stewart, y John Goerzen, editado por O'Reilly Media y disponible gratuitamente en línea (en inglés), donde se pueden encontrar muchísimos más ejemplos y por supuesto un nivel de profundidad mucho mayor en la presentación del lenguaje.

      Para aprovechar a fondo la combinación entre el libro y TryHaskell basta con arrancar por el capítulo 1, donde se describen muchos ejemplos iniciales utilizando ghci, que es la consola interactiva del entorno Haskell, lo que es el equivalente directo de la consola que encontramos en la página.

      Para todos aquellos interesados en la programación funcional pero que no tuvieron la oportunidad (o el coraje) de acercarse a Haskell, puede ser una buena manera de entender un poco más de que se trata sin la necesidad de tener que hacer una gran inversión inicial de tiempo.

       

      jueves, 20 de enero de 2011

      Raros Lenguajes Nuevos: CoffeeScript

      CoffeeScript

      CoffeeScript es un lenguaje que compila a JavaScript, y mantiene una premisa fundamental: sigue siendo JavaScript.

      El código es compilado a su equivalente, y es posible utilizar cualquier librería o extensión como en el ambiente original. El código final generado es prolijo y entendible, pasa las validaciones de JavaScript Lint y funciona en cualquier motor de JavaScript.

      Lo que CoffeeScript aporta es una sintaxis simplificada, inspirada en Ruby y Python, despojada de llaves y puntos y comas, bastante más legible pero con exactamente el mismo poder y características del JavaScript tradicional.

      Veamos algunos ejemplos:

      # Asignación:
      number   = 42
      opposite = true
      # Condiciones:
      number = -42 if opposite
      

      Esto genera el siguiente JavaScript:

      var number, opposite;
      number = 42;
      opposite = true;
      if (opposite) {
      number = -42;
      }
      

      Y aunque estos ejemplos suenan triviales, ya pueden notarse algunas abreviaturas importantes. Pero veamos un ejemplo más extremo, que utiliza declaración de funciones, espacios de nombre y comprensión de arrays:

      # Declaración de funciones
      square = (x) -> x * x
      
      # Declaración de un array:
      list = [1, 2, 3, 4, 5]
      
      # Funciones dentro de un espacio de nombres:
      math =
        root:   Math.sqrt
        square: square
        cube:   (x) -> x * square x

      # Comprensión de Arrays: cubes = (math.cube num for num in list)

      Y su equivalente en JavaScript:

      var cubes, list, math, num, square;
      var __slice = Array.prototype.slice;
      
      square = function(x) {
        return x * x;
      };
      
      list = [1, 2, 3, 4, 5];
      
      math = {
        root: Math.sqrt,
        square: square,
        cube: function(x) {
          return x * square(x);
        }
      };
      
      cubes = (function() {
        var _i, _len, _results;
        _results = [];
        for (_i = 0, _len = list.length; _i < _len; _i++) {
          num = list[_i];
          _results.push(math.cube(num));
        }
        return _results;
      })();
      

      ¿No es notoriamente más clara la versión en CoffeeScript?

      La sintaxis completa y referencia está disponible en línea.

      ¿Cómo funciona? El compilador está escrito en CoffeeScript (en la mejor tradición geek) utilizando Jison Parser Generator. La versión de línea de comando funciona sobre Node.js, aunque el compilador en si puede correr en cualquier motor de JavaScript.

      Algo muy interesante es que cualquiera que quiera jugar un poco no necesita instalar nada. Simplemente puede ir al sitio de CoffeeScript dentro de GitHub y elegir “Try CoffeeScript” en el menú superior para acceder a un editor en línea que permite escribir código CoffeeScript del lado izquierdo y va mostrando cómo se compila (en tiempo real, letra por letra) en JavaScript, como se ve en la figura:

       

      Try CoffeeScript