Cuando se genera un evento en una página web, como hacer un click sobre un elemento, si dicho elemento no tiene implementada una función onclick, se busca dicha función en su elemento padre, y así sucesivamente hasta llegar al elemento body. Este mecanismo se llama emergencia de eventos o event bubbling y puede ser aprovechado para definir las funciones de tratamiento de eventos sobre un elemento padre y que se aplique sobre todos los hijos a la vez, tal y como se explica aquí. Esta sería una forma tradicional de realizarlo con jQuery:

$('#thing').click(function(e) {
  var target = $(e.target);

  if (target.hasClass('quit') return doQuitStuff();
  if (target.hasClass('edit') return doEditStuff();
  // and so on...
});

jQuery.delegate = function(rules) {
  return function(e) {
    var target = $(e.target);
    for (var selector in rules)
      if (target.is(selector)) return rules[selector].apply(this, $.makeArray(arguments));
  }
}

$('#thing').click($.delegate({
  '.quit': function() { /* do quit stuff */ },
  '.edit': function() { /* do edit stuff */ }
}));

Damien Katz, el autor de COuchDB, explica como piensa implementar la técnica de Map/Reduce que publicó Google para tratar con cantidades ingentes de datos. Damien Katz: Incremental Map/Reduce y Damien Katz: Incremental Map/Reduce/Combiner?

El ejemplo siguiente crea sus propias operaciones de combinación dentro de la función Reduce. Supongamos que tenemos una base de datos llena de recibos y queremos calcular el total gastado en un mes:

// este sería un recibo de ejemplo

{
"_id":"2DA92AAA628CB4156134F36927CF4876",
"type":"recibo"
"amount":19.95,
"note":"esto funcionara",
"year":2008,
"month":1,
"day":12,
....
"}
}

// a continuación la función Map

function (doc) {
  if (doc.type == "recibo") {
    var key = [doc.year, doc.month];
    emit(key, doc.amount);
  }
}

// y una función Reduce para calcular los totales de los recibos:

function (date, values) {
  var result = {totalSpent:0, numPurchases:0};
  for(var i=0; i<values.length; i++) {
     switch (typeof values[i]) {
     case "number":
       result.totalSpent += values[i];
       result.numPurchases++;
     case "object":
       // este es un objeto, y salida de una reducción anterior
       result.totalSpent += values[i].totalSpent;
       result.numPurchases += values[i].numPurchases;
     }
  }

  return result;

}

// Una vez guardado en un documento de diseño, se pueden obtener los valores de Enero de 2008:
// GET /db/_view/receipts/amount_spent_month?key=[2008,1] //Resultado:

{"total_rows":12,
 "rows":[
   { "key":[2008,1],
     "value": { "totalSpent": 1252.1
                "numPurchases": 13}
   }
 ]
}

Tiene sentido como usuario de OpenID. Me explico, OpenID se basa en demostrar que eres el poseedor de una URL:

1. Se introduce una URL propia
2. El servicio al que se intenta acceder consulta en esa URL quién provee OpenID
3. El proveedor solicita la clave para esa URL que demuestre que se es el propietario.

Inteligente técnica: comprobar si el usuario ha accedido a ciertos sitios de compartición de enlaces (como Del.icio.us, NetVibes, BlinkList o Google Links), comprobando si un enlace a dichas páginas se muestra como "visitado" al mostrar la página. Con esa información es posible mostrar sólo los iconos de los servicios que el visitante use en lugar de mostrar una fila de iconos sin ningún criterio. Sniff browser history for improved user experience

¿Tienes un mashup de maps? ¡Hazlo un mapplet! En Programa con Google.

cabel.name: FancyZoom 1.0 es una librería Javascript que hace un zoom muy suave de una imagen mostrada en una web al hacer clic sobre ella. No usa ningún framework Javascript adicional y pesa 53KB.

Una más que buena noticia para internet y para los estándares. En breve podremos autenticarnos en un único sitio y podremos acceder con esa cuenta a centenares de sites sin necesidad de registrarse. Ya era hora. Via OpenID Foundation.

En este post, Douglas Crockford, el descubridor de JSON, habla sobre el concepto de hilos en programación concurrente. Dice que son demasiado complejos para programar y que sólo deberían estar disponibles a bajo nivel (Sistema Operativo), pero para los lenguajes de programación que funcionan sobre él. En particular, implementar hilos en Java fue una mala idea.

O alguien estaba muy aburrido: “Este programa en Haskell tiene como salida un programa en Python que tiene como salida un programa en Ruby que tiene como salida el programa original en Haskell”. Delirante.
A Neighborhood of Infinity: A Third Order Quine in Three Languages. Visto en Anarchaia.org.

Emezeta Card PHP Cheat Sheet es una chuleta u hoja de referencia para PHP. Es la más completa que conozco. Con diferencia.
Via aNieto2K.

No es más que una breve reflexión sobre como implementar consultas de tipo SQL sobre conjuntos de datos y notación de objetos en Javascript.

table1 = { rows: [ {a:1, b:2} , {a:1, b:5} , {a:1, b:3} , {a:5, b:7} ] } // definición del conjunto de datos

// un from filtra los objetos con los que vamos a trabajar
from(table1)
> { rows: [ {a:1, b:2} , {a:1, b:5} , {a:1, b:3} , {a:5, b:7} ] }

// el where se especifica con la potencia de una función javascript
from(table1).where( function(row){return row.a==1} )
> { rows: [ {a:1, b:2},  {a:1, b:5} , {a:1, b:3} ] }

// finalmente el select indica que campos se "copian" del objeto filtrado resultante
from(table1).where( function(row){return row.a==1} ).select('b')
> [ {b:2},{b:5},{b:3} ]

// la ordenación es simple también
elms= from(table1).where( function(row){return row.a==1} ).select('b').orderby('b')
> elms= [ {b:2},{b:3},{b:5} ]

// así se accedería a la estructura resultante
elms[2].b
> 5

Amazon Web Services Developer Connection ElasticDB es una alternativa de bajo coste a la base de datos Amazon Simple DB. ElasticDB funciona en estrecha conjunción con Amazon Simple Storage Service (Amazon S3) a través de ElasticDrive, el servidor de base de datos CouchDB y de Amazon Elastic Compute Cloud (Amazon EC2), facilitando la habilidad de almacenar, procesar y hacer consulta de conjuntos de datos a una fracción del coste que supondría hacerlo con Amazon SimpleDB. Características:

• Un servidor de base de datos de documentos (CouchDB), accesible via una API RESTful basada en JSON.
• Sin esquemas y con un espacio de direcciones plano. (todo en una tabla).
• Replicación incremental robusta distribuida con gestión y detección bidireccional de conflictos.
• Consultable e indexable, con un motor de informes orientado a tabla que usa Javascript como lenguaje de consulta.

Acerca de CouchDB

Más que interesante tutorial de javascript ant sobre las técnicas usadas para crear las famosas librerías de Javascript (Prototype, jQuery, MooTools, YUI, o Dojo).

Interview: Simon Willison on OpenID (Yahoo! Developer Network blog). Y también Yahoo! OpenID Provider service now available as a public beta. Servicio de provisión de OpenID disponible como beta pública. Esperemos que su compra por Microsoft no frene la innovación que empezaba a verse desde Yahoo!

PHP.js es una librería javascript con muchas de las funciones de uso frecuente en PHP (como utf8_encode o include) pero portadas a Javascript. Via aNieto2K.

Scott Klarr publica una recopilación de chuletas (hojas de referencia) de Javascript, jQuery y Ajax.

Chickenfoot es una extensión para Firefox que permite trabajar con la interfície del navegador, usar un shell interactivo para manipular la página, monitorizar las interacciones con las páginas o escribir scripts (guiones) que funcionan con varios sites. Por ejemplo, un script podría visitar una página, copiar texto de una parte de ella, ir a Google, buscar ese texto y guardar el primer enlace de los resultados en un archivo de texto local. Se trata de una herramienta muy potente, similar a IBM CoScripter, que permite realizar acciones muy complejas que hasta ahora era necesario realizar manualmente.

go("http://www.google.com/")
click("Images")
go("http://images.google.com/imghp?hl=en&tab=wi")
enter("Sign in", "koalas")
click("Search Images button")
go("http://images.google.com/images?hl=en&q=koalas&btnG=Search+Images
&gbv=2")

Phil Hassey ha creado tinypy 64k que es una implementación en 64k de un subconjunto de Python. Puede arrancarse como un ejecutable que compila ficheros Python en bytecode (código intermedio como el de Java) y ejecutarlos sobre una máquina virtual.

Un más que interesante análisis del coste de desarrollar con ciertos navegadores y el beneficio asociado a ello. Por ejemplo, los de Microsoft tienen un coste altísimo debido a la infinidad de errores que generan, pero por desgracia son los más usados por los usuarios por lo que de alguna forma el esfuerzo se ve compensado. Esto mejora terriblemente con Firefox, que da muy pocos problemas pero tiene una base de usuarios grande. Via John Resig - The Browsers of 2009

Según John Resig, se está llegando a un acuerdo para incluir una API de convertir un objeto JSON a cadena y viceversa. La idea es tener un método rápido para su uso cuando se quiera intercambiar información con un servidor. Mozilla ya lo tiene implementado pero sólo internamente (accesible para las extensiones y XUL). Sólo tienen que llegar a un acuerdo para respetar un estándar a la hora de acceder a esa funcionalidad.

Clusterer es un objeto añadido a la API de Google Maps. Es capaz de manejar un gran número de marcadores sobre un mapa, miles es necesario, pero sin convertir al navegador en una tortuga como pasaría al intentar mostrarlos directamente via la API oficial. Clusterer usa dos técnicas para lograrlo:

• Sólo los marcadores visibles actualmente son creados.
• Si demasiados marcadores serán visibles, entonces se agrupan en marcadores agrupados.

Definir un objeto Console si no está creado para que no dé errores en caso de no existir:

if (! ("console" in window) || !("firebug" in console)) {
    var names = ["log", "debug", "info", "warn", "error", "assert", "dir", "dirxml", "group"
                 , "groupEnd", "time", "timeEnd", "count", "trace", "profile", "profileEnd"];
    window.console = {};
    for (var i = 0; i < names.length; ++i) window.console[names[i]] = function() {};
}

CouchDB for Helma: zumbrunn.com/mochazone Para hacerse una idea de la sencillez de CouchDB:

var c = new CouchDB('testing','localhost',8888);
c.createDb();
c.save({ title:'Testing', content:[1,2,3] }); 

Simon Willison ha echado un vistazo a la tecnología Comet (envio de información desde el servidor al navegador a través de una conexión persistente) y ha quedado sorprendido de la facilidad de uso. Resulta chocante la cantidad de código que usa para crear un cliente que muestra diapositivas publicadas por un servidor Comet:

dojo.require("dojox.cometd");
jQuery(function($) {
 dojox.cometd.init("http://example.com/cometd");
 dojox.cometd.subscribe("/slideshow/change", function(comet) {
  $('#currentSlide').attr('src', comet.data.src);
 });
});

La idea es convertir este código...

  
Megadeth Show Last Night
  Posted by Chris on June 4th
  

    Went to a show last night. Megadeth. 
    It was alright.
  

  
Megadeth Show Last Night
  Posted by 
    Chris 
    on 
    June 4th
  
  

    Went to a show last night. Megadeth. It was alright.
  

Recomiendo la lectura de las técnicas que usan en Clientside para tratar errores que puedan aparecer en código Javascript.

En Opera Developer Community han realizado una pequeña demo que, aprovechando la etiqueta canvas de los navegadores modernos (un recuadro en el que se puede dibujar), han creado una simulación que implementa leyes físicas para que un conjunto de objetos reaccionen como en la realidad al colisionar entre sí.

flickr.places.findByLatLon es un nuevo método de la API de Flickr que permite encontrar fotos a partir de sus coordenadas geográficas.

John Resig - Server-Side JavaScript with Jaxer La gente de Aptana acaba de publicar Jaxer. La idea es llevar una parte del navegador al servidor (a diferencia de servidores de aplicaciones como Helma, Persevere y otros que implementan javascript en ese lado) pero como una capa más entre el servidor de aplicaciones (Apache, Resin, Tomcat, Jetty, ...) y el cliente. Está basado en el motor de Mozilla, así que puede imaginarse como un navegador capaz de generar páginas, modificarlas dinámicamente con Javascript (incluso usando librerías), pero se ejecuta como un proceso independiente del lado del servidor. La página generada contendría secciones de javascript con posibles tags runat="server" o runat="both" que indicarían que el código se puede ejecutar también en el lado del servidor. El siguiente ejemplo muestra un textarea al usuario y al mismo tiempo permite guardar lo que el usuario introduzca en un archivo del servidor.

< html>
< head>
  
  
  
< /head>
< body onserverload="load()">
  

    
    
  
< /body>
< /html>

Se trata básicamente de Mozilla corriendo detrás de Apache en el lado del servidor, pero extendido con la funcionalidad del servidor que podrías esperar (API ), como leer y escribir archivos, acceder a bases de datos y otra comunicación externa. Pero dado que la parte del servidor se ejecuta dentro de un entorno de navegador completo, que incluye no sólo el DOM sino también CSS y toda la funcionalidad Javascript del cliente, incluyendo peticiones XMLHTTP y todo lo demás. Así puedes trabajar en ambos lados sin estar cambiando de estado mental continuamente.

Los chicos de Helma acaban de sacar un nuevo núcleo experimental para su servidor de aplicaciones en Javascript OpenMocha (Mocha es el nombre original de Javascript). La idea es aplicar lo que ellos llaman soft-coding o codificación suave, cuyo concepto clave es crear sobre la marcha la aplicación mientras se está ejecutando haciendo las modificaciones directamente (editándolas desde el mismo navegador, un paso más de la interpretación de código). zumbrunn.com/mochazone/e4xd and jhino - javascript server-side soft-coding/

Este artículo de A list apart parece que va a implicar un enorme cambio en cuanto al comportamiento de los navegadores y la ya famosa etiqueta DOCTYPE que aparece al principio de cada documento HTML. Aunque su intención original era establecer el tipo de motor que debía usarse para renderizar la página, la actualización de la última versión del Internet Explorer (después de pasar la eternidad de 5 años congelado) ha roto multitud de páginas creadas con el IE6 en mente. Proponen usar una etiqueta META con los navegadores target con los que se ha probado la página durante su creación, de forma que sea responsabilidad de los futuros motores mostrar la página de la mejor forma posible para mantener la compatibilidad. Personalmente me maravilla la cantidad de estándares y soluciones que la actitud de Microsoft obliga a la industria a crear. Tienen la enorme suerte de mantener el parque más grande de usuarios pero si en algún momento eso deja de ser así, el desprecio acumulado por tantos años va a hacer que todo el mundo ignore a esta empresa. Supongo que se lo merecerán. Via Simon Willison en Beyond DOCTYPE: Web Standards, Forward Compatibility, and IE8 y A quote from Eric Meyer.

Acaba de liberarse la beta 2 de MooTools MooTools 1.2. A parte de contar con 5 veces más documentación que hasta ahora (el conocido punto débil de esta framework), han creado el concepto de accesores (accesors) que permite establecer varios cambios a la vez y opciones predefinidas. Otros cambios son más facilidad para acceder a las dimensiones, desplazamientos, y altura visible de los elementos. También se introduce el concepto de almacenamiento de elementos o element storage para evitar los problemas de almacenar variables en los elementos del DOM. Se crea un sistema más adecuado mediante las funciones store y retrieve.

Telegraph to become OpenID provider : Telegraph Blogs. Me encanta cuando de repente empiezan a aparecer soportes por todas partes para una nueva tecnología. En este caso se puede afirmar que OpenID es the next big thing (la siguiente gran tendencia).

Me he encontrado con este artículo del blog Programa con Google y a la vez con esta clase PHP que reduce el tiempo de carga en un 500% con 3 líneas de código.

Alex Bosworth ha creado un foro usando la nueva SimpleDB de Amazon, y los resultados no parecen muy alentadores:

• No hay ordenación, lo que obliga a realizar continuamente toda clase de rodeos para evitar esta característica. Además prácticamente obliga a devolver todos los registros para poder hacer la ordenación manualmente.
• Los datos están limitados a 1024 bytes. La solución no es trivial, si se pretende segmentar la información en bloques de ese tamaño, no hay garantías de volver a obtener la información correcta al no existir ordenación (punto anterior). La alternativa es usar Amazon S3 para estos casos, pero parece demasiado engorroso.
• No hay identificadores autoincrementales, por lo que hay que apañarselas para generar cadenas únicas que identifiquen los registros. La hora exacta actual puede ser una buena idea.
• No hay consistencia, por lo que la información puede tardar hasta 20 segundos en verse reflejada por parte de Amazon. Eso quiere decir que si después de insertar información se vuelve a cargar una página (algo que hacemos casi todos siempre), es posible que el dato acabado de introducir no aparezca con lo que ello implica.
• No hay tipos. Lo cual puede verse como algo positivo, pero que no lo es tanto cuando se echa a faltar el "null", lo que distingue la falta de valor en un campo. Eso implica que al introducir un nuevo campo en una tabla hay que inicializar el valor en todos los registros existentes.
• No es posible obtener multiples filas de datos. Para la aplicación que ha creado Alex, mostrar la primera página le requiere obtener todos los registros de la tabla de hilos y también todos los registros de la de mensajes, debido una vez más a que no existe ordenación. Esto puede además disparar la factura que se le paga a Amazon mensualmente, ya que son factores el ancho de banda y el número de consultas.

Amy Editor es un editor online de código fuente para desarrolladores. Soporta JavaScript, Ruby, PHP, C#, Java, HTML, YAML, etc. Tiene resaltado de sintaxis, indentación inteligente para cada lenguaje, deshacer (undo) ilimitados, atajos de teclado personalizables, auto-completado de palabras (tecla ESC), etc.

También puede ser integrado fácilmente en cualquier página web, por lo que pueden empezar a aparecer entornos de programación completos (IDEs) online y facilitar enormemente realizar cambios a aplicaciones web.

Via WebAppers.

Desde ahora, es posible indicar la URL de un blog propio como identificador de OpenID 1.1 desde cualquier sitio que lo solicite. Via Blogger in Draft.

Acaban de venirme tres noticias seguidas del blog de Simon Willison sobre el reciente OpenID de Yahoo!.

1. openid.yahoo.com. Guía para humanos de OpenID con Tour. Parece que están interesados en un sello asociado con el equipo para evitar el phishing.
2. Ash Patel a través de Willison: Un ID de Yahoo! es una de las cuentas más útiles y reconocibles de internet y con nuestro soporte de OpenID, aún será más potente. Soportar OpenID da a nuestros usuarios la libertad de llevar su ID dentro y fuera de la red de Yahoo!, reduciendo el número de usuarios y claves que necesitan recordar y ofreciendo un solo socio fiable para que gestione tu identidad online.
3. Yahoo! anuncia soporte para OpenID. Nota de prensa oficial: "El soporte de Yahoo! triplica el número de cuentas OpenID a 368 millones". Se menciona la identidad dirigida; se habilitará para yahoo.com y para flickr.com. La beta pública se inicia el 30 de Enero.

Parece que se ha cerrado una operación de compra de MySQL por parte de Sun, la compañía de Java. Sun To Acquire MySQL. Via Simon Willison.

Tutorial en The Art and Science of JavaScript [JavaScript & AJAX Tutorials].

Limitaciones por navegador y servidor web:

• Internet Explorer: 2083 carácteres
• Firefox: 65536 carácteres
• Safari: 80000 carácteres
• Opera: 190000 carácteres
• Apache: 4000 carácteres
• Microsoft Internet Information Server (IIS): 16384 carácteres
• Perl HTTP::Daemon: 8000 carácteres

El mínimo por tanto serían los 2000 carácteres del IE (cómo no) aunque probablemente con las versiones nuevas se amplie considerablemente. Muy útil a la hora de crear bookmarklets.
Via aNieto2K.

Ian McKellar ha creado un sistema sencillo para autenticarse en un sitio con OpenID desde un móvil. Ha usado Twitter para permitirle enviar un SMS con un código temporal que servirá como prueba de que se posee el móvil y por tanto la identidad solicitada. Simple y efectivo. Via A simpler mobile OpenID workflow?.

Interesante componente para seleccionar varios elementos de un mismo conjunto desde el teclado y con la ayuda del autocompletado, imitando el iPhone.
Devthought » TextboxList meets Autocompletion

Nunca he oido a nadie de la comunidad REST decir que construir sistemas distribuidos fuese "fácil". [...] Los defensores del WS-* (SOAP) han estado obsesionados históricamente con hacer las cosas fáciles, generalmente para un analista de negocios imaginario que no se acerca al nivel tecnológico que ellos tienen. Los defensores de REST, por otra parte, parecen mucho más interesados en mantener todo el sistema simple y para todos los que lo usen.
- Ryan Tomayko.

Via Simon Willison. Las negritas son mías.

Es prácticamente imposible enseñar buena programación a estudiantes que han tenido una exposición previa al BASIC: como programadores potenciales están mutilados más allá de toda esperanza de regeneración.

Edsger Dijkstra

Douglas Crockford's The Department of Style - Basic.

Después del éxito de la prueba mítica de Acid 2 para indicar la compatibilidad de los navegadores con los estándares y con su cada vez mayor adopción, aparece una nueva versión Acid3 (aún no definitiva) de la misma prueba que además tiene tests para Javascript/ECMAScript. Via John Resig

Es bien conocido el problema que aparece al trabajar con Ajax e intentar hacer peticiones a un servidor de un dominio distinto al de la página que solicita la información. Por seguridad no se permiten fácilmente dichas conexiones, obligando a usar proxies u otras técnicas. Esta propuesta del w3C propone la creación de listas de acceso para dar mayor control a los documentos del lado del cliente sobre a qué sitios se permite y a cuales no realizar peticiones desde el documento.

La idea es que desde las mismas cabeceras de la página servida (o sea, desde el propio servidor y sin posibilidad de modificarlo una vez recibido por el cliente) se indiquen los sitios con los que se puede conectar.

Addendum: Firefox 3 ya implementará este mecanismo, además de uno equivalente basado en un archivo XML en el raíz del sitio tal y como explica John Resig.

La última versión de la API de Google Maps ya soporta los otros sistemas de Google como Marte y la Luna. Ahora se pueden hacer los típicos mashups con otros planetas.

Via Blog "Programa con Google".

Este diagrama explica las relaciones entre objetos, funciones y prototipos de Javascript.
Javascript Object Hierarchy.

Este plugin implementa el protocolo Bayeux (la esencia de Comet) en jQuery. Actualmente soporta handshake (protocolo de inicio de conexión), subscripciones, enlace de callbacks en el sistema de eventos de jQuery basado en nombres de canales.

Seguramente esto despegue al igual que dojox.cometd.

Via Comet Daily y Simon Willison.

Cualquier URL de página de usuario de Flickr podrá ser usada como identificador de ese usuario. Siguiendo el estándar OpenID, Flickr pedirá su propia clave para demostrar que quien intenta acceder es el propietario de la página, certificando de esa forma la identidad del usuario.

OpenID es un sistema de identificación digital descentralizado, con el que un usuario puede identificarse en una página web a través de una URL y puede ser verificado por cualquier servidor que soporte el protocolo.

Son buenas noticias por la enorme cantidad de usuarios de Flickr / Yahoo existentes que tendrán un lugar para demostrar su identidad siguiendo el estándar.

Via ReadWriteWeb y Simon Willison.

syntaxhighlighter es una librería 100% javascript que ayuda a publicar pedazos de código online con facilidad y que tengan muy buena pinta. La he instalado en este mismo blog y se puede ver en posts anteriores. Ejemplo:

En Javascript claro. Con gráficos. Va a costar años quitar la mala fama del lenguaje debida a las implementaciones de los navegadores. Esto ayuda. p4wn.

Caja es un proyecto de Google que permite ejecutar scripts de terceros sin temer por la seguridad. Caja limpia la parte de Javascript del contenido a publicar eliminando aquellas partes que puedan ser usadas para un escalado de privilegios que permitiera inyectar código malicioso.

Curiosamente, como parte de este proyecto es posible inspeccionar la librería json.js que se usa internamente en Google para convertir una cadena JSON en un objeto Javascript sin usar la función Eval (que permitiría cualquier cosa al contenido a insertar suponiendo una brecha enorme para la seguridad de la aplicación web). Tal y como explican en javascript ant y el propio Douglas Crockford en este artículo.

DataPortability.orges un sitio dedicado a la portabilidad de datos. Como usuarios, la identidad, fotos, videos y otras formas de datos personales deberían ser descubribles y compartidos por las herramientas o proveedores que decidamos. Es necesario un estándar como DHCP para la identidad. Un sistema de archivos distribuido para los datos. Esta página listará los estándares y colaboradores que están haciendo que pase.

Los estándares son OpenID (autenticación de usuarios), OAuth (autenticación de APIs), XMPP (mensajería instantánea), RSS (sindicación de contenidos), APML (perfil de intereses), yadis (descubrimiento de servicios de identidad), OPML (suscripciones), hcard (datos personales) y xfn (relaciones).

Lo cierto es que hay en marcha un montón de proyectos muy útiles que necesitan una fuerte cohesión para resultarlo aún más.

EditArea y CodePress son dos plugins que permiten disponer de un completo editor de código fuente en una página web. Tiene búsqueda y sustitución de texto, sintaxis resaltada y correspondencia de paréntesis.

Me he permitido traducir el interesante artículo de Morris Johns sobre clausuras ( JavaScript Closures for Dummies | Developing thoughts > Morris Johns ) :

JavaScript Closures (Clausuras) para torpes

Las clausuras no son mágicas

function decirHola(nombre) {
 var texto = 'Hola ' + nombre;
 var decirAlerta = function() { alert(texto); }
 decirAlerta();
}

Un ejemplo de una clausura

• Una clausura son las variables locales de una función - mantenidas vivas después de que la función haya retornado, o también
• una clausura es una estructura de pila que no se desasigna cuando la función retorna (como si una estructura de pila se asignara en lugar de permanecer en la pila principal).

function decirHola2(nombre) {
 var texto = 'Hola ' + nombre; // local variable
 var decirAlerta = function() { alert(texto); }
 return decirAlerta;
}

function() { alert(texto); }

Más ejemplos

Ejemplo 3

function decir667() {
 // Variable local que termina en la clausura
 var num = 666;
 var decirAlerta = function() { alert(num); }
 num++;
 return decirAlerta;
}

Ejemplo 4

function estableceUnasGlobales() {
 // variable global que termina dentro de la clausura
 var num = 666;
 // almacena algunas referencias a funciones como variables globales
 gAlertaNumero = function() { alert(num); }
 gIncrementaNumero = function() { num++; }
 gPonNumero = function(x) { num = x; }
}

Ejemplo 5

function construyeLista(lista) {
 var resultado = [];
 for (var i = 0; i < lista.length; i++) {
  var item = 'item' + lista[i];
  resultado.push( function() {alert(item + ' ' + lista[i])} );
 }
 return resultado;
}
function testLista() {
 var fnlista = construyeLista([1,2,3]);
 // uso j sólo para prevenir confusión con i    
 for (var j = 0; j < fnlista.length; j++) {
  fnlista[j]();
 }
}

puntero = function() { alert(item + ' ' + lista[i]) };
resultado.push(puntero);

Ejemplo 6

function decirAlicia() {
 var decirAlerta = function() { alert(alicia); }
 // variable local que termina estando dentro de la clausura
 var alicia = 'Hola Alicia';
 return decirAlerta;
}

Ejemplo 7

function nuevaClausura(algunNum, algunaRef) {
 // variables locales que terminan dentro de la clausura
 var num = algunNum;
 var unArray = [1,2,3];
 var ref = algunaRef;
 return function(x) {
  num += x;
  unArray.push(num);
  alert('num: ' + num + 
  '\nunArray ' + unArray.toString() + 
  '\nref.algunaVar ' + ref.algunaVar);
 }
}

Resumen

• Cuando se use function dentro de otra función, se usa una clausura.
• Cuando se use eval() dentro de una función, se usa una clausura. El texto que evalúas puede referenciar variables locales de una función, y dentro del eval puedes incluso crear nuevas variables locales usando eval('var foo= ...
• Cuando uses Function() dentro de una función, no se crea una clausura. (La nueva función no puede referenciar variables locales de la función llamando Function() ).
• Una clausura en javascript es como mantener copia de todas las variables locales, justo como estaban cuando la función retornó.
• Es mejor pensar que una clausura se crea siempre en el momento de la entrada a la función, y que las variables locales se añaden a esa clausura.
• Un nuevo conjunto de variables locales se mantiene cada vez que una función con una clausura es llamada (Dado que las funciones contienen una declaración de función en su interior, una referencia a esa función interior es retornada o bien se mantiene una referencia externa de alguna manera).
• Dos funciones podrían parecer que tienen el mismo código pero podrían tener un comportamiento totalmente distinto debido a su clausura 'oculta'. No creo que el código javascript pueda realmente averiguar si una referencia a función tiene una clausura o no.
• Si estás intentando hacer cualquier modificación de código fuente ( por ejemplo: miFuncion = Function( miFuncion.toString().replace(/Hola/,'Buenas')); ), no funcionará si miFuncion es una clausura (Desde luego, nunca nunca pensarías en hacer sustituciones de cadenas sobre código fuente, pero ... ).
• Es posible obtener declaraciones de funciones dentro de declaraciones de funciones dentro de funciones - y puedes obtener clausuras a más de un nivel.
• Creo que normalmente una clausura es la definición usada para ambos, la función y las variables que son capturadas. Ten en cuenta que no uso esa definición en este artículo.
• Sospecho que las clausuras de javascript difieren de las que se encuentran normalmente en los lenguajes funcionales.

Enlaces

• TrimBreakpoint hace un uso rebuscado de las clausuras para dejarte inspeccionar las variables locales de una función desde una ventana emergente de breakpoint (punto de ruptura de la ejecución).
• Douglas Crockford ha simulado atributos y métodos privados para objetos usando clausuras.
• Una gran explicación de cómo las clausuras pueden causar fugas de memoria en IE si no tienes cuidado. Al menos con las versiones anteriores a la 7.

Gracias