Category Archives: Desarrollo de Software

De Programador a Desarrollador

Cuando tenía doce años, comencé a programar en Basic, en un ZX Spectrum de 128K… en esos momentos, y los años siguientes, hacer un programa, para mi, era sentarme delante de mi ordenador, durante unas cuantas horas, incluso echando noches en vela, para al final ver el resultado… un pequeño programa de gestión de contactos, un juego de puzzle, tetris, plataformas 2D… y eso, a lo largo de los años… y de los lenguajes, pasando por Basic, C, C++, Modula-2, Pascal, Java, Perl, PHP, Python, Ruby, Erlang…

La programación se convierte, en mi vida, en mi tiempo libre y, después, en mi trabajo, en una forma de realizar programas de ideas que me surgen, de forma heróica, y sin una fuerte organización que me permita ver el resultado de mi esfuerzo, ni las horas que voy a invertir, ni si merece la pena hacerlo de una cierta forma u otra.

Como programador, disfruto de la programación sin orden, anárquica, programo lo que quiero, como quiero y todo el tiempo que quiero. Me encuentro con los problemas típicos de haber abordado un problema del modo equivocado, y tener que reescribir una y otra vez el mismo código para alcanzar una forma óptima de lograrlo… pero no es óptimo y muchas veces aburre, ¿cuál es el siguiente paso?

Desarrollar es tener una idea en mente, darle forma hasta conseguir una idea completa y organizada, o al menos creíble, de un producto software conseguible mediante algún camino que se pueda tomar. Es decir, que si programo el código de una cierta forma, conseguiré lo que me propongo, ya que, mediante un diseño previo, he podido analizar las posibilidades de que no me ocurra el encontrarme ante un callejón sin salida.

Pero no es solo saber de antemano donde nos metemos al comenzar a programar, sino también, poder distribuir el trabajo en un equipo de desarrollo, un equipo de programadores. El análisis del problema nos permite ver qué hay que desarrollar exactamente, detecta las necesidades para que, después, el diseño nos diga el cómo podemos abarcar el problema para su resolución. Y ese cómo incluye la división del trabajo.

Como desarrollador, y viendo la programación como una parte del conjunto de hacer un proyecto de software, he podido aprender que, para poder realizar de forma más óptima un proyecto, hay dos caminos:

  • predictivo / por procesos: cuando se ha desarrollado ya bastante software del mismo tipo, es fácil poder estimar y cerrar requisitos, es fácil tener una especificación del problema a resolver, realizar el análisis, el diseño y la programación del mismo. Es fácil predecir cuánto tiempo se puede tardar en cada fase y realizarlo sin problemas. En este sentido, es bastante fácil tomar un modelo de procesos como el CMMI, SPICE o Metrica-3, y seguirlo para conseguir nuestro objetivo, consiguiendo además, la máxima documentación útil sobre el proyecto.
  • ágil / por iteraciones: si el proyecto que se quiere conseguir es sobre una tecnología que no se domina, plataforma nueva, o requisitos cambiantes, lo mejor es emplear una metodología ágil, que nos permita agregar flexibilidad para el cambio de requisitos, mediante entregas cortas, periódicas y agregando valor cada vez al proyecto a desarrollar, mediante la continua liberación de versiones. Las metodologías más usadas son Scrum, XP, Lean, FDD, DSDM, Crystal, Kanban, …

En conclusión, el siguiente paso ha sido convertirme en desarrollador. Conocedor de las metodologías predictivas y ágiles y poder dar a cada proyecto la orientación necesaria para poder llevarlo a cabo de la mejor forma posible.

La liebre y la tortuga

En este cuento voy a intentar explicar lo que significa programar rápido y lo que significa programar de forma ágil. La primera forma sería la que se considera comenzar lo antes posible, para terminar lo antes posible… pero ciertamente, sin planificación, dar palos de ciego a ciertos niveles de implementación, es más lento que planificar la estrategia de desarrollo a priori. Vamos a verlo con el cuento de…

