• Shortcuts : 'n' next unread feed - 'p' previous unread feed • Styles : 1 2

» Publishers, Monetize your RSS feeds with FeedShow:  More infos  (Show/Hide Ads)


Date: Monday, 22 Sep 2014 11:55
Enlaces interesantesAhí van los enlaces recopilados durante la semana pasada, espero que os resulten interesantes ;-)

.Net

ASP.NET

Azure / Cloud

Conceptos/Patrones/Buenas prácticas

Data access

Html/Css/Javascript

Visual Studio/Complementos/Herramientas

Otros

Publicado en Variable not found
Author: "noreply@blogger.com (José M. Aguilar)"
Send by mail Print  Save  Delicious 
Date: Monday, 22 Sep 2014 11:34
Novedades de C# 6.0Hace algún tiempo comentamos alguna de las novedades que se incluirán en la próxima versión de C#, concretamente el nuevo operador de navegación segura “?.”, pero la cosa no acaba aquí: se avecinan un buen número de cambios que prometen seguir mejorando nuestro lenguaje favorito :-)

Por ejemplo, una nueva característica que tendremos disponible es la inicialización de propiedades automáticas, algo que antes también podíamos hacer, aunque de forma menos directa.


Es decir, hasta el momento para inicializar una propiedad automática teníamos que hacerlo en el constructor de la clase, como sigue:



Pues bien, en la nueva versión podremos usar una nueva construcción mucho más directa:



Simplemente añadimos la expresión de igualdad tras la declaración, y listo. Además del obvio ahorro en pulsaciones de teclas, el resultado a nivel de código es más expresivo y legible, puesto que mantiene unida la definición de la propiedad con su valor inicial.

Los valores usados en la inicialización son los que podríamos suponer de forma intuitiva: constantes, miembros estáticos o llamadas a métodos estáticos, nada de referencias a this o a otros miembros de instancia de la clase. Vaya, igual que en la inicialización de miembros privados de la clase de toda la vida.

Y como era de esperar, la inicialización se producirá antes de que la ejecución pase por el constructor, por lo que en ese punto ya tendremos los valores cargados si los necesitamos para algo:



Por supuesto, es algo que también podemos utilizar con propiedades en las que el setter es privado, puesto que la inicialización es interna a la clase:



E incluso hace posible el uso de propiedades automáticas de sólo lectura, algo que antes sólo podíamos conseguir usando propiedades con backing fields:



En fin, que sin ser un cambio espectacular, se trata de uno de esos pequeños detalles que nos hará la vida algo más fácil cuando aterricen las nuevas versiones de todo que se están cocinando.

Publicado en Variable not found.
Author: "noreply@blogger.com (José M. Aguilar)"
Send by mail Print  Save  Delicious 
Date: Monday, 22 Sep 2014 09:30

Estimados usuarios de Xailer,

En esta ocasión quiero simplemente compartir con vosotros formas sencillas de mejorar el IDE de Xailer que yo personalmente utilizo y espero que os pueda ser de utilidad a todos vosotros.

Por defecto, el editor de código fuente del IDE utiliza una fuente no proporcional de nombre ‘Courier’ que seguro que todos conocéis, que junto con la fuente ‘FixedSys’, vienen acompañando a Windows desde hace muchísimo tiempo, Desde hace tiempo decidí cambiar dicha fuente por defecto por alguna más bonita y actual (a mi modo de ver) y esta es mi elección:

https://www.google.com/fonts/specimen/Droid+Sans+Mono

Que podéis descargar desde la siguiente dirección:

http://www.fontsquirrel.com/fonts/droid-sans-mono

Seguro que alguno de vosotros ya está trabajando con otras fuentes en Xailer. Si es así os agradezco que lo indiquéis en los comentarios de este artículo.

Un saludo

Author: "--"
Send by mail Print  Save  Delicious 
Date: Monday, 22 Sep 2014 05:06

En los últimos posts vimos qué nos ofrece ReactJS a otras librerías para desarrollar interfaces de usuario con Javascript y construimos un componente de ejemplo con ReactJS para hacernos una idea de cómo trabajar con ReactJS.

Como ya vimos al crear el componente de ejemplo, ReactJS permite utilizar una sintaxis especial llamada JSX para generar las vistas, y es necesario realizar de alguna forma la conversión de este JSX al código Javascript puro que se encargará de construir el DOM. Esto se puede hacer directamente en el browser, pero es preferible hacerlo durante la “compilación” de la aplicación para minimizar el impacto en los clientes que accedan a nuestra aplicación web.

En este post vamos a ver cómo podemos aprovechar herramientas basadas en node.js para crear un flujo de trabajo basado en grunt que nos facilite el desarrollo de aplicaciones ReactJS.

Browserify

Browserify es una herramienta que permite organizar una aplicación Javascript en varios archivos y referenciar unos desde otros a través de require('module'), como si se tratase de una aplicación para node.js.

Browserify se encargará de unir estos archivos de manera “inteligente”, es decir, incluyendo sólo los módulos necesarios en el orden adecuado, y generar un único fichero listo para ser utilizado en el browser, ya sea incluyéndolo directamente en la página o a través de alguno de los sistemas de carga de módulos (AMD, CommonJS, UMD, etc.).

Para nuestro ejemplo vamos a usar browserify junto a grunt, por lo que deberemos instalar las siguientes herramientas:

npm install grunt-cli -g
npm install grunt --save-dev
npm install grunt-browserify --save-dev
npm install grunt-contrib-wath --save-dev

Técnicamente, la última dependencia no es necesaria, pero nos resultará útil para detectar automáticamente cambios en el código fuente y recompilar la aplicación.

Con esto instalado, podríamos crear un fichero de configuración para grunt como éste:

/*global module, require */

module.exports = function(grunt) {
  var srcFiles = ['Gruntfile.js', './lib/**/*.js', './specs/**/*.js'];
  grunt.initConfig({
    pkg: grunt.file.readJSON('package.json'),    
    browserify: {
      build: {
        options: {
          standalone: "app"
        },
        src: './lib/index.js',
        dest: './dist/app.js'
      }
    },
    watch: {
      dev: {
        files: srcFiles,
        tasks: ['browserify'],
        options: { spawn: false }
      }
    }
  });
  grunt.loadNpmTasks('grunt-browserify');
  grunt.loadNpmTasks('grunt-contrib-watch');
  grunt.registerTask('default', ['browserify']);
  grunt.registerTask('dev', ['watch']);
};

Ya vimos en su momento cómo configurar grunt, así que nos centraremos en la configuración de browserify.

En la configuración del task de browserify debemos indicar el archivo que contiene el “punto de entrada” a nuestra aplicación. A partir de él, browserify irá analizando los módulos importados y detectará automáticamente todos los archivos que necesita incluir en el resultado final. También debemos indicar el nombre del fichero de salida, en este caso ./dist/app.js y el “tipo” de resultado que queremos generar, en este caso app para indicar que será un script que incluiremos directamente en una página sin utilizar ningún sistema de carga de módulos.

Además hemos añadido un task watch (y un alias dev para ese task) que se encarga de detectar cambios en los fuentes y relanzar el proceso de compilación, haciéndonos la vida un poco más cómoda durante el desarrollo.

React-Tools

Lo que hemos visto hasta ahora es completamente genérico y podemos utilizarlo para cualquier tipo de aplicación. Si queremos desarrollar una aplicación con ReactJS, vamos a necesitar instalar algunos paquetes más:

npm install react --save-dev
npm install react-tools --save-dev
npm install grunt-react --save-dev

react es el módulo npm de ReactJS. Sería equivalente a incluir el script de ReactJS en la página, pero nos permite usarlo al “estilo node.js” usando un require('react') desde los archivos que luego pasaremos por browserify.

react-tools contiene, entre otras cosas, herramientas para transformar el código JSX en código Javascript, y grunt-react contiene todo lo necesario para integrar react-tools con grunt.

Con esto instalado, podemos modificar la configuración de browserify en grunt para incluir la transformación de los JSX:

  // ... el resto de la configuración no cambia
  browserify: {
    options: {
      transform: [ require('grunt-react').browserify ]
    },
    build: {
      options: {
        standalone: 'app'
      },
      src: './lib/index.js',
      dst: './dist/app.js'
    }
  },
  // ... resto de configuración

Escribiendo el código

Todo esto está muy bien, pero llevamos un rato y no hacemos más que instalar herramientas. ¿Cómo se escribe el código ahora que hemos montado todo esto?

Si volvemos al ejemplo de ReactJS que vimos en el post anterior, ahora podríamos partirlo en tres ficheros y organizarlo un poco (esto es, claramente, innecesario en un caso tan simple como éste, pero bueno).

En un primer fichero podemos definir el componente para mostrar un único elemento de la lista y dejarlo en un fichero BeerItem.js:

