La práctica se basaba en realizar un sistema para resolver tableros de shikaku, mediante el algoritmo de vuelta atrás. Mi solución es óptima pero no del todo correcta desde un punto de vista académico, ya que el uso del algoritmo (de backtracking) es menos usado de lo que debería.

Para poder ver el código, este puede descargarse a través de un cliente de Subversion, en sistemas Unix/Linux es tan fácil como:

svn co http://project.bosqueviejo.net/svn/shikaku/trunk

Explicación del código

Bueno, tengo que reconocer que, después de algo más de un año de haberlo hecho, he tenido que releer y revisar de nuevo todo para acordarme (y reaprender) cómo hace lo que hace.

Por ello, voy a escribir una documentación básica sobre el código en sí, para tenerla como referencia, cuando tenga que volver al mismo otra vez, y para que sirva a todos aquellos que lo necesiten.

En principio, el código se divide en las siguientes clases:

• shikaku.tablero.Combinacion: esta clase se encarga de almacenar combinaciones. Una combinación es un rectángulo que se sitúa ocupando un espacio de X*Y=N. La combinación debe de tener en alguna de sus casillas el número contenido, por lo que se almacena también la ordenada de N para comprobaciones.
• shikaku.tablero.Ordenada: es cada uno de los números que aparecen en el tablero. Se almacena su posición dentro del tablero y la representación numérica del mismo.
• shikaku.tablero.Tablero: almacena las dimensiones del tablero, la lista de combinaciones fijas (las que solo tienen una combinación válida detectada) y la lista de soluciones posibles para el tablero.

Una ejecución de shikaku tiene los siguientes pasos:

1. Entra en main de la clase shikaku, donde se detecta el origen de datos, hasta saber de donde se va a cargar el tablero.
2. En run se crea una instancia del tablero, y se ejecuta, para cada punto del tablero, el generador de la clase Combinacion.
3. El generador se encarga de buscar combinaciones válidas para el punto dado, dentro del tablero y validando su posición dentro del tablero (es decir, que no haya parte del rectángulo fuera) y con respecto al resto de puntos (que no tenga contenido nada más que el punto del que tiene que hacer la combinación).
4. El último paso para la resolución, es llamando a buscaSoluciones, de la clase Tablero, que se encarga de realizar el algoritmo de vuelta atrás para buscar las soluciones al tablero.

Estos son los pasos más importantes dentro del código para resolver el tablero de shikaku.

La depuración

Uno de los motivos por los que el algoritmo no es del todo de tipo vuelta atrás, es precisamente por el uso de tres algoritmos voraces que se ejecutan antes que el último, de vuelta atrás. Estos algoritmos realizan una criba sobre las combinaciones basándose en tres premisas que debe cumplir cada combinación para ser válida:

1. Que no haya nada fuera del tablero: esto se realiza mediante una simple validación a la hora de generar las combinaciones. Es simple y rápida, y quita mucho procesamiento al algoritmo final.
2. Combinaciones con un solo número: esto se refiere a que dentro del rectángulo que conforma la combinación, solo esté contenido el número objeto de la combinación y ningún otro. Esta validación también está incluida a la hora de generar las combinaciones, para lo que se necesita, en el generador, pasar todos los puntos del tablero.
3. Eliminar combinaciones imposibles: imposibles, además de las que se descartan en los puntos anteriores, son las que colisionan con todas y cada una de las combinaciones posibles de otro número vecino. Si la combinación de un número colisiona con todas las combinaciones posibles de otro número, como es lógico, no podrá ser posible.

Ciertamente, con estos algoritmos se llega a resolver un alto porcentaje de los tableros básicos, sin necesidad de realizar el algoritmo de vuelta atrás. Solo los tableros grandes y con dificultad alta, necesitan, además de estos algoritmos voraces, el de vuelta atrás.

Mejoras

En sentido académico, teniendo en cuenta uno de los requisitos que se pide, que es que sea un algoritmo de vuelta atrás, quizás sea más correcto que la depuradora actúe solo a nivel de rama y no en profundidad.