La liebre y la tortuga

En Silicon Valley, había un programador tan rápido que podía escribir cientos y miles de líneas de código en cuestión de pocas horas, trabajaba rápidamente y, por ello, era conocido como la liebre. Aunque era un poco alocado, se lanzaba directamente a programar y no planificaba bien los proyectos.

No obstante, todos lo admiraban por lo rápido que hacía aparecer código en tan poco tiempo.

Por otro lado, estaba otro programador, algo más lento, que planificaba en papel y lentamente todos sus desarrollos, con lo que en un día obtenía muy pocas líneas de código. Este programador era conocido, por esto mismo, como la tortuga.

La liebre y la tortuga trabajaban en la misma empresa y, ante la fuerza que la admiración del resto ejercía sobre el primero, por su característica totalmente opuesta a la del segundo, la liebre instigaba e intentaba siempre perjudicar a la tortuga.

En la sala de trabajo, un día, cuando la tortuga ya se cansó de tanta hostilidad, aprovechó la oferta de un trabajo de programación importante, con un nivel de desarrollo importante y grande, para retar a la liebre: tú que eres tan rápido, te desafío a desarrollar este programa más rápido que yo.

Toda la sala quedó estupefacta, salvo el director de proyectos, que disimuladamente sonrió, agregando: sería interesante verlo. A lo que el resto de la sala agregó más risas.

El director de proyecto se dirigió a la liebre y le preguntó: ¿serías capaz de desarrollar este proyecto en menos tiempo que la tortuga? A lo que la liebre respondió sin dudar: ¡claro que sí! Pues os doy a ambos una semana para el desarrollo del proyecto, quien antes lo termine cumpliendo con los requisitos especificados, será el ganador.

La liebre comenzó a reir, aceptó el trato, al igual que la tortuga y fue a seguir riendo con sus compañeros durante largo rato mientras la tortuga marchó a su puesto de trabajo. La tortuga analizó el proyecto e inmediatamente localizó una serie de patrones claros que seguir, tomó los requisitos y trazó los diagramas que le harían cumplir con los mismos de la mejor forma, para seguir con una planificación ajustada al tiempo que tenía para cumplir con el proyecto. Se puso manos a la obra y comenzó el diseño.

Mientras tanto la liebre, se tomaba su tiempo y, mientras hablaba con sus compañeros decía: si ya sé cómo lo voy a hacer, es una chorrada de proyecto, ¡muy fácil!

En el segundo día, la tortuga terminaba su diseño con diagramas de UML, marcaba la división y los patrones que integrarían cada una de las clases, así cómo los detalles del diseño de interfaz y otras características a tener en cuenta en diagramas de secuencia.

Al tercer día, la liebre comenzó a codificar, en poco tiempo, tenía un trozo de código que cumplía los primeros requisitos y reía a gusto creyendo saber que conseguiría su propósito. Mientras, la tortuga, acababa de sentar el esquema de clases y la estructura básica, la arquitectura de soporte y preparaba todo para comenzar la codificación al día siguiente.

En el cuarto día, la liebre comenzó a encontrarse los primeros problemas, algunos requisitos chocaban directamente con muchas de las partes ya desarrolladas y en funcionamiento, así como datos ya implementados en la base de datos, con lo que se veía obligada a rehacer la estructura de datos, eliminar todo el código que no le servía y volver a escribir código nuevo. La tortuga comenzaba la codificación con la estructura de clases autogenerada por las herramientas CASE que usaba y trazaba las líneas de código de acceso a datos y lógica de negocio, escribía las pruebas unitarias para asegurar que todo salía bien y seguía adelante.

