Wednesday, January 21, 2009

Compiler research: the next 50 years

Este post no tiene que ver directamente con LayerD pero me pareció interesante compartir algunas partes de un interesante artículo titulado "Compiler research: the next 50 years" de la respetada publicación "ACM communications volume 52 issue 2". Transcribo las partes que me parecieron más interesantes:


 

Today, compilers and highlevel languages are the foundation of the complex and ubiquitous software infrastructure that undergirds the global economy. It is no exaggeration to say that compilers and high-level languages are as central to the information age as semiconductor technology.

In the coming decade, 2010 to 2020, compiler research will play a critical role in addressing two of the major challenges facing the overall computer field: Cost of programming multicore processors and Security and reliability of complex software systems.

Cultural Shift

To address these challenges, the compiler community must change its current research model, which emphasizes small-scale individual investigator activities on one-off infrastructures. Complete compiler infrastructures are just too complex to develop and maintain in the academic research environment.

Exploiting large-scale parallel hardware will be essential for improving an application's performance or its capabilities in terms of execution speed and power consumption. The challenge for compiler research is how to enable the exploitation of the power of the target machine, including its parallelism, without undue programmer effort.

Enable the creation of compiler research centers. There are few large compiler research groups anywhere in the world today. At universities, such groups typically consist of a senior researcher and a few students, and their projects tend to be short term, usually only as long as a Ph.D. project. Meanwhile, the few industrial groups studying advanced compiler technology tend to focus on near-term solutions, even as the compilers, the programs they translate and analyze, and the target execution environments have increased in complexity. The result is that too much of today's compiler research focuses on narrow problems, ignoring the opportunity to develop revolutionary strategies requiring long-term commitment for their development and evaluation.

The computer science community has achieved notable success in developing novel compiler infrastructures, including: compiler front-end development; program-analysis frameworks for research in compilers; verification tools, security applications, and software-engineering tools; and virtual machine frameworks for both mainstream and special-purpose languages. Even if the GNU and industry-developed compilers were a useful infrastructure for research, development of new robust, easy-to-use infrastructures by the researchers who need them are critical for future advances. Not only is it important to support such research projects, the research community must recognize their academic merit.

Compiler courses must clearly demonstrate to students the extraordinary importance, range of applicability, and internal elegance of what is one of the most fundamental enabling technologies of computer science.

Knowledge of the power and limitations of compiler algorithms is valuable to all users of compilers, debuggers, and any tool built using compiler algorithms that encapsulate many, if not most, of the important program-analysis and transformation strategies necessary for performance and correctness. Therefore, learning about compiler algorithms leads to learning about program optimization and typical programming errors in a deep and rigorous manner. For these reasons, programmers with a solid background in compilers tend to excel in their profession.

Definitivamente sería bueno que todo programador alguna vez construya su propio lenguaje de juguete aunque más no sea. Hoy por hoy hay muchas herramientas como para que esto sea una tarea más de tener ganas que de saber mucho para construir algo sencillo. Claro, si se quiere avanzar para abarcar lenguajes completos la dificultad y tiempo necesario aumenta mucho pero sigue siendo como todo una cuestión de ponerle laburo. En este sentido LayerD puede ser usado muy bien como herramienta didáctica para enseñar sobre compiladores ya que escribir un lenguaje LayerD de alto nivel es una tarea que se puede automatizar con cosas como Bison o JavaCC, para la etapa intermedia se puede usar el compilador Zoe que nos librara de la tarea de tener que diseñar y construir un analizador semántico a mano (cosa que suele ser lo más "complicado/laborioso" de un compilador por no haber prácticamente herramientas). Si se desea alterar la semántica de Zoe se puede modificar el código fuente en casos de querer cambiar mucho la semántica, o simplemente escribir un par de extensiones con classfactorys para cambios o incorporaciones no tan drásticas. Finalmente la generación de código se puede usar o modificar alguno de los generadores de código Zoe que hay.