Hay que tener en cuenta que esto penalizaría el rendimiento y empeoraría en lo que a gestión de memoria se refiere, pero prima más cumplir con los requisitos

Entradas relacionadas:

1. Algoritmos heurísticos y algoritmos voraces

¿Por qué una introducción acerca de closure?, pues porque uno de los lenguajes que comienza a ser muy usado, es precisamente este: clojure.

¿Qué es clojure?

Es un lenguaje concurrente, en definición corta, según su web oficial, es un lenguaje de propósito general, que se compila y ejecuta sobre la JVM, dando la versatilidad de un lenguaje scripting, pero al mismo tiempo la robustez que requieren los programas multihilo.

Además, permite el acceso a frameworks Java, con lo que su integración con los entornos Java hace que sea un lenguaje que compita directamente con Scala, en este campo.

Para los que programan en Java, PHP, Perl, Python, Ruby… ver lenguajes como Haskell, Erlang, Lisp, Prolog o Clojure puede resultar en principio algo chocante, ya que la sintaxis es muy diferente. Es normal, su forma de actuación, lo que se puede hacer con ellos y no con los otros, es también distinto. El cambio de sintaxis, fuera de ser un impedimento, yo lo considero una forma de obligarte a cambiar el chip, antes de comenzar a programar.

¿Y para qué sirve?

Bueno, tanto hablar, tanto hablar… pero, ¿y qué hace este lenguaje?, ¿para qué es bueno? En un primer vistazo, los desarrolladores del mismo te pueden responder de forma rápida: para concurrencia.

Después, más detenidamente, te puedes dar cuenta de que es un tipo lenguaje tipo Lisp, con lo que, no solo es bueno con la concurrencia, sino también con la organización de datos e identificación de forma inteligente… o lo que se suele llamar la inteligencia artificial.

Conclusiones

Lisp es un lenguaje que tengo en la lista de tareas por aprender. A través de clojure, ahora, puedo darle una visión un poco más enfocada a los entornos que se usan actualmente para la programación, de modo que pueda ser más útil que simplemente aprender Lisp.

Por mi parte, recomiendo la elección de este lenguaje a todo aquél que tenga problemas a resolver en entornos que requieran de un procesamiento deductivo y con alta concurrencia, por ejemplo: videojuegos, elementos de telecomunicaciones, etc.

No hay entradas relacionadas.

No obstante, los equipos antiguos que aún manejan navegadores antiguos, no podrán visualizar estas mejoras, pero al menos, ya se habrá iniciado una mejor forma de realizar páginas web.

En principio, Derek, nos introduce en la historia de esta nueva liberación. Los grupos de trabajo principales: Apple, Mozilla y Opera (y muchos otros menos conocidos); se reunen para trabajar en una nueva liberación de este lenguaje de etiquetas basado en el uso cotidiano que se le da en estos momentos.

Cambios o Puntos fuertes

• Se agregan etiquetas para marcar correctamente o de forma más concreta y correcta los elementos que se visualizan en la web: header, nav, section, article, aside, footer, figure…; con lo que, en lugar de usar la etiqueta div en todos los casos, se puede usar cualquiera de las anteriores para indicar que son cuadros de navegación (nav), cabeceras (head), etc.
• Añaden etiquetas con características nuevas: hgroup, details, summary, mark, output, progress, menu, video, audio…; con lo que se puede incluir de forma más fácil un reproductor de vídeos o audio, modificando su visualización fácilmente a través de CSS, así como barras de progreso, menús, etc.
• Se dispone de lienzo para poder dibujar: canvas. Este se puede usar para hacer cosas como una visualización personalizada con ampliaciones y cambios en línea (por parte del navegador) como: una lupa o ampliador, o juegos.
• Se incluyen nuevas APIs: drag’n drop, edición de documentos, caché offline, almacenamiento simple en cliente, almacenamiento estructurado en cliente, mensajería entre documentos…
• Formularios potenciados, con la agregación de los tipos de entradas: color, number, time, month, date, datetime, datetime-local, url, range, email, search, tel y week. Con esto se permite hacer formularios mucho más simples que den posibilidad de entrada de datos para un selector de colores, fechas y horas, URLs, rango de números, emails, etc. Además de agregar atributos, que los completan: required, autocomplete, autofocus, pattern (para formateado) y más…
• Se eliminan elementos como: center, font, frameset y strike.