El quinto día, para la liebre, comenzaba el stress, la desesperación, se acerca el final del proyecto, aún no están todos los requisitos y se han vuelto a encontrar problemas. Como no hay una visión global, no sabe cuantos problemas más puede llegar a encontrar y, para los ya encontrados, la recodificación es algo pesada. Con lo que parece que solo lleva, de forma constante la mitad del proyecto. Por otro lado, la tortuga ha terminado la parte de lógica de negocio y manejo de datos, así como la parte de seguridad y acceso, el controlador, con lo que solo le restan las vistas, con las pruebas funcionales para acabar el proyecto.

El sexto día, cuando se había previsto la entrega del proyecto, la liebre había pasado toda la noche en su puesto de trabajo, intentando, con chapuzas, terminar a tiempo el proyecto, haciéndolo de forma muy deficiente y sin probarlo. Sin embargo, la tortuga, ya acababa la vista, haciendo siempre la ejecución de las pruebas de regresión para probar la integración de cada una de las partes, junto con las funcionalidades pedidas y el entorno en sí.

A la entrega del proyecto, la liebre presentó un proyecto con fallos, que no terminaba de funcionar y que tenía implementados los requisitos solicitados de forma dudosa, mientras que la tortuga entregaba un proyecto bien pensado, con un resultado limpio y funcional.

Ante los resultados, el director de proyectos se dirigió a la liebre y le dijo: no es cierto que es más rápido quien más rápido programa, sino quien, con menos código y menos trabajo, consigue hacer lo mismo en menos tiempo; y con ello, la tortuga ha demostrado, que es más rápido que la liebre.

Conclusión: usar metodologías ágiles acelera realmente el desarrollo, porque optimiza el proceso de creación.

Reia: Ruby sobre Erlang

Al igual que en Java se pueden ejecutar lenguajes scripting tales como Ruby (JRuby), Python (Jython), Groovy… es posible hacer esto mismo en otros lenguajes, como C y Erlang.

Erlang, es un lenguaje funcional, del que ya hablé en otro artículo, lo cual tiene sus ventajas para ciertos algoritmos… pero también sus inconvenientes para otro tipo de algoritmos, por lo que el poder combinarlo con lenguajes de scripting tan potentes como Ruby, es una forma de poder acelerar nuestros desarrollos… allanamos el camino quitando todas las piedras :-)

El sistema que hace esto es Reia. Este sistema, escrito en erlang y reia (casi la misma sintaxis que Ruby), da las capacidades de un lenguaje dinámico sobre un lenguaje funcional, dando la posibilidad de escribir código tanto en erlang como en reia e ir alternando. El resultado siguen siendo los archivos beam que la máquina de Erlang interpreta y ejecuta sin problemas.

ETL: Extracción, Transformación y Carga

Este término, ETL, se acuña a la mayoría de transformaciones de datos que deben de realizar empresas para compatibilizar sus datos con los de sus proveedores y/o clientes.

Este sistema se basa en los tres pasos de los que salen sus siglas:

  • Extration: la extracción se refiere a obtener datos. Si tenemos una fuente de datos como puede ser un fichero CSV, o un fichero Excel (lo más típico en muchas empresas), el trabajo comienza por configurar ese fichero como origen de datos. También hay posibilidad, según la complejidad del sistema o lo avezado del programador, de poner otros orígenes de datos más originales, como son: base de datos relacionales, jerárquicas (o directorios), conjuntos de ficheros, conexiones HTTP, FTP, POP3 o IMAP, etc.
  • Transformation: la transformación se refiere a, con los datos tomados de las fuentes específicas, realizar las transformaciones oportunas para obtener los datos que se requieren. Estas transformaciones se pueden realizar en múltiples lenguajes de script. Normalmente, en muchas plataformas, se usan lenguajes como JavaScript, otros tienen una interfaz gráfica desde la que se configuran las transformaciones.
  • Loading: la carga de datos consiste en tomar los datos procesados, una vez terminada la operación de transformación, y depositarlos donde se indique, ya sea una base de datos, un conjunto de ficheros o un fichero, en el directorio especificado o enviado a través de FTP, HTTP POST o SMTP… etc.