Ojala, como dice el artículo se le dé más importancia a la investigación en relación a compiladores y en la próxima década veamos avances emocionantes al respecto. Personalmente, opino que son mucho más importantes los cambios y avances a realizar en lo que respecta al diseño de lenguajes de alto nivel que lo relacionado a mejorar los generadores de código de bajo nivel. Si bien coincido en que la generación de código optimizado y eficiente es clave, también pienso que es mucho más favorable para la ciencia de la computación y la industria del software cada vez que se logra elevar el nivel de abstracción en el desarrollo de software. Los primeros compiladores no generaban código super optimizado, sin embargo la ventaja de poder programar en un nivel de abstracción más alto le garantizo el éxito a los compiladores. El éxito de entornos de ejecución como Java y .NET no fue porque sus primeros intérpretes fueran excelentes, sí por poseer la capacidad de facilitar el desarrollo y mantenimiento del software.

Tuesday, November 11, 2008

LayerD es proyecto oficial

En estos días tuve la grata noticia de poder confirmar a LayerD como proyecto de investigación oficial reconocido por la Secretaria de Ciencia y Tecnología (SCyT) de la Universidad Tecnológica Nacional.

Por esto debo agradecer nuevamente al Ing. Juan Carlos Vazquéz por haberme incentivado a llevar el proyecto al laboratorio de la facultad y a todas las personas que me ayudaron en el transcurso de su ejecución. También al Dr. Ricardo Medel por aceptar ser director de la mencionada oficialización del proyecto.

Es muy grato haber podido, aún en una etapa relativamente temprana de su desarrollo, utilizar las herramientas y lenguajes desarrollados ya en dos proyectos comerciales, también ejecutados dentro del ámbito de Laboratorio de Investigación de Software de la Regional Córdoba como son los proyectos Janus (realizado para la mismísima Microsoft directamente) y Transito (desarrollo que se está llevando a cabo para el Gobierno de la Provincia de Córdoba).

Creo que voy a tener un poco más de tiempo en lo subsiguiente, por tanto espero poder publicar más cosas incluyendo manuales y un SDK actualizado en estos meses finales del 2008.

Sunday, October 19, 2008

El LayerD de las eminencias

Me agrada muchísimo enterarme – lamentablemente recién ahora – del trabajo de eminencias mundiales en ciencias de la computación como son:

  • Alan Kay : Creador de Smalltalk, Simula, uno de los padres inventores de la orientación a objetos en los 70, Ganador del premio Turing (para quienes no conocen son como los premios nobel en las ciencias de la computación)… bue si no sabes quién es Alan Kay se merece lo "googlees".
  • Dan Ingalls: Colaborador de Alan Kay en los míticos Xerox PARC implemento el primer compilador de Small Talk, trabajo en los equipos que inventaron las primeras UI de la historia, en los laboratorios de HP, entro otros trabajos.
  • Yoshiki Ohshima, Ian Piumarta, Andreas Raab: Todos ellos conocidos científicos de ciencias de la computación con docenas de trabajos publicados en los congresos "top" como los organizados por el ACM.

Entre otros colaboradores están desarrollando el proyecto "Steps Toward the Reinvention of Programming" el cual intenta resolver muchos de los problemas existentes en la ingeniería de software planteando (humildemente al igual que lo afirmo e intento colaborar proponiendo soluciones con LayerD) las limitaciones del software actual y sus problemas de implementación como el "bloated code", la fragilidad del software, la escasa expresividad de los programas, las limitaciones de acoplamiento del código fuente actual entre otros problemas.

Aún no he tenido tiempo de estudiar este proyecto en profundidad pero por lo que he leído es muy ambicioso y no abarca sólo la etapa de implementación.

Me resulto muy grato como para la etapa de implementación del software planean (y utilizan) mecanismos muy similares a los que uso en LayerD:

La diferencia principal de su método (principalmente está detrás de esta parte Ian Piumarta parece ser) es que utilizan lenguajes dinámicos en tiempo de compilación y ejecución. También tiene en común como tratan y hablan del problema de los lenguajes y tecnologías actuales de desarrollo en cuanto al acoplamiento a los entornos de ejecución, librerías y hardware (el ambiente) y señalan que es necesario eliminar estas limitaciones para poder "reinventar la programación". En definitiva, se trata de un proyecto que tiene mucho en común filosóficamente hablando con LayerD aunque la implementación sea diferente en varios sentidos y común en algunos otros.

