Noticias Weblogs Código

Blog Bitix

Agregador Blog Stack rediseñado

September 30, 2014 07:00 PM

Blog Stack

Estas últimas semanas he podido dedicar un poco de tiempo a al proyecto personal de Blog Stack. Blog Stack es un agregador o planeta de bitácoras en español sobre linux, sotware libre, programación, desarrollo, metodologías ágiles y tecnología. En dos artículos anteriores explicaba más en detalle que es Blog Stack, en uno de ellos hacía una descripción y presentación y en otro explicaba como está hecho en el aspecto técnico tanto detallando cuales son las tecnología que usa como la arquitectura del proyecto.

En este tiempo que he podido dedicarle he mejorado el diseño y aspecto visual de la página, destacando a dos columnas los últimos artículos agregados, incluyendo etiquetas con imágenes y modificando ligeramente el menú de navegación al archivo, preguntas frecuentes y como solicitar agregar una bitácora. Probablemente cuando tenga más ideas, un poco más de tiempo y el ánimo para implementarlas siga mejorándolo más. Pero el rediseño no ha sido todo, he credo una cuenta de twitter para BS de modo que los artículos que vaya agregando sean publicados en tweets de forma automática y posiblemente lleguen a más gente.

Si tienes una bitácora de la temática de BS con pocos “offtopics” y quisieras agregarla en un apartado de las preguntas frecuentes tienes las instrucciones, basta con un correo electrónico o una petición en GitHub y una información básica sobre tu bitácora. Blog Stack tiene algunas características que otros agregadores o planetas carecen para los editores, por ejemplo, agregar de forma segura los gist de GitHub, vídeos de youtube o vimeo, presentaciones de SpeakerDeck o publicidad de Amazon de modo que el contenido agregado se presente de forma muy parecida que en la bitácora original. Además, BS es capaz de mostrar publicidad de la bitácora agregada si usa AdSense o los comentarios de las entradas si usa Disqus. En el caso de los lectores pueden suscribirse únicamente a determinadas etiquetas de Blog Stack si solo están interesados en determinados temas.

La siguiente acción que realizaré será preguntar a los autores de algunas buenas bitácoras si quisieran agregarse a BS. En muchos casos por las licencias de creative commons que muchos empleamos para nuestras bitácoras podría hacerlo sin preguntar pero prefiero hacerlo antes por lo que considero las formas correctas y cortesía.

» Leer más, comentarios, etc...

Variable not found

Declaración de variables en expresiones de C# 6

September 30, 2014 11:52 AM

C#Seguimos comentando novedades que encontraremos en la próxima versión de C#, y en esta ocasión vamos a ver una nueva característica que, sin resultar espectacular, sí nos va a proporcionar una fórmula más cómoda y concisa para resolver algunos escenarios bastante habituales.

Seguro que os resulta familiar el siguiente código, más que nada porque lo habréis escrito decenas o cientos de veces:


Personalmente, la introducción de parámetros out en las llamadas siempre me resulta incómodo porque me hace volver atrás para declarar una variable expresamente para la ocasión. Y hay otros casos en los que la sensación de vuelta atrás es igualmente molesta.

Pues la respuesta de C# a este frecuente escenario, y como veremos enseguida a otros más, son las llamadas declaration expressions, que vendrá a traducirse como expresiones de declaración o algo así. Esta nueva característica permite introducir declaraciones de variables en el interior de expresiones, por lo que el ejemplo anterior podría implementarse de forma más concisa:



Como podréis observar, hemos introducido la declaración de la variable en línea, justo en el lugar en el que la vamos a necesitar, lo que nos ahorra esa molesta vuelta atrás para declararla.

Veamos otro ejemplo. Esta vez vamos a utilizar una expresión declarativa con un parámetro ref que inicializamos también sobre la marcha:



¿Interesante, verdad? Pues veamos otro ejemplo bastante frecuente: el uso de variables para almacenar temporalmente el resultado de una expresión que necesitamos reutilizar más adelante. Seguro que no son pocas las veces que os encontráis con un escenario como el siguiente:



Por supuesto, a nadie se le ocurriría dejar ese código así; lo normal sería utilizar su equivalente más legible y eficiente:

image

Pues bien, usando la declaración en expresiones podríamos obtener un código como el siguiente:

image

Con esto, además de no tener que volver atrás para declarar la variable cuando estamos escribiendo el if, habremos conseguido en efecto colateral bastante interesante: no polucionar el bloque de código en el que nos encontramos con variables que sólo tienen sentido en un ámbito interior.

Es decir, en el nuevo C# la declaración de una variable en una expresión dará a ésta visibilidad únicamente en el interior del bloque de código en el que la utilizamos. Volviendo al ejemplo anterior, la variable index sólo será visible dentro del if, que es precisamente donde la necesitamos.

Como ya habréis adivinado, podemos utilizar este tipo de expresiones en cualquier punto de nuestro código: prácticamente, en todos los lugares en los que podamos introducir expresiones, podremos declarar variables. Esto quiere decir que también tendremos capacidad de usar esta característica desde el lado oscuro de la legibilidad:



Una última observación. Habréis notado que no es necesario indicar explícitamente el tipo de dato cuando declaramos variables de esta forma. Siempre que la inferencia de tipos tenga información para hacer bien su trabajo podremos usar var, mientras que en otras ocasiones tendremos que ser más explícitos. Vaya, que será exactamente igual que cuando declaramos variables de la forma tradicional.

En definitiva, creo que es una incorporación interesante al lenguaje que agilizará la codificación en esos escenarios tan frecuentes y, como efecto colateral, nos ayudará a que el ámbito de las variables sea más cercano a su punto de utilización. Pero como todo, úsese con sentido común ;-)

Y si queréis conocer más sobre el C# que se avecina, no os perdáis los posts anteriores de la serie:
Publicado en Variable not found.

» Leer más, comentarios, etc...

Picando Código

Revista The Original Hacker #9

September 29, 2014 03:00 PM

The Original Hacker #9

The Original Hacker #9

Está disponible de manera libre y gratuita la revista digital The Original Hacker. Es un proyecto que trata de Software Libre, Hacking y programación a cargo de Eugenia Bahit.

Pueden descargarla en este enlace, y acá tienen el resumen de esta edición:

Si la edición anterior de The Original Hacker a alguien le resultó fuera de lo común, con esta nueva publicación probablemente flipe por completo. Filosofía Zen, mitos derrumbados, recuerdos desenterrados y raros descubrimientos unidos por un denominador común: el verdadero espíritu Hacker.

El artículo estrella de la edición Nº9 de The Original Hacker, es el que mejor representa al verdadero espíritu de la palabra Hacker. Se trata de «Las 12 reglas del aprendiz de Hacker», una guía para no solo convertirse en un buen estudiante de sistemas, sino también, para aprender a emplear la inteligencia estratégica en beneficio de la propia sabiduría. Un artículo que bien aprovechado podría convertirse en el futuro «Zen del Hacker».

Con la llegada de la última versión LTS de Ubuntu, la 14.04, comenzaron los problemas con Apache. La mayoría, generados por una política poco acercada por parte de Canonical, que en el afán por hacer un sistema «apto para usuarios poco ávidos» terminaron excediéndose, llegando a establecer configuraciones por defecto en binarios destinados a programadores, como el caso del paquete apache2 disponible en los repositorios. Sin embargo, en medio del caótico resultado, uno de ellos, resulta ser un bug que Apache se niega a reconocer como tal. En esta entrega, la «explicación del bug #56883 de Apache y la forma de solventarlo» hasta tanto los desarrolladores se animen a revisarlo.

Para retomar con «cosas raras» un artículo que parece salido del cajón de los recuerdos ¿alguien se acuerda de las TUI, las Text User Interfaces? Para los amantes del scripting, una «guía de desarrollo con dialog, la herramienta principal para creación de TUI con GNU Bash» y su disponibilidad en otros lenguajes como Python.

Finamente, se hace honor al verdadero hacking avanzando sobre uno de los temas más controvertidos y que mayor cantidad de discusiones genera en el mundo del desarrollo de aplicaciones Web: la «ingeniería de Web Software con Python y ¡Sin Frameworks!» En esta oportunidad, desmitificando otro de los tantos mitos que corren sobre el terreno de las aplicaciones Web: «el manejo de sesiones». En este artículo queda demostrado como con un simple «pip» y unas pocas líneas de código, el manejo de sesiones en Python NO requiere de frameworks para aportar seguridad, confianza y un desarrollo sustentable a la aplicación.

Perderse esta edición, podría ser peligroso para la salud. ¡Disfrútenla!

Descarga: The Original Hacker #9

» Leer más, comentarios, etc...

Variable not found

Enlaces interesantes 171

September 29, 2014 11:55 AM

Enlaces interesantesAhí van los enlaces recopilados durante la semana pasada, espero que os resulten interesantes ;-)

.Net

ASP.NET

Azure / Cloud

Data access

Html/Css/Javascript

Cross-platform

Otros

Publicado en Variable not found

» Leer más, comentarios, etc...

Koalite

Reagent, una libería para usar ReactJS desde ClojureScript

September 29, 2014 05:06 AM

Después de conocer un poco con ReactJS, hacer un pequeño ejemplo con ReactJS y ver cómo podíamos automatizar la compilación de aplicaciones basadas en ReactJS, ha llegado el momento de cambiar de lenguaje y ver cómo podemos utilizar ReactJS desde ClojureScript.

ClojureScript es una implementación de Clojure que permite compilar código Clojure a Javascript, con lo que podemos ejecutarlo en el browser o incluso en plataformas como Node.js, en lugar de usar la JVM como motor de ejecución. Como era de esperar, con ClojureScript podemos utilizar las APIs nativas del navegador, pero además existen librerías que nos permiten trabajar de una forma más idiomática.

En el caso concreto de ReactJS, hay varias alternativas para utilizarlo desde ClojureScript. La más completa seguramente sea Om, que no sólo ofrece un interface sobre ReactJS sino que además aprovecha otras características “modernas” de Clojure (como los canales de core.async). Esto hace que sea una librería algo más intrusiva que el propio ReactJS, puesto que cubre un área mayor de la aplicación en lugar de limitarse a la pura generación del DOM.

