Noticias Weblogs Código

Picando Código

Reseña: Interstellar

November 22, 2014 07:40 PM

Interstellar

Fui al cine a ver Interstellar, la nueva película de ciencia ficción dirigida y escrita por los Nolan. Evité leer reseñas antes de verla, pero sí me habían llegado comentarios. Parecía una de esas películas que generan reacciones muy extremas para ambos lados: O te gusta o la odiás.

Antes de seguir un pequeño recordatorio de que lo siguiente es mi opinión y que si no estás de acuerdo no quiere decir que ninguno de nosotros esté equivocado, simplemente tenemos puntos de vista, experiencias y apreciaciones distintas y eso hace a la diversidad de esta dañina especie humana (si esto está siendo leído por otra especia, excelente :D ).

No voy a comentar nada de la trama, así que sería seguro leer esto antes de ir a verla (a menos que quieran ir a verla sin los prejuicios generados tras leer esto). Desde la parte técnica, la película es muy buena. Muchos ángulos de cámara buenos, mucho realismo en los viajes espaciales, la ambientación, etc. Nada que reclamarle. Algunas cosas se sintieron como un abuso de “habilidad cinematográfica”. Mas bien un “miren lo que puedo hacer”, con escenas algo lentas mostrando naves o interacciones en el espacio.

Está todo bien con esto, supongo que si alguien es muy fanático de ese tema en particular lo disfrutó mucho. Pero yo lo sentí como intentando repetir 2001 Odisea del Espacio. Pero 2001 tuvo su impacto porque salió en 1968, no se había hecho nada así antes y era increíble ver eso en una pantalla de cine.

En 2014 el humano transmite fotos desde un cometa y Marte, y los efectos especiales del cine llegaron al punto donde casi nada nos asombra porque prácticamente lo vimos todo. Entonces esas escenas lentas creo que no aportaban y si quisiera ver ese tipo de escenas asombrándome por cómo lo lograron miraría de nuevo 2001 que en la época que fue hecha, lograr ese impacto visual tenía mérito.

Las actuaciones están muy bien. Además del protagónico de Matthew McConuaughey vuelven del Nolanverso Gatúbela (Anne Hathaway) y Alfred (Michael Caine) entre otros. La verdad que nada que criticar por ahí. Incluso Anne Hathaway que generalmente me resulta tediosa en otras películas, acá me cayó bien.

Los robots son protagonistas relevantes en la trama, funcionan también como para agregarle un poco de humor (aunque tampoco es que termine siendo una película graciosa) y creo que fueron los personajes que me cayeron más simpáticos. Pero también, suenan como a figurita repetida de “ser sin sentimientos que se termina ganando el corazón de todos”. Tienen una “personalidad” bastante amistosa con un humor mezcla de Bender, GLaDOS y otros robots del estilo, e incluso hacen alguna referencia bastante directa a HAL 9000.

Interstellar

Mucha gente comentó sobre los aspectos científicos de la historia. Cómo algunas cosas eran basadas en estudios científicos reales, aunque para otras medio que se inventaron alguna cosa. No me puse a criticar eso porque siendo mis películas favoritas las que personas pueden volar agarrada de un martillo y los mapaches cargan armas gigantes, no voy a achacar imperfecciones científicas en una película de ciencia ficción. Y para mirar sobre ciencia de verdad y aprender tengo Cosmos.

El guión tiene muchas buenas ideas, mucho potencial, pero el resultado final me resultó mal ejecutado (a mí, no implica que esté mal ejecutado). Es una película larga, dura casi 3 horas y lo noté. Es una mala señal cuando estás mirando una película y te das cuenta que es muy larga. En más de un momento pensé “va un montón de película y todavía faltan cerrar muchas cosas”. Creo que sería mucho más entretenida si durara por lo menos una hora menos.

Como decía la historia se va armando con buenas ideas pero me quedó la impresión de que al final se habían metido en temas de ciencia ficción medio profundos y no sabían cómo salir así que medio que apuraron el desenlace encontrando una vuelta rápida para salir del embrollo y como que puede haber quedado algún cabo suelto. Esos cabos sueltos podrían atribuírse a haberse dejado a la libre interpretación o falta de tiempo, recursos o lo que sea para cerrarlos. Ahondar mucho más en eso sería contar demasiado de la trama.

Me hizo acordar a la película Contact de 1997 basada en una novela de Carl Sagan. Dato extra: mirando información de Contact mientras escribo esto, encontré que también está protagonizada por Mathew McConaughey. Si no recuerdo mal tiene bastante en común, pero tendría que volver a mirarla para refrescar mi memoria.

Me gusta la ciencia ficción así que los temas que aborda me resultan interesantes pero no llega a profundizar tanto en ninguno. Estoy seguro que todas las ideas interesantes fueron todas recontra analizadas y exploradas de formas más entretenidas en novelas del género antes. Por esto me quedó como la impresión de que fuera una novela adaptada al cine que había perdido mucho de su esencia en esa transición.

Es una buena película de todas formas, muchas cosas que muestra seguramente den para una interpretación profunda y filosófica según distintos puntos de vista. Por lo tanto genera discusiones interesantes, mas allá de que el rato que se haya pasado mirándola. No la amé, pero tampoco la odié, recomiendo ir a verla y después me cuenten qué les pareció.

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

Blog Bitix

Introducción a Ansible

November 22, 2014 10:00 AM

Ansible

Siempre que nos sea posible deberíamos automatizar las tareas que realizamos. Automatizar tareas hará sencillo realizarlas permitiéndonos hacer todos los despliegues de una aplicación que queramos con menos posibilidades de cometer errores manuales o nos permitirá disponer de una nueva máquina aprovisionada exactamente como pueda estar la máquina de producción en mucho menos tiempo. En el ámbito del aprovisionamiento de máquinas y administración de la infraestructura IT hay varias opciones, entre ellas están Chef, Puppet y Ansible.

En este artículo haré una breve introducción de Ansible que principalmente se emplea en servidores pero también podríamos emplearlo para nuestra propia máquina. Con Ansible podremos:

  • Automatizar el aprovisionamiento de máquinas.
  • Gestionar la configuración de los servicios de esas máquinas.
  • Realizar despliegues y orquestar los servicios.

Hay que destacar que Ansible no necesita instalar un agente (al contrario de Chef o Puppet) en cada una de las máquinas del inventario que queramos administrar lo que lo hace fácil de emplear, usa un modelo «push» en el que la máquina donde se ejecuta Ansible envía por ssh los comandos necesarios a aplicar en vez de ser cada una de las máquinas las que obtienen de un repositorio las recetas a usar. En los artículos Application Deployment, Configuration Management y Continous Delivery nos describen algunos casos de uso y sus ventajas empleando Ansible.

Para trabajar con Ansible necesitaremos inventariar las máquinas y probablemente definir algunas variables. Podría ser de la siguiente forma en el caso de una máquina para desarrollar.

<noscript><pre><code>devbox ansible_connection=local ansible_python_interpreter=python2 [devbox] devbox [devbox:vars] path = &quot;projects&quot; subversion_user = &quot;picodotdev&quot; subversion_password = &quot;***&quot;</code></pre></noscript>

En el inventario descrito como un archivo en formato INI se asignan los nombres del host o sus direcciones IP, también se pueden hacer agrupaciones de máquinas por ejemplo en base al rol (base de datos, servidor web, …). Una vez que disponemos del inventario podemos empezar a usar Ansible, por ejemplo haciendo un ping a todas las máquinas o instalando un determinado paquete:

<noscript><pre><code>$ ansible devbox -i hosts -m ping $ ansible devbox -i hosts -m pacman -a &quot;name=docker state=installed&quot;</code></pre></noscript>

El parámetro -m indica el módulo de Ansible que usamos y a continuación indicamos los parámetros. Ansible dispone de una amplia colección de módulos que nos permiten hacer cantidad de tareas.

Pero en vez de usar Ansible mediante comandos podemos emplear recetas contenidas en playbooks descritos en formato YAML en las que definimos varias tareas y podemos usar las variables del inventario. Con el siguiente playbook instalamos varios paquetes en una máquina Arch Linux y hacemos un checkout de dos proyectos de subversion, para ello usamos en la primera tarea el módulo para gestionar paquetes con pacman, hay módulos para los gestores de paquetes de otras distribuciones (apt, yum, …) y en la segunda tarea hacemos un checkout de dos proyectos usando el módulo del sistema de control de versiones subversion. Los módulos son idempotentes de forma que una vez que el sistema está en el estado deseado no se realiza la operación, esto hace que el mismo playbook pueda ser ejecutado tantas veces como se desee evitando efectos colaterales por reejecuciones, lo importante es el estado que se quiere conseguir, Ansible se encarga de realizar las acciones necesarias para llegar a él desde el estado actual del sistema.