Soporte

Los navegadores que lo soportan, de momento, son Firefox, Opera y Chrome. En 2011, Microsoft, planea sacar IE 9, el cual tendrá también soporte de HTML 5.

Beneficios y Desventajas

Derek señala los siguientes beneficios de HTML 5:

• Tiene una sintaxis más clara.
• Elementos semánticos más concretos.
• Nuevos elementos de formulario que facilitan la programación de los mismos.

Por mi parte agregaría:

• Hace que se dependa menos de Flas, Silverlight y ciertas librerías de JavaScript.
• Hace que el navegador dibuje y ejecute de forma más rápida la web.

Las desventajas, que las hay, son:

• La especificación de HTML 5 no ha finalizado, aún pueden sucederse cambios.
• No todo funciona en todos los navegadores.

Conclusiones

Como dice la presentación: Evolution, not Revolution; por lo que, como mejora que constituye HTML 5, habrá que tenerla presente, ya que dentro de unos años, la mayoría de los navegadores soportarán estas características y, emplearlas, constituirá una ventaja con respecto al rendimiento, tanto por parte del navegador, como por parte del desarrollador.

La presentación:

Entradas relacionadas:

1. JavaScript y CSS no intruso en HTML

Después de esta acción, shoes murió… era muy complicado encontrar un sistema shoes que funcionase y se compilase con las nuevas versiones de ruby, así como un tutorial tan completo como el que tenía why en su propia página web.

No obstante, en este mismo año, mental y más gente en la red, ha ido recopilando de las cachés y de lo que guardaban entre unos y otros y, amparándose en las licencias con las que fueron publicadas cada cosa, han vuelto a poner, eso sí, en otros enlaces distintos, cada una de las cosas que why dió de baja de Internet (salvo su twitter, claro).

La nueva web: http://hacketyhack.heroku.com

El código fuente se puede descargar de aquí.

Entradas relacionadas:

1. Shoes: programación fácil de GUI en Ruby

Desde siempre, el sistema HTTP, llamado también web, ha sido un sistema cliente-servidor, donde el cliente siempre ha sido el navegador web, o cualquier herramienta que pudiese hacer una petición HTTP hacia un servidor, y el servidor, un ente pasivo, se encargaba de procesar la petición y retornar una respuesta. Nada más.

Una de las implementaciones más usadas por este sistema se produce gracias a la característica de HTTP 1.1 de mantener viva la conexión (keep alive) permitiendo al navegador realizar más peticiones y al servidor encauzar una respuesta progresiva, como una lluvia de estrellas (cometas) es el streaming, ya que el sistema puede enviar datos de vídeo progresivamente.

El problema viene dado, también, por la propia especificación de HTTP 1.1, donde se indica que sólo puede haber dos conexiones simultáneas con entre navegador y servidor, con lo que, el uso en una página web con hoja de estilos y bastantes imágenes puede no ser muy aconsejable.

¿Qué aporta de nuevo o de mejorado websockets? a través de HTML y JavaScript de forma simple, se establece una conexión con el servidor dada una URL y un sub-protocolo en el que deben de hablar. Una vez conectado, los elementos html pueden tener eventos del tipo: onopen, onmessage, onclose; indicando los tres eventos que pueden darse en la conexión y el diálogo abierto con el servidor.