En este post vamos a ver otra alternativa, reagent, que se define a si misma como un interface minimalista entre ReactJS y ClojureScript, y que no es más que eso, una pequeña capa de abstracción sobre ReactJS para poder escribir componentes de ReactJS de una forma más cómoda desde ClojureScript.

¿Por qué ClojureScript?

Dada la cantidad de lenguajes que compilan (o transpilan, según se mire) a Javascript, es razonable preguntarse por qué usar ClojureScript en lugar de, por ejemplo, TypeScript o ClojureScript.

Dejando de lado las bondades de Clojure como lenguaje, hay un par de factores que hacen que me parezca especialmente interesante la integración entre ClojureScript y ReactJS.

Por una parte, como vimos en el primer post de esta serie, ReactJS hace una distinción muy férrea entre la información mutable (state) y la información inmutable (props). Esto cuadra muy bien con la filosofía de Clojure, en la que por defecto la información es inmutable y existen mecanismos, como los atom para gestionar de forma explícita la mutabilidad.

Esto hace además que podamos mejorar el ya de por si excelente rendimiento de ReactJS. ReactJS utiliza un modelo de DOM Virtual sobre el que calcula diferencias para optimizar el renderizado en pantalla reduciendo al máximo el número de operaciones lanzadas sobre el DOM real. Para ello, necesita comparar las distintas versiones del DOM virtual y así detectar los cambios. Puesto que la mayoría de la información en Clojure se almacena en estructuras de datos persistentes (inmutables), esta comparación puede hacerse muchas veces realizando una simple comparación por referencia, lo que evita tener que recorrer estructuras de datos complejas para detectar cambios, acelerando así el proceso de renderizado aún más.

Por otro lado, y esto es una cuestión más personal, en ReactJS se utiliza una sintaxis especial, el JSX, para “mezclar” javascript con HTML a la hora de generar el DOM. En Clojure es frecuente utilizar técnicas similares, con librerías como Hiccup, por lo que esta forma de trabajar resulta bastante idiomática.

Un ejemplo

No voy a entrar en mucho detalle de cómo funciona ClojureScript (eso daría para un par de posts), pero vamos a ver un ejemplo de uso muy básico de reagent para poder compararlo con ReactJS.

Partiremos del mismo ejemplo de la lista de cervezas, en el que pretendíamos construir un interface como éste:

react-sample

En ReactJS, la forma de implementar cada componente era definiendo un objeto a través de la función React.createClass:

var BeerList = React.createClass({
  render: function() {...}
});

Con reagent, la forma más simple de implementar una función es a través de una función. Un componente en reagent no es más que una función que devuelve el DOM que se debe generar. Para ello, cuenta con una sintaxis parecida a la de hiccup, y la información inmutable que recibe el componente (las props de ReactJS) son directamente los parámetros que recibe la función. Existen otras alternativas para cubrir casos más complejos, pero de momento nos quedaremos con esta forma de trabajar.

Partiendo de esto, el componente que muestra la información de una cerveza sería algo tan simple como esto:

(defn beer-item [beer count]
  [:li "[" count "] " beer
   [:button {:on-click #(add-one! beer)} "Otra más"]])

Se trata de una función que recibe el nombre de la cerveza (beer) y las unidades consumidas hasta el momento (count) y genera el DOM necesario.

Para el componente que genera la lista completa, tendríamos algo así:

(defn beer-list []
  (let [total (reduce + (vals @beers))
        items (map (fn [[name count]] (beer-item name count)) @beers)]
    [:div
     [:p "Llevas " total  " cervezas"]
     [:ul items]]))

Aquí podemos ver una diferencia entre la manera de gestionar el estado mutable en ReactJS y en Reagent. En ReactJS es necesario utilizar las funciones getInitialState, setState y getState para tratar con el estado mutable, porque era necesario que la librería pudiese detectar cambios en el estado y así forzar el renderizado del componente que poseía ese estado.

En reagent se utilizan atoms para almacenar el estado mutable. Estos atoms no son exactamente los mismos que en Clojure, sino que son una implementación propia de reagent con algunas características especiales, pero exponen el mismo API que un atom de Clojure (y que podéis consultar en este post). A través de los atoms reagent puede detectar cuando se producen cambios en el estado y volver a renderizar a los componentes necesarios.

Aunque en el ejemplo se está utilizando un atom definido globalmente, es posible trabajar con atoms locales a cada componente si tiene más sentido.

El código completo del ejemplo sería éste:

(ns reagent-cljs.core
  (:require [reagent.core :as r]))

(enable-console-print!)

(def beers
  (r/atom {"Mahou 5 Estrellas" 0
           "Chimay triple" 0
           "Cibeles Imperial IPA" 0}))

(defn add-one! [beer]
  (swap! beers update-in [beer] inc))

(defn beer-item [beer count]
  [:li "[" count "] " beer
   [:button {:on-click #(add-one! beer)} "Otra más"]])

(defn beer-list []
  (let [total (reduce + (vals @beers))
        items (map (fn [[name count]] (beer-item name count)) @beers)]
    [:div
     [:p "Llevas " total  " cervezas"]
     [:ul items]]))

(r/render-component [beer-list] (.-body js/document))

Si tenéis curiosidad por ver cómo se estructura un proyecto de ClojureScript (o al menos una de las formas de estructurarlo), podéis echarle un vistazo en GitHub.

Una vez instalado leiningen y clonado el repositorio, tan sólo necesitáis ejecutar:

lein cljsbuild auto

El código se generará cada vez que se modifique algún fichero y podréis ver la página en funcionamiento abriendo el archivo index.html de la raíz del proyecto.

Resumen

Algunas de las ideas subyacentes a ReactJS hacen que encaje muy bien con un lenguaje como ClojureScript, especialmente por el tratamiento de la (im)mutabilidad y, en menor medida, por el uso de una sintaxis embebida en el propio lenguaje para la generación del DOM.

Reagent ofrece un interface simple sobre ReactJS para hacer que usarlo desde ClojureScript sea una experiencia muy cómoda. Como se puede ver en el ejemplo, el código que resulta mantiene un estilo muy típico de Clojure y aprovecha bastante bien las características de este lenguaje.

Posts relacionados:

  1. Crear un componente con ReactJS
  2. Cómo utilizar ReactJS con Browserify
  3. ReactJS: un enfoque diferente

» Leer más, comentarios, etc...

Juanjo Navarro

Cursos interesantes en Coursera

September 28, 2014 12:07 PM

Coursera

Estos días comienzan unos cuantos cursos en Coursera que quizá te interesen (yo estoy apuntado a un par de ellos):

  • Programming Languages
    Este no es un curso en el que se aprenda a programar. Es un curso para gente que ya sepa programar en el que se estudian los conceptos detrás de los lenguajes de programación. Se pone un gran énfasis en la programación funcional (es una buena oportunidad para aprender sobre ella) y durante el curso (que dura 10 semanas) se estudian los lenguajes ML, Racket y Ruby (aunque la elección de lenguajes es lo de menos, las técnicas que se estudian son aplicables a muchos lenguajes, sobre todo funcionales). Este es un curso que ya empecé en una edición anterior (hace algo así como un año ) y tuve que abandonar por falta de tiempo. Esta vez, espero completarlo.
  • Data Science Specialization
    Esta en realidad es una “especialización” de Coursera (una serie de cursos relacionados entre sí para especializarte en una materia). Aquí se trata de aprender sobre la “ciencia de los datos”: Cómo usar la informática para recolectar y analizar las grandes cantidades de datos disponibles hoy en día (secuencias de ADN, información sobre millones de estrellas disponibles en internet, etc). Yo seguramente no voy a hacer todos los cursos de esta especialización, pero por ahora me he apuntado a los siguientes:
    • The Data Scientist’s Toolbox
      Este es un curso muy corto (teóricamente son 4 semanas pero la verdad es que se puede hacer perfectamente en un fin de semana) donde se explican las bases para hacer el resto de cursos: Cómo instalar el software necesario, qué es Github y cómo crearse una cuenta, etc. Este ya lo he completado pero cada mes empieza una nueva edición.
    • R Programming
      Se oye mucho hablar últimamente del lenguage R (para análisis de datos y estadísticos) y este es el curso de la especialización en el que yo estaba más interesado. Ya lo he completado (termina hoy) y realmente me ha parecido muy interesante. R es un lenguaje super-especializado en el tratamiento de datos con cosas muy curiosas (como que todas las funciones, incluso la simple suma, funcionan con vectores, de tal manera que cuando escribes “a+b” en realidad estás sumando dos vectores que pueden contener 1 millón de datos cada uno). Igual que el anterior (y que todos los de la especialización) el curso inicia una nueva edición cada mes.
    • Getting and Cleaning Data
      Este es el que voy a empezar ahora. Se trata de utilizar el lenguage R para obtener los datos de distintas fuentes y en distintos formatos (CSV, XML, json) y limpiar los datos para dejarlos listos para la fase de análisis.

Y por ahora ya está bien. En la próxima entrada os hablaré de algunos otros cursos a los que no me he apuntado por distintas razones pero que creo que os pueden interesar.

» Leer más, comentarios, etc...

Blog Bitix

Configuración usando código Java

September 26, 2014 05:18 PM

Java

En las dos últimas entradas he explicado como compilar un archivo de código fuente Java desde una aplicación y como cargar esa clase compilada de forma dinámica para ser utilizada en un programa, la segunda entrada trataba el como monitorizar un directorio o archivo para ver si han tenido cambios con la nueva API que a partir de Java 7 disponemos.

En esta entrada quiero explicar un ejemplo de como aprovechar estas dos funcionalidades diferentes en un caso práctico y que nos puede ser útil en algún caso. La idea del ejemplo es definir la configuración de una aplicación como podría ser una aplicación web en un archivo de código fuente Java y que cuando se produjese algún cambio se recargase de forma dinámica.

Algunas ventajas de definir la configuración de la aplicación de esta manera son las siguientes:

  • Al ser el archivo de configuración código Java que se compila podemos aprovecharnos de la validación que hace el compilador para estar seguros de que está libre de errores léxicos y sintácticos, el archivo solo se cargará cuando está libre de errores de compilación. Al compilarlo el compilador nos advertirá de los errores que contenga de forma precisa.
  • Por otra parte al ser código en el archivo de configuración podemos usar el lenguaje Java para hacer ciertas operaciones que en un xml u otro formato de archivo de texto plano no podemos hacer. Podríamos hacer un cálculo o conectarnos a la base de datos u otro sistema para recuperar cierta información. En algunos casos el lenguaje Java puede ser mejor opción para describir la configuración que los archivos de texto, son los mismos problemas de ant y maven comparados con gradle. También el código Java puede ser la forma más breve y útil para describir la configuración de la aplicación que archivos de texto, usando código Java podremos devolver objetos, listas, … en vez de Strings o números.
  • La recarga del archivo de configuración cuando se produzcan cambios en él nos evitará tener que reiniciar la aplicación, simplemente haremos el cambio y la configuración se aplicaría. Esto puede ser útil en las aplicaciones web evitándonos tener que hacer un reinicio de la aplicación.

Una de las razones de la existencia de los archivos de configuración es tener esa configuración de forma externalizada a la aplicación de tal forma que podamos cambiar la configuración sin tener que modificar la aplicación ni tener que recompilarla. Con la compilación y carga dinámica de la clase Java de la configuración podemos tener estas mismas propiedades de los archivos de configuración. Si a esto le sumamos la recarga dinámica evitamos tener caídas de servicio en la aplicación por modificaciones en el archivo de configuración.

Todo esto es algo que se comenta en el libro The Pragmatic Programmer con las siguientes lineas:

Many programs will scan such things only at startup, which is unfortunate. If you need to change the configuration, this forces you to restart the application. A more flexible approach is to write programs that can reload their configuration while they’re running. This flexibility comes at a cost: it is more complex to implement. If it is a long-running server process, you will want to provide some way to reread and apply metadata while the program is running.

Esta es la teoría, veamos el código del ejemplo de configuración en Java con recarga dinámica. La mayor parte del código está en la clase ConfiguracionManager. Esta tiene dos métodos que son usados en la clase Main de la aplicación, el método load carga la clase y la compila, y el método monitor que monitoriza el archivo en busca de cambios y llama al método load cuando los detecte.

<noscript><pre><code>package io.github.picodotdev.blogbitix.config; import java.nio.file.FileSystems; import java.nio.file.Path; public class Main { public static void main(String[] args) throws Exception { Path path = FileSystems.getDefault().getPath(&quot;src/main/java/io/github/picodotdev/blogbitix/config/AppConfiguracion.java&quot;); ConfiguracionManager manager = new ConfiguracionManager(&quot;io.github.picodotdev.blogbitix.config.AppConfiguracion&quot;, path).load().monitor(); int n = 0; while (n &lt; 20) { Thread.sleep(2000); System.out.println(manager.get()); } } }</code></pre></noscript>
<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 { private String fullName; private Path path; private Configuracion configuracion; private Thread thread; private boolean closed; public ConfiguracionManager(String fullName, Path path) { this.fullName = fullName; this.path = path; } public Configuracion getConfiguracion() { return configuracion; } public Map get() { return configuracion.get(); } public ConfiguracionManager load() throws Exception { List&lt;String&gt; l = Arrays.asList(fullName.split(&quot;\\.&quot;)); String name = l.get(l.size() - 1); String source = loadSource(); 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(fullName, source)); compiler.getTask(new NullWriter(), manager, null, null, null, files).call(); configuracion = (Configuracion) manager.getClassLoader(null).loadClass(fullName).newInstance(); return this; } public ConfiguracionManager monitor() throws Exception { closed = false; Runnable task = new Runnable() { @Override public void run() { while (!closed) { try (WatchService 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); } } } }; thread = new Thread(task); thread.setDaemon(true); thread.start(); return this; } public void close() throws Exception { closed = true; } private String loadSource() throws Exception { StringBuffer source = new StringBuffer(); char[] buffer = new char[128 * 1024]; Reader reader = new FileReader(path.toFile()); int n = reader.read(buffer); while (n != -1) { source.append(buffer, 0, n); n = reader.read(buffer); } return source.toString(); } } </code></pre></noscript>

Esta idea de no utilizar archivos de configuración sino emplear código como la mejor forma y más breve de definirla es algo que hace gradle con los archivos de configuración del proyecto y apache tapestry para definir los módulos y la configuración del contenedor de inversión de control, parece una tendencia por el hecho de tener las propiedades y ventajas comentadas sobre otro tipo de archivos ya sean xml o sus sustitutos más recientes como yaml, json, … que son más compactos y legibles que xml pero que siguen adoleciendo de algunos de los mismos defectos.

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

» Leer más, comentarios, etc...

Picando Código

Debian Jesse con GNOME 3

September 26, 2014 04:00 PM

Debian Jessie + GNOME Shell

Debian Jessie + GNOME Shell

Hace poco Debian volvió a elegir a GNOME como entorno de escritorio por defecto. En noviembre de 2013 Debian cambió GNOME por XFCE pero tras una recalificación, XFCE perdió su lugar.

Aparentemente las razones principales son la accesibilidad y la compatibilidad con systemd.

La verdad que mi experiencia con GNOME y Debian viene siendo lo suficientemente buena como para que no me ponga a pensar en probar otro entorno de escritorio. Cuando volví a Debian de ArchLinux, comenté un poco las primeras impresiones.

Me resulta sumamente práctico que la tecla “Windows” (o Super) sea un atajo de teclado que nos deja ver las “actividades” y elegir aplicaciones de cualquiera de los escritorios, reacomodarlas arrastrando y soltando, o buscar aplicaciones y lugares desde el lanzador. Es lo que se ve en la imagen que acompaña esta nota. Siempre uso 4 escritorios virtuales y me sirve para separar distintos perfiles de actividad.

El “lanzador” hoy en día se ha transformado para mí en parte imprescindible del uso de la computadora. Lo que antes haría desde un menú de aplicaciones o con “ejecutar comando” (Alt + F2), ahora lo hago apretando la tecla “Windows” y empezando a escribir las primeras letras del comando. Generalmente el sistema es lo suficientemente inteligente como para mostrarme lo que quiero usar a las pocas letras de haber empezado.

GNOMELas aplicaciones que más uso son 3 básicamente: La terminal, el navegador web y el procesador de texto. Para la terminal vengo usando desde hace años la terminal al estilo “Quake”, cuando usaba KDE era Yakuake y desde hace un tiempo Guake.

Lo único que me presenta problemas en todo el entorno es que usando 2 monitores, cuando salgo de Guake el foco puede estar en cualquier lado y nunca está donde esperaría. Creo que es mas bien un problema de definir el foco con el mouse en las preferencias. Según un comentario que dejaron en la entrada que enlazo más arriba del cambio de XFCE a GNOME, este problema estaría arreglado en la versión más nueva. Pero a su vez estoy usando cada vez menos el mouse por lo siguiente:

Un ejercicio que hago de hace unos años cada tanto, es poner el mouse a la izquierda del teclado. Esto hace que use más la mano que menos uso -en mi caso al ser derecho- la izquierda. Para los zurdos aplica lo mismo poniendo el mouse a la derecha del teclado. La idea es que esa parte del cerebro que se encarga de dirigir el brazo que no usamos haga algo, y a la vez que esa mano no sea tan inútil. Un efecto colateral interesante es que al empezar a acostumbrarme de cero muchas veces elijo usar el teclado y creo que me muevo mas rápido o por lo menos de manera más eficiente eligiendo la aplicación que quiero usar desde el teclado mismo.

En cuanto al navegador, uso Firefox y las herramientas para desarrolladores para todo lo que sea desarrollo con JavaScript. La consola web, el editor de estilos, el inspector, son herramientas imprescindibles que ya vienen instaladas con Firefox (o Iceweasel en Debian).

Mi procesador de texto es Emacs y hago todo lo que es programación y “funcionalidades de IDE” con Emacs y la terminal. También uso Thunderbird para el correo, y prácticamente todo lo demás que necesito está en el navegador.

Una herramienta que ayuda mucho a la personalización de GNOME es gnome-tweak-tool (disponible en los repos de Debian) que entre otras cosas permite gestionar las extensiones.

Debian Jessie va a entrar en modo código congelado en noviembre, así que de a poco se va a ir preparando la próxima versión estable de Debian. En breve seguramente llegue a Debian Testing la versión 3.14 de GNOME que trae varias mejoras, veremos qué tal está:



» Leer más, comentarios, etc...

Picando Código

Oktober Datafest 2014

September 25, 2014 02:00 PM

Oktober Datagest

Empieza el mes de los datos abiertos nuevamente en Uruguay \o/

Como vienen haciendo desde 2012, DATA organiza este octubre un Datafest, una serie de eventos para fomentar la creación de aplicaciones sociales en base a datos abiertos:

Buscamos desarrollar aplicaciones, visualizaciones o herramientas bajo licencias de software libre y a la vez colaborar en la resolución o visibilización de problemáticas sociales.

Este año el Oktober DATAFEST estará compuesto por 4 actividades. A lo largo de los distintos eventos los equipos seguirán un proceso de creación, desarrollo y puesta en funcionamiento de los proyectos. Si ya pensaste alguna idea (aunque aún no tengas equipo) te recomendamos que la subas al hackdash, así se puede ir sumando gente, podés ir recibiendo comentarios y la empezamos a trabajar.

El 1er evento será este sábado 27/09, nos juntamos en Crafted Code (Bvar. España 2529) a las 15:00 hs. para darle forma a las ideas y los equipos detrás de ellas. ¡Ideal para curiosos!

No te olvides de anotarte en: https://eventioz.com/oktober2014

Oktober Datafest 2014

Oktober Datafest 2014


» Leer más, comentarios, etc...

Blog de Federico Varela

Maratón de Punta del Este 2013 - Previa

September 23, 2014 11:41 PM

Lo que hace unos meses era un sueño lejano, dentro de pocas horas será un desafío real. El domingo 22 de setiembre a las 8 am estaré en el arco de largada sintiendo la adrenalina de correr por primera vez una maratón, 42 kilómetros de goce y sufrimiento. Quedan atrás las excusas y dolores, cuando el cuerpo diga basta y la cabeza empiece a flaquear, habrá que correr con el corazón en la

» Leer más, comentarios, etc...

Variable not found

Uso de miembros estáticos en C# 6, ¿una buena idea?

September 23, 2014 11:58 AM

En posts anteriores hemos hablado del operador de navegación segura “.?” y de la inicialización de propiedades automáticas, y vamos a comentar ahora otra de las novedades de la versión de C# que viene en camino, pero que en esta ocasión no tengo claro que sea un avance en la dirección correcta. Os lo cuento y ya decidís vosotros ;-)

Hay escenarios en los que en el interior de una clase utilizamos de forma intensiva miembros estáticos de otras clases. Un ejemplo habitual podemos encontrarlo en componentes que hagan mucho uso de System.Math para la realización de cálculos matemáticos, o incluso en el conocido System.Console:



Pues bien, en C# 6 podremos indicar mediante un using que vamos a realizar llamadas a miembros estáticos de la clase que indiquemos, por lo que no será necesario especificarla en cada llamada:



Internamente, cuando el compilador encuentra esas llamadas a WriteLine() o ReadLine(), determinará que pertenecen al objeto System.Console porque no existe ningún otro candidato más apropiado que las implemente. Si la propia clase Program dispusiera de un método estático WriteLine(), se habría utilizado éste.

También se tienen en cuenta casos en los que la llamada pudiera resultar ambigua para evitar. Por ejemplo, si estamos haciendo un using de dos clases que implementan un método estático con el mismo nombre y signatura, el compilador se quejará y tendremos que referenciarlas de forma explícita, como hemos hecho hasta ahora.

Ciertamente usando esta característica podemos ahorrar muchas pulsaciones de teclas, así como hacer más claro nuestro código… ¿o no? El problema lo veo justamente ahí: en la claridad. Aunque visualmente el código resulta menos denso y más fácil de leer, estamos incluyendo un cierto grado de “ofuscación” (por llamarlo de alguna forma) que puede complicar la comprensión de lo que se hace o dónde se hace. Por ejemplo, fijaos en las llamadas que se realizan desde el siguiente método:



Podemos ver que usamos muchos métodos matemáticos y por tanto sería un caso de uso de esta nueva característica del lenguaje, pero en un vistazo no se sabríamos quién los está implementando. En versiones de C# anteriores a la 6, podríamos asegurar que Sinh(), Pow(), Sqr() o Floor() son miembros de la clase actual o algunas de sus antecesoras, pero en la nueva versión un using System.Math al principio del archivo podría invalidar esta afirmación.

De hecho, ni aún existiendo ese  using System.Math  podríamos estar seguros de dónde se encuentra definido un método, porque podríamos tener una implementación local a la clase del mismo que sería la utilizada aunque a nivel de código no quede explícitamente indicado. Y también puede dar lugar a confusiones casos como la llamada a Sqr() del código anterior porque, aunque parezca lo contrario, no existe en System.Math (el método que realmente existe es  Sqrt()).

En fin, supongo que ocurre como con muchas otras características del lenguaje, que no son de por sí buenas ni malas: todo depende del uso que se les dé. Probablemente hacer un uso razonable de esta característica en un contexto concreto y acotado podría ser útil para ahorrarnos trabajo, pero no tengo claro si el coste en términos de legibilidad compensará en muchos casos.

Ya con el tiempo, cuando vea cómo se utiliza y los problemas que crea en proyectos reales igual cambio de idea, pero de momento pienso que se podían haber ahorrado el esfuerzo.

Publicado en Variable not found.

» Leer más, comentarios, etc...

Arragonán

Semanas 326, 327 y 328

September 23, 2014 12:53 AM

Nada menos que tres, sí, TRES semanas acumuladas sin resumen semanal. Mezcla de cantidad de trabajo, despistado que es uno y la innegable pereza cuando he tenido tiempo para dedicar un rato a ponerme a recopilar y escribir el resumen.

Y que curioso me ha resultado repasar las cosas que hice hace tres semanas, me da la sensación que fue hace más.

Pasé por las Geek’s Talks, donde estuvimos hablando de frameworks y las librerías de desarrollo que estamos usando cada uno. En mi caso hablé un poco sobre las que vengo utilizando en los últimos meses: que si Ruby on Rails, que si Grails, que si JQuery, que si últimamente sufro estoy trabajando con Cordova, que estoy empezando con Angular, que si un poco de Sinatrarb… tampoco entramos en mucho detalle, pero estuvo bien como hilo conductor de la conversación.

Tuvimos una reunión/café/comida en Cuéntica. Un puñado de personas estuvimos intercambiando opiniones sobre el desarrollo de APIs. Por la parte de la crew de Cuéntica estaban David Olmos y Guillermo Latorre; por la crew de Spines Pablo Jimeno, Francho Joven y Rafa García, y como devs indepes Néstor Salceda y yo mismo. Siempre es un placer juntarse con colegas para hablar de lo que sea, aunque sea trabajo :)

Hacía unas semanas que venía colaborando en la organización de una charla de David Cabo sobre datos abiertos que se hizo el día 11. Se nota que David está muy rodado dando este tipo de charlas, si tenéis oportunidad de verlo no os lo perdáis, uno de los referentes en el estado español en estas cuestiones, como perfil técnico y activista del tema para mi es la principal referencia. Mientras podéis ver las slides de su charla en Reutilización de datos y transparencia.

Me pasé a ver la proyección del documental Sign Painters dentro del Festival Asatlo (festival de arte urbano organizado en Zaragoza). No me atrevo a hacer un resumen, pero básicamente muestra como la profesión de creación de rótulos a mano está muy afectada por la evolución tecnológica (principalmente por el uso de vinilos y ordenadores, impresoras, etc.), pero que todavía tiene unos pocos nichos en los que se mantiene, incluso se vuelve a apostar por ello como diferenciación. Personalmente me gustó el ver cierta idea de gremio, el respeto a los que habían estado antes y el ver orgullo del trabajo propio.

Volví a pasarme por las Geek’s Talks (ahora es reunión quincenal), que centrándose en temática de TED talks también se abría a que se hablara de cualquier otro tipo de charla (que fuera en inglés, claro) que a alguien de los asistentes le hubiera gustado. En mi caso comenté una charla que vi un par de días antes de la quedada, Marco Tempest: The electric rise and fall of Nikola Tesla.

Foto de familia de Geeks

Es septiembre y vuele el fútbol. Me refiero a la preocupación para la puesta a punto e inicio inminente de la temporada en los equipos en los que juego, aunque en realidad llevo muchas semanas del verano echando pachangas, pero lo de jugar en ligas locales tiene su aquel. Además que siempre por estas fechas me viene a la cabeza un sideproject que al final nunca he arrancado relacionado con el fútbol, amateur claro.

Entre estas semanas también surgieron varios posibles proyectos en los que tocó trabajar: alguna reunión, cruzarse emails y whatsapps, algunas llamadas, redactar un par de propuestas… En septiembre también es habitual que la gente vuelva de vacaciones y aparezcan nuevos posibles proyectos en los que trabajar. Veremos si sale alguno para cuando me libere de los actuales.

Y hablando de los actuales:

  • Vuelta a proyectoSinNombre. Sí proyectoSinNombre sigue dando coletazos. Poca cosa, pero tocó ver algunas cosas de con la gente de sistemas.
  • En Minchador ya tenemos la landing nueva diseñada (a falta de, culpa mía, darle un repaso a los contenidos). Falta ponernos a hacer temas de maquetación, personalmente me mola mucho como pinta. También estuve modificando alguna pequeña funcionalidad.
  • En Nort sigo trabajando. Tanto en la versión móvil como en la web, tanto el backend como algunas cuestiones de frontend, cerrando desde tickets de pequeños bugs a historias de usuario bastante interesantes y con mucha chicha. Este proyecto continúa teniendo el grueso de mi dedicación.
  • En mhop algunos arreglos, coordinando algunas cosas y trabajando en documentación para un subproyecto que creo, y espero, poder bautizar bastante pronto.

Buena semana.

» Leer más, comentarios, etc...

Variable not found

Enlaces interesantes 170

September 22, 2014 11:55 AM

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

» Leer más, comentarios, etc...

Variable not found

Inicialización de propiedades en C# 6.0

September 22, 2014 11:34 AM

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.

» Leer más, comentarios, etc...

xailer.info

Xailer IDE: Mejorando su visualización

September 22, 2014 09:30 AM

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

» Leer más, comentarios, etc...

Koalite

Cómo utilizar ReactJS con Browserify

September 22, 2014 05:06 AM

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

» Leer más, comentarios, etc...

Blog Bitix

Monitorizar archivos con Java

September 20, 2014 07:27 AM

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

» Leer más, comentarios, etc...

Picando Código

Captain Marvel: First Contact

September 15, 2014 03:00 PM

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.

» Leer más, comentarios, etc...

Variable not found

Enlaces interesantes 169

September 15, 2014 07:06 AM

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

» Leer más, comentarios, etc...

Koalite

Crear un componente con ReactJS

September 15, 2014 05:06 AM

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

» Leer más, comentarios, etc...

Blog Bitix

Compilar y cargar de forma dinámica una clase Java

September 13, 2014 10:00 PM

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

» Leer más, comentarios, etc...

proyectos Ágiles

The spirit of Agile - 2 minutes video

September 13, 2014 03:07 PM

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

» Leer más, comentarios, etc...

Picando Código

¡Feliz día de los Programadores!

September 13, 2014 03:04 PM

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?

» Leer más, comentarios, etc...

Navegapolis

¿La Casa Blanca se desmarca de CMMI?

September 12, 2014 04:34 PM

¿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:
 

» Leer más, comentarios, etc...

Picando Código

Día del Futuro – Es la gente construyendo Montevideo Abierto

September 09, 2014 03:30 PM

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 ½).

» Leer más, comentarios, etc...

Meta-Info

¿Que es?

Planeta Código es un agregador de weblogs sobre programación y desarrollo en castellano. Si eres lector te permite seguirlos de modo cómodo en esta misma página o mediante el fichero de subscripción.

rss subscripción

Sponsors

Puedes utilizar las siguientes imagenes para enlazar PlanetaCodigo:
planetacodigo

planetacodigo

Si tienes un weblog de programación y quieres ser añadido aquí, envíame un email solicitándolo.

Idea: Juanjo Navarro

Diseño: Albin