El sistema es simple y, por lo tanto, como todo lo simple, tiene una gran cantidad de aplicaciones que facilitan, entre otras cosas:

  • Automatización de tarifas, ya que si el proveedor nos envía sus tarifas en formato de fichero o en un email formateado de alguna forma, se pueden obtener esos datos y cargarlos en nuestro sistema de base de datos, hacer las transformaciones precisas e, incluso, enviar los resultados a nuestros clientes en formato PDF por email.
  • Comunicación con el cliente, en modo de que, tomando los datos de nuestras base de datos con referencia a saldos, ingresos, tarifas o cualquier información que interese al cliente, pueden ser también ofertas o productos marcados como rebajados, se envíe esta información en formato PDF con una presentación predefinida a cada uno de nuestros clientes.
  • Generación automática de informes. Por supuesto, estos ETL que se creen se pueden ejecutar cuantas veces se quiera y de forma programada, por lo que, pueden servir para generar, por ejemplo, ficheros HTML estáticos (o incluso con código PHP) que nos muestren información referente a datos de nuestra base de datos.
  • Simplificar datos. Otra forma de usarlos es para crear lo que se conoce como tablas resumen, son tablas que tienen un conjunto de datos representados por la suma de sus campos, como por ejemplo el gasto de un cliente, se puede representar, además de por las líneas de detalle, por una sola tupla que sume todas esas líneas y se presente solo una por mes, e incluso en otra fuente de datos, una por año.

En cuanto más se adentra uno en este mundo de la acumulación e integración de datos, más funcionalidades se le pueden dar a estos sistemas ETL.

Sistemas ETL disponibles hay:

  • Benetl: un software algo simple, escrito en Java, que presenta las posibles transformaciones a través de pantallas. Ofrece bastantes características, pero se ve algo limitado.
  • Barracuda Integrator: tiene la pega, para mi gusto, de que es software propietario y que parece que solo funciona en Windows, pero hay que admitir que tiene buenas características y tiene una serie de presentaciones en las que se puede apreciar su uso, fácil y sencillo, y su potencial. El lenguaje para transformaciones es Visual Basic.
  • Clover ETL: este software es gratuito, no libre y, la parte negativa, es que la interfaz (Clover GUI) es de pago. No obstante, ofrece un sistema intuitivo, ágil y fácil de usar. Se ejecuta sobre varias plataformas, no solo Windows, y el lenguaje de transformación implementado (además de la posibilidad de uso gráfico) es propio: CTL; basado en C.
  • Pentaho Data Integration: es un software libre escrito en Java que permite tomar información de muchos y diversos orígenes de datos, hacer la transformación en lenguajes como Javascript y hacer la “entrega” de datos en distintos destinos.

Por tanto, considero el sistema ETL a tener en cuenta y usar software específico, una forma de acelerar los procesos más pesados en lo que respecta la informatización de tareas en las empresas.

Pruebas Unitarias

Después de haber estado adentrándome en TDD, muy poco a poco, he visto que el primer paso para hacer más fácil esta doctrina, son las pruebas unitarias.

Las pruebas unitarias son pruebas que se realizan sobre unidades aisladas de código, generalmente objetos, para asegurar que, con unos ciertos valores de entrada, siempre se reciben los mismos valores de salida, o los valores de salida que se esperan.