Hay que recordar que la interacción vendrá dada por el servidor, esto es que, un programa ejecutándose en el servidor (que no tiene porqué ser de tipo web) puede enviar un evento al puerto especificado por el cliente y el mensaje ser recogido por el navegador y dárselo al elemento al que haga referencia el propio mensaje.

De momento, en Google Chrome se encuentra operativo y se puede probar. En el artículo de Joe Armstrong se puede descargar un código en Erlang para el servidor y un código HTML para el navegador.

Realizaré pruebas y ya comentaré la impresión que me cause el sistema.

No hay entradas relacionadas.

Erlang fue diseñado para escribir programas concurrentes que se ejecutasen eternamente. Erlang usa procesos concurrentes para estructurar el programa. Estos procesos no tienen memoria compartida y se comunican por paso de mensajes asíncronos. Los procesos de erlang son ligeros y pertenecen al lenguaje, no al sistema operativo. Erlang tiene mecanismos que permiten que los programas cambien on-the-fly (en vivo) así, esos programas pueden evolucionar y cambiar sin detener su ejecución. Estos mecanismos simplifican la construcción de software implementando sistemas non-stop (que no se detienen).

El desarrollo inicial de Erlang tuvo lugar en 1986 en el Laboratorio de Computación de Ericsson. Erlang fue diseñado con un objetivo específico en mente: proporcionar una mejor forma de programar aplicaciones de telefonía. En ese momento, las aplicaciones de telefonía eran atípicas del tipo de problemas que podían resolver los lenguajes de programación convencionales. Las aplicaciones de telefonía son, por su naturaleza, altamente concurrentes: un simple switch debe manejar decenas o cientos de miles de transacciones simultáneas. Tales transacciones son intrínsecamente distribuidas y el software se espera que sea altamente tolerante a fallos. Cuando el software que controla los teléfonos falla, sale en los periódicos, algo que no ocurre cuando fallan las aplicaciones de escritorio. El software de telefonía debe también cambiar on-the-fly, esto es, sin perder el servicio mientras se realiza una actualización del código. El software de telefonía debe también operar en tiempo real, con ajustados requisitos de tiempo para algunas operaciones, y más relajado tiempo en otras clases de operaciones.

Como puede leerse en el extracto, Joe Armstrong, fijó los requisitos de Erlang en solucionar los problemas de un entorno altamente concurrente, que no puede permitirse caer y que debe de actualizarse sin pérdida de servicio.

Actualmente, esta definición casa con casi la mayor parte de servicios en Internet.

Entradas relacionadas:

1. Erlang: concurrente, distribuido y en tiempo real
2. Reia: Ruby sobre Erlang
3. Erlang y Asterisk… ErlAst

Para mi, esta versión, además de corregir fallos de la anterior, aporta características que le hacen acercarse aún más a la forma de programación profesional que viene dada con otros lenguajes como Java, C#, C++, Python, Ruby…

Espacios de nombres (namespaces)

Los espacios de nombres, llamados en otros lenguajes: paquetes, módulos, …; con esto, podemos tener organizado nuestro código, no solo en directorios, sino también bien delimitado su espacio de nombres mediante el uso del namespace.

Por ejemplo, si tenemos dos directorios: File y BD; que pertenecen a un programa y cada uno de ellos tiene un archivo para contener la clase Output, en las versiones anteriores de PHP habría que incluir uno u otro, o modificar el nombre para que fuese FileOutput y DBOutput, redundando la ruta con el nombre de la clase.

Ahora, con el uso de namespaces, se puede delimitar con solo agregar una sección de código como esta:

namespace File {
 
    class Output {
        /* ... */
    }
}
 
namespace {
    $f = new File\Output();
}

Static… ahora sí

En las versiones anteriores de PHP, los valores static no eran tratados del todo bien, no permitiéndose algunos usos que parecían lógicos y no produciéndose, sobre todo en la herencia, los resultados que se esperaban.

Ahora, ya se permite el uso de variables para contener el nombre de la clase a la que llamar de forma estática, es decir, ya se permite este uso:

class A {
    public static function say() {
        echo "Hola\n";
    }
}
 
$clase = "A";
$clase::say();

Así mismo, el uso del late state binding, es posible mediante la palabra clave static, de modo que, si se llama a un método estático como static::metodo() en lugar de como self::metodo(), se llama al método de la clase hija que haya sobrecargado al método que se llama. Un ejemplo:

class A {
    public static function who() {
        echo __CLASS__;
    }
    public static function test() {
        static::who(); // Here comes Late Static Bindings
    }
}
 
class B extends A {
    public static function who() {
         echo __CLASS__;
    }
}
 
B::test();  // output: B

Por último, la función especial __call no se llama cuando no hay un método de clase que no exista, en su lugar se llamará a __callStatic, de modo que se pueda hacer diferencia de cuando se está llamando a un método de objeto y cuando se llama a un método de clase.

Más de Late State Binding

Hasta ahora, cuando se quería hacer una clase abstracta que llamase a funciones de sus clases hijas, que aún no han sido declaradas, éstas debían ser abstractas. Pero si la clase no era abstracta y el método a llamar no constaba como abstracto, la llamada no se realizaba a esa función, sino a la del padre.

El sistema de late state binding, asegura que la llamada a métodos se hará siempre de abajo a arriba, es decir, si existe un método en la clase hija que se instanció, aunque el método en ejecución sea el del padre, el método que se llama es el de la clase hija. Más o menos lo que se vió con los métodos estáticos, pero esta vez con métodos.

Funciones anónimas

El uso de funciones anónimas (closures o lambda) es una técnica de programación que permite completar código escrito, mediante el desarrollo parcial de algún algoritmo. Imagina que quieres hacer un código en el que tengas que hacer algo, un paso inicial, un paso intermedio y, en cada iteración una ejecución específica, para terminar con un último paso tras esa iteración.

El código concreto dentro de la iteración puede variar… y de hecho variará en cada implementación, pero el resto no, el resto se mantiene de forma fija. Pues, se puede implementar el esqueleto del programa, y aceptar como parámetro de la función que se haga, una variable que contenga el código a ejecutar. La función que completaría nuestro código se puede hacer así:

$code = function ($dato1, $dato2) {
    echo $dato1 . "--" $dato2 . "\n";
};
 
algoritmo($code);
 
function algoritmo( $func ) {
    for ($i=0; $i<100; $i++) {
        $func($i, $i*$i);
    }
}

También se pueden emplear funciones como array_walk, preg_replace_callback, uasort, etc.

Esto permite realizar códigos como los que se realizan en Ruby o en los lenguajes funcionales y declarativos.

Recolector de Basura de Referencias Circulares opcional

Se deja al programador la decisión de si quiere activar el recolector de referencias circulares del garbage collector, o no. Por defecto viene activado y actúa de la siguiente forma, con este código:

class A {
    function __construct () {
        $this->b = new B($this);
    }
}
 
class B {
    function __construct ($parent = NULL) {
        $this->parent = $parent;
    }
}
 
for ($i = 0 ; $i < 1000000 ; $i++) {
    $a = new A();
    unset($a);
}
 
echo number_format(memory_get_usage());

Si se ejecuta desde consola, con una versión de PHP anterior a la 5.3, se verá en pantalla un error fatal, de que el límite de memoria se ha superado.

Esto es debido a que la liberación de memoria, cuando se va a proceder a liberar la clase B, ve que tiene una referencia a A, que ya va a ser liberada y crea un ciclo, con lo que, para evitarlo, no libera B. En las versiones de PHP 5.3 en adelante, se detecta este ciclo como tal y se liberan ambas.

También existe la posibilidad de desactivar este comportamiento o ver si está activo, con las funciones gc_enable, gc_enabled y gc_disable.

Nowdoc y Heredoc

Hasta ahora, los bloques de tipo heredoc eran los únicos que permitían escribir de forma libre un texto para después usarlo como variable. Ahora también disponemos de los nowdoc, que son iguales, salvo que no se hace parseo de variables. Un ejemplo:

$hola = "Hi, ";
 
$hd = < <<END
texto $hola
END;
 
$nd = <<<'END'
texto $hola
END;
 
echo $hd; // output: texto Hi,
echo $nd; // output: texto $hola

Constantes

Ahora, la palabra clave const puede ser empleada fuera del alcance de una clase, con lo que, en lugar de usar define se puede emplear esta forma:

// antes
// define("CONSTANTE", "Hola mundo!");
 
// ahora
const CONSTANTE = "Hola mundo!";

Operador Ternario simplificado

El operador ternario (expr1)?(expr2):(expr3) ahora permite dejar vacío el espacio correspondiente a (expr2) de modo que si (expr1) es verdadero, se retorna (expr1) y si es falso, se retorna (expr3).

Nuevos Módulos

PHPar

Al igual que JAR, PHPar sirve para empaquetar los PHP en un solo fichero, con lo que se mejora el despliegue de las aplicaciones, la organización del código, etc.

Intl

Mejores funciones de internacionalización para PHP. Hasta ahora, en PHP el único soporte de internacionalización que había disponible era gettext, ahora, con el uso de Intl y sus clases, se facilita internacionalizar una aplicación web, ya que tiene soporte para numeración, fecha, etc.

FileInfo

Da información sobre ficheros, usando la cabecera magic del propio fichero, intenta localizar de forma heurística su tipo, pudiendo retornarlo en formato MIME.

Etiquetas de Salto

Bueno, como en todo, hay avances y retrocesos, esto de proporcionar a PHP un elemento de código spaguetti como es el goto, no hace sino potenciar los malos usos, por lo que yo descartaría su uso.

Migración

Como cualquier liberación de lenguaje, PHP viene con mejoras, agregados y, además, cambios que implican que códigos anteriores puedan dejar de funciona, con lo que es aconsejable leerse bien la guía de migración, para ver los cambios que se introducen, lo que llega a ser deprecated, etc.

Conclusiones

Con esta liberación, PHP da varios matices que le hacen acercarse más a lenguajes como C++ y Java, agregando cosas como PHPar y los namespaces, así como mejorando su implementación de POO.

Considero que el cambiar a esta versión y desarrollar con las nuevas implementaciones hará que los códigos desarrollados sean más claros y, sobre todo, más organizados, por lo que es una buena baza para realizar el cambio.

Además, viendo la guía de migración, se deja entrever que los cambios de la versión anterior, 5.2.x, a esta nueva rama, son mínimos, con lo que, si se ha desarrollado código acorde a la versión anterior, realizar los cambios para adecuarse a esta versión, no es nada complicado.

No hay entradas relacionadas.

Cuando se realizan scripts para ciertas tareas para automatizarlas, pero que tienen que tomar datos del usuario, así como los datos que se presentan son útiles, tanto para rápida consulta, como para dar dicha información por teléfono o usarla en el código, otra interfaz, etc. surge el problema de que la consola se hace un paso como a otro mundo y resulta incómodo.

Una forma de ahorrar la pulsación de teclas, diseñando una interfaz que nos sea útil y presente la información, así como la toma de datos, de forma organizada y práctica, son las aplicaciones basadas en GUI, que se han comenzado a introducir en lo lenguajes de scripting… solo que, el uso de los mismos, se hace tan tedioso, que resulta incómodo realizar una interfaz para usuario en esos sistemas.

Hace poco, en un curso de Ruby on Rails que estaba dando Dani, un colega muy versado en Ruby y su mundo, nos enseñó un juguetito bastante gracioso para hacer GUI desde Ruby: Shoes.

Lo instalé para GNU/Linux y lo comencé a probar… en cuestión de una hora tenía una pequeña aplicación que tomaba información de un ActiveRecord, hacía una consulta según los datos de entrada que le introducía y rellenaba el resto del formulario con los datos de salida… muy útil en esos momentos para la resolución de incidencias, ya que suelen venir con datos incompletos y la resolución debe de ser rápida (y ya estaba cansado de ir a golpe de consulta SQL… mucho que teclear para obtener solo un par de datos )