/** @jsx React.DOM */

var React = require('react');

var BeerItem = React.createClass({
  // ... código del post anterior
});

module.exports = BeerItem;

Utilizamos el típico sistema de módulos de node.js, con su require para acceder a otros módulos y su exports para definir lo que exporta este módulo. Es importante recordar que cada fichero debe empezar con la directiva /** @jsx React.DOM */ para que el preprocesador de ReactJS sepa cómo tratarlo.

La estructura del código para la lista completa (BeerList.js) es similar:

/** @jsx React.DOM */

var React = require('react');
var BeerItem = require('./BeerItem.js');

var BeerList = React.createClass({
  // .... código de post anterior
});

module.exports = BeerList;

Aquí además del módulo react que instalamos antes, estamos referenciando el módulo BeerItem que acabamos de crear.

Para finalizar, tendríamos el fichero index.js con el punto de entrada de la aplicación:

/** @jsx React.DOM */

var React = require('react');
var BeerList = require('./BeerList');

React.renderComponent(<BeerList/>, document.getElementById('content'));

Ahora para compilar el resultado final, podemos ejecutar grunt, y si queremos que se ejecuté automáticamente cada vez que cambiamos algo, grunt dev.

Tenéis el proyecto completo en github por si queréis jugar un rato con él.

Resumen

La sintaxis JSX usada por ReactJS para mezclar Javascript y HTML es algo que puede causar rechazo, sobre todo a los que estén muy preocupados por el rendimiento de las páginas y la comodidad a la hora de trabajar.

Con el conjunto de herramientas que hemos visto en este post no hay que sacrificar rendimiento al cargar nuestras páginas parseando el JSX (cosa que, por ejemplo, si ocurre con las directivas de angularjs) y podemos conseguir un flujo de trabajo muy cómodo a la hora de desarrollar.

Posts relacionados:

  1. Crear un componente con ReactJS
  2. ReactJS: un enfoque diferente
  3. Utilizar Chart.js con Knockout.js
Author: "--"
Send by mail Print  Save  Delicious 
Date: Saturday, 20 Sep 2014 07:27
Java

Java a partir de la versión 7 del JDK ofrece el soporte para recibir notificaciones de cambios en el sistema de archivos sin tener que estar monitorizándolos constantemente en busca de actividad. No tener que estar monitorizando los archivos de forma «polling» para buscar cambios además de hacer que el código sea más sencillo desde el punto de vista de la programación hace que no se malgasten recursos del sistema si los cambios son esporádicos.

Para ofrecer esta funcionalidad y a partir de Java 7 hay disponibles unas pocas nuevas clases dentro de lo que se conoce como la nueva API de entrada y salida (NIO) que sustituye al método tradicional de entrada y salida con las clases del paquete java.io entre otras cosas para trabajar con el sistema de archivos.

Para monitorizar los archivos y recibir notificaciones cuando se produzcan cambios en ellos deberemos emplear las clases Path y WatchService. Empleando estas dos clases el código para monitorizar cambios en los archivos de un directorio sería: registrar el servicio de monitorización obtenido de la clase FileSystems, escuchar los eventos cuando se produzcan y procesarlos de forma secuencial en un bucle. En el ejemplo se monitoriza el archivo fuente de una clase Java que es compilado en memoria e instanciada como explicaba en el anterior artículo:

<noscript><pre><code>package io.github.picodotdev.blogbitix.config; import java.io.FileReader; import java.io.Reader; import java.nio.file.FileSystems; import java.nio.file.Path; import java.nio.file.StandardWatchEventKinds; import java.nio.file.WatchEvent; import java.nio.file.WatchKey; import java.nio.file.WatchService; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.Map; import javax.tools.JavaCompiler; import javax.tools.JavaFileManager; import javax.tools.JavaFileObject; import javax.tools.ToolProvider; public class ConfiguracionManager { ... public ConfiguracionManager monitor() throws Exception { closed = false; Runnable task = new Runnable() { @Override public void run() { WatchService watchService = null; try { while (!closed) { watchService = FileSystems.getDefault().newWatchService(); path.getParent().register(watchService, StandardWatchEventKinds.ENTRY_MODIFY); WatchKey watchKey = watchService.take(); if (watchKey == null) { return; } for (WatchEvent&lt;?&gt; event : watchKey.pollEvents()) { Path p = (Path) event.context(); Path pp = path.getParent().resolve(p); if (path.equals(pp)) { load(); } } } } catch (Exception e) { throw new RuntimeException(e); } finally { try { if (watchService != null) watchService.close(); } catch (Exception e) {} } } }; thread = new Thread(task); thread.setDaemon(true); thread.start(); return this; } }</code></pre></noscript>

En este ejemplo solo se monitorizan los cambios de los archivos pero usando otras propiedades se pueden monitorizar la eliminación y creación, en la clase StandardWatchEventKinds pueden verse estas propiedades. Una cosa a tener en cuenta es que se pueden monitorizar directorios no archivos en concreto, pero como en el ejemplo una vez que recibimos las notificaciones de monitorización es algo que podemos hacer nosotros. Ejecutando el programa una salida del su funcionamiento podría ser la siguiente en el que la clase se recarga cuando se detectan cambios en ella variando los valores que se emiten en la consola.

Esta funcionalidad de monitorización de cambios de archivos junto con la compilación y carga dinámica de archivos con código fuente Java puede utilizarse para hacer que la configuración de una aplicación esté definida en código Java y se cargue dinámicamente sin tener que reiniciar la aplicación. Y esto es lo que mostraré en la siguiente entrada y explicaré con más detalles que ventajas tienen esta idea.

El código fuente completo puede encontrarse en el siguiente repositorio de GitHub.

Referencia:
Path
WatchService

Author: "--"
Send by mail Print  Save  Delicious 
Date: Monday, 15 Sep 2014 15:00

Captain Marvel – First Contact

Hace poco caí con la serie Captain Marvel a cargo de Peter David. Me gusta lo que leí de Hulk por el autor, y su Aquaman es un despelote. Fue quien hizo que Aquaman perdiera un brazo y lo reemplazara con un harpón, aparte de un cambio estético importante que es el que imagino para Jason Momoa en la película Batman V Superman :D. Varias de sus historias con Hulk son de las mejores historias escritas sobre el personaje.

Me enteré que Peter David también había llevado adelante Captain Marvel, no el de la Distinguida Competencia (que ahora cambió su nombre a Shazam!), sino el de Marvel Comics. Han habido muchos/as Capitanes Marvel, fueron todo una familia Marvel (en ese primer universo), y en el universo Marvel empezó siendo un alienígena de la raza Kree llamado Mar-Vell, el manto pasó por varias mujeres y hombres terrícolas y extraterrestres, y la Capitana Marvel actual es Carol Danvers (a no confundir con Ms. Marvel: Kamala Khan).

Si no conocen toda la historia con los superhéroes Marvel y les resulta medio confuso, no se preocupen, nada de esto es tan importante a la hora de leer este cómic. Aunque sí se disfruta más teniendo un poco de idea, si les interesa pueden arrancar por buscar Captain Marvel en Wikipedia y adentrarse en una aventura de horas siguiendo enlaces y leyendo artículos (¿hay un nombre para esa situación?).

Captain Marvel Vs. Hulk

Captain Marvel Vs. Hulk

A modo de introducción resumida, esta instancia de Captain Marvel es el hijo del Captain Marvel original (Mar-Vell, el Kree), se llama Genis-Vell y está unido a Rick Jones (el amigo de Bruce Banner responsable del accidente con la bomba gamma que lo transformó en Hulk, entre otras cosas) a través de dos brazaletes que al golpearlos intercambia a Rick y Genis-Vell de nuestro plano de existencia a la Zona Negativa (o por lo menos así lo plantea al principio) y viceversa. Ya en la época de la guerra Kree-Skrull Rick Jones tenía una relación así con Mar-Vell, por lo que no es casualidad.