No es la primera vez que encuentro que existe algún proyecto "filosóficamente" similar a LayerD, de hecho es algo que se viene buscando hace mucho tiempo lograr. Anteriormente tenía conocimiento de proyectos similares como el empuje de la Programación Orientada al Lenguaje por tipos como Sergey Dmitriev y la programación intencional impulsada por el mítico Charles Simonyi (Xerox, Microsoft, Intentional Programming); aunque estos autores no hablan demasiado del acoplamiento del software a APIs y entornos de ejecución, lo cual para mi es fundamental erradicar, sino que hablan más de utilizar paradigmas más abstractos.

LayerD se desarrollo en su formato actual alrededor de fines del año 2002, es muy grato para mi saber que aún cuando no conocía nada de estos proyectos, meta-programación, programación orientada al lenguaje o programación intencional, haya llegado a desarrollar algo muy similar a las tecnologías que estas eminencias ganadoras de premios Turing y repletas en PhD, Masters y cosas por el estilo. Me da esperanzas porque me hace pensar que en la próxima década definitivamente veremos nacer un nueva era en la ingeniería de software de la mano de algunos de estos proyectos y saber que humildemente forme parte de uno de ellos que impulsa con pasión hacia ese destino inevitable de nuestra querida profesión me hace sentir bien y tener la certeza de que no perdí el tiempo todos estos años que tanto esfuerzo – a pesar de mis limitaciones, ignorancia y falta de experiencia – puse en este proyecto.

Les dejo algunos links, y sigo estudiando :-P

http://www.vpri.org/html/work/NSFproposal.pdf

http://piumarta.com/papers/colas-whitepaper.pdf

http://vpri.org/html/work/ifnct.htm

Sunday, October 5, 2008

Hablemos de Ingeniería



El viernes pasado dí una pequeña charla en el Laboratorio de Investigación de Software de mi facultad (UTN - FRC) y duro poco más de hora y cuarto.

El objetivo era dar una introducción al proyecto LayerD a quienes no lo conocían.


Los temas de la charla fueron:

  • ¿Qué es LayerD? : una introducción en dos minutos explicando que se trata básicamente de lenguajes de programación con algunas características "novedosas" como compiladores multi-stage, extensibles y modulares.
  • Motivaciones del Proyecto : se explico como se tuvieron en cuenta los problemas actuales a la hora de implementar software, lo que se espera para el hardware de las proximas decadas y el software que se viene en los proximos años. Todo ello influyo en el diseño de LayerD.
  • Hablemos de Ingeniería : a lo largo del tiempo aprendi que no es sencillo explicar el framework LayerD y menos justificar sus características simplemente nombrandolas, por lo tanto me tome la mayor parte de la charla para hablar sobre ingeniería de software, compararla con otra ingeniería (civil) y analizar las limitaciones y frustraciones actuales de nuestra querida profeción, también introducir sobre como sobrellevar estas límitaciones. Se introdujo al tema de diseñar lo que llamo arquitecturas "bidimensionales" de software, donde no sólo se tiene en cuenta la "dimensión de tiempo de ejecución" (es decir todo lo que sucede cuando el software se esta ejecutando) sino también empezar a considerar la existencia de otra dimensión la "dimesión física". Aplicar tecnicas conocidas de diseño como la separación en capas también en esta dimensión física del software nos permite elevar considerablemente su nivel de abstracción y abrir la puerta para una mayor reutilización, tiempo de vida y menores costos de mantenimiento del software.
  • Paradigmas al Vuelo : se hablo rápidamente del impulso que se le esta dando a "nuevos" (no tanto) paradigmas que impulsan el desarrollo de software más abstracto como la orientación al lenguaje, programación declarativa, lenguajes de dominio especifico, programación intencional, model driven development, etc. Y como con LayerD es posible implementar software bajo estos paradigmas.
  • El Diseño de LayerD : Se explico brevemente el diseño y como todo encaja con los requerimientos y los problemas existentes en la ingenieria de software. Si todo salio como esperaba, se mostro porque LayerD tiene el diseño que tiene y como cada pieza y funcionalidad es necesaria.
  • Ejemplos : Se mostraron diversos ejemplos.
  • El Futuro / Lo pendiente : Se hablo de toda la inmensa lista de pendientes dentro del proyecto y como esto es apenas un punto de partida. Se invito a quienes quieran participar a ayudar a completar el proyecto o tomar lo aprendido para sus propios proyectos.