En la misma página hay un tutorial y, bajando el código, se pueden ver ejemplos donde hay desde programitas simples de reloj, hasta videojuegos en 3D … lo recomiendo, a mi me ha ayudado mucho.

Entradas relacionadas:

1. ¡Shoes vive!
2. Ruby… esa pequeña joya
3. Lenguajes de Programación

Centrándonos en la vista, existen miles de soluciones, para alejar al diseñador del código y al programador del diseño, pero aún así, cuando se habla de AJAX y desarrollos específicos… el programador tiene que tocar diseño y el diseñador preocuparse de lo que hará el código de servidor.

Este dolor de cabeza puede paliarse mediante el uso de códigos no intrusivos, lo que facilita la especificación de una interfaz basada en identificadores para el tratamiento del HTML.

El código no intrusivo de servidor lo trataré en otro artículo para que no resulte este muy extenso.

CSS no intrusivo

En principio, desde el punto de vista del navegador, todo es HTML. Pero, al igual que en los procesadores de texto, para facilitar la estructura de estos ficheros y no plagarlos de contenido referente a tipos de letra, colores, fondos… se crearon las hojas de estilos.

Las hojas de estilos en cascada (CSS) ayudan, junto con la especificación de identidades y clases, a dar estilos (colores, fuentes y forma de presentación en general) a las etiquetas escritas en HTML.

El CSS se pude incrustar en las etiquetas HTML mediante el uso de las etiquetas style, o incluso a través de los atributos style dentro de cada una de las etiquetas típicas de HMTL.

La mejor forma de hacer que no sea intrusivo, es colocar esos estilos en un fichero separado, y agregarlo mediante el uso de la etiqueta link en la sección head.

JavaScript no intrusivo

El código JavaScript es algo que se ha ido haciendo cada vez más con el HTML. En principio, se usaba la etiqueta script dentro de la sección head para agruptar todas las funciones de javascript, a las que se iban llamando desde etiquetas como onclick, onmouseover, onchange…, es decir, las etiquetas de eventos de HTML, que se destinan para JavaScript.

Después su uso se fue masificando y mezclando cada vez más con el HTML, haciendo que la etiqueta script, en muchas páginas, se encuentre repetida y segregada a lo largo de todo el texto HTML y, además de eso, en atributos como href, donde se indica explíticitamente que se ejecutará un código javascript.

Esto hizo que el código javascript se convirtiese en parte simbiótica de HTML y, en muchos desarrollos, que no se pudiese separar fácilmente.

Con ciertas técnicas, como las usadas en CSS, la separación de JavaScript se puede llevar a cabo sin problemas, pero requiere de ciertas pautas y costumbres a la hora de realizar el HTML:

• Asignar ID a las etiquetas con las que se vaya a trabajar dinámicamente.
• Asignar una clase a todo tipo de etiquetas que se usen para un fin similar.
• Intentar no realizar anidamientos muy profundos.
• En caso de tenerlos, intentar diferenciar los niveles de profundidad con IDs claros.
• No abusar de tablas.
• Tener especial cuidado con las etiquetas div, sobre todo por su uso con varios navegadores.

Con esto, solo tener claro que, el fichero de tipo javascript que se asocie al HTML, debe tener un código lanzador, que se encargue de asociar las funciones javascript oportunas a los eventos y las modificaciones pertinentes.

Es importante también recordar que, para mejorar la depuración, es mejor generar cuanto menos código por javascript, mejor. Es decir, que si hay que modificar las propiedades de una tabla por dar la posibilidad de varios tipos de ordenación, hacer las funciones específicas para ese cambio en JavaScript, pero no caer en la tentación de pasar los datos a array de javascript para hacerlo todo desde ahí.

Conclusiones