Para implementar las pruebas, según el lenguaje que se use, existen las siguientes librerías o métodos:

  • Java: el proyecto junit podría considerarse el primero en tener este tipo de framework para realización de pruebas, es de los que más activo tienen su desarrollo, la última versión publicada es de hace unos meses.
  • C: el proyecto CUnit no se actualiza desde 2006, pero parece que el desarrollo quedó muy avanzado y es útil para realizar las pruebas.
  • PHP: el proyecto PHPUnit se sigue actualizando y sigue creciendo poco a poco, es bastante maduro y apto para su uso en proyectos de PHP, ya sean de la versión 4 ó 5.
  • Ruby: el nombre del proyecto para ruby, a diferencia del resto, es Test::Unit. En este caso se presenta como un módulo para la realización de pruebas unitarias. Esto es porque en Ruby, no solo están disponibles este tipo de pruebas, sino también pruebas funcionales y de integración… pero eso será otro tema ;-) . El uso del módulo resulta muy similar al resto de frameworks.
  • Python: el proyecto recibe el nombre de PyUnit. Este proyecto hace tiempo que no recibe actualizaciones, pero está en un estado maduro. En su página se dice que se usa para las pruebas de Zope, que es, posiblemente, la mayor pieza de código escrita en python.
  • Perl: en las instalaciones desde CPAN, para instalar módulos de Perl, siempre que se descarga el módulo se ejecutan las pruebas unitarias del mismo, para asegurarse de que se cumplen todas las dependencias y que el código, en ese entorno, reacciona como se espera. El proyecto es PerlUnit.

En la mayoría de casos, cada uno de los proyectos ha sido motivado por junit, con lo que el uso, la ideología y la forma de trabajar es muy similar.

Ahora, después de comentar los proyectos, vamos a comentar lo que realmente importa, las ventajas:

  • Pruebas exhaustivas: el desarrollo de pruebas unitarias tiene como ventaja principal que el código se prueba con datos planteados con detenimiento e intentando cubrir todos los casos posibles, por lo que, es muy útil para descubrir si nuestro software cumple con las especificaciones marcadas (requisitos).
  • Facilita el probar reiteradamente: es decir, si necesitamos realizar pruebas sobre un componente, y ese componente no reacciona como esperamos, en lugar de ir alimentando la entrada de datos cada vez que lo probemos, podemos realizar una batería de pruebas específicamente para él, e incluirlo en la batería de pruebas global.
  • Fase de Calidad: el agregar las pruebas unitarias y ejecutarlas al final, cuando ya se ha terminado de desarrollar el código, no indica que el código sea infalible, pero si las pruebas se han desarrollado cubriendo todos los casos de uso triviales y posibles fallos que se puedan suceder, asegura que el código funcionará como se espera.

Por tanto, el desarrollo de estas pruebas, ya sea a priori, como indica TDD, o a posteriori, como elemento de QA (quality asurance, garantía de calidad), o ambos, resulta una herramienta indispensable que nos puede ahorrar la mayor parte de incidencias que se abren una vez el proyecto está en producción o entregado al cliente.

Scrum: 7 sprints y 3 proyectos después

Mi última entrada sobre Scrum, hablaba de la implementación del gráfico Burndown, de esto hace ya casi 3 meses, aunque realmente, comenzamos la andadura en algo antes.

En principio, tengo que tener presente que he estado usando algunas otras metodologías, como la Espiral de Boehm y Metrica-3, con lo que, he podido ver y sufrir en mis propias carnes, lo que significa e implica usar una metodología ágil, las ventajas que aporta y lo fáciles que tienden a ser, realmente.