Para quienes le interese dejo las diapositivas aquí (no son tan interesantes sin el "speech" supongo je). Por cierto, si sos de la UTN recorda que todos los viernes estamos dando charlas en nuestro laboratorio, además compartimos galletas y café. Seas o no alumno de la UTN podes entrar a nuestra pequeña red social para enterarte de varias cosas que pasan en nuestro laboratorio.

Ya no pongo fechas (demasiado trabajo y terminando de cursar) pero en cualquier momento publico los manuales y actualizo la documentación además del SDK y los fuentes publicos.

Saludos.

Thursday, August 7, 2008

Programación Concurrente con LayerD

Los lenguajes LayerD actuales no definen prácticamente ninguna librería de base. Esto no es sin embargo un problema ya que LayerD está diseñado para utilizar la infraestructura de los entornos de ejecución y librerías actuales como ensamblados .NET o cualquier librería Java.

Naturalmente se puede programar sistemas concurrentes usando las librerías disponibles en las plataformas que soporten los Generadores de Código Zoe de los cuales dispongamos. Adicionalmente, y quizás mucho más interesante, al ser Meta D++ un lenguaje "extensible" (a través de classfactorys y gracias al lenguaje intermedio Zoe) es posible desarrollar "estructuras" que nos permitan programar este tipo de sistemas de manera más sencilla.

A modo de ejemplo posteo uno de los escuetos ejemplos del SDK donde se muestra una sencilla estructura que permite ejecutar una secuencia de instrucciones en paralelo (para .NET):

using Zoe::DotNET::Utils;
// Uso el Main de consola por defecto para .NET, si gusta puede usar el Main tradicional :-)
Zoe::ConsoleProgram::New{
    // Diga Hola!!
    Console::WriteLine("Welcome to new semantic structures with LayerD !!");
    //Ejecutar instrucciones en hilos separados
    Concurrent::ExecuteParallel{
        //En un hilo cuento cosas
        for(int n=0;n<40000001;n++)
            if(n%20000000==0)Console::WriteLine("I am on "+n+".");
        //En otro hilo cuento dos cosas :-)
        {
            for(int n=0;n<40000001;n++)
                if(n%2000000==0)Console::WriteLine("You are on "+n+".");
            for(int n=0;n<40000001;n++)
                if(n%2000000==0){
                    Console::WriteLine("We are on "+n+".");
                }
        }
    };
    Console::Read();
    // Fin
};

El ejemplo superior ejecutara cada instrucción dentro del bloque "Concurrent::ExecuteParallel" en un hilo diferente.

Este ejemplo sólo corre en .NET porque esta implementado usando sólo la librería de dicho entorno de ejecución. La buena noticia es que junto a mi amigo (el Ingeniero) Pablo Frias vamos a estar desarrollando en los próximos meses una librería para programación concurrente en LayerD que sea además multiplataforma (al menos Java y .NET) e incluya estructuras de "alto nivel" como tareas, ciclos paralelos, etc.

Pueden ver este ejemplo en el SDK, el cliente y la classfactory. Saludos.

Tuesday, July 22, 2008

Primer Upload de Código Fuente

Como se prometió con anterioridad empecé a subir el código fuente del proyecto LayerD para que esté disponible bajo licencias Open Source.

Los links a SourceForge:

En el primer upload de código subí los siguientes componentes:

  • Compilador Meta D++
  • Zoe CodeDOM para C++ y C#
  • Modulo de Salida Zoe para .NET
  • Modulo de Salida Zoe para Meta D++ (para compilación interactiva)
  • Generador de CodeDOM para C++ y C# (utilidad que genera las clases del CodeDOM a partir del esquema del lenguaje Zoe en XSD)
  • Una librería común usada por los módulos de salida Zoe y el compilador Zoe (cuando estos son programados para en .NET)

Para todos estos componentes utilice la licencia BSD, licencia que otorga enorme flexibilidad ;-).

Cuando revise un poco el código del compilador Zoe lo subo al repositorio de SourceForge, esta porción de código pienso usar licencia Eclipse o Mozilla (un poco más "restrictiva" que la BSD). El código de los modulos subidos varía en calidad ya que fue desarrollado durante diversas etapas :-), un poco a la apurada, un poco bien, un poco "temporal".

Bueno, los post están pobres últimamente, pero estoy preparando cosas interesantes y aplicaciones prácticas reales como software que corre en .NET escritorio, ASP.NET y J2EE sin cambios. Tampoco me he olvidado de la documentación que también la estoy revisando y actualizando. Por cierto, aparentemente LayerD se usará en una parte de otro proyecto comercial (es decir un proyecto "real" de desarrollo) más adelante les confirmo.

Por cierto, cualquier consulta sobre el código me consultan, ni hablar si quieren colaborar en algo serán más que bienvenidos ;-)

Saludos. Alexis.-

Tuesday, June 24, 2008

Inferencia de tipos de variables locales

Meta D++ (el único lenguaje LayerD de alto nivel funcional hoy por hoy) basa su semántica en una copia exacta del lenguaje intermedio de la plataforma LayerD, el lenguaje Zoe.

Zoe posee características de orientación a objetos básica como polimorfismo, ocultación y herencia. Sin embargo, algunas características disponibles en otros lenguajes de programación orientados a objetos no se encuentran disponibles nativamente. Por otro lado, Zoe (y por tanto todo lenguaje LayerD de alto nivel como Meta D++) posee un diseño modular y procesamiento programable en "tiempo de compilación". Estas características de Zoe permite programar extensiones para los lenguajes LayerD de alto nivel sin depender de los fabricantes o diseñadores de lenguajes.

En esta nota mostraré cómo es posible incorporar en Zoe (y por extensión en Meta D++) inferencia de tipos para variables locales. Esta idea es desarrollada en algunos lenguajes como C# a partir de la versión 3.0 y trata simplemente de no requerir duplicar el tipo en una declaración "infiriéndolo" de su inicialización, por ejemplo en lugar de escribir:

int a = 12;
ArrayList lista = new ArrayList();
MiTipo[] matriz = new MiTipo[4];

En C# a partir de la versión 3.0 se puede escribir lo siguiente:

var a = 12;
var lista = new ArrayList();
var matriz = new MiTipo[4];

El lenguaje Meta D++ no soporta esta capacidad nativamente que en ocasiones suele ser útil permitiendo escribir unas cuantas letras menos a los programadores y también mejorar la legibilidad del código eliminando la redundancia. Pero ello no es limitación para incorporar la característica en Zoe usando una classfactory y luego poder usarla desde Meta D++.

El código en Meta D++ para incluir esta capacidad usando una classfactory es el siguiente:

public factory class var{
public:

//Declaro el constructor de tipo por defecto
type var(){
    try{
        //Si no es llamado como parte de una
        //declaracion de variable local es un error
01        if(context.get_Parent().get_TypeName()!="XplDeclarator")
            return new XplType();
        //Obtengo la declaración
02        XplDeclarator^ decla = (XplDeclarator^)context.get_Parent();
        //Busco la primera expresion de inicialización
03        if(decla.FindNode("/e")!=null){
            //Determino el tipo a partir de la expresion de inicialización
04            return ZoeHelper::MakeTypeFromString(    ((XplExpression^)decla.FindNode("/e")).get_typeStr() );
        }
        else{
            //Si no posee expresion de inicializacion
            //busco la primera asignación
05            XplNode^ temp = context.CurrentBlock.FindNode(
                        "/a/l/n("+decla.get_name()+")");
            if(temp!=null){
                //Determino el tipo a partir de la expresion
                //derecha de la primera asignación
06                return ZoeHelper::MakeTypeFromString( ((XplAssing^)temp).get_r().get_typeStr() );
            }
        }
    }
    catch(Exception^ error){
        //Si hubo algun error emito un mensaje y luego genero un error
07        Console::WriteLine(error.Message);
    }
    //Esto generará un error de compilación
08    return new XplType();
}

}