La serie arrancó como spin-off de Avengers Forever, y tuvo una tirada inicial de 35 números. Luego se relanzó desde el número 1 (manteniendo la numeración original en la tapa también) y Peter David cambió completamente el tono. Estos números fueron los primeros que leí (a partir del #36, renumerado como #1) y me convencieron de conseguir todas las ediciones compiladas.

Lo que me atrajo enseguida fue el camino oscuro por el que empieza a transitar la personalidad del personaje. Me hizo acordar a Irredeemable de Mark Waid. Decidí empezar desde el principio, y tras investigar cómo se organizaba la cronología, volví atrás a Captain Marvel: First Contact.

Captain Marvel... ¿Shazam?

Captain Marvel… ¿Shazam?

Captain Marvel – First Contact incluye los números 1 al 6 y el #0. Es completamente distinto a lo que había leído en el #1 (36), pero no me arrepiento de haberlo obtenido también.

Para sacarlo del medio capaz, salta con el tema de Shazam! y Captain Marvel en el #0 de una forma bastante divertida, y creo que no se vuelve a mencionar. La página que incluyo a la izquierda de estos párrafos es la de la situación en cuestión y es buena representando la relación de los personajes de acá en más. El tono humorístico se mantiene con algunos guiños y hasta podría decirse “rompimiento de la cuarta pared”.

Las historias son bastante entretenidas, Rick y el Capi van desarrollando su relación -a las caídas en un principio. Mientras Rick intenta poner en orden su vida y arreglar las cosas con su esposa Marlo, el Capi aprende a usar su conciencia cósmica (el poder de saber todo lo que va a pasar y está pasando a escala universal, que también tiene Silver Surfer y otros personajes de cómics).

Marlo, la mujer de Rick, tiene sus propias aventuras y desventuras, haciéndola una parte importante de la historia. Trabaja en una tienda de cómics donde se dan algunos de esos chistes “internos” que comentaba.

Para animar todavía más las cosas aparecen otros personajes conocidos del universo Marvel como Hulk, Wendigo, Moondragon y Drax El Destructor.

Moondragon (Peter David) sobre la evolución

Moondragon (Peter David) sobre la evolución

También aparece el mundo atómico donde se desarrollan las historias que pueden leer en el compilado Hulk: Heart of the Atom, que leí hace poco y comenté en Multiverseros:

Hulk: Heart of the Atom es una compilación de varios números relacionados al mundo de K’ai, un planeta sub-atómico donde Hulk se enamora de Jarella. Hay historias de distintos niveles pero en general me gustó bastante. Me encanta Hulk y estas historias muestran distintas perspectivas de su personalidad y motivaciones, y presentan varios personajes del universo Hulkiano. Es una compilación interesante de parte de su historia, recomendado para amantes de Hulk.

Estas historias son mucho más livianas de lo que esperaba tras leer lo Waideano que comentaba más arriba, pero son bastante divertidas. El arte a cargo de ChrisCross es bueno, no es un despelote y tiene sus altos y bajos, pero está bastante bien y acompaña al estilo de la serie.

No encontré que los números entre 7 al 35 estuvieran coleccionados en tomos, pero me encantaría poder leer cómo sigue. Mientras tanto lo siguiente en mi lista es saltar a Captain Marvel: Nothing to Lose que empieza con la renumeración del #36 a #1 y arranca la historia oscura “Irredimieable”. Vamos a ver qué tal.

Si les interesa Captain Marvel, han leído historias de Hulk de Peter David y les gustaron, creo que les puede gustar este tomo. Igual tengo un poco más de expectativa por lo que se viene, pero me llevé una grata sorpresa con First Contact.

Author: "--"
Send by mail Print  Save  Delicious 
Date: Monday, 15 Sep 2014 07:06
Enlaces interesantesAhí van los enlaces recopilados durante la semana pasada, espero que os resulten interesantes ;-)

<Spam>Por cierto, aprovecho para informaros de que si estáis interesados en aprender ASP.NET MVC u otras tecnologías, en CampusMVP han lanzado para este mes una oferta que no podréis rechazar ;-)</Spam>

.Net

ASP.NET

Azure / Cloud

Data access

Html/Css/Javascript

Visual Studio/Complementos/Herramientas

Cross-platform

Otros

Publicado en Variable not found
Author: "noreply@blogger.com (José M. Aguilar)"
Send by mail Print  Save  Delicious 
Date: Monday, 15 Sep 2014 05:06

En el anterior post explicaba cuál es el enfoque de ReactJS para construir interfaces de usuario. Después de sentar las bases de la filosofía que hay detrás de ReactJS, en este post vamos a ver un pequeño ejemplo que nos permita hacernos una idea más clara que cómo se utiliza ReactJS.

El componente de ejemplo

El componente de ejemplo que vamos a construir está formado por una lista cervezas en la que podemos ir incrementando la cantidad de cervezas ingeridas y nos mostrará el total consumido hasta el momento. El aspecto será algo así:

react-sample

Lo primero que necesitamos es decidir de qué forma vamos a organizar la información que vamos a mostrar, decidiendo qué componentes vamos a crear y qué información será inmutable (propiedades) en cada componente y qué información será mutable (estado) en cada componente.

En este caso, podemos tener un componente que llamaremos BeerItem que represente cada elemento de lista. Este componente recibirá como propiedades inmutables el nombre de la cerveza a mostrar, el número de veces que se ha consumido, y la función callback que se invocará al tomarnos una cerveza más.

Además, tendremos un componente, BeerList que encapsula la lista de cervezas y la cuenta total. Esta información es mutable para este componente y, por tanto, formará parte de su estado. Cada vez que se incremente la cuenta de una cerveza, se modificará el estado de este componente y, por tanto, se provocará un nuevo renderizado del componente actualizando el DOM generado.

Creado los componentes

Un componente en ReactJS es un objeto javascript que contiene una serie de funciones y propiedades que son gestionadas por ReactJS. Para crear un componente, se debe utilizar la función React.createClass. Nuestro componente para mostrar un elemento de lista es el siguiente:

var BeerItem = React.createClass({
  incCount: function() {
    this.props.addOne(this.props.beer);
  },
  render: function() {
    return <li>[{this.props.count}] {this.props.beer} <button onClick={this.incCount}>Una más</button></li>;
  }
});

En el objeto que pasamos a createClass estamos definiendo la función render que se encarga de generar el DOM asociado al componente y una función adicional incCount que usa el componente para gestionar el evento asociado al click del botón.

Para acceder a las propiedades inmutables recibidas por el componente debemos usar this.props. Estas propiedades las recibe el componente en el momento de crearlo, cosa que haríamos con un código similar a éste:

<BeerItem beer="Mahou 5 estrellas" count=4 addOne=someFuncToAddOneBeer />

Lo más llamativo de todo esto es esa especie de pseudohtml que aparece mezclado con el código de javascript y que se usa como valor de retorno de la función render. Este pseudohtml es lo que ReactJS llama JSX, Javascript XML y ayuda a definir el DOM de una forma más cómoda. ReactJS cuenta con herramientas para convertir esta sintaxis a funciones Javascript “puras”, y aunque podemos hacer eso manualmente, en general resulta más claro usar JSX para definir los componentes.

La transformación se puede realizar directamente en el browser o en un proceso de precompilación en el servidor, lo que permite ahorrar tiempo de ejecución en el cliente y reutilizar las plantillas ya compiladas.

Ahora que tenemos el componente para mostrar una cerveza, vamos cómo es el componente que muestra la lista completa:

var BeerList = React.createClass({
  getInitialState : function() {
    return {
      beers: [
        {name: "Mahou 5 estrellas", count: 0},
        {name: "Cibeles Imperial IPA", count: 0},
        {name: "Chimay Triple", count: 0}
      ]
    };
  },

  addOne : function(beerName) {
    var beers = this.state.beers,
      beer = beers.filter(function(x) { 
        return x.name === beerName;
      })[0];

    beer.count ++;

    this.setState({beers: beers});
  },

  render: function() {
    var total, beerItems;

    total = this.state.beers.reduce(function(acc, x) {
      return acc + x.count;
    }, 0);

    beerItems = this.state.beers.map(function(x) {
      return <BeerItem beer={x.name} count={x.count} addOne={this.addOne} />;
    }, this);

    return <div><p>Llevas {total} cervezas</p><ul>{beerItems}</ul></div>;
  }
});

Este componente mantiene estado mutable, por lo que aparece la función getInitialState, que devuelve el estado inicial, y se utiliza la función setState para actualizar el estado. Cada vez que se invoca la función setState ReactJS se encarga de volver a llamar a la función render para volver a generar el DOM.

En su función render se están creando componentes de tipo BeerItem como los que hemos definido antes para representar cada elemento de la lista, y estamos asignándoles sus propiedades (información inmutable) a través de atributos del JSX. Como se puede ver, la forma de “comunicar” los componentes hijos con el componente padre es a través de una función callback, addOne, que se pasa como una propiedad más del hijo.

Si os fijáis, cada vez que se incrementa la cuenta de una cerveza se actualiza el estado, lo que fuerza a regenerar el DOM de todas las cervezas. Recordad que en realidad ReactJS trabaja generando un DOM virtual que luego compara con el DOM real para lanzar los mínimos cambios necesarios, por lo que esto no supone un problema de rendimiento. A cambio, cuando estamos en el método render tenemos toda la información (estado y propiedades) disponible, por lo que es muy sencillo razonar sobre ella y tomar las decisiones de renderizado adecuadas.

Por último, para empezar a mostrar un componente de ReactJS en una página debemos usar la función React.renderComponent indicando el componente a mostrar y el elemento HTML en el que vamos a insertar el DOM generado por el componente:

