Qué es Joose

Qué es el framework Joose

Fuente del Joose

El código fuente de Joose es hosteado en GitHub

Joose

Es una librería open-source de JavaScript que soporta clases, herencia, mixins, traits y programación orientada a aspectos. Su sistema de objetos es multiparadigma, soporta el estilo de programación basado en clases y en prototipos. Joose se especializa en dotar al lenguaje JavaScript de técnicas de programación exitosas, por eso se lo usa a menudo con otros frameworks orientados al DOM/Ajax, como jQuery, YUI, Dojo, Prototype, Mootools y PureMVC.

Ejemplos de clases con Joose

A continuación implementamos dos clases con Joose: la clase Punto y la clase Punto3D

Class("Punto", {
    has: {
        x: {is: "rw"},
        y: {is: "rw"}
    },
    methods: {
        clear: function () {
            this.setX(0);
            this.setY(0);
        }
    }
});

Class("Punto3D", {
    isa: Punto,
    has: {
        z: {is: "rw"}
    },
    after: {
        clear: function () {
            this.setZ(0);
        }
    }
});

Punto3D es una subclase de Punto. Tiene un atributo más y un código adicional que corre antes del método clear() de su superclase. El valor "rw" significa que el atributo del objeto se de lectura y escritura, es decir que automáticamente se generan los métodos de acceso get() y set().

Qué es POE Perl

El POE o Perl Object Environment es una librería de módulos escrita en Perl por Rocco Caputo y otros. Originalmente fue desarrollada como el núcleo de un entorno de ejecución y servidor de objetos persistentes. Evolucionó en un framework de propósito general para multitarea y networking, abarcando y proveyendo una interfaz consistente para otros bucles de eventos tales como Event y los toolkits Tk y Gtk.

Capas de abstracción: Arquitectura POE

POE puede ser pensado como un pequeño sistema operativo modular. Uno o más programas o instancias POE pueden correr juntas en forma concurrente y son generalmente muy adecuadas para multitarea colaborativa. El paquete POE consiste en abstracciones y namespaces que guian el futuro desarrollo de POE en una convención abierta-cerrada al estilo CPAN.

La capa de evento

La arquitectura informal consiste en un conjunto de capas con un kernel de fondo. Este pequeño kernel representa la capa de eventos, los cuales operan como el loop principal de cada instancia POE que está corriendo. La primera llamada es al "despachador de eventos" - POE::Kernel.

La capa I/O

El próximo requerimiento del Kernel es para los manejadores de Input-Output que existen en una sola capa de I/O llamada Wheels. Wheels inicia acciones, maneja los resultados de eventos de bajo nivel y produce eventos de alto nivel para las sesiones que los usan. Wheels es construido como un conjunto uniforme de abstracciones - POE::Wheel, que se sitúa por encima del Kernel. Hay siete Wheels en la distribución base de POE que son altamente especializados y bien definidos.

La capa de archivos

Los manejadores que realmente trabajan leyendo y escribiendo archivos. Se construyen de acuerdo a definiciones menos abstractas contenidas en el módulo POE::Driver.

Componentes POE

Varios paquetes más grandes han sido escritos en POE de acuerdo a la documentación POE::Component. Estos módulos son manejadores de eventos, la mayoría de los cuales son pequeños demonios que proveen servicios a paquetes más grandes a los que pertenecen. Algunos facilitan comunicaciones de alto nivel entre módulos, especialmente a aplicaciones que necesitan mantener independencia del resto de la distribución Perl.
En general los componentes POE son procedimientos de alto nivel que realizan grandes tareas. Por ejemplo:

• Component::Server::TCP - un servlet TCP de propósito especial
• Component::Client::TCP - un cliente TCP POE-aware
• POE::Component::IRC - un cliente IRC con casi todas sus funcionalidades
• POE::Component::Server::IRC - un servidor IRC bajo desarrollo
• POE::Component::UserBase - un servlet para persistencia de datos y autenticación de usuarios

Los componentes POE tienden a ser librerías altamente reusables que manejan tareas tediosas, liberando a los programadores para que se enfoquen en hacer cosas más interesantes. 

Testear con Perl una expresión regular

En la vida de todo programador Perl hay un momento especial en el que hay que escribir una expresión regular. Entonces nos encontramos con que nuestro patrón matchea con más o menos de lo esperado. O nada en realidad.
Este script es util para testear nuestros patrones de ExpReg con algún string y ver si matchea y dónde matchea:

    #!/usr/bin/perl

    # lee una linea de entrada a la vez
    while (<>) {
      chomp;
      if (/YOUR_PATTERN_GOES_HERE/) {
        # codigo misterios! ver explicacion
        print "Matched: |$`<$&>$'|\n"; 
      } else {
        print "No match.\n";
      }
    }

Este script es un test para que lo usen los programadores, no los usuarios finales. Por eso no tienen ningún prompt ni información de cómo se usa. Toma cualquier número de líneas como entrada y chequea cada una contra el patrón que colocas en lugar de "YOUR_PATTERN_GOES_HERE". Para cada línea que matchea se ejecuta el "codigo misterioso". Lo que hace es colocar entre paréntesis angulares el string que coincide con el patrón. Por ejemplo si el patrón es /match/ y la línea de entrada es antesmatchdespues, la salida dirá "antes<match>despues". De esta forma se hace más visible con qué parte de la cadena matchea el patrón. Prueba y verás!

Un poco de Javascript avanzado

Se trata de una traducción que tiene algunos años, espero que les guste:

Hey, yo no sabía que podías hacer eso

Si tú eres un desarrollador web y vienes del mismo lugar que yo, probablemente has usado un poco de Javascript en tus páginas web, la mayoría para pegar la interface de usuario (UI).

Hasta hace poco, conocía que Javascript tenía más capacidades OO que las que empleaba, pero no me sentía a gusto para usarlas. Cuando los navegadores comenzaron a soportar más características normalizadas de DOM y Javascript, me pareció viable escribir código más complejo y funcional para correr en el cliente. Esto ayudado por el nacimiento del fenómeno AJAX.

Cuando comenzamos a aprender lo que toma escribir nuestras buenas aplicaciones con AJAX, empezamos a notar que el Javascript que solemos usar es realmente tan sólo la punta del iceberg. Vemos ahora que Javascript se usa más allá de los quehaceres simples de UI como la comprobación de la entrada y otras tareas frívolas. El código del cliente ahora es mucho más avanzado y compuesto, tanto como una aplicación real de escritorio o un cliente pesado de un ambiente cliente-servidor. Vemos las librerías de clases, objetos modelo, jerarquías, patrones, y muchas otras cosas que acostumbramos sólo ver del lado del código del servidor. 

Ver más...