Efectivamente el código para agregar inferencia de tipos de variables locales lleva apenas 12 líneas de código efectivo en Meta D++. Y permite ser utilizado desde un programa cliente Meta D++, por ejemplo como sigue:

static int Main(string^[] args){
    ArrayList^ test = new ArrayList();
    ///Insert code here
    var n = "hola";
    var matriz = new int[] = {1,2,3,4};
    var matriz2 = new App[4];
    var matriz3;
    matriz3 = new int[10];
    var j;
    j = 12.4f;
    var y;
    y = new App();
    return 0;
}

El ejemplo de programa cliente inferirá que "n" es de tipo "string^", matriz de tipo "int[]", j de tipo "float", etc.

¿Cómo funciona la classfactory?

La classfactory "var" utiliza un tipo de constructores especiales accesibles por classfactorys. Estos constructores se denominan "Constructores de Tipo", específicamente el usado es un "constructor de tipo por defecto" ya que no toma ningún parámetro.

Los constructores de tipos en classfactorys son llamados cada vez que un programa cliente declara una variable o nombra el tipo de la classfactory, en el caso del ejemplo cada vez que se declara una variable local de tipo "var".

A continuación explico cada una de las líneas marcadas con números del programa:

01 – Si no se trata de una declaración de variable local retorno un tipo vacio (usando "new XplType()") lo cual generará un error en el programa cliente, en este caso es lo que deseo.
02 – Obtengo el nodo de declaración, es decir el padre del contexto de llamada al constructor de tipo.
03 – Busco la primera expresión a partir del nodo de declaración, la cual será la expresión de inicialización.
04 – Si encuentro una expresión de inicialización utilizo el tipo de dicha expresión para inferir el tipo de la variable.
05 – Si no encuentro una expresión de inicialización busco una asignación.
06 – Si no encuentro una asignación es un error, emito un tipo vacio para generar el error.
07 – Si ocurre un error inesperado cualquiera capturo la excepción.
08 – Si la ejecución llega a la última línea es un error, retorno un tipo vacio para generar el error.

Resumen

Para agregar una nueva funcionalidad, en este caso inferencia de tipo de variables locales, basta con desarrollar una classfactory de una decena de líneas. Luego, la funcionalidad esta disponible en cualquier lenguaje LayerD de alto nivel sin necesitar cambiar ningún compilador o modulo generador de código, simplemente código en el mismo lenguaje que el resto de un programa ordinario LayerD. Por supuesto que no todas las nuevas funciones que querramos agregar a los lenguajes LayerD serán tan fácil de desarrollar, sin embargo, si poseeremos en nuestras manos las herramientas y la libertad para hacerlo cuando creamos que lo necesitamos sin depender de los diseñadores de los lenguajes o los fabricantes de los compiladores.

El ejemplo sencillo presentado se puede mejorar emitiendo errores usando la interfaz "compiler" o incluso permitir la inferencia de variables locales sin utilizar el tipo "var". Más interesante, toda extensión semántica para el lenguaje, como la presentada, la podemos usar sólo donde lo queremos e incluso combinar funcionalidad.

Otros tipos de extensiones semánticas que podemos desarrollar para cualquier lenguaje LayerD, por nombrar algunas, incluyen: tipos genéricos, aspectos, tipos anónimos, precondiciones y postcondiciones, tareas, bloques para ejecución en paralelo, bloques for concurrentes para matrices o colecciones, estructuras de sincronización, bloques de recuperación, y un etcétera tan largo como tu propia imaginación y capacidad.