<noscript><pre><code>- hosts: devbox tasks: - name: install packages (Arch Linux) pacman: name={{ item }} state=present sudo: true when: ansible_distribution == &quot;Archlinux&quot; with_items: - vim - subversion - mariadb - redis - docker - ansible - python2-pip - python2-virtualenv - name: checkout projects environment: LANG: es_ES.UTF-8 LC_CTYPE: es_ES.UTF-8 subversion: repo={{ item.url }} dest={{ projects }}/{{ item.path }} username={{ subversion_user }} password={{ subversion_password }} with_items: - { url: &quot;http://server.com/svn/repos/project1/trunk&quot;, path: &quot;project1&quot; } - { url: &quot;http://server.com/svn/repos/project2/trunk&quot;, path: &quot;project2&quot; }</code></pre></noscript>

Para ejecutar un playbook usamos el comando ansible-playbook en vez de simplemente el comando ansible.

<noscript><pre><code>$ ansible-playbook ansible/install.yml -i hosts</code></pre></noscript>

En los playbooks podemos usar tareas, grupos de máquinas, variables, variables de grupos, asignar valores a variables, usar condicionales, bucles, hechos (facts, información obtenida por ansible), notificaciones y realizar acciones en base a ellas, aplicar etiquetas a tareas, hacer includes, plantillas (para los archivos de configuración de los servicios, por ejemplo de apache o mysql), esperar a condiciones, cifrar archivos que contengan información sensible y que podamos incluir en una herramienta de control de versiones sin riesgo a comprometer la información, usar roles que aplican todas estas cosas según la función que queramos que tenga una máquina.

El libro Ansible Up & Running es un buen punto de partida que explica los aspectos básicos ya en su versión de vista previa, por supuesto la propia documentación del proyecto y los recursos de evangelización están bastante bien. En la siguiente buena y completa presentación se explican con un poco más detalle más cosas:

También, en el siguiente repositorio de GitHub hay varios ejemplos que podemos revisar para ver como se organizan los archivos y carpetas y las convenciones en su estructura que se usan implícitamente.

Habiendo hecho una introducción a Docker y esta a Ansible en el siguiente artículo comentaré como usar Docker con Ansible.

Referencia:
Artículo en la wikipedia
Presentación sobre Ansible
Ansible examples
Introducción a Docker
Guía de inicio básico de Docker
Cómo crear una imagen para Docker usando un Dockerfile
Integración entre Ansible y Docker

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

Blog Bitix

Integración entre Ansible y Docker

November 22, 2014 10:00 AM

Ansible
Ansible

En la introducción de Docker y inicio básico de dokcer explicaba como usar Docker y en la introducción a Ansible explicaba las características de Ansible y como usarlo. Podemos usar Docker y Ansible de forma separada pero también podemos combinarlas para beneficiarnos de las propiedades de cada una. En Ansible disponemos de dos módulos que nos permite manejar las imágenes y los contenedores de Docker, estos son docker y docker_image.

Usando tareas de ansible podemos automatizar el arranque del servicio de docker, la construcción de las imágenes con los Dokerfile y el inicio o parada de los contenedores de docker. En el ejemplo se construye una imagen base en la que se basarán el resto de imágenes, se crea una imagen con mysql, otra de redis y finalmente la imagen apps donde se ejecutarán las aplicaciones que usarán los servicios de mysql y redis.

<noscript><pre><code>--- - hosts: devbox - name: start docker service service: name=docker state=started sudo: true - name: build docker images docker_image: name=&quot;{{ item.name }}&quot; tag=&quot;{{ item.tag }}&quot; state=&quot;present&quot; path={{ item.path }} with_items: - { name: &quot;picodotdev/base&quot;, tag: &quot;1.0&quot;, path: &quot;../docker/base&quot; } - { name: &quot;picodotdev/mysql&quot;, tag: &quot;1.0&quot;, path: &quot;../docker/mysql&quot; } - { name: &quot;picodotdev/redis&quot;, tag: &quot;1.0&quot;, path: &quot;../docker/redis&quot; } - { name: &quot;picodotdev/apps&quot;, tag: &quot;1.0&quot;, path: &quot;../docker/apps&quot; }</code></pre></noscript>

Una vez que disponemos de las imágenes de docker podemos arrancar contenedores con ellas automatizándolo con ansible. En este caso se inicia el servicio de docker, se inicializan los contenedores con los volúmenes donde se guardan los datos de forma persistente de mysql y redis, se inician los contenedores de mysql y redis usando los volúmenes anteriores y finalmente el contenedor de las aplicaciones. Al final, se muestra cierta información de las imágenes como sus direcciones IP.

<noscript><pre><code>- hosts: devbox tasks: - name: start docker service service: name=docker state=started sudo: true - name: start mysql data docker container docker: image=busybox:latest name=picodotdev-mysql-data state=present volumes=&quot;/var/lib/mysql&quot; register: mysql_data_container - name: start redis data docker container docker: image=busybox:latest name=picodotdev-redis-data state=present volumes=&quot;/var/lib/redis&quot; register: redis_data_container - name: start mysql docker container docker: image=picodotdev/mysql:1.0 name=picodotdev-mysql state=running volumes_from=picodotdev-mysql-data hostname=mysql ports=3306:3306 command=/sbin/my_init register: mysql_container - name: start redis docker container docker: image=picodotdev/redis:1.0 name=picodotdev-redis state=running volumes_from=picodotdev-redis-data volumes=&quot;{{ keys_path }}:/mnt/keys&quot; hostname=redis ports=6379:6379 command=/sbin/my_init register: redis_container - name: start apps docker container docker: image=picodotdev/apps:1.0 name=picodotdev-apps state=running volumes=&quot;{{ projects_path }}:/mnt/projects,{{ grails_path }}:/root/.grails,{{ gradle_path }}:/root/.gradle,{{ keys_path }}:/mnt/keys&quot; hostname=apps ports=8080:8080,8443:8443 links=picodotdev-mysql:mysql,picodotdev-redis:redis command=/sbin/my_init register: apps_container - name: update hosts with containers ip address replace: dest=/etc/hosts regexp=&quot;^(\d+\.\d+\.\d+\.\d+)(\s+{{ item.host }})$&quot; replace=&quot;{{ item.ip }}\2&quot; sudo: true with_items: - { host: &quot;mysql&quot;, ip: &quot;{{ mysql_container['ansible_facts']['docker_containers'][0]['NetworkSettings']['IPAddress'] }}&quot; } - { host: &quot;redis&quot;, ip: &quot;{{ redis_container['ansible_facts']['docker_containers'][0]['NetworkSettings']['IPAddress'] }}&quot; } - { host: &quot;apps&quot;, ip: &quot;{{ apps_container['ansible_facts']['docker_containers'][0]['NetworkSettings']['IPAddress'] }}&quot; } - name: display containers info debug: msg=&quot;info&quot; with_items: - { name: &quot;{{ mysql_container['ansible_facts']['docker_containers'][0]['Name'] }}&quot;, ip: &quot;{{ mysql_container['ansible_facts']['docker_containers'][0]['NetworkSettings']['IPAddress'] }}&quot;, id: &quot;{{ mysql_container['ansible_facts']['docker_containers'][0]['Id'] }}&quot; } - { name: &quot;{{ redis_container['ansible_facts']['docker_containers'][0]['Name'] }}&quot;, ip: &quot;{{ redis_container['ansible_facts']['docker_containers'][0]['NetworkSettings']['IPAddress'] }}&quot;, id: &quot;{{ redis_container['ansible_facts']['docker_containers'][0]['Id'] }}&quot; } - { name: &quot;{{ apps_container['ansible_facts']['docker_containers'][0]['Name'] }}&quot;, ip: &quot;{{ apps_container['ansible_facts']['docker_containers'][0]['NetworkSettings']['IPAddress'] }}&quot;, id: &quot;{{ apps_container['ansible_facts']['docker_containers'][0]['Id'] }}&quot; }</code></pre></noscript>

Ansible dispone muchos módulos que nos permiten automatizar las tareas:

En el siguiente repositorio de GitHub está el código completo del ejemplo.

Referencia:
Introducción a Docker
Guía de inicio básico de Docker
Cómo crear una imagen para Docker usando un Dockerfile
Introducción a Ansible
http://docs.ansible.com/docker_module.html
http://docs.ansible.com/docker_image_module.html

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

Blog Bitix

Inicio básico de Docker

November 22, 2014 10:00 AM

Docker

En el artículo anterior introductorio sobre Docker comentaba cuales son sus principales características, que diferencias tiene con la virtualización y algunos casos y motivos por los que nos puede interesar usarlo. El objetivo de este artículo será a modo de guía rápida como empezar a usar docker. Comentaré cuales son los comandos básicos para manejar docker, las imágenes y los contenedores.

Antes de empezar con la guía propiamente hay que tener en cuenta que otra de las características de docker es que únicamente se inicia un solo proceso, cuando este finaliza finaliza la instancia del contenedor. Aunque en principio un contenedor solo tiene un proceso, podemos usar como proceso inicial uno que arranque otros, la imagen pushion tiene un sistema de inicio adaptado al funcionamiento de docker (no siendo así upstart de las imágenes de ubuntu o systemd usado por otras distribuciones) con el que podemos iniciar otros procesos, en cualquier caso es recomendable que un contenedor sino tiene un solo proceso tenga unos pocos procesos relacionados con el servicio que proporciona la imagen, la recomendación es no proporcionar una imagen con un montón de servicios/procesos sino varias pequeñas cuyos servicios colaboren. Una imagen de un contenedor es básicamente el sistema de archivos que usará el proceso que iniciamos en el contenedor, necesitamos obtener o construir una imagen para iniciar los contenedores y trabajar con docker.

Primeramente deberemos instalar el paquete de docker, en el caso de Arch Linux con el siguiente comando:

<noscript><pre><code>$ sudo pacman -S docker</code></pre></noscript>

Para poder usar docker sin emplear el comando sudo deberemos crear y añadir nuestro usuario al grupo docker:

<noscript><pre><code># groupadd docker # usermod -aG docker picodotdev</code></pre></noscript>

Una vez instalado el paquete y añadido nuestro usuario al grupo docker podemos iniciar el servicio de docker, en Arch Linux con systemd:

<noscript><pre><code>$ sudo systemctl start docker.service</code></pre></noscript>

Con el comando «docker images», «docker ps», «docker ps -a» podemos respectivamente ver las imágenes de docker disponibles en nuestro sistema, las instancias de los contenedores iniciadas y las instancias de los contenedores incluyendo las no iniciadas.

<noscript><pre><code>$ docker images $ docker ps $ docker ps -a</code></pre></noscript>

Con los comandos «docker rm [contenedor]» y «docker rmi [imagen]» podemos eliminar las instancias de contenedores y las imágenes que no estén siendo usadas por ningún contenedor, si están siendo usadas deberemos eliminar primero el contenedor.

Una vez conocemos los comandos básicos para gestionar las imágenes y contenedores aún nos quedan conocer los comandos para obtener las imágenes y como iniciarlas. No hace falta que las imágenes las construyamos nosotros desde cero sino que podemos utilizar las que otras personas han construido. Docker dispone de un registro o repositorio de imágenes en el que la comunidad (otras personas) publica las que ellos han construido, en este registro podemos encontrar imágenes para cualquier servicio de los más utilizados ya sea mysql, nginx, redis, wordpress, postgresql, ubuntu, centos, … Este repositorio de imágenes hace que podamos disponer de estos servicios muy fácilmente, sin embargo, hay que tener en cuenta que algunas imágenes no son construidas por alguien “oficial” de ese servicio, cualquier persona puede construir una imagen de un servicio y hacerlo disponible en el repositorio esto hace que algunas imágenes puedan no ser de la máxima calidad o que estén apropiadamente mantenidas. Por ello, es recomendable utilizar las imágenes más descargadas y usadas, a pesar de todo con docker si una imagen no nos gusta podemos basarnos en ella para construir una que se adapte totalmente a nuestras necesidades y con la que nos sintamos cómodos.

Para obtener una imagen usamos el comando «docker pull [imagen]» indicando el usuario que creó la imagen, el nombre de la imagen y el tag. En el siguiente enlace en la pestaña tags podemos ver las imágenes para docker de debian y sus tag:

<noscript><pre><code>$ docker pull debian:7.7</code></pre></noscript>

Una vez descargada la imagen podemos iniciar un contenedor de la imagen con:

<noscript><pre><code>$ docker run -i -t --name debian debian:7.7 /bin/sh</code></pre></noscript>

En la terminal que se inicia podemos usar cualquier comando que usaríamos en un sistema debian como apt-get.

Este es el momento para explicar otra de las peculiaridades de los contenedores de docker y es que estos no conservan el estado de una ejecución a otra y cada vez que ejecutemos el comando se creará una nueva instancia del contenedor. Para conseguir la persistencia al crear las imágenes se pueden establecer puntos de montaje, esta persistencia está externalizada en otros contenedores con el solo propósito de servir como volúmenes de datos, también se puede montar un directorio del sistema anfitrión.

Si usamos el comando «uname -a» puede verse que aunque el contenedor usa el sistema de archivos de una distribución debian el kernel empleado es el del sistema anfitrión, esto es así porque los contenedores docker en esencia no son más que procesos dentro del sistema.

Continuando esta serie de artículos sobre docker explicaré como construir una imagen mediante los Dockerfiles con la que podamos usar una base de datos mysql y explicaré en más detalle como podemos conseguir la persistencia que necesitaremos para almacenar los datos de la base de datos usando otro contenedor con este propósito.

Referencia:
Introducción y características de Docker
Cómo crear una imagen para Docker usando un Dockerfile
Introducción a Ansible
Integración entre Ansible y Docker
https://registry.hub.docker.com/
http://phusion.github.io/baseimage-docker/

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

Blog Bitix

Cómo crear una imagen para Docker usando un Dockerfile

November 22, 2014 10:00 AM

Docker

Las imágenes de docker son el sistema de archivos que usa el proceso o procesos que se arrancan en los contenedores. Si nos convencen las características de docker y estamos decididos a usarlo y ya sabemos como administrar de forma básica los contendores si queremos disponer de una imagen adaptada a los servicios que necesitamos para iniciar contenedores tendremos que crearla, en este artículo explicaré cómo crear una imagen para docker personalizada.

Antes de crear una imagen para docker podemos buscar en el registro de imágenes de docker que han creado otros usuarios y los han compartido por si hay alguna que ya se adapte a nuestras necesidades, si nos sirve alguna y es algo popular nos evitaremos tener que modificarla nosotros mismos según salgan nuevas versiones de los servicios que use. El registro de imágenes de docker es un servicio en el que los usuarios comparten y colaboran en la creación de las imágenes. Para los servicios más conocidos dispondremos ya de las imágenes como podrían ser: mysql, redis, postgresql, ubuntu, wordpress, nginx, mongodb, …

Si no hay ninguna que se adapte totalmente a nuestras necesidades, no nos gusta como están construidas las existes o no confiamos en el mantenimiento que puedan tener esas imágenes podemos crear las nuestras propias. Para crear una imagen de docker se necesita una receta en forma de archivo Dockerfile que contiene la descripción e instrucciones para construir la imagen. Para crear un dockerfile podemos basarnos en los de las imágenes del registro de docker.

Este podría ser el contenido y la receta de un dockerfile si quisiésemos crear una imagen de docker para mysql, lo paso a explicar después.

<noscript><pre><code>FROM phusion/baseimage:0.9.15 MAINTAINER picodotdev &lt;pico.dev@gmail.com&gt; ENV HOME /root RUN apt-get update -q RUN /etc/my_init.d/00_regen_ssh_host_keys.sh RUN echo 'root:$6$l/PahbyY$jFhqIAuvHeK/GwjfT71p4OBBkHQpnTe2FErcUWZ8GIN1ykdI7CgL05Jkk7MYW6l.0pijAlfoifkQnLpaldEJY0' | chpasswd -e ADD bashrc /root/.bashrc ADD timezone /etc/timezone EXPOSE 22 CMD [&quot;/sbin/my_init&quot;]</code></pre></noscript>
<noscript><pre><code>FROM picodotdev/base:1.0 MAINTAINER picodotdev &lt;pico.dev@gmail.com&gt; ENV HOME /root RUN apt-get install -y mysql-server mysql-client ADD my.cnf /etc/mysql/my.cnf RUN mkdir /etc/service/mysql ADD mysql /etc/service/mysql/run RUN chmod +x /etc/service/mysql/run RUN rm -R /var/lib/mysql &amp;&amp; \ mkdir /var/lib/mysql &amp;&amp; \ mkdir /mnt/keys VOLUME [&quot;/var/lib/mysql&quot;, &quot;/mnt/keys&quot;] RUN apt-get clean &amp;&amp; \ rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/* EXPOSE 22 3306 CMD [&quot;/sbin/my_init&quot;]</code></pre></noscript>

Los Dockerfile tienen algunas instrucciones:

  • FROM: indica la imagen base a partir de la cual crearemos la imagen que construirá el Dockerfile.
  • MAINTAINER: documenta el creador de la imagen.
  • ENV HOME: establece el directorio HOME que usarán los comandos RUN.
  • RUN: permite ejecutar una instrucción en el contenedor, por ejemplo, para instalar algún paquete mediante el gestor de paquetes (apt-get, yum, rpm, …).
  • ADD: permite añadir un archivo al contenedor, en muchas ocasiones se utiliza para proporcionar la configuración de los servicios (ssh, mysql, …).
  • VOLUME: establece puntos de montaje que al usar el contenedor se pueden proporcionar, los volúmenes son al forma de externalizar un determinado directorio y proporcionar persistencia (las imágenes de docker son de solo lectura y no almacenan datos entre diferentes ejecuciones).
  • EXPOSE: indica los puertos TCP/IP por los que se pueden acceder a los servicios del contenedor, los típicos son 22 (SSH), 80 (HTTP) y en este caso el puerto por defecto de mysql 3306.
  • CDM: establece el comando del proceso de inicio que se usará si no se indica uno al iniciar un contenedor con la imagen.

El Dockerfile-base crea una imagen base que usaremos posteriormente en la imagen de mysql, configura el color del prompt, la contraseña de root y expone el puerto 22 para poder hacer ssh.

En este ejemplo en vez de usar una imagen propia de Ubuntu en la directiva FROM he usado una imagen especial, phusion/baseimage:0.9.15. La imagen phusion/baseimage proporciona un sistema init adaptado al funcionamiento de los contenedores de docker al contrario de las imágenes de ubuntu que emplean upstart. Si usásemos alguna imagen de ubuntu y quisiésemos iniciar varios procesos en el contenedor deberíamos usar un servicio como punto de entrada como supervisord, con la imagen phusion/baseimage no sería necesario ya que ya ofrece esta funcionalidad de forma más sencilla.

Con las instrucciones RUN y ADD instalamos el paquete de mysql y el cliente de mysql y añadimos la configuración de mysql en el archivo my.cnf. En /etc/service/mysql/run dejamos el comando del servicio que iniciará el proceso de mysql como espera el sistema init de la imagen phusion. Con VOLUME [“/var/lib/mysql”] establecemos un punto de montaje para poder externalizar y persistir los datos de las bases de datos de mysql.

Una vez tenemos el Dockerfile y los archivos de configuración a incluir con los comandos ADD contruimos la imagen con:

<noscript><pre><code>$ docker build -t &quot;picodotdev/base:1.0&quot; docker/base $ docker build -t &quot;picodotdev/mysql:1.0&quot; docker/mysql</code></pre></noscript>

Para proporcionar la persistencia a la imagen de mysql podemos crear un contenedor específico que contenga los datos. Con el siguiente comando creamos un contenedor de datos, uso la imagen busybox ya que es una de las más pequeñas:

<noscript><pre><code>$ docker run --name mysql-data -d -v /var/lib/mysql busybox</code></pre></noscript>

Posteriormente podemos iniciar y parar el contenedor de msql con:

<noscript><pre><code>$ docker run --name mysql -d -p 3306:3306 --volumes-from mysql-data picodotdev/mysql:1.0 /sbin/my_init</code></pre></noscript>

En el artículo solo he indicado los Dockerfile, los archivos que añadimos con la instrucción ADD a las imágenes de docker pueden encontrarse en el siguiente repositorio de GitHub.

En los siguientes artículos comentaré la herramienta de automatización ansible y como sacarle provecho para iniciar los contenedores en una máquina de desarrollo (devbox). También en algún otro artículo comentaré la opción de bitnami que dentro de poco ofrecerá soporte para docker y como con esta opción podemos usar un servicio «out-of-the-box» si tener que crear ni siquiera un Dockerfile o tener que documentarnos para instalar un servicio (que en algunos casos pueden tener cierta complejidad) aunque sea usando virtualización con virtualbox o computación en la nube.

Referencia:
Introducción a Docker
Guía de inicio básico de Docker
Introducción a Ansible
Integración entre Ansible y Docker

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

Blog Bitix

Introducción y características de Docker

November 22, 2014 10:00 AM

Docker

Docker es una de las herramientas de la que se está hablando mucho, esto es así ya que tiene varios aspectos interesantes que cambian la forma de desarrollar aplicaciones. Docker es una forma de ejecutar procesos de forma aislada pero también se compone de herramientas para construir imágenes y un repositorio para compartirlas.

Al contrario de la virtualización Docker no emula o virtualiza una máquina y su sistema operativo con lo que los procesos son mucho más ligeros y hace que el hardware pueda ser aprovechado más al poder aumentar la densidad de los servicios en una misma máquina. Los contenedores y servicios incluidos en ellos inician muy rápidamente, en pocos segundos. Además, no es necesario el sistema de archivos completo del sistema operativo invitado con lo que docker usa una fracción de espacio de almacenamiento necesario en la virtualización.

La tecnología de contenedores no es nueva y también está disponible en otros sistemas operativos como OpenVZ también en Linux, FreeBSD Jails o los contenedores de Solaris.

Docker tiene varias características interesantes. Es ligero ya que no hay virtualización aprovechándose mejor el hardware y únicamente necesitando el sistema de archivos mínimo para que funcionen los servicios. Los contenedores son autosuficientes (aunque pueden depender de otros contenedores, por ejemplo, un wordpress que necesita una base de datos mysql) no necesitando nada más que la imagen del contenedor para que funcionen los servicios que ofrece. Las imágenes de docker son portables entre diferentes plataformas el único requisito es que en el sistema huésped esté disponible docker. Es seguro, pudiendo hacer que los contenedores se comuniquen por un túnel solo disponible para ellos, los contenedores están aislados en el sistema mediante namespaces y control groups.

Para los desarrolladores tiene las siguientes ventajas:

  • Podemos disponer de un entorno de desarrollo (devbox) o servicio en varios minutos/horas en vez de algún día. Esto es así porque la configuración y los servicios necesarios están automatizados en la construcción de las imágenes de los contenedores mediante Dockerfiles.
  • Al estar los servicios en contenedores no hace falta instalarlos en la máquina en la que son alojados, de forma que podemos disponer de los servicios y después eliminarlos de forma sencilla sin “ensuciar” el sistema huésped.
  • Nos permite tener versiones más parecidas o iguales a las usadas en producción. Por ejemplo, en Arch Linux nos permite tener un mysql de la distribución Ubuntu usando la misma versión.

El registro de contenedores de Docker es una forma colaborativa de ofrecer imágenes. Hay disponibles multitud de contenedores con los servicios más populares: MySql, PostgreSQL, Redis, Nginx, WordPress, …

Para los administradores de sistemas tiene las siguientes ventajas:

  • Pueden proporcionar entornos similares o iguales a los entornos de pruebas, QA o producción independientemente de la distribución que se use.
  • Es posible desplegar un contenedor en cualquier infraestructura Linux.
  • La creación de los contenedores puede ponerse bajo un sistema de control de versiones.

En el siguiente vídeo y presentación muy completa están ampliados muchas de sus posibilidades y funcionalidades.

Una vez conocidos los aspectos básicos y en que se diferencia docker de la virtualización así como el caso de uso de por ejemplo un devbox o disponer de entornos similares a los de producción de una aplicación, en el siguiente artículo comentaré cómo instalar docker, cómo empezar a usarlo, cómo obtener imágenes de servicios y pararlos y administrarlos.

Referencia:
Inicio básico de Docker
Cómo crear una imagen para Docker usando un Dockerfile
Docker
Introducción a Ansible
Integración entre Ansible y Docker
Seguridad Docker
Four ways Docker fundamentally changes application development
Docker, qué es y sus principales características

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

Variable not found

¿Problemas al compilar aplicaciones MVC 3 y 4 desde hace unos días?

November 19, 2014 12:58 PM

ASP.NET MVCPues sí, a mí me ha pasado, así que lo comento por aquí porque es posible que alguien más se vea en esta situación al ir a tocar una aplicación MVC antigua.

Resulta que hace unos días Microsoft distribuyó a través de Windows Update un parche de seguridad denominado Microsoft Security Bulletin MS14-059, clasificado como importante, y cuyo objetivo es corregir una vulnerabilidad descubierta en sistemas basados en MVC desde la versión 2 relativa a la forma en que el framework valida los datos de las peticiones entrantes, y que hacer que un atacante utilizara técnicas XSS para obtener un acceso privilegiado a sitios web.

Hasta aquí todo bien, el problema viene cuando por cualquier motivo tenemos que volver a compilar esas aplicaciones. Las versiones de MVC anteriores a la 5 referenciaban directamente a ensamblados guardados en el GAC con un número de versión determinada, que la instalación del parche de seguridad ha incrementado. Como consecuencia, al compilar estas aplicaciones obtenemos errores variopintos como el siguiente:
Could not locate the assembly "System.Web.Mvc,Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35,processorArchitecture=MSIL".
La verdad es que al principio sorprende bastante (“¿Cómooo? Pero si hace meses que no toco esta aplicación, ¿cómo es posible que no compile? ¿Quién la ha roto?”), pero buscando un poco por la red es fácil encontrar varias soluciones.

La que a mí me ha funcionado consistió simplemente en ejecutar el siguiente comando en la consola del gestor de paquetes Nuget (ojo, ¡haced antes una copia del proyecto, por si falla!):

Install-Package Microsoft.AspNet.Mvc -Version <version> -Project <YourProjectName>
En la línea anterior debéis sustituir:
  • <YourProjectName> por el nombre de vuestro proyecto. Esto es simplente para asegurar que instaláis el paquete en el proyecto correcto si estáis usando una solución con varios de ellos.

  • <Version> depende de la versión del framework usada en el proyecto y debe ser:

    • 4.0.40804.0 si usáis MVC 4

    • 3.0.50813.1 si usáis MVC 3

Tras ello, Nuget descargará varios paquetes y dejará el proyecto actualizado.

Desde el blog oficial de herramientas y desarrollo web de .NET recomiendan comprobar que la propiedad “Copia local” esté activa en la referencia del proyecto hacia el ensamblado System.Web.Mvc, pues al parecer existe un bug conocido de Nuget que puede resetear dicha propiedad, y que necesariamente debe estar activa para que éste sea copiado a la carpeta /bin tras construirse la solución.

En mi caso no fue necesario hacer nada pues estaba todo correcto, y a partir de ese momento todo volvió a la normalidad y pude comenzar a compilar de nuevo sin problema.

Ya a la hora de desplegar al servidor, simplemente tened en cuenta unos detalles:
  • Tendréis que subir los binarios de Mvc, porque probablemente hasta el momento en el servidor se utilizaban los presentes en el GAC.
  • Estad atentos al web.config, porque en la misma instalación realizada por Nuget es posible que se hayan introducido modificaciones en él, que tendréis que actualizar en el servidor.
Por si esto no os funciona, os dejo un par de enlaces donde amplían la información y ofrecen algunas alternativas a este método:
Publicado en Variable not found.

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

Koalite

.NET es open source, ¿y ahora qué?

November 18, 2014 08:31 PM

En el anterior post hablaba sobre el código que había demostrado su validez y mencionaba el caso el código de .NET liberado por Microsoft recientemente. En los comentarios, Sergio Leon me preguntaba algunas cosas:

Por cierto, sé que has estado trasteando con el código de .NET que han liberado. A grandes rasgos ¿Qué quieres sacar de ello? Lo digo porque seguro que son buenos motivos los que te empujan a ello, y yo sin embargo no encuentro casi ninguno, pero claro “algo me he perdido seguro” :) Es decir, ni tengo costumbre ni he “respirado” mucho open source, la verdad, y como dices tú, será la comunidad .NET la que tendrá que tirar del carro con el open source, pero realmente ¿Qué es tirar del carro en el contexto open-source? Yo no me veo haciendo un pull-request a .NET Core… ¿Qué hacer con ese código? ¿Curiosidad? ¿Aprender de él? Poco más se me ocurre en “mi contexto”.

Son preguntas interesantes, y creo que merece la pena responderlas en un post y que queden más accesibles que una respuesta a un comentario.

OJO: Esto es una opinión puramente personal. Ni pretendo predecir el futuro, ni imponer mi criterio, ni nada parecido, tan sólo exponer mi opinión, mis deseos y mis temores. Estaré encantado de leer otras opiniones en los comentarios.

Disponer del código fuente de .NET no es algo tan novedoso. Una cosa es que el proyecto fuese de código cerrado, y otra que el código no estuviera accesible, ya fuese a través del Reference Source, o incluso dicen las malas lenguas que se podía descompilar, aunque no es lo mismo (y además creo que es ilegal).

Lo bueno de esto es que tienes código preparado para ser liberado, leído por otros, modificado por otros y compilado por otros. Eso tiene su mérito y no debe de ser nada fácil. Liberar un código que lleva muchos años semi-encerrado bajo llave tiene que costar (y no quiero ni pensar lo bien que se lo habrán pasado los abogados de Microsoft con todo esto).

Leer ese código, al igual que el de otros proyectos de código abierto, aparte de satisfacer mi afición pornográfica, me ayuda a ver otros estilos de programación, otras formas de resolver problemas y, además, en este caso no deja de ser un código en el que me baso cada día para desarrollar aplicaciones, así que no está de más conocerlo.

Como dice Sergio, yo tampoco me veo haciendo un pull request, pero eso no quita que me guste cotillear.

Un aspecto que me interesa especialmente es el sistema de compilación. Puede sonar raro, pero tengo cierta obsesión por automatizar todo lo relacionado con la compilación y ver cómo otras personas resuelven esos problemas me parece interesante.

Sin embargo, si somos realistas, para la mayor parte de desarrolladores .NET, que no son esos del twitter y los blogs, sino los que están picando código como buenamente pueden en cárnicas y no quieren complicarse la vida, poder acceder al código de .NET no sirve para nada. Y estos van a seguir pesando mucho durante muchos años, porque precisamente trabajan por y para los mejores cliente de Microsoft.

¿Qué podemos sacar de todo esto, nosotros, los usuarios de .NET?

Bueno, aquí habría que poner las cosas en contexto, ya que no sólo estamos hablando de que el código de .NET (o mejor dicho, de una parte) sea abierto, sino que dentro del pack deberíamos incluir más cosas como el anunciado soporte para otros sistemas operativos (Linux y MacOS) y la modularización del runtime y el framework en paquetes NuGet.

Desde esa perspectiva, y pensando fundamentalmente en el aspecto “de negocio” se abren posibilidades interesantes.

Por una parte, poder desplegar en un futuro (espero que no muy lejano) aplicaciones .NET sobre Linux es un factor importante. Ahora mismo, y con todos mis respetos para Mono, desplegar una aplicación .NET en Linux no es algo trivial, y los costes de licencia de Windows siguen siendo un factor a tener en cuenta en determinados sectores (al menos en los que yo me muevo).

Por otro lado, me gustaría pensar que esto puede permitir que otras grandes empresas se involucren más en la evolución de .NET como plataforma y evitar estar tan atado a un único fabricante.

Tal vez algunos recordéis una empresa llamada Sun Microsystems que, allá por el 2006, decidió liberar el código de Java. De Sun Microsystems ya no queda gran cosa, sus restos los compró Oracle, pero independientemente de lo mucho o poco que a Oracle le interese Java, es innegable que Java goza de muy buena salud y existen empresas como Google o IBM que aportan mucho al mundo de Java.

Esto es lo que me gustaría, pero lo que me temo, y ojalá me equivoque, es que a corto plazo no vamos a ver nada de esto. Microsoft ha vivido mucho tiempo muy aislado y hoy en día no me imagino a Google (que todos vemos en qué parámetros se mueve últimamente) contribuyendo a mejorar .NET, pero insisto, ójala me equivoque.

También me gustaría ver unos usuarios de .NET desligados de Microsoft como empresa.

Cuando hace un año estuve danzando por algunas charlas sobre Java 8 y teniendo conversaciones sobre el tema, los usuarios se identificaban como usuarios de Java (del lenguaje o de la plataforma), pero nunca de Oracle (cosa comprensible, por otra parte).

Sin embargo, entre los usuarios de .NET, igual que entre los de Apple, existe una identificación con la empresa que hay detrás que, para mi gusto, es poco productiva y a veces los acerca peligrosamente a ser fanboys.

Tampoco veo a los alpha geeks (o hipsters, como queráis) que abandonaron .NET hace unos años volviendo a .NET por este anuncio. Seguirán usando su node.js, scala, erlang o lo que toque, pero creo que será difícil que vuelvan, y eso es una gran pérdida, porque este tipo de personas (pese a sus rarezas y manías) aportan innovación, montando proyectos locos que rompen paradigmas e introduciendo nuevas formas de trabajar.

Sin eso, esto de tener una plataforma abierta no deja de ser un brindis al sol. Seguirá siendo una plataforma controlada por Microsoft, los usuarios seguirán utilizando únicamente las librerías que produzca Microsoft y, sí, todo será abierto, pero a efectos prácticos no habrá mucha diferencia.

No sé qué podría hacer Microsoft para evitar esta situación y, seamos realistas, tampoco sé si se va a producir o esto es sólo un desvarío mío. Seguro que ellos cuentan con gente mucho más lista que yo y con una visión de futuro mucho más clara, pero yo sinceramente creo que es más complicado de lo bonito que quieren verlo algunos.

Aprovechar estos pasos que está dando Microsoft requiere un esfuerzo conjunto de sus usuarios, y el grueso de los usuarios de Microsoft no están acostumbrados a estas cosas, y ni siquiera sé si les compensa hacerlo. No hay que olvidar que el mayor interesado en esto es Microsoft, no sus usuarios. Éstos, o al menos los más competentes (y por tanto interesantes para el futuro de .NET), pueden cambiar de tecnología y plataforma sin demasiados problemas.

Por mi parte, me alegra mucho ver estos cambios, me encanta ver que surgen proyectos como scriptcs y OmniSharp y me gusta ver cada vez más desarrollos en F#, pero la verdad es que ahora mismo siento que todo esto llega un poco tarde para mi.

Hace bastante tiempo que ya no dedico mi tiempo libre a jugar con .NET. Lo utilizo a diario en el trabajo, es una plataforma que me gusta, soy muy productivo con C#, pero cuando quiero divertirme, programo en Clojure o en Javascript. Y divertirse también es importante.

Posts relacionados:

  1. Open Source en un mundo Microsoft

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

Variable not found

Expresiones lambda en miembros de función de C# 6

November 18, 2014 12:52 PM

imageSeguimos hablando de las novedades de C# 6, y en esta ocasión nos centraremos en una interesante característica cuyo nombre, sinceramente, no estoy seguro de ser capaz de traducir de forma correcta del original “Expression bodied function members”. Quizás sería algo así como “expresiones en cuerpo de miembros de función”, pero bueno, lo importante no es el nombre sino el concepto, así que vamos a centrarnos en él.

Comencemos desde el principio. Los miembros de función son aquellos miembros de un tipo que contienen código ejecutable, como métodos, propiedades, indexadores, operadores y otros. En general, todos ellos permiten implementar su comportamiento mediante la introducción de un bloque de código, tradicionalmente enmarcado entre llaves.

Pues bien, esta novedad del lenguaje permite sustituir el cuerpo de miembros de función por una concisa expresión lambda, logrando simplificar bastante el código y acelerando su creación.

Pero veámoslo con un ejemplo. Observad la siguiente clase, y más concretamente la cantidad de caracteres necesarios para implementar su propiedad de sólo lectura FullName en C# tradicional:



A partir de C# 6, podremos dejarla así de limpita:



Genial, ¿verdad? De un plumazo hemos eliminado muchísimo ruido de nuestro código, mejorando la legibilidad y evitando gran cantidad de golpes de tecla. Observad que incluso hemos eliminado el bloque get, implícito cuando usamos la sintaxis lambda en una propiedad.

Aunque la lambda del ejemplo anterior es simplemente una expresión de concatenación, al codificarla podríamos usar cualquier tipo de expresión, y desde ella tendremos acceso a cualquier miembro que también tuviéramos disponible al usar la sintaxis tradicional, como sus demás miembros de instancia o estáticos, privados o públicos.

De nuevo volviendo al ejemplo anterior, hemos mostrado cómo reescribir una propiedad, pero por supuesto podemos hacer lo mismo con métodos. Esto será especialmente interesante para simplificar aquellos cuyo cuerpo sólo tengamos una línea con un return; como muestra, fijaos que controladores MVC más bonitos podríamos escribir en escenarios simples:

image

Bueno, y como podréis imaginar también podemos usar esta sintaxis con métodos estáticos:



Quizás la única precaución que hay que tener en cuenta es que en el caso de miembros de función que retornan void también podemos utilizar las lambdas, aunque en su interior sólo podremos usar expresiones sin retorno, al igual que ocurre con las lambdas tradicionales:



También los operadores personalizados o implícitos son buenos candidatos a utilizar esta sintaxis reducida, puesto que su cuerpo  consiste muy a menudo en una simple expresión de evaluación directa:



Asimismo, otro buen sitio para utilizarlo sería en los miembros indexadores:



Aunque pueda parecer obvio, un último detalle que creo interesante resaltar es que estas expresiones, a diferencia de las lambda tradicionales, no pueden tener cuerpo, es decir, no podemos usar llaves e incluir en su interior varias instrucciones. La verdad es que esto tiene bastante sentido porque en caso de necesitar un cuerpo ya tenemos la sintaxis anterior; esta nueva fórmula viene a ayudarnos cuando el cuerpo de un miembro de función es una simple expresión de evaluación directa.



En definitiva, de nuevo se trata de una mejora del lenguaje nada espectacular, pero sin duda interesante vistas a simplificar código y evitar pulsaciones de teclas innecesarias. En mi opinión será bien recibida y pronto tendrá bastantes adeptos.

Y por último, recordaros los posts anteriores de la serie por si queréis conocer otras novedades que acompañarán a C# 6:
Publicado en Variable not found.

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

Una sinfonía en C#

Javascript Hoisting, scope de variables

November 18, 2014 12:10 PM

Una característica de Javascript difícil de comprender (sobre todo comprender si es un bug o un feature) es el scope de las variables declaradas dentro de una función.

El intérprete de Javascript mueve las declaraciones al principio de la función.

Esto quiere decir que si yo declaro una variable por la mitad del código de una función su declaración (no la asignación) se mueve al principio, veamos un ejemplo:

var a = 'hola';

function saludar() {
	console.log(a);
	var a = 'chau';
	console.log(a);
};

saludar();

image

En este caso esperamos que le primer mensaje en imprimirse diga “hola” sin embargo dice “undefined” ¿por qué? simple: para el interprete la declaración está al principio de la función, es decir, que lo que en realidad se ejecuta es esto:

var a = 'hola';

function saludar() {
	var a;
	console.log(a);
	a = 'chau';
	console.log(a);
};

saludar();

En definitiva lo importante es tener en cuenta este comportamiento o poner todas las declaraciones al principio.

Nos leemos. Leonardo.

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

Picando Código

Nuevo diseño en Picando Código

November 18, 2014 11:30 AM

Fernando¡Picando Código estrena nueva apariencia!
Para lograr el nuevo tema, pasamos por varias etapas:

Primero hubo un intenso estudio de experiencia de usuario contratando un equipo de profesionales. Varios UX Designers y UI Integrators junto a expertos en Front-end Development conformaron un equipo multidisciplinario donde fluyó la sinergia con resultados impactantes.

Usamos la metodología Lean Kanban Agile Scrum Disruption® para definir la arquitectura de la información. El proyecto fue coordinado por un Principal (no sabemos cuál es el rol de este integrante del equipo, pero su título nos dice que es más importante que el resto).

Tras meses de tests de usuarios on-site con heatmaps y eye tracking, logramos un Minimum Viable Product. Pivotamos sobre el producto buscando el engagement del usuario final, y el resultado es lo que tienen a la vista (si están leyendo el post desde el blog y no desde el RSS o algo de eso…).

Todo esto que que escribí es mentira. El diseño es prácticamente el mismo que tenía el blog desde hace un tiempo. Ha ido cambiando progresivamente desde enero del 2013, y ahora hubo un cambio más “radical”. La diferencia principal es que migré de framework CSS a SimpleGrid.

Las ventajas son un área de lectura horizontal más amplia, manteniendo el diseño responsivo en distintos tamaños de pantalla. Aproveché para corregir algún detalle que otro por acá y por allá, pero lo más interesante es que agregué algunos huevos de pascua por ahí…

Tema Picando Código v5

Tema Picando Código v5

Llamé al tema “Picando Código v6″ para ser original, porque es la sexta instancia de tema que arranco “desde cero”. Como siempre, es un trabajo en progreso. Seguramente en los próximos días encontraré detalles para ir corrigiendo, si encuentran algo les agradezco dejen su comentario por acá, o si se sienten super generosos, manden un Pull Request por GitHub.

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

Arragonán

Semana 336

November 17, 2014 04:51 PM

Semana de relativa tranquilidad la anterior al haber acabado mi colaboración en Nort y no tener compromisos que me obligaran a darles mucha dedicación. Empecé a tomarme unas pequeñas vacaciones trabajadas en las que quiero dedicarme más que nada a proyectos propios y no tanto a trabajos para terceros. La primera mitad de la semana fue bastante tranquila, ya lo necesitaba, pero bastante menos la segunda.

El viernes empecé un pequeño tour de una semana por unas pocas ciudades de la península camino al Encuentro de Valleys, en Cáceres. Un evento en el que diferentes comunidades locales compartíamos diversos puntos de vista, formas de hacer, experiencias y problemas que nos hemos ido encontrado. Me pareció interesante y debo decir que me encantó conocer a un puñado de gente y volver a ver a unos cuantos conocidos. Y de nuevo, la gente en Cáceres muy buenos anfitriones!

Os dejo aquí la presentación que hicimos Rafa Ramos y yo

Presentación 2º Encuentro de Valleys. 2014. Cáceres. from cachirulovalley

Respecto a proyectos en los que estoy trabajando:

  • Me tocó tocar mucho Less para los cambios del frontend de mhop. Desde luego que, aunque para algunas cosas me defiendo, no soy nada buen maquetador. Estuvimos probando los cambios en staging y salieron un puñado cosas que limar.
  • Se anunció por fin OutreachBox y la campaña de crowdfunding en Goteo. No voy a extenderme, pero me dejo como deberes escribir un post sobre esto esta semana.
  • También estuve actualizando algunas cositas de un pequeño pet-project que quizás termine haciendo público, aunque no es gran cosa.

Buena semana.

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

Picando Código

Tuxy Computers – Startup española de computadoras con software libre

November 17, 2014 03:21 PM

TuxyRecibí un correo de Tuxy Computers, una startup española con compromiso en el software libre. La empresa creó una marca de computadoras pre-instaladas con software libre: Tuxy Computers.

En España (al igual que en América Latina y seguramente otras tantas partes del mundo) la oferta de computadoras con GNU/Linux es prácticamente nula. Pero sí hay demanda de parte de los usuarios.

Tuxy Computers nació como respuesta a esa demanda, con equipos de gama alta y componentes de última generación. El presupuesto está dedicado 100% al hardware gracias a que todo el software instalado es libre y gratuito.

Entre los productos pueden encontrar Mini-Computadoras, ideales para hacer de media center o similar, aunque hay equipos más potentes y con un diseño similar en la sección Sobremesa.

Entre las Portátiles que ofrecen, destacan las RX771, equipada con tarjetas gráficas Nvidia GeForce GTX 800M. La pantalla es de 17.3 pulgadas HD, 1920 x 1080, procesador Intel Core i7 – 4710, 8GB de RAM 1600Mhz DDR3 (ampliable hasta 24GB), disco de 500 GB y tarjeta NVIDIA GeForce GTX 860M con 2GB GDDR5.

TUXY RX771

TUXY RX771

Si están pensando comprarse una computadora nueva, esta es una opción a tener en cuenta. Así no van a tener que pagar una licencia OEM a Microsoft por un sistema operativo que no van a usar :)

Esperemos que con el tiempo sigan surgiendo más opciones para poder comprar computadoras sin sistemas operativos privativos pre-instalados. Si bien Ubuntu no es una distribución de GNU/Linux recomendada por la Free Software Foundation (recomiendan Trisquel basada en Ubuntu), es un paso en la dirección correcta. Difunde la idea del software libre,  y en el peor de los casos no se está pagando una licencia de software y se debería poder reemplazar por nuestra distro preferida sin mayores problemas.

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

Variable not found

Enlaces interesantes 176

November 17, 2014 12:55 PM

Enlaces interesantesAhí van los enlaces recopilados durante la semana pasada, en gran parte protagonizados por los jugosos anuncios y lanzamientos que se hicieron públicos en el evento Connect que tuvo lugar de hace unos días. Espero que os resulten interesantes :-)

.Net

ASP.NET

Azure / Cloud

Conceptos/Patrones/Buenas prácticas

Data access

Html/Css/Javascript

Visual Studio/Complementos/Herramientas

Cross-platform

Otros

Publicado en Variable not found

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

Koalite

Código bonito, código feo, código que funciona

November 17, 2014 05:06 AM

Cuando uno empieza a programar (bueno, y algunos también después de muchos años) trata el código como algo con lo que hay que pelearse, que hay que golpear a martillazos hasta que conseguimos que, más o menos, encaje en el hueco que tiene que encajar.

Es una época en la que no te preocupas mucho de cómo ha quedado el código, aparecen fragmentos redundantes, código duplicado, variables con nombres poco descriptivos, comentarios irrelevantes o desactualizados… En definitiva, lo que podríamos considerar la antítesis del clean code que promulgan Uncle Bob y compañía.

Con el tiempo, toca mantener ese código, modificándolo para añadirle nuevas funcionalidades o corregir errores. Los martillazos que usamos para encajar el código de cualquier manera ya no nos parecen tan buena idea y empezamos a convencernos de que es importante cuidar la forma en que escribimos el código, y que conformarnos con la primera cosa que más o menos parece que funciona tal vez no sea la mejor solución.

El efecto rebote

En ocasiones, este afán por huir del nefasto código que escribíamos inicialmente nos lleva a prestar demasiada atención a la forma del código, recreándonos en aspectos estéticos, que además siempre tienen un componente muy subjetivo y temporal (las modas van y vienen).

Si vemos un par de comentarios, automáticamente pensamos que el código es poco claro y por eso están ahí. Si vemos un método con más de 5-6 líneas, enseguida tenemos la tentación de refactorizarlo. Si vemos un par de if’s anidados, sospechamos, y si vemos un switch, directamente se nos ponen los pelos de punta pensando en por qué no se habrá usado polimorfismo con una jerarquía de clases.

Lo que generalmente no vemos es que el código no sólo nos cuenta una historia sobre lo que hace, sino que también tiene su propia historia. A todos nos gusta leer código autoexplicativo que nos va contando lo que hace como si fuese un buen libro, pero todo el código se escribe por algún motivo concreto y en un momento determinado, y ese contexto es el que muchas veces acaba marcando el aspecto del código.

¿Ese estilo de nombrar las variables que hoy parece tan feo? Tal vez cuando se escribió el código hace 7 años era lo más estandarizado. ¿El if incomprensible que aparece al principio del método? A lo mejor está ahí para evitar un bug que surgió en producción y que ahora, tiempo después, ya nadie recuerda.

Código que funciona

Pero además de factores histórico-estéticos, también es posible que, simplemente, el código funcione bien. Hay algo que he aprendido con el tiempo, y es a respetar el código que funciona.

Hay código que funciona, lleva mucho tiempo en producción, ha pasado por muchas manos, muchos bugs, y ha llegado a un punto en que es estable, eficiente y esa aparente dificultad de mantenimiento no importa porque ya no hay que tocarlo más. Ya está terminado. Tiene muchas cicatrices y no es tan bonito como cuando lo diseñaron, pero está curtido en mil batallas y es capaz de resolver perfectamente el problema para el que fue construido.

Si repaso el código que he escrito, puedo encontrar código así sin muchos problemas. Y la tentación de reescribirlo es grande. Muy grande. Si cuando ves código que escribiste hace un tiempo no te entran ganas de reescribirlo, malo, no estás evolucionando; pero si cada vez que ves código que no te gusta lo reescribes, peor, no estás madurando.

Reescribir un código que funciona y que no te está estorbando sólo porque es feo suele ser una mala idea. Para empezar, tiene un coste asociado porque es tiempo que dedicas a rehacer algo que funciona en lugar de a implementar nuevas funcionalidades, pero además es probable que tu conocimiento del problema no sea tan profundo como el que hay acumulado en ese código y acabes (re)introduciendo bugs corregidos hace tiempo.

Antes de que los paladines del código limpio se lancen con sus herramientas de refactoring, sus tests de regresión y sus videos de Uncle Bob a por mi, y por si no ha quedado claro, aquí estoy hablando de reescribir código perfectamente válido y funcional sólo porque “te parece feo”, o dicho de otro modo: hay razones perfectamente válidas para refactorizar y reescribir código, pero que no te guste su aspecto no es una de ellas.

Un caso actual

La semana pasada se anunció la liberación del código de .NET Framework (o más concretamente una parte, CoreFx), y aunque ese código llevaba tiempo accesible (más o menos), ahora que está en Github, nuestro amor por la pornografía nos ha llevado a muchos a echarle a un vistazo. Las reacciones han sido variadas, pero en generar hay partes que sorprenden por no ser todo lo bonitas o consistentes que a uno le gustaría.

Llevo bastante tiempo usando liberías de código abierto y estoy acostumbrado a leer su código, y no es la primera vez que veo un código que no me gusta, pero que funciona estupendamente bien. El antiguo código de protobuf-net, era horrible, pero el rendimiento y la estabilidad de la librería es sensacional. El código de NHibernate tampoco es el más bonito del mundo, pero es una librería que uso a diario y funciona muy bien.

Conclusiones

Como siempre digo, el código importa, pero el contexto más. Cuando te encuentres con un código que lleva mucho tiempo en producción aportando valor, no sólo te fijes en el aspecto que tiene. Seguramente detrás de él haya una historia que explique por qué está escrito de esa forma, y lo que sin duda ya ha demostrado es que es capaz de cumplir con su cometido.

Puede que ese código no sea el más sencillo de entender o mantener, pero una vez que se ha estabilizado y otro ya ha pagado el precio de esa complejidad adicional a la hora de mantenerlo, lo mejor que puedes hacer es aprovecharlo en lugar de empeñarte en luchar guerras que ya están ganadas.

No hay posts relacionados.

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

Ingenieria de Software / Software Engineering / Project Management / Business Process Management

Coaching

November 17, 2014 04:29 AM

The POSITIVE Model of Coaching - Getting People Excited About Their Goals http://www.mindtools.com/pages/article/positive-coaching.htm

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

Ingenieria de Software / Software Engineering / Project Management / Business Process Management

Use case fragments

November 17, 2014 04:15 AM

Use Case Fragments http://www.modernanalyst.com/Resources/Articles/tabid/115/ID/3116/Use-Case-Fragments.aspx

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

El blog de Adrián Arroyo

¿Qué nos espera en Haiku Beta?

November 17, 2014 12:00 AM

No sé si conoceis Haiku. Se trata de un sistema operativo libre (bajo licencia MIT) que intenta ser un clon libre de BeOS siguiendo su filosofía. Podríamos compararlo a Linux respecto a UNIX o ReactOS respecto a Windows NT. El caso es que no comparte nada con otros sistemas operativos disponibles en el mercado y eso lo hace muy interesante. La historia de Haiku y BeOS es muy interesante y podeis encontrar mucha información al respecto que no voy a replicar. Sin embargo el desarrollo de Haiku siempre ha sido muy lento y ahora mismo estamos en los albores de la Beta 1 de Haiku. Después de 4 alphas bastante estables se van a atrever a lanzar la primera beta. ¿Por qué ahora? Vamos a ver las novedades que traerá Haiku para saber porque se ha decidido este importante paso.

Haiku Desktop

Compilador actualizado

Haiku ya dispone de una vía rápida para obtener un compilador con las últimas características que se esperan de él. La versión que está instalada en mi máquina virtual tiene GCC 4.8.3 (publicado el 22 de mayo de 2014). Sin embargo no será el compilador por defecto. Durante mucho tiempo en Haiku solo se podía usar GCC 2.95 y va a seguir siendo el compilador por defecto. Las razones es que el código generado por este compilador son compatibles con el último BeOS. Actualmente en Haiku se ofrecen 4 descargas para x86: una usando solo GCC 2, otra usando solo GCC 2, una híbrida usando por defecto GCC 2 y otra híbrida usando por defecto GCC 4. Recomiendo la híbrida usando por defecto GCC 2.

GCC 2 vs GCC 4

Nuevas arquitecturas

Relacionado con lo anterior Haiku ha podido ser portado a arquitecturas diferentes como PPC, ARM, m68k y x86_64. Decir que la versión ARM es todavía muy prematura aunque se han hecho grandes avances en ello.

Navegador web actualizado

Haiku antes disponía de Firefox. Un día Firefox decidió usar Cairo como librería de renderizado. Esto supone un aumento de velocidad para Firefox en aquel momento pero rompe el port existente con BeOS/Haiku/ZETA. Cairo al igual que GTK nunca han estado soportados de manera oficial en BeOS y con GTK2 el port que había dejó de funcionar. Desde entonces Haiku ha sufrido la carencia de navegadores decentes. Algo más grave si tenemos en cuenta la importancia de HTML5. Así pues ahora mismo en 2014 tenemos los siguientes navegadores gráficos actualizados funcionando sobre Haiku:

Pero también tendríamos versiones antiguas de:

  • Firefox (BeZilla)
  • Opera
  • NetPositive

Qupzilla usa WebKit y Qt, además es bastante inestable. Y su interfaz no es la típica de Haiku. Por eso no es muy usado por la comunidad. NetSurf es bastante estable ya que es una de las plataformas a las que está enfocado, pero NetSurf es un navegador muy pequeño comparado con otros. Usa su propio motor y es muy ligero pero muy poco compatible. De hecho no soporta JavaScript. Nos queda WebPositive, el navegador oficial de Haiku. Usa WebKit pero usando una interfaz nativa de Haiku y con llamadas propias al sistema. Está implementado con la API BWebView para que otras aplicaciones lo puedan usar. Es el navegador más avanzado con un soporte decente para HTML5 y JavaScript. Le sigue faltando WebGL y alguna que otra API pero el soporte de SVG, Canvas 2D, Audio y muchas otras características es bastante decente. Mencionar también que Haiku soporta OpenJDK 7 como un port que funciona decentemente.

WebPositive html5test.com score

Sistema de paquetería

Quizá la característica más importante para Haiku ha sido el sistema de paquetería. Un gran sistema que se podría calificar como de lo mejores en mucho tiempo. Esto no quiere decir que Haiku no tuviese sistema de paquetería antes, realmente tenía uno muy simple pero que servía, eran los OptionalPackages. Sin embargo el concepto de sistema de paquetería ha sido rediseñado para Haiku y el resultado es bastante bueno. Lo primero que vemos son dos programas dedicados a gestionar la paquetería para los usuarios, el primero es pkgman, el de línea de comandos y el segundo es HaikuDepot, para realizar todas las operaciones desde la línea de comandos. Esta es una cosa que me gusta de Haiku, cuidan tanto la línea de comandos como la interfaz gráfica y quieren que tengas las mismas características en cualquier entorno. Respecto a los paquetes, usan una extensión .HPKG y para instalarlos los tendremos que copiar en nuestra carpeta de usuario (actualmente es /boot/home/config/packages) y ya está.

¿Sólo hay que copiar los paquetes? ¿ya está?

Sí, solo hay que copiar. La magia reside en el PackageFS, un sistema de archivos que surge de la lectura del HPKG y montando los ficheros en sus respectivos lugares en modo lectura. Para ello hay un demonio vigilando la carpeta y si recibe cambios los descomprime y los monta en el sistema de ficheros. Esto influye a que ahora solo la carpeta /boot/home pueda ser escrita simple y llanamente porque el resto de carpetas (/boot/system es la única que veo) están montadas en modo solo lectura de los paquetes del sistema. Estos estan localizados en /boot/system/packages. En esta carpeta también podremos escrbir y borrar pero teniendo en cuenta que el HPKG con el kernel también está ahí conviene tener cuidado con la carpeta. Y la cosa se hace más graciosa cuando comprobamos que cada paquete tiene cargada su instancia del sistema operativo y sus librerías (/boot/system/package-links). La verdad es que las instalaciones son muy rápidas y funciona por lo general. En un próximo post enseñaré a crear paquetes para Haiku (usando HPKG) de dos métodos distintos y que ocurre con la gestión de dependencias. También crearemos un repositorio y veremos como hacer Haiku un sistema operativo 100% rolling release usando los HPKG.

Haiku Depot

Conclusión

Me habré dejado cosas seguro y además la compatibilidad con aplicaciones de terceros ha aumentado. Haiku se acerca a su primera beta y las cosas se ponen muy pero que muy interesantes.

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

Variable not found

Declaración de variables en expresiones de C# 6

November 16, 2014 06:38 PM

C#
[Actualizado 16-Nov-2014] El equipo de diseño del lenguaje C# ha decidido finalmente no incluir esta característica en la versión 6. En fin, fue bonito mientras duró :(

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

Ingenieria de Software / Software Engineering / Project Management / Business Process Management

CIOs

November 15, 2014 04:51 AM

Gerente de sistemas. Desafios de su rol. http://iaap.wordpress.com/2014/11/14/gerente-de-sistemas-desafios-de-su-rol/

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

Ingenieria de Software / Software Engineering / Project Management / Business Process Management

Agile Matrix

November 15, 2014 04:44 AM

Agile Through a Matrix Lens http://tynerblain.com/blog/2014/11/12/agile-through-a-matrix-lens/

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

Picando Código

Picando Código revivió, larga vida a Picando Código…

November 14, 2014 02:00 PM

DesconectadoSi quisieron entrar al blog recientemente posiblemente hayan notado que no estaba ahí. Por un problema con el dominio, el blog estuvo fuera de línea por un buen rato. La peor parte me la llevé por el correo electrónico, porque me quedé sin mi correo picandocodigo.net por todo ese tiempo.

El sitio seguía acá, base de datos, servidor, archivos, todo funcionando, pero sin el dominio, por lo que no se podía acceder.

Pero acá estamos de nuevo, espero que no hayan extrañado mucho. Ya que estamos, ¿cómo estás lector? ¿qué te trae por acá? ¿Qué contás de nuevo?

Todo empezó cuando descubrí que no funcionaba mi correo electrónico, llegué a que el dominio no funcionaba, e hice los trámites correspondientes para que se restaurara la cosa. Después de eso no había más que esperar. No dormí demasiado tranquilo sabiendo que todos los correos que llegaran a mi cuenta estaban rebotando…

Ayer cada tanto revisaba el sitio refrescando la url en una pestaña de Firefox. Como suele pasar con los programadores vagos como uno, cuando hay que repetir una tarea un par de veces en la computadora, terminamos escribiendo un programa que lo haga por nosotros.

Así fue que abrí Emacs y abrí el archivo nuevo “ping.rb”. Decidí volver a usar la gema requests (nota relacionada), que conocí hace poco en RubyConf Argentina. Se trata de una gema super simple para hacer pedidos HTTP inspirada en la biblioteca del mismo nombre de Python. También usé la gema tco, que permite imprimir con colores en la terminal. Fue así que escribí el siguiente código:

require 'requests'
require 'tco'
 
while true do
  begin
    response = Requests.request("GET", "http://picandocodigo.net")
    puts "WORKING".bg("#00FF00") if response.status == 200
    `vlc --fullscreen http://www.youtube.com/watch?v=wOh968qao74 &amp;`
    break
  rescue => e
    puts e.message.fg("#FF0000")
  ensure
    sleep 60
  end
end

Cada 1 minuto revisar si responde el dominio y si el código de retorno del pedido es 200 (OK!), ejecutar vlc con este video que siempre me pone de buen humor. Mientras tanto, imprimir el mensaje de error si no encontraba el nombre o servicio. Este es el tipo de script del que estamos pendientes al principio, pero nos dejamos para sorprender al “yo” del futuro.

Así fue, lo dejé corriendo en una terminal, me entretuve con el trabajo y me olvidé por completo. Más tarde se dió la casualidad que estaba usando una de mis gemas ricojson para parsear la respuesta de una API en la terminal, y ya me estaba poniendo de buen humor con mi yo del pasado. “Qué bien que estuviste en escribir esa gema, por más que seas el único de los dos usuarios que tiene” (en RubyConf Argentina me contó Martín de cinemargentino que conocía a un usuario más :D )

En ese mismo momento me interrumpió VLC ejecutando el video en cuestión. Obviamente dejé lo que estaba haciendo, verifiqué que el sitio y el correo electrónico estaban funcionando correctamente de nuevo, y paré todo para mirar el video en cuestión…

El momento de la verdad

El momento de la verdad

Así que de ese tiempo oscuro en el que estuve aislado de mi correo electrónico y mi blog personal, saqué este post… El script lo ejecuté a las 12:08:12 y terminó a las 17:28 con algunos segundos:

ping-server-00

Así que estuvo 5 horas y 20 minutos funcionando :)

Algo que “aprendí” es que WordPress a veces cuando “se da cuenta” que perdió un post programado, lo publica. El post de ayer estaba programado para más temprano. Cuando finalmente pude entrar al Escritorio del sitio, fui a editarlo para darle una nueva programación, y se publicó solo.

Espero que no vuelva a pasar, y si pasa, prometo otro post al respecto. ¡Gracias por leer!

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

Picando Código

Captain Marvel: Coven

November 13, 2014 03:00 PM

Captain Marvel en la cruzSi hubo algo de sutileza en el volúmen anterior respecto a Genis-Vell y su complejo de dios, en la primera viñeta de este volúmen se va todo por la borda (imagen que acompaña este post).

Captain Marvel y Rick Jones siguen unidos a nivel mental y molecular, y llegaron al acuerdo de intercambiar su lugar cada 24 horas entre “nuestro” universo y  el Microverso.

Colgarse en esa cruz le da la oportunidad a Genis de retomar el cuestionamiento de las relaciones entre padres e hijos, y se compara con el ocupante anterior de la cruz. Estos delirios son siempre discutidos por Rick que sigue haciendo de voz de conciencia y evitando que su locura lo lleve a destruír el universo o quién sabe qué…

Siguen siendo interesantes los planteos críticos, como que la cruz no es más que un dispositivo, método de ejecución de tiempos romanos y que adorarla no es distinto a adorar una silla eléctrica, rematando con “¿y piensan que yo estoy demente?”. Se aprovecha de este diálogo para citar a Nietzche y el tema de la muerte de “Dios” dentro de una iglesia.

El problema con la iglesia en esta primera historia es que a pesar de ser domingo temprano, no hay fieles. Con eso conecta con el resto del Universo Marvel con aquella historia en que Asgard se posiciona flotando sobre Nueva York y Thor actúa de “dictador benevolente” con los humanos.

Captain Marvel Godliness

Así es que Captain Marvel se dirige a Asgard, y empieza la acción. Además de varias situaciones divertidas y frases célebres de Genis relacionadas a su locura, se pone en tela de juicio la actitud de Thor así como la definición de qué es un dios, y por qué Captain Marvel no puede ser uno. Estos temas acompañan al resto de la historia durante todo el tomo.

La segunda historia presenta un nuevo personaje: Karl Coven. Se trata de un asesino serial sentenciado a muerte. Rick Jones fue testigo de uno de sus asesinatos, por lo que presencia su ejecución. Por alguna razón Coven vuelve a la vida tras la inyección letal, y la justicia debe dejarlo ir por “haber cumplido la sentencia”.

Buscando venganza intenta asesinar a Rick y termina conociendo a Captain Marvel y generando una relación “amistosa”. En el siguiente número aparecen dos personajes alienígenas en Nueva York, que hacen que coincidan Coven, Genis y Spider-Man. Acá se genera una situación particularmente delirante en un experimento de Genis surgido a partir de su curiosidad por el sistema legal terrestre.

Captain Marvel: Problem?

Mientras se da todo esto, en el Microverso Rick Jones se transformó en un “Dios del Rock”, lo que lleva a otros desenlaces divertidos. Cada detalle de la trama va acompañado del característico humor demencial de Genis, y la manera en que utiliza su conciencia cósmica para manipular a los protagonistas cual piezas de ajedrez. Esto llega a un punto alto con el excelente final donde Marvel se burla de todos -cual hipotética deidad- usándolos de títere y dándole una lección a Rick sobre humanidad y locura.

MCaptain Marvel: Covene alegra haber encontrado esta serie, la verdad que merece mi recomendación. A través de la acción y un humor medido y particular, roza temas “filosóficos” y cósmicos, lo que le dan un nivel más de entretenimiento y cosas para pensar post lectura.

El tomo Coven colecciona Captain Marvel números 7 al 12, escrito por Peter David e ilustrado por Kyle Hotz e Ivan Reis. En la primera historia los personajes y Asgard se ven un poco raros, pero el arte en general es bastante bueno a lo largo de toda la colección.

A esta altura ya me encariñé con el personaje y su personalidad tan particular. Todavía me quedan dos tomos por leer, y me da la impresión de que me van a dejar gusto a poco.

No comenté mucho al respecto para no quemarlos, pero hay algún que otro guiño más al Captain Marvel de la Distinguida Competencia :D

Si tienen la posibilidad, lean algo del Captain Marvel de Peter David, no se van a arrepentir. El próximo tomo a leer es Crazy like a Fox, con los números 13 al 18.

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

Ingenieria de Software / Software Engineering / Project Management / Business Process Management

PMO value

November 12, 2014 02:11 PM

http://www.pmoplanet.com/2012/02/23/current-climate-where-do-pmos-add-value/

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

Picando Código

Polaris – Iniciativa de Mozilla para acelerar la privacidad centrada en el usuario en línea

November 11, 2014 02:00 PM

Foto por  Stephen Melkisethian (Flickr - Licencia CC)

Foto por Stephen Melkisethian (Flickr – Licencia CC)

Para Mozilla, la privacidad de un individuo en Internet no es opcional. Esto los ha llevado a desarrollar características que potencian la privacidad tanto en el escritorio como en las plataformas móviles, incluyendo LightBeam, Ghostery, Privacy Badger en cuanto a extensiones, la preferencia de Do Not Track (no rastrear), navegación privada e “invitados”, altos niveles de cifrado con Firefox Sync, un enfoque de permisos individuales en aplicaciones (si Android contara con eso…) y el botón Forget.

El botón de Forget (“Olvidar”) provee una manera sencilla para que Firefox borre toda la actividad reciente. DuckDuckGo, el buscador de Internet que respeta la privacidad del usuario y no lo rastrea, fue agregado como buscador pre-instalado en las versiones recientes de Firefox.

Según una encuesta realizada en nombre de Mozilla el 74% del grupo de personas de 18 a 64 años encuestadas siente que su información personal es menos privada hoy en la web que lo que era hace un año. La misma cantidad cree que las compañías de Internet saben demasiado sobre ellos. Mozilla se quiere enfocar en mejorar esta situación.

Polaris es una iniciativa de privacidad que junta los esfuerzos de Mozilla con el CDT (Center for Democracy & Technology) y el Proyecto Tor. El objetivo es alinear las metas y políticas en pos de la privacidad de los usuarios de internet. CDT será asesor en temas como combatir la censura en Internet y proteger el anonimato en línea, vías vitales de promover la libertad de expresión.

El proyecto Tor es una red abierta que nos protege del análisis de tráfico, una forma de vigilancia que atenta contra la libertad y privacidad personal, confidencialidad, relaciones y seguridad de estado. Provee un navegador web llamado T” basado en Firefox. El primer experimento bajo el nombre de Polaris es que los ingenieros de Mozilla están evaluando los cambios a Firefox de Tor, para determinar si se pueden hacer cambios en el código mismo de Firefox para que Tor funcione más rápido y de manera más fácil.

Mozilla también va a empezar a alojar sus propios Middle-Relays de alta capacidad, lo que ayudará a las redes de Tor ser más responsivas y servir a más usuarios.

Por otro lado, el primer producto de Polaris se trata de una nueva característica (bajo prueba actualmente en las versiones Nightly de Firefox), que busca entender cómo ofrecer protección a los usuarios que quieren ser libres de trackeos invasivos sin penalizar a los anunciantes y sitios de contenido que respeten las preferencias de los usuarios.

Para conocer más de Polaris, pueden visitar la wiki o leer el anuncio oficial.

» 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