Después de haber realizado siete iteraciones, o sprints, y haber completado tres versiones de un proyecto, ya en producción, y otros tres proyectos más casi en producción, puedo dar mis conclusiones acerca de esta metodología de planificación del desarrollo de software:

  • Scrum permite el desarrollo ágil, esto es, sobre todo, basándonos en un diseño global, y aplicando un poco la metodología de los prototipos evolutivos, conseguir una versión simple, lo más rápidamente posible y que asiente las bases de lo que será la aplicación futura.
  • Las iteraciones cortas, de dos a tres semanas, permiten una supervisión de lo que se va haciendo cada poco tiempo, pudiendo cambiar el rumbo entre sprint y sprint, para adecuarse a los cambios de requisitos funcionales o cambios de prioridad que puedan surgir a lo largo del desarrollo del programa.
  • El gráfico de burn-down es una muy útil herramienta que permite tener una visión dinámica de la velocidad con la que se va produciendo el desarrollo y prepararse, de forma anticipada, a posibles variaciones en las fechas de entrega, ya sea resumiendo o eliminando funcionalidad. En caso positivo, si la marcha del proyecto va más rápido, permite agregar otras tareas no planificadas o prioritarias que se pensaban hacer en futuros sprints.
  • Las tarjetas y el tablero de juego que plantea esta metodología, le da una visión lúdica al trabajo y hace que se convierta en un juego. Las tareas se suceden y, todos saben lo que hace cada cual. Incluso los directivos inmediatamente superiores, en lugar de interrumpir el trabajo, con solo mirar el tablero, ya saben cómo va el proyecto.
  • El hecho de partir tareas, hace que se puedan paralelizar mejor, con lo que aumenta la potencia del trabajo en equipo, pudiendo hacer varias personas tareas sin solaparse. En esto, el trabajo con metodologías de tipo Xtreme Programming, programando por parejas, tareas concretas de corto espacio de tiempo y basándonos en el desarrollo orientado a pruebas hace que sea más óptimo.

A todo esto, sumamos el orgullo de poder presentar los proyectos en la fecha pactada, junto con la sensación de que el trabajo se ha realizado en el tiempo adecuado, sin quemar a nuestro personal, y tenemos una combinación muy óptima.

¿Qué es lo siguiente? En principio me planteo seguir profundizando en las técnicas de Xtreme Programming para integrarlas en el desarrollo de las tareas individuales que propone Scrum, ya que así son completamente compatibles y muy potentes. Así mismo, adentrarme más aún en los frameworks de pruebas unitarias tanto para PHP, como Ruby, Erlang y C. Espero así, conseguir incluso hasta mejores resultados, ya no hablando de tiempos, sino de calidad de producto.

Mentalidad de Suficiencia

Citando a Kent Beck, de su libro Extreme Programming Explained:


En la Gente del Bosque y la Gente de la Montaña, el antropólogo Colin Turnbull dibuja el contraste de dos sociedades. En las montañas, los recursos eran escasos y la gente estaba siempre al borde de la hambruna. La cultura a la que evolucionaron era horrible. Las madres abandonaban a sus bebés, los entregaban a hordas de niños salvajes errantes en cuanto tenían opciones mínimas de sobrevivir. Violencia, brutalidad y traición estaban a la orden del día.

En cambio, en el bosque había plenitud de recursos. Una persona tenía solo que emplear media hora al día para cubrir sus necesidades diarias. La cultura del bosque era la imagen en el espejo de la cultura de la montaña. Los adultos compartían el cuidado de los niños, quienes eran nutridos y amados hasta que estaban preparados para cuidar de sí mismos. Si una persona, accidentalmente, mataba a otra (el crimen deliberado no se conocía), era exiliado, pero solo tenían que ir a otra parte del bosque y solo por unos meses, y la gente del bosque le llevaba comida.

Xtreme Programing es un experimento que responde a la pregunta, ¿Que pasaría si tuvieras suficiente tiempo? Ahora, no tienes tiempo extra, porque esto es un negocio, después de todo y estamos jugando a ganar. Pero si tuvieras suficiente tiempo, escribirías tests; podrías reestructurar el sistema cuando aprendieses algo; podrías hablar con muchos colegas programadores y con el cliente.

Tal mentalidad de suficiencia es inhumana, al contrario que la incesante pesadez de lo imposible, imponiendo fechas de entrega que desperdician el talento en la programación en el mundo de los negocios. La mentalidad de suficiencia es también buena para los negocios. Esta crea sus propias eficiencias, al igual que la mentalidad de escasez crea sus propios perjuicios.

Este texto explica el uso de Xtreme Programming y los beneficios que conlleva. Leyendo esta introducción, queda claro, tal y como intenta transmitir el autor, que lo que propone esta metodología, no es solo producir más rápido, sino mejor, en sentido de que los desarrolladores no terminen quemados, como suele suceder en la mayoría de los casos.

Este tipo de metodologías, contribuyen a seguir haciendo la programación divertida, incluso en el trabajo.

Agradecer a mi amigo Jonathan la ayuda en la traducción, que sin él el texto habría quedado en inglés o muy mal expresado :-P

REST: Representational State Transfer

Después de haber usado durante unos años sistemas RPC para la compartición de la información, XML-RPC, SOAP y Elm; llego a REST, un concepto que mencionó primero un compañero de trabajo, Juanse, y después vi en profundidad en un curso de Ruby on Rails que se organizó en la empresa en la que trabajo (gracias Dani por ese curso tan completo).

El sistema REST se basa en usar las entidades de datos como recursos. Por ejemplo, si tenemos usuarios y queremos hacer un sistema de gestión de usuarios, mediante una URL, podemos establecer el recurso como:

http://bosqueviejo.net/users

Este recurso será accedido por HTTP, mediante el método GET, lo cual retornará, en formato serializado (XML, JSON, YAML…) la información solicitada, el listado de usuarios. También podemos especificar, mediante la agregación de un identificador, en la URL, que solo queremos un usuario concreto:

http://bosqueviejo.net/users/admin

Como se puede apreciar, el sistema de localización, es claro y limpio.

Lo más interesante viene en las siguientes acciones. Para hacer una agregación a la lista de usuarios, es decir, para insertar o agregar un nuevo usuario, se puede emplear la misma URL, agregando los datos como cuerpo del mensaje HTTP y usando el método PUT.

Por ahora, no tenemos novedades con respecto al uso estándar de los sistemas web, ya que la petición de páginas se realiza mediante GET y el envío de formularios a través de POST. Sin embargo, para las acciones de inserción, por ejemplo, se emplea PUT, con la misma dinámica que POST, solo que reacciona como una actualización sobre los datos existentes, por lo que, la URL que se usará, deberá de ser de la segunda forma que se vió anteriormente.

Por último, para eliminar un dato, usando la URL concreta como en el caso de PUT y POST, pero empleando el método DELETE, se indicará al sistema REST que se desea eliminar el recurso solicitado.

Las ventajas que ofrece este sistema son claras. Al hacer uso de los métodos de HTTP, el servidor web puede ser usado a nivel de autenticación para restringir en modo todo o nada la modificación, eliminación y agregación de recursos a usuarios no autenticados o a ciertos usuarios, e incluso, en concordancia con la raíz de URL, limitar el acceso a ciertos recursos, con ciertos métodos, etc. Además, a nivel de log del sistema web, se tienen datos más concisos sobre el acceso y uso del sistema.

Los inconvenientes son que las acciones tienen que ser muy específicas y, para las cadenas de búsqueda, se hace necesario el uso de los parámetros de URL, lo cual hace que no quede tan claro y limpio el sistema.

Este sistema, bien usado, constituye un punto de partida muy válido para la comunicación con sistemas BPM y la instauración de sistemas de consulta tan potentes y configurables como SQL.

JavaScript y CSS no intruso en HTML

Cuando se pensaba en MVC, la capacidad para dividir las tareas obvias de tratamiento de datos, en lógica de negocio (el modelo), control de flujo de ejecución (el controlador) y la presentación de datos (la vista), aún quedaban en el aire muchos problemas en lo que respecta a las interaces, propiamente dichas, entre estas tres capas.

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.

Lenguajes: nuevas versiones

En estos últimos días he visto los nuevos lanzamientos, o lo que se espera lanzar en varios “mundos” del desarrollo del software. Por un lado, hay varios puntos donde la interfaz pasado-futuro corre bastante peligro.

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.