Lo que se trata, en base, es llegar a lo que W3C considera que debería ser la web semántica, pero con el uso de HTML. Intentar organizar los datos con las etiquetas existentes, sin usar estilos de presentación, solo los datos, y agregar a esas etiquetas el estilo de presentación deseado, mediante CSS externo y el dinamismo de cliente que se requiera, mediante JS externo.

Las ventajas que agrega, es que el cambio de una presentación a otra, se puede hacer con tan solo variar el CSS, y agregar nuevas funcionalidades, es solo modificar el JS.

Entradas relacionadas:

1. El futuro de la web: HTML 5

Los desarrolladores de ciertos lenguajes han creído conveniente romper con el pasado de uso de dichos lenguajes para acogerse a los progresos y prácticas más usadas actualmente. Haremos repaso.

Perl 6

El lanzamiento de esta versión de Perl ha traído de cabeza a varios programadores, en algunos sitios ya existen guías de migración de Perl 5 a Perl 6 a modo de poder ayudar a los programadores a pasar a esta nueva versión y aprovechar sus nuevas características. Entre ellas, cabe destacar:

• Tipificación
• Parámetros en subrutinas
• Orientación a Objetos
• Comparaciones encadenadas
• Evaluación perezosa
• Macros

Larry Wall mencionó que la versión 5 era su reescritura de Perl, su visión de cómo debía de ser y que, la versión 6, debía de ser la reescritura de Perl para lo que quiera que sea la comunidad.

PHP 6

La versión de PHP 5, trajo consigo una orientación a objetos muy mejorada. Pero aún hoy, con la versión 5.2 estable y la 5.3 en inestable, se echa en falta una versión más completa del lenguaje, características avanzadas como las que se encuentran en otros lenguajes como Ruby, Java, Python o C++.

Por ello, la versión de PHP 6, nos aportará mejoras considerables como:

• Closures y lambda
• Traits
• Namespaces
• Más mejoras en la orientación a objetos

Por otro lado, hay que mencionar que esta versión ya no asegura la compatibilidad hacia atrás, es decir, con scripts programados para versiones de PHP 3.x, 4.x o incluso algunas del 5.x.

Python 2.6 y 3.0

El último lanzamiento de la versión 2.x se hizo con la versión 2.6, la cual incluye características y corrección de fallos, además herramientas para migrar a la versión 3, e incluso comenzar a usar elementos específicos de la versión 3 incluídos en la 2.6, a través del comando future.

La versión 3.0 de Python rompe también la interfaz pasado-futuro al no ser compatible con la rama anterior a nivel de scripts. No obstante, se han incluido herramientas para facilitar su transición.

Las mejoras incluidas:

• Print es una función
• Views e Iterators en lugar de Lists
• Nueva sintaxis de anotaciones, argumentos y literales
• Cambios en las librerías estándares (reorganización)
• …

Conviene realizar una migración y estudiar un poco los cambios, si se desea realizar el salto a esta nueva versión.

Ruby 1.9.1

El comentario más sonado sobre esta versión es: el más rápido que la 1.8; y es que, parece que, aún no habiendo cambiado mucho la forma del lenguaje, sí han cambiado los procedimientos internos para hacerlos más óptimos.

Lea las características para más información.

Conclusiones

Aprender un lenguaje no es una seguridad en cuanto a dejar de aprender se refiere. Dentro de cada uno de los lenguajes de programación existentes, se han observado cambios patentes que se realizan con una periodicidad de pocos años, con lo que es bueno mantenerse al tanto de las nuevas versiones, otros lenguajes y, sobre todo, las necesidades y entornos, sus progresos y cómo se adaptan los lenguajes a ellos, puesto que determinarán si estamos eligiendo adecuadamente nuestra herramienta de trabajo o no.

Entradas relacionadas:

1. Lenguajes de Programación
2. Sistemas de Control de Versiones: ¿centralizados o distribuidos?
3. Lenguajes Funcionales para el Desarrollo Web