React.renderComponent(, document.getElementById('content'));

Podéis jugar con el código completo del ejemplo en este fiddle.

Resumen

Crear componentes de ReactJS es bastante sencillo, aunque hay que tener claro qué tipo de información queremos que sea mutable e inmutable en cada componente y cual es la jerarquía de componentes que queremos montar. Esto puede resultar algo confuso al principio, especialmente si estás acostumbrado al uso de patrón MVVM donde toda la información es mutable y la comunicación entre componentes se puede realizar en cualquier dirección y no sólo de padres a hijos.

Aunque no sea obligatorio, usar JSX es muy recomendable para generar el DOM porque mejora mucho la legibilidad. Lo malo es que eso hace necesario recurrir a herramientas externas para convertir el JSX a javascript puro, y eso complica un poco la experiencia de desarrollo. Aun así, en el próximo post veremos como podemos preparar un flujo de trabajo que nos simplifique la vida.

Posts relacionados:

  1. ReactJS: un enfoque diferente
  2. Crear modelos más ricos sin tipos enumerados
  3. Crear modelos más ricos quitando lógica de los servicios
Author: "--"
Send by mail Print  Save  Delicious 
Date: Saturday, 13 Sep 2014 22:00
Java

Desde la versión 1.6 del JDK disponemos de una API para acceder al compilador desde un programa Java. En el ejemplo de este artículo utilizaré varias clases de esa API para conseguir compilar un archivo con la definición de una clase Java y posteriormente instanciarla y usarla. En posteriores artículos comentaré un ejemplo práctico y muy útil con el que podemos sacar provecho de esta funcionalidad.

Las clases que necesitaremos de esa API son:

  • JavaCompiler que es la interfaz para acceder al compilador desde un programa Java.
  • JavaFileManager que es una abstracción para gestionar los archivos fuente y las clases. Usaremos uno propio llamado ClassFileManager.
  • SimpleJavaFileObject clase que contiene el código fuente Java.

Y también necesitaremos redefinir algunas:

  • La clase ClassFileManager que extiende ForwardingJavaFileManager y se encargará de cargar los objetos JavaClassObject con un ClassLoader.
  • La clase JavaClassObject que extiende SimpleJavaFileObject y contendrá el código bytecode generado en memoria por el compilador.
  • CharSequenceJavaFileObject clase que extiende SimpleJavaFileObject y que contiene el código fuente en un objeto de tipo CharSequence.
  • La interfaz Configuracion es la interfaz que debe cumplir la clase Java que compilaremos, cargaremos de forma dinámica en la aplicación y posteriormente invocaremos sus métodos.

En el javadoc de las clases hay una descripción más amplia de cada una de ellas.

En el siguiente código suponiendo que disponemos en la variable source de un código Java a compilar y de la que crearemos mas tarde una instancia de la clase que define podemos hacerlo de la forma indicada continuación. Antes de mostrar el código código la clase a compilar y a cargar de forma dinámica en este ejemplo debe cumplir el contrato definido en una determinada interfaz de modo que una vez compilada y cargada sepamos que métodos podemos invocar de esa clase. En este caso el código fuente de la clase a compilar está hardcodeada en un String en el propio programa pero perfectamente podría haber obtenido su contenido de un archivo del disco duro o de una base de datos.

<noscript><pre><code>package io.github.picodotdev.config; import java.util.ArrayList; import java.util.List; import javax.tools.JavaCompiler; import javax.tools.JavaFileManager; import javax.tools.JavaFileObject; import javax.tools.ToolProvider; public class Main1 { public static void main(String[] args) throws Exception { // Definir la clase String[] sources = new String[] { &quot;package io.github.picodotdev.blog.bitix;&quot;, &quot;import java.util.HashMap;&quot;, &quot;import java.util.Map;&quot;, &quot;public class AppConfiguracion implements Configuracion {&quot;, &quot;private static Map config;&quot;, &quot;static {&quot;, &quot;config = new HashMap();&quot;, &quot;config.put(\&quot;propiedad\&quot;, 11);&quot;, &quot;}&quot;, &quot;public Map get() {&quot;, &quot;return config;&quot;, &quot;}&quot;, &quot;}&quot; }; String source = join(sources); String name = &quot;io.github.picodotdev.blog.bitix.AppConfiguracion&quot;; // Compilar la clase JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); JavaFileManager manager = new ClassFileManager(compiler.getStandardFileManager(null, null, null)); List&lt;JavaFileObject&gt; files = new ArrayList&lt;JavaFileObject&gt;(); files.add(new CharSequenceJavaFileObject(name, source)); compiler.getTask(new NullWriter(), manager, null, null, null, files).call(); // Cargar e instanciar la case Configuracion configuracion = (Configuracion) manager.getClassLoader(null).loadClass(name).newInstance(); // Invocar un método de la clase System.out.println(configuracion.get()); } private static String join(String[] s) { StringBuffer sb = new StringBuffer(); for (int i = 0; i &lt; s.length; i++) { sb.append(s[i]); } return sb.toString(); } }</code></pre></noscript>
<noscript><pre><code>package io.github.picodotdev.config; import java.util.Map; public interface Configuracion { Map get(); }</code></pre></noscript>

Con este ejemplo puede intuirse el ejemplo práctico que comentaré que no es más que utilizar código Java para definir la configuración de una aplicación, esto tiene varias ventajas sobre utilizar un xml u otro tipo de formato de archivo de configuración de la aplicación (una de ellas que utilizando un IDE el compilador nos informará de errores y nos ofrecerá asistencia al escribir código). Esta idea junto con la posibilidad de monitorizar un archivo para ver si se han producido cambios en él (también con la API de Java) y recargarlo puede darnos como resultado una funcionalidad en la que la configuración se basa en código Java y que la configuración pueda recargarse de forma dinámica, si la aplicación se utiliza en un servidor de aplicaciones podríamos cambiar la configuración sin tener que reiniciar la aplicación.

Casi para terminar las clases de utilidad:

<noscript><pre><code>package io.github.picodotdev.blogbitix.config; import java.io.IOException; import java.security.SecureClassLoader; import javax.tools.FileObject; import javax.tools.ForwardingJavaFileManager; import javax.tools.JavaFileObject; import javax.tools.JavaFileObject.Kind; import javax.tools.StandardJavaFileManager; public class ClassFileManager extends ForwardingJavaFileManager { /** * Instance of JavaClassObject that will store the compiled bytecode of our class */ private JavaClassObject object; /** * Will initialize the manager with the specified standard java file manager * * @param standardManger */ public ClassFileManager(StandardJavaFileManager standardManager) { super(standardManager); } /** * Will be used by us to get the class loader for our compiled class. It creates an anonymous * class extending the SecureClassLoader which uses the byte code created by the compiler and * stored in the JavaClassObject, and returns the Class for it */ @Override public ClassLoader getClassLoader(Location location) { return new SecureClassLoader() { @Override protected Class&lt;?&gt; findClass(String name) throws ClassNotFoundException { byte[] b = object.getBytes(); return super.defineClass(name, object.getBytes(), 0, b.length); } }; } /** * Gives the compiler an instance of the JavaClassObject so that the compiler can write the byte * code into it. */ @Override public JavaFileObject getJavaFileForOutput(Location location, String className, Kind kind, FileObject sibling) throws IOException { object = new JavaClassObject(className, kind); return object; } } </code></pre></noscript>
<noscript><pre><code>package io.github.picodotdev.blogbitix.config; import java.net.URI; import javax.tools.SimpleJavaFileObject; public class CharSequenceJavaFileObject extends SimpleJavaFileObject { /** * CharSequence representing the source code to be compiled */ private CharSequence content; /** * This constructor will store the source code in the internal &quot;content&quot; variable and register * it as a source code, using a URI containing the class full name * * @param className * name of the public class in the source code * @param content * source code to compile */ public CharSequenceJavaFileObject(String className, CharSequence content) { super(URI.create(&quot;string:///&quot; + className.replace('.', '/') + Kind.SOURCE.extension), Kind.SOURCE); this.content = content; } /** * Answers the CharSequence to be compiled. It will give the source code stored in variable * &quot;content&quot; */ @Override public CharSequence getCharContent(boolean ignoreEncodingErrors) { return content; } }</code></pre></noscript>
<noscript><pre><code>package io.github.picodotdev.blogbitix.config; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.OutputStream; import java.net.URI; import javax.tools.SimpleJavaFileObject; public class JavaClassObject extends SimpleJavaFileObject { /** * Byte code created by the compiler will be stored in this ByteArrayOutputStream so that we can * later get the byte array out of it and put it in the memory as an instance of our class. */ protected final ByteArrayOutputStream bos = new ByteArrayOutputStream(); /** * Registers the compiled class object under URI containing the class full name * * @param name * Full name of the compiled class * @param kind * Kind of the data. It will be CLASS in our case */ public JavaClassObject(String name, Kind kind) { super(URI.create(&quot;string:///&quot; + name.replace('.', '/') + kind.extension), kind); } /** * Will be used by our file manager to get the byte code that can be put into memory to * instantiate our class * * @return compiled byte code */ public byte[] getBytes() { return bos.toByteArray(); } /** * Will provide the compiler with an output stream that leads to our byte array. This way the * compiler will write everything into the byte array that we will instantiate later */ @Override public OutputStream openOutputStream() throws IOException { return bos; } }</code></pre></noscript>

El código fuente completo puede encontrarse en el siguiente repositorio de GitHub.

En el siguiente artículo comentaré como monitorizar un archivo con código fuente Java para ver si se han producido cambios en él. Y basándome en estos dos artículos comentaré como disponer de un archivo de configuración que se recargue al detectase cambios en él.

Referencia:
Dynamic in-memory compilation

Author: "--"
Send by mail Print  Save  Delicious 
Date: Saturday, 13 Sep 2014 15:07

This 2' video shows "The spirit of Agile" as a lever for success in the mindset change.

the_spirit_of_agile

 

Credits:

  • Agile Coach: Silvia Sistaré.
  • Concept and Production: Blua Producers and Xavier Albaladejo
Author: "--"
Send by mail Print  Save  Delicious 
Date: Saturday, 13 Sep 2014 15:04

Como todos los días 256 del año, hoy se celebra el día de los programadores.

$ irb
2.1.2 :001 > Time.now.yday
 => 256

Esto que ya es una tradición por el blog, desde 2007 festejo todos los años el día con un post: Posts sobre el Día de los Programadores. Todos los años aprovecho la ocasión para comentar en qué ando programando.

Code Monkeys

Desde que me fui de Neo, estuve un tiempo de vacaciones, programando poca cosa cada tanto. Pero en agosto volví al mundo laboral, ahora como programador contractor para LivePress, un producto de live-blogging basado en WordPress. Tiene mucho de JavaScript, algo de PHP y algunas cosas más. Estoy bastante contento con el trabajo, la modalidad de trabajar desde casa (o desde cualquier otro lado donde haya internet) te da mucha libertad, es desafiante e interesante como para mantenerme entretenido y hay buena comunicación con el cliente.

También desde el año pasado programé varios proyectos de código abierto, la mayoría los publiqué por acá como ricojson, volumerb, gibil, y algunas cosas más. Si bien no son proyectos super útiles, me entretengo programándolos y son una buena forma de mantenerme en práctica. Tengo algunos proyectitos más que todavía no he publicado por ahí porque están sin terminar, pero es cuestión de otro fin de semana de proyectos :D

No puedo decir que esté usando alguna tecnología nueva, pero sí aprendiendo cada vez más JavaScript y metiéndome en ese mundillo (aunque esto viene pasando desde hace ya unos años). Pero cada vez me acerco más a poder decir que me siento cómodo con el lenguaje (aunque Ruby sigue siendo mi lenguaje favorito). También a medida que pasa el tiempo estoy cada vez más cómodo con Emacs y la línea de comando, voy usando de a poco cosas nuevas que voy aprendiendo que me hacen más productivo a la hora de interactuar con la computadora y programar.

Estimados lectores y lectoras que programan, ¡feliz día! ¿En qué están programando estos días? ¿Qué tecnologías nuevas han empezado a usar o aprender?

Author: "--"
Send by mail Print  Save  Delicious 
Date: Friday, 12 Sep 2014 16:34

¿CMMI?CMMI es un modelo para mejorar y evaluar la madurez de las empresas de software y la capacidad de sus procesos. La Administración americana lo puso en marcha (entonces como CMM) en los 80 a través de SEI para tener un medio con el que evaluar la fiabilidad de sus proveedores de software.

En los 90, las críticas hacia los modelos de procesos generaron su antítesis: la agillidad que los consideraba inapropiados, e incluso contraproducentes para el desarrollo de software.

Desde entonces hay dos tendencias estratégicas distintas para lograr la excelencia en proyectos de software: basar la calidad en la capacidad de los procesos, o basarla en el talento de las personas.

a) La calidad de un sistema de software es consecuencia de la calidad de los procesos empleados en su desarrollo. La evaluación de los procesos (CMMI, ISO 15504, Spice...) es la estrategia adecuada para determinar el nivel de calidad que ofrece la empresa.

b) La calidad de un sistema de software depende principalmente del talento de las personas. Contar con los mejores profesionales y un clima de trabajo adecuado es una garantía de éxito más fiable que la capacidad de los procesos de trabajo que tenga institucionalizados la empresa.

Aplicar las dos estrategias simultáneamente: procesos + talento es también una opción pero a menudo más quimérica que realista cuando se trata de sistemas de software innovadores, porque los procesos combinan bien con el trabajo disciplinado, pero no tanto con el talento creativo. De hecho la primera reacción al combinarlos fue el Manifiesto Ágil.

 
cmmi vs agile
 
 
Observando lo ocurrido con el proyecto healtcare.gob y las decisiones de la Casa Blanca en el último año:
 
Author: "juan.palacio@gmail.com (Juan Palacio)"
Send by mail Print  Save  Delicious 
Date: Tuesday, 09 Sep 2014 15:30

Este jueves voy a participar en un evento de D.A.T.A. y la Intendencia de Montevideo en el marco de Día del Futuro:

Día del Futuro

Día del Futuro

Vamos a charlar sobre tecnologías, datos abiertos, usos y demás. Vamos a tomar café, conversar y discutir maneras de hacer del mundo (empezando por Montevideo) un lugar mejor con tecnología y esos temas.  ¡Están invitados!

Jueves 11 de Setiembre – 16:00
Intendencia de Montevideo – Sala Dorada (piso 1 y ½).

Author: "--"
Send by mail Print  Save  Delicious 
Date: Monday, 08 Sep 2014 07:15
Enlaces interesantesPues era prácticamente ayer cuando dejaba en pausa el blog por la cercanía de las vacaciones, y ya estamos por aquí otra vez listos para la nueva temporada. Y no, no es que me haya pegado más de un mes de descanso (¡quién pudiera!), más bien casi ha sido al contrario: un verano bastante liado y muy pocos días de desconexión efectiva... pero bueno, contento y entusiasmado por la temporada tan apasionante y repleta de novedades que tenemos por delante :-)

Y para celebrar el retorno como la ocasión merece, ahí van unos cuantos enlaces cosechados durante la semana pasada, que, como siempre, espero que os resulten interesantes.

Eventos

.Net

ASP.NET

Azure / Cloud

Conceptos/Patrones/Buenas prácticas

Data access

Html/Css/Javascript

Visual Studio/Complementos/Herramientas

Otros

Publicado en Variable not found
Author: "noreply@blogger.com (José M. Aguilar)"
Send by mail Print  Save  Delicious 
Date: Monday, 08 Sep 2014 05:06

En los últimos años el auge de las aplicaciones basadas en HTML5 y Javascript ha sido imparable, y si a este lo unimos que Javascript no ofrece un conjunto de librerías estándar que dicte una forma canónica de hacer las cosas (como sí ocurre en otras plataformas como .NET o Java), es natural que este auge haya venido acompañado de la aparición de muchas librerías y frameworks para desarrollar este tipo de aplicaciones.

logo-reactjs

ReactJS es otra librería más diseñada para ayudarnos a desarrollar aplicaciones SPA, con una fuerte carga de interactividad en el cliente gracias al uso de Javascript. Ha sido desarrollada por Facebook y está publicada como Open Source con una licencia Apache 2.0.

Lo interesante de ReactJS es que aporta un enfoque distinto al que podemos ver en otras herramientas como KnockoutJS o AngularJS de las que ya hemos hablado por aquí en alguna ocasión.

OJO: este es un post de contar cosas, no de ver código. Si estás buscando eso, te sugiero que consultes la documentación de ReactJS o busques algún tutorial. Si quieres comprender mejor la filosofía que hay detrás de ReactJS, tal vez este post pueda ayudarte.

Una cuestión de alcance

Lo primero que debemos saber de ReactJS es que se trata de una librería para desarrollar interfaces de usuario. No estamos hablando de un framework todo incluido como AngularJS, Durandal o Ember, sino más bien de algo similar a KnockoutJS, al menos en cuanto a alcance.

ReactJS nos permitirá desarrollar el interfaz de usuario de una aplicación web, la V en un patrón MVC o MVVM, pero no incluye cosas como routing, acceso a servicios rest, inyección de dependencias, sistema de módulos, etc. A cambio, tampoco nos impone muchas restricciones sobre la forma de usarla, por lo que podemos mezclarla con otras librerías para conseguir el resto de funcionalidades.

Es bastante frecuente ver ReactJS usado en combinación con otras librerías. Hay quien ha integrado AngularJS y ReactJS (por motivos que ya veremos más adelante), y es habitual ver soluciones basadas en ReactJS y Backbone, una mezcla especialmente interesante puesto que Backbone aporta todo lo que le falta a ReactJS y no tiene un sistema de vistas propio.

El problema que trata de resolver ReactJS, al igual que todas estas librerías (o partes de estos frameworks), es el de construir un interfaz de usuario rico que permita mostrar en pantalla información sobre un modelo e interactuar con él. Esto es algo que puede complicarse rápidamente cuando tenemos mucha información a mostrar sobre distintos controles y necesitamos mantener sincronizada la información mostrada con el estado de los controles cada vez que se produce algún cambio.

La corriente general

Si pensamos en los frameworks y librerías más utilizados, AngularJS, Ember, Knockout, Durandal, etc., todos tratan de resolver el problema aplicando el patrón Model-View-ViewModel y un sistema de databinding bidireccional que se encargue de sincronizar automáticamente la vista y el viewmodel. Para ello suelen contar con algún mecanismo para definir declarativamente esos bindings y ahorrarnos mucho código.

El problema de este enfoque es que resulta muy difícil saber de antemano las implicaciones que tiene cada cambio. Al responder a una acción del usuario se provocan cambios en el modelo, que se propagan a distintos “controles” cuyo valores pueden cambiar, provocando nuevos cambios en el modelo y así sucesivamente, convirtiéndose en la fiesta loca de los rebotes:

Flujo de información MVVM

Cualquiera que haya trabajado con AngularJS se habrá encontrado alguna vez con el error “10 $digest() iterations reached” que indica que los rebotes entre modelo e interfaz de usuario no consiguen estabilizarse.

Este comportamiento hace que sea más complicado razonar sobre el flujo de información dentro de la aplicación y predecir el orden en que se acabarán ejecutando las cosas.

El enfoque alternativo

El planteamiento que realiza ReactJS es completamente distinto. ReactJS utiliza un sistema de databinding unidireccional, en el cual los controles son generados a partir de la información del modelo, pero la actualización del modelo se realiza de forma explícita.

Para montar este sistema, cada componente (control) de ReactJS cuenta con un método render que es el responsable de generar el HTML correspondiente al componente. Durante este proceso de generación, es posible enganchar manejadores de eventos a los elementos HTML para detectar cambios y actuar sobre el modelo. Cuando se producen cambios que afectan al estado interno del componente, éste se vuelve a renderizar por completo, no sólo aquellas partes el componente que han cambiado.

A simple vista, esto puede parecer sumamente ineficiente, pero aquí entra en juego una de las características de ReactJS que además lo convierte en una librería extremadamente eficiente: el Virtual DOM.

En lugar de generar directamente elementos HTML y modificar el DOM, que es una operación muy lenta, los componentes de ReactJS generan (renderizan) un modelo del DOM en memoria. Una vez generado el Virtual DOM completo, ReactJS se encarga de buscar las diferencias entre el DOM real y el virtual y realizar únicamente las modificaciones necesarias sobre el DOM real.

Esto implica un mayor consumo de memoria porque hay que mantener el Virtual DOM, pero generalmente no suele ser un problema y la mejora de rendimiento lo compensa. De hecho hay casos en los que compensa integrar este modelo con otros frameworks como AngularJS por la mejora de rendimiento que se consigue.

Para acabar de cuadrarlo todo, ReactJS mantiene una distinción muy clara entre dos tipos de información, las propiedades (props) del componente y el estado (state) del componente.

Las propiedades del componente están formadas por información que es inmutable para el componente. Esta información se recibe a través del objeto props en el momento de construir el componente y el componente puede asumir que no será modificada en ningún momento durante su ciclo de vida.

Se trata de información que el componente no “posee”, por lo que será otro componente el responsable de modificarla. Cuando esa modificación se produzca, el dueño de la información reconstruirá nuevamente todo su Virtual DOM asociado, incluyendo sus componentes hijos que serán creados desde cero con la nueva información. Es por ello que podemos asumir que durante el ciclo de vida de un componente, es decir, desde que se crea hasta que se destruye, esta información es inmutable.

El estado del componente se almacena en la propiedad state y está formado por aquella información que sí es gestionada y modificada directamente por el componente. Cada vez que se realiza un cambio en el estado del componente como respuesta a una acción del usuario (o a algún otro factor externo), ReactJS se encarga de renderizar nuevamente el componente por completo. Puesto que un componente puede contener otros componentes, en el proceso de renderizado se volverán a crear estos componentes hijos con la nueva información. Es posible (y habitual) que el estado mutable de un componente sean propiedades inmutables de sus componentes hijos.

En el siguiente esquema podemos ver cómo se genera la jerarquía la componentes y cómo se propaga la información de unos a otros:

Flujo de información reactjs

La información siempre fluye de componentes padres a componentes hijos, un componente hijo no puede modificar directamente el estado de un componente padre. Esto hace que sea más fácil razonar sobre el comportamiento general de la aplicación y las implicaciones de cada cambio realizado sobre el modelo y sobre el DOM.

Hay muchas situaciones en las que tenemos que notificar cambios en un componente hacia su padre. Para esos casos la solución es simple: incluir dentro de las propiedades inmutables que recibe el hijo al ser creado una función callback del padre que será invocada en el momento oportuno. De esta forma tratamos todo de forma homogénea y la función callback no es más que otro elemento más de las propiedades inmutables que recibe el componente al ser creado. Esto además nos ahorra recurrir a otro tipo de mecanismos, como eventos, con los cuales es más complicado seguir el flujo de ejecución.

A priori esta distintición entre estado mutable e inmutable puede parecer confusa, pero si lo piensas un poco es bastante más clara que otros sistemas como el anidamiento/aislamiento/copia de $scopes que hace AngularJS para solucionar el mismo problema.

Conclusiones

Como decía antes no soy ningún experto en ReactJS, así que no veas estas conclusiones como una verdad absoluta, sino como mi opinión personal en este momento sobre esta librería.

El alcance limitado de ReactJS puede ser un punto a favor o en contra, dependiendo de lo que estés buscando. Cuando empecé a analizar AngularJS ya avisaba de que si hacías una aplicación con AngularJS, te casabas con AngularJS, y un tiempo después eso se acabó convirtiendo en un problema.

Sin embargo, si no quieres tener que buscar componentes por separado e integrarlos tú mismo, recurrir a soluciones tipo “todo incluido” puede ser una buena salida, aunque hay que valorar los riesgos de ambas opciones (que los tienen).

En mi opinión, utilizar librerías específicas para cada responsabilidad de la aplicación es una buena estrategia a medio plazo, ya que permite cambiarlas por separado en caso de ser necesario y evita que acabes acoplando todo tu código a la filosofía de una librería concreta.

Esto es algo muy natural en plataformas como .NET, donde el acceso a datos te lo proporciona una librería, la capa de presentación otra, la inyección de dependencias otra, y así sucesivamente, pero en Javascript parece que hay una tendencia mayor a buscar la solución todo incluido.

El enfoque que tiene ReactJS para la gestión de la información en la vista me parece muy atractivo. Durante mucho tiempo utilicé un enfoque similar en aplicaciones de escritorio aplicando variaciones del patrón MVP (Model-View-Presenter) y siempre me resultó más fácil de seguir que el código basando en eventos y rebotes del patrón MVVM, aunque no cabe duda de que en esto hay un componente personal importante.

Además, con el tiempo he ido apreciando cada vez más el valor de la inmutabilidad y lo mucho que ayuda a razonar sobre un sistema, por lo que la separación que hace ReactJS entre lo que podemos considerar inmutable y lo que podemos considerar mutable en cada contexto (componente) me parece un acierto.

En próximos posts seguramente profundizaré un poco más en ReactJS y lleguemos a ver algo de código, pero como siempre, prefiero sentar las bases antes en empezar a trastear.

Posts relacionados:

  1. Datomic, una base de datos diferente
Author: "--"
Send by mail Print  Save  Delicious 
Date: Sunday, 07 Sep 2014 01:00
LyX

Hace unos días publiqué una nueva edición del libro PlugIn Tapestry, sobre el framework Apache Tapestry para el desarrollo de páginas y aplicaciones web con Java. En este artículo quiero recoger las herramientas que utilicé para escribirlo y algunas cosas básicas a conocer para tener un libro con un aspecto decente y más prefesional. Son cosas muy básicas pero que a mi me costo un poco poco encontrarlas para conseguir lo que quería, quizá a alguien le sirvan.

Herramientas

Empecé evaluando la herramienta más adecuada para escribir el libro, en un principio empecé con Google Docs, también con LibreOffice, sin embargo, al final descubrí LyX y fué el que empleé. ¿Por que LyX? Porque al contrario de Google Docs y LibreOffice que son procesadores de textos LyX es un procesador de documentos ¿que significa esto? Que con LyX te centras casi exclusivamente en escribir el contenido del libro no de estar formateándolo. Como procesador de documentos hace que no tengas tanto control sobre los estilos pero a la vez hace que todo el libro tenga un formato homogéneo y no tengas que «microgestionar» el estilo de cada elemento, en un documento grande de más de 250 páginas es muy útil y te evita casi todo el trabajo de mantener la coherencia en los estilos, ahorrándole a uno mucho tiempo.

LyX

LyX es una herramienta que funciona excelentemente, mucho mejor que LibreOffice según mi experiencia y tiene más posibilidades que Google Docs. LyX tiene varias funcionalidades que nos serán muy útiles como la creación de índices (también para figuras, cuadros, …), inclusión de figuras y referencias que permiten a un término hacer referencia a otra parte del libro, inlcuir los listados de código en archivos externos, …

Una de las primeras cosas que deberemos hacer es indicarle a LyX la clase de documento que pretendemos escribir a partir del cual se establecerán los estilos y opciones que LyX nos ofrecerá, también las secciones que dispondremos. Con la clase de documento book tendremos secciones numeradas y no numeradas, la diferencia es que además de unas tener numeración y otras no es que las numeradas aparecerán en el índice y las no numeradas no. Para ello seleccionamos Documento > Configuración.

Entre las mismas opciones podemos seleccionar las tipografías, el diseño de la página (A4, A5, …), los márgenes y una parte importe donde podremos modificar varios aspectos del documento, el preámbulo LaTeX, lo difícil de esta sección es saber cuales son las opciones podemos escribir en él pero si necesitamos modificar algo probablemente debamos insertarlo en esta sección. Un posible contenido es el siguiente donde defino y modifico el color de los hiperenlaces del libro y las opciones por defecto de los listados.

<noscript><pre><code>\usepackage{listings} \definecolor{tapestry}{RGB}{86, 157, 2} \definecolor{gris}{RGB}{200, 200, 200} \lstset{language=java,tabsize=4,breaklines=true,frame=single,rulecolor={\color{gris}}} \hypersetup{linkcolor=tapestry,citecolor=tapestry,urlcolor=tapestry}</code></pre></noscript>

Otras opciones deberemos incluirlas como código Tex al principio (Insertar > Código Tex) del documento, para establecer cuál es la palabra a emplear para nombrar los capítulos, figuras y listados que por defecto aparecerán en inglés en vez de español (Chapter 1 en vez de Capítulo 1). Este es el primer recuadro en rojo de la imagen LyX.

Con LyX si necesitamos reorganizar los capítulos o secciones es muy simple, para ello abrimos el panel del esquema, seleccionamos la sección o capítulo y pulsamos sobre las flechas de ordenación.

Fuente del documento

Podemos modificar la fuente del documento en Documento > Configuración > Tipografías. La fuente del elemento Romana será la que se use para la mayoría de elementos del documento.

Encabezados y pies de página

En Documento > Configuración > Diseño de página podemos establecer si queremos encabezados y pies de página en los que se incluye el número de página. Tenemos a nuestra disposición de varios tipos.

Referencias

Las referencias permiten hacer referencia a otra parte del documento donde el concepto esté explicado de forma más completa. Las referencias son creadas en dos pasos, primero toda sección del documento a la que queramos hacer referencia deberemos asignarle una etiqueta Insertar > Etiqueta.

Una vez que disponemos la etiqueta podemos insertar una referencia a ella en cualquier otra parte del documento con Insertar > Referencia cruzada. Disponemos de varios formatos para la referencia como texto al que hace la referencia o como la página en la que se encuentra.

Listados de código

Si el libro versa sobre un téma técnico y queremos mostrar listados de código tenemos dos opciones incrustar el código dentro del texto en LyX o hacer que se incluyan desde un archivo externo. En mi caso prefiero la segunda ya que de este modo si en algún momento queremos hacer alguna corrección a algún listado me parece más fácil hacerlo en el archivo externo que en el propio LyX, además el documento LyX queda más sencillo que con listados de código.

Para insertar un listado de código como documento externo debemos usar la opción Insertar > Archivo > Documento hijo, seleccionamos el archivo, en tipo de inclusión seleccionamos Listado de código y con el parámetro language=Java podemos hacer que LyX proporcione resaltado de sintaxis según el lenguaje del listado, en este caso Java.

Portada

Con LyX no podremos crear una portada atractiva dado lo limitado que estamos para modificar los estilos. Sin embargo, podemos incluir las páginas de un pdf externo a nuestro ducmento LyX. Este pdf externo lo podemos crear con la herramienta que queramos LibreOffice o Inskape. Con la opción Insertar > Archivo > Material externo podemos insertar todas las páginas del documento o solo las que queramos.

Corrector ortográfico

Parte de la revisión consiste en corregir los posibles fallos ortográficos que cometamos, LyX incluye un corrector ortográfico. Para hacer uso de él deberemos instalar los diccionarios, en Arch Linux instalaremos los paquetes aspell y aspell-es. Una vez instados podemos hacer uso del corrector con Herramientas > Corrector ortográfico, una vez iniciada la revisión podremos ir corrigiendo las palabras que no se encuentren en el diccionario.

Versiones en formato de libro electrónico (pdf, epub y mobi)

En un principio no lo tuve en cuenta pero con LyX es posible generar muy fácilmente además de la versión pdf, la versión epub y mobi del libro con la ayuda de Calibre. La versión de libro electrónico en formato epub y mobi es muy útil para los usuarios que posean un lector de ebooks como el Kindle o cualquier otro, el pdf también se puede leer en un ebook pero una página del pdf no entrará de forma completa en la pantalla y obligaremos al usuario a hacer varios cambios de página.

Una vez que tenemos nuestro documento podemos exportarlo a diferentes formatos, uno de ellos es pdf para ello seleccionamos la opción Archivo > Export > PDF (LuaTeX). Para las versiones en libro electrónico deberemos exportar primeramente a formato LyXHTML una vez tenemos el libro en este formato comprimimos en un archivo zip todos los archivos que forman parte del libro (los genera en la misma ubicación del archivo .lyx). Este zip lo importamos en nuestra biblioteca de Calibre y a continuación lo empleamos para hacer la conversión a formato epub y luego a mobi. Con esto ya tenemos la versión en formato electrónico de nuestro libro que podrá ser leído de forma más cómoda en un libro electrónico.

Con LyX le podemos ofrecer al usuario la versión del libro que prefiera sin mucho trabajo por nuestra parte.

Revisión, difusión y publicidad

Para finalizar diré que escribir un libro es un trabajo que consume mucho tiempo y esfuerzo y aunque parezca que no escribir el contenido del libro puede no ser la parte más costosa, revisarlo me costó tanto como escribirlo así como el hacer la aplicación con los ejemplos, la página en la que la alojaría y el marketing para darlo a conocer lo máximo posible publicándolo en webs en las que sus usuarios podrían estar interesados, en este caso en JavaHispano, Barrapunto, en este blog y en los varios planetas en los que este blog puede publicar sus entradas.

Referencia:
Introducción a LaTeX/XeTeX/LyX

Author: "--"
Send by mail Print  Save  Delicious 
Date: Friday, 05 Sep 2014 16:30

Guardians Of The Galaxy

El martes pasado fui al cine a ver por segunda vez Guardianes de la Galaxia, y aprovecho para escribir al respecto. Seguramente ya se habrán enterado que es una de las películas más taquilleras del año, rompiendo varios récords de venta en el mundo. Si no la vieron, se están perdiendo una buena película.

Parece que Marvel encontró la fórmula para hacer el tipo de películas que yo quiero ver. Cada nueva entrega dentro de su universo cinematográfico me gusta más. Ya Captain America: The Winter Soldier había superado mis expectativas, pero Guardians Of The Galaxy me dejó más que sorprendido, pasando a mi lista de películas preferidas (no solo de Marvel).

Guardians Of The Galaxy

No es un título más en la creciente lista de cine de superhéroes. Es mas bien una película de aventuras, acción y ciencia ficción centrada en un grupo de antihéroes en el espacio. Combina de forma armoniosa estos géneros con bastante humor y la dósis justa no empalagosa de drama.

Los personajes son geniales, me hicieron encariñarme en el poco tiempo que dura la película. Me gustó cómo fue interpretado cada uno de ellos y las interacciones que se daban. Dudo que haya podido existir una elección mejor del elenco, todo se da de manera tan fluída y eficiente que no le cambiaría nada (veremos si sale una versión extendida con todavía más escenas más adelante). Son el tipo de personajes que me gustaría ver en una serie semanal de ciencia ficción en televisión dirigidos por Joss… Bueno, se entiende.

¿Sutileza? No, no van a encontrar ni un poquito de eso acá. La película incluye lo que en mi libro, es una de las mejores escenas en la historia del cine:

Rocket & Groot

La primera vez que salí de verla, hice el comentario “Es la Star Wars de esta década”, refiriéndome a la sensación que me había dejado. Tenemos naves espaciales peleando en mundos intergalácticos, seres alienígenas, una historia atrapante y divertida, y bastante sentimiento esparcido por los distintos componentes que la conforman. Ojalá los nuevos episodios de Star Wars vayan por este lado y no por el de las precuelas…

La música es un protagonista más, con una banda sonora de temas de los años 70 que combina muy bien con el ambiente espacial futurista. También hay canciones de las “épicas” de películas del estilo, y están equilibradas acompañando a la acción, pero el cassette de temas pop de Peter Quill…-perdón, Star-Lord- se lleva el premio. Veo que en el espacio encontraron una alternativa a las pilas, no creo que Quill se haya llevado un suministro de por vida de baterías AA al espacio, y recuerden que los walkman tienen piezas mecánicas así que gastan bastante.

No necesitan saber nada de antemano ni haber visto otra de las películas de Marvel para entender qué está pasando. Personalmente no conocía a los personajes principales más que de alguna aparición mínima como secundarios en algún cómic. Pero me dió cierta emoción escuchar en el cine que se hable de los Kree y Ronan el Acusador. Me encantó cómo llevaron a Thanos a la pantalla grande. Se ve como un tipo jodido, se impone, y da la sensación de que “todavía no vimos nada”. Va mi apuesta que Avengers 3 va a estar basada en Infinity Gauntlet con la intersección del universo cósmico de Marvel y los héroes de la tierra (no es una apuesta tan arriesgada a esta altura, se veía venir tras la escena post-créditos de Avengers y se confirma ahora con las Gemas del Infinito).

Mi recomendación final: véanla, ríanse, lloren (un poquito nomás) ¡y disfruten!

Author: "--"
Send by mail Print  Save  Delicious 
Date: Friday, 05 Sep 2014 14:30
JSConf Uruguay

JSConf Uruguay

Ya se están subiendo a YouTube los videos de la JSConf Uruguay 2014, realizada el pasado mes de marzo. Entre los videos van a encontrar charlas de Douglas Crockford, Jeremy Ashkenas, Angel Java López y más.

Pueden ir viéndolos en el canal de YouTube de la conferencia. Todavía no están subidas todas las charlas, pero anunciaron que van a ir subiendo más.

Con Pablo Terradillos y Pablo Cúbico, Mozillians argentinos, hicimos un taller sobre desarrollo de aplicaciones para Firefox OS. Creo que los talleres no fueron grabados, así que no creo que haya video. Estén atentos al canal de YouTube o sigan a @JSConfUY en Twitter para enterarse cuando haya novedades.

Si no pudieron ir y se quedaron con las ganas, estén atentos a JSConf Buenos Aires a realizarse a fines de noviembre. Todavía no hay muchos oradores anunciados, pero está abierto el llamado a charlas. En una de esas cruzo el charco en noviembre y me mando hasta ahí.

Author: "--"
Send by mail Print  Save  Delicious 
Date: Friday, 05 Sep 2014 08:16

Estimados usuarios de Xailer,

Tenemos el placer de anunciaros una nueva versión de Xailer que incluye un montón de novedades y mejoras, a destacar las siguientes:

    • General:
      • Potencial GPF en modo multithread
      • Correción en el pintado del background de controles
      • Perdidas de memoria esporádicas
    • IDE:
      • Creación de controles de usuario
      • TLabelExNuevo editor de propiedades
      • En sistemas multi-proyecto permitir enlazar ficheros de recursos de los proyectos hijos en el proyecto padre
      • Al ‘publicar proyecto’, comprimir todos y cada uno de los recursos que aparezcan en los ficheros .rc
      • Asistente para ordenación de controles por posición
      • Debugger: Mejor soporte de hashes y matrices
      • TTabControl: Permitir insertar pestañas en controles heredados
      • Editor:Actualizado a Scintilla 3.4.2
      • Editor:Soporte de PHP, JavaScript y HTML
      • Intellisense:Mostrar funciones de clase con distinta imagen
      • Intellisense:Mostrar lista con Ctrl+Sp aunque el simbolo haya sido resuelto
      • Editor DBF: Error en edición de tipos numéricos con decimales
      • Restaurar las ventanas despues de ejecutar en el mismo orden en que estaban
    • DataControls
      • TDbfDataset: Nuevo parámetro lScoped en método SetRelation
      • TMySQL: Soporte de tipos float con notación científica
      • TMySQL: Tipos MEMO y BLOB en DbStruct no estaban diferenciados
      • TWebDataSource: Nuevos métodos UpdateFile y DeleteFile
      • TWebDataSource: Error en operaciones de BulkExecute
      • TSqlite: Actualizada librería a la versión 3.8.4.3
    • Controles
      • TControl: Nuevas propiedades nAlignMarginLeft, nAlignMarginTop, nAlignMarginRight y nAlignMarginBottom
      • TFolderPage: Perdida de memoria
      • TFolderPage: El evento OnChangeFocus no se disparaba cuando cambiaba la página
      • TFlatBtn: Nueva propiedad nClrTextHot
      • TBrowse: Error de ajuste de ancho de la columna cuando ésta tiene varias líneas
      • TMenuItem: Error si el evento OnCheckState devolvía NIL
      • TPicture: Nueva propiedad nTimeFrame para Gifs animados que indica el tiempo de espera entre frames de la imagen
      • TEdit: Nuevo método Replace idéntico al existente en TMemo
      • TLabelEx: Soporte de color con formato <#rrggbb>
      • TPicture: Parametro nBgColor adicional en método MakeThumbnail()
    • Clases
      • TZipArchive: Error en lPathRelative
      • TCanvas: Nuevo método Polygon
      • TIni: Nuevo parámetro lTrim en método SetEntry
      • TSysImageList: Perdidas de memoria
    • Fast-Report
      • TFastReport: Nueva propiedad lLoadOnDemand
      • TFastReport: Soporte de códigos QR
      • TFastReport: Nuevos métodos: ClearVariables, VariablesList y CategoryList
      • TFastReport: Nuevo método SetFormatSettings
      • TFastReport: Preview incompleto cuando se lanzaba después de haber entrado en modo diseño
      • TFastReport: Error en carga de datasets vacios en modo diseño
      • TFastReport: Error en establecimiento de variables de categoría Xailer
      • TFastReport: Error en establecimiento de valores antes de que se cargara la DLL
      • TFRDataset: Nueva propiedad lLoadOnDemand
      • TFRDataset: Error con determinados tipos de ADS
      • TFRPreview: Nueva propiedad lBtnClose
      • TFRPreview: Nuevos métodos Close() y PreviewClose()
    • Funciones
      • Nueva función XA_Is_Win8()
      • GPF en StrEncodeEscape() cuando se usaba como primer parámetro una cadena vacía
      • Nueva función Polygon()
      • Nueva función EnumResourceNames( <hModule>, <cType> | <nType> ) –> aResourceNames
    • Ejemplos
      • Nuevo ejemplo de FastReport

Os recordamos que para poder usar esta nueva versión hay que tener una suscripción activa de Xailer y que exige realizar de nuevo el registro de todas sus instalaciones. Todos los usuarios con suscripción activa deben haber recibido un E-mail con la nueva información de registro, pero en cualquier caso puede volver hacer el registro directamente desde la opción de menú Ayuda-Registrar el producto.

En caso de no tener una suscripción activa sólo podrá utilizar Xailer 3.3. en modo DEMO y por lo tanto deberá instalarla en un distinto directorio.

Un saludo

[El equipo de Xailer]

Author: "--"
Send by mail Print  Save  Delicious 
Date: Thursday, 04 Sep 2014 19:14

cubo Descargar Descargar el artículo en formato pdf.

Introducción

Es tanta la información de estándares, modelos, marcos y prácticas para desarrollo de software, que apostar por uno u otro puede acabar siendo más una decisión guiada por conformidad con la mayoría, que por conocimiento y  evaluación de las opciones existentes. Para ayudar en esta decisión este artículo dibuja el marco general de los modelos de procesos y prácticas de la industria del software: CMMI, ISO 15504, Scrum, Extreme Programming, DSDM, MSF, RUP, PMI, etc. en una síntesis ejecutiva que muestra los principios de los principales modelos, sus fortalezas y debilidades.

Author: "juan.palacio@gmail.com (Juan Palacio)"
Send by mail Print  Save  Delicious 
Next page
» You can also retrieve older items : Read
» © All content and copyrights belong to their respective authors.«
» © FeedShow - Online RSS Feeds Reader