Video: El cuerpo Humano y los efectos de la gravedad

El siguiente video lo encontré tan fascinante que quiero compartirlo con ustedes, en él se muestran a distintas personas saltando, lo que nos hace poder apreciar el efecto que la gravedad tiene sobre nosotros, todo esto en cámara lenta, para visualizarlo mejor son personas de cuerpo desnudo.

La razón de compartirlo es que quizá muchos no tengan muy en cuenta que nosotros estamos moldeados enteramente por la gravedad de la tierra, nuestras piernas, facciones y muslos responden a la fuerza de gravitación. En otras palabras, si viviéramos en Júpiter u otro planeta con fuerza gravitacionaria distinta, nuestros cuerpos hubieran evolucionado de forma totalmente diferente.


Maravilloso, ¿No creen?, actualmente estos videos en forma de galería se presentan Los Ángeles, California; más detalles en el interior del video. El tema me parece bastante interesante, quizá dedique un par de post a esto después.

Fuente: Boing Boing 

Asociar archivos Scala en Eclipse

Si estás interesado en entrar de lleno a programar en Scala es bueno que prepares totalmente tu ambiente de trabajo. En los tutoriales anteriores hemos trabajado directamente con editores de texto, ahora mostraré cómo asociar los documentos con terminación .scala con el IDE Eclipse, empezaremos agregando el plugin:


a ) Desde el menú princpipal buscamos Help -> Install New Software
b ) En la nueva ventana seleccionamos Add
c ) Agregamos cualquier nombre y en Location usamos esta direción:
http://download.scala-ide.org/sdk/e37/scala29/stable/site/
Si tenemos duda de la versión puedes consultarlo en el siguiente enlace.
d ) Selecionamos todo y continuamos en Next; la instalación empezará. Probablemente en algún punto se te muestre un Security Warning, sólo acéptalo.
e ) Se nos pedirá reinicar Eclipse.
f ) Cuando iniciemos de nuevo, tendremos que escoger algunas opciones de configuración, nos aseguramos de utilizar el recomendado “Use recommended default settings
Ahora ya podrás incluso selecionar una nueva perspectiva o crear projectos basados en Scala.

Usando Eclipse para programar Scala/Lift

Normalmente cuando empezamos a programar usamos un IDE como Eclipse, Netbeans u otro para desarrollar nuestras aplicaciones, en la mayoría de los casos compilamos y ejecutamos todo desde la misma herramienta, sin embargo existen otras alternativas que nos dan más poder sobre lo que estamos haciendo. Les mostraré cómo usar Eclipse para desarrollar nuestro proyecto en Scala/Lift con la leve diferencia que la compilación la seguiremos haciendo desde el SBT.

1.- Aunque existen inclusive versiones de Eclipse listas para Scala, esta vez dejaré la opción para que descarguen la versión que gusten desde la página oficial, si nunca has tocado este IDE puedes usar la versión Classic.

2.- Una vez instalado y ejecutado debemos modificar el archivo /project/plugins.sbt, ahí agregamos el plugin para Eclipse con el siguiente apartado justo al final:

resolvers += Classpaths.typesafeResolver

addSbtPlugin("com.typesafe.sbteclipse" % "sbteclipse-plugin" % "2.1.2")

El espacio en blanco entre las dos sentencias es necesario. Tenemos que compilar para ver los cambios:

./sbt
eclipse

Automáticamente se descargará el plugin, posteriormente creará los archivos necesarios para que Eclipse lea nuestra proyecto: .project y .classpath. Si queremos de igual manera descargar la documentación que nos apoye en el código, ejecutamos el siguiente comando:

eclipse with-source=true

Si deseas dejar esto permanente estonces debes agregar la siguiente propiedad al archivo build.sbt:

EclipseKeys.withSource := true

Lo anterior descargará toda la documentación necesaria, recuerda compilar de nuevo usando el comando eclipse para efectuar los cambios.
3.- Casi todo está listo, sólo falta configurar el Eclipse, para ello lo abrimos y generamos un nuevo proyecto:

a ) Desde el menú File -> Import -> Existing Projects into Workspace, aseguramos no selecionar “Copy projecs into workspace

Y eso es todo, ahora podrás modificar y recibir apoyo con la documentación desde el IDE, esto es bastante efectivo pues separamos la compilación del proyecto del editor, lo que nos da bastante control sobre todo lo que hagamos.

Puedes consultar el siguiente enlace si no estás seguro de la versión que necesitas del plugin.

Parte 2: Scala/Lift Hot Deployment – Compilar cambios sin reiniciar el servidor

En la primera parte hemos hablado un poco de cómo hacer un Hot Deployment, aunque ese proceso generaba otro problema puesto que reiniciaba el servidor. Ahora veremos un proceso en el cual podremos compilar al aire sin afectar nuestra actividad en la aplicación.

Para nuestro problema usaremos una librería, JRebel, pueden obtener una licencia gratuita desde el siguiente enlace, aunque es de paga pueden renovarla cada cierto tiempo sin pagar por ella, básicamente entra en la dirección mencionada y busca JRebel Free Trial, se te pedirán unos datos, al finalizar obtendras un key code, guárdarlo, lo usaremos en breve.

Una vez obtenida la licencia descárga la versión genérica desde aquí  después procede a descomprimirla; normalmente guardo el archivo en el directorio  raíz de mi proyecto: lib/zt/jrebel, posteriormente ejecuta el archivo jrebel-config.sh localizado en:  lib/zt/jrebel/bin

Puedes ejecutarlo desde comando o ejecutando el archivo directamente, eso hará que se lance el Wizard  de configuración:
1.- Primero escogemos myJRebel license
2.- Pegamos el código que obtuvimos desde el sitio.
3.- Finalizamos

Ahora debemos configurar nuestro SBT para notificarle que estamos usando JRebel como agente al iniciar, para ello modificamos nuestro script que se encuentra ubicado en la raíz de nuestro proyecto, el archivo sbt debe contener el siguiente código:

java -Drebel.log=true -Drebel.lift_plugin=true -noverify -javaagent:lib/zt/jrebel/jrebel.jar 
-Xmx1024M -Xss2M -XX:MaxPermSize=512m -XX:+CMSClassUnloadingEnabled -jar 
`dirname $0`/sbt-launch-0.12.1.jar "$@"

Observa que sólo estamos agregando la línea 1 donde indicamos usar JRebel desde la ubicación que hayamos escogido. Si has pagado por una licencia entonces puedes agregar el path al documento que te envíen con esta otra propiedad:

-Drebel.license=/path/to/jrebel.lic

Es hora de probar, inicia tu servidor como siempre. Si en dado caso recibieras un error como el siguiente no te alarmes:

Error opening zip file: /jrebel/jrebel.jar
Error occurred during initialization of VM
agent library failed to init: instrument

Significa que el path que hemos puesto en el parámetro -javaagent es incorrecto, o que bien la instalación no se llevó acabo, para saber si el proceso salió bien ahora podrás ver información de JRebel cuando se ejecuta la aplicación por primera vez, no sólo eso, por cada código modificado se te notificará la re-carga de la clase, por ejemplo:

[2013-03-14 10:00:20] JRebel: Reloading class 'project.appwen.HelloWorld'.

Desde este enlace encontrarás más errores conocidos. Si tienes alguna duda deja un comentario.

Actualización:

Parece ser que desde la última versión de JRebel la instalación se hace de manera diferente, el única cambio es que después de ejecutar el wizard los archivos jrebel.licjrebel.properties son creados en la ubicación /home/actualuser/.jrebel/, estos deben ser copiados a la misma dirección donde está el jar: lib/zt/jrebel/jrebel.jar si no hacemos esto al inicar el servidor mostrará el error de “NO LICENSE FOUND“.

Fuente: Lift, JRebel

Parte 1: Scala/Lift Hot Deployment – Compilar cambios sin reiniciar el servidor

Entre los temas que suelen salir a flote entre programadores sobre todo de la parte Web, es la necesidad de compilar el código con cada cambio que se hace, proceso que muchas veces puede variar de los pocos segundos a unos 20 min esto dependiento del tamaño de la aplicación.

Siempre ha habido un acalorado debate en cuanto a esto que en inglés se le conoce como Hot Deployment. Aunque estoy de acuerdo en es que una mala práctica, cuando se está desarrollando en modo pruebas es bastante útil pues nos hace salvar bastante tiempo, caso contrario cuando es llevado a producción.

Sin embargo la realidad hoy en día es que los sistemas crecen en forma exponenciañ y aplicaciones como Facebook, Twitter o cualquier aplicación o sistema que maneja gran cantidad de usuarios no puede darse el lujo de hacer apagar o reiniciar su servidor para una actualización.

Aquí es donde nacen lenguajes como Erlang o Scala. Permitan un Hot Deployment real sin necesidad de reiniciar la aplicación puesto que son sistemas distribuídos, me gustaría indagar un poco más en eso adelante en algún post, es un tema bastante interesante.

Voy a dividir este artículo en dos partes, en esta primera entrega mostraré cómo compilar con cada cambio que se haga a los archivos, sin necesidad de usar un IDE en especial, esto quiere decir que con hacer un simple cambio desde un editor genérico de texto a uno de los códigos de Scala se compilará de manera automática, aunque ejecutará la acción de recargar el contenedor web. La segunda entrega hablaremos de cómo realizar lo mismo sin recargar nuestra aplicación.

Nuestro servidor tiene un comando que hace todo por nosotros, pero debemos compilar nuestra aplicación con el comando que todos ya conocemos:

./sbt

Al hacerlo estamos entrando siempre al Simple Build Tools, que es un prompt de comandos para el servidor, estando ahí ejecutamos lo siguiente:

~; container:start; container:reload /

¿Y qué significa todo esto? el prefijo ‘~‘ le indica al SBT que compile los cambios, el punto y coma ‘;‘ sólo es una secuencia de comandos, que se traduce como: a cada cambio compila, reinicia y recarga el contenedor web. En general el comando estará atento a los cambios realizados sólo a los documentos en Scala al igual que cambios en el directorio “src/main/sources/“. Cabe aclarar que al ejecutar el comando entras en modo de escucha, por lo que quizá veas algo como lo siguiente:

Waiting for source changes... (press enter to interrupt)

Cada modificación se verá reflejada en la terminal, para salir de este modo basta con presionar la tecla enter. Para hacer pruebas está bien, sin embargo si planeas modificar muchos archivos puedes correr el riesgo de recibir el mensaje “java.lang.OutOfMemoryError: PermGen space” correspondiente a que la memoria está totalmente llena.

En el siguiente post veremos cómo evitar el reinicio del servidor y no tener un error de memoria.

 

Fuente: Lift Web

Ghost in the Shell está de vuelta en una precuela, Arise

812506-major_tachikomaNormalmente no hablaría de estos temas, pero en este caso lo vale mucho. Ghost in the Shell fue un animé que marcó mucho en mi vida por los temas tan complejos que maneja y es aquí donde entra este blog.

La serie narra la vida de Motoko Kusanagi, una agente que trabaja para el gobierno en la sección 9, encargada de espionaje y seguridad nacional. Nuestra protagonista es un cyborg con la más alta tecnología al más puro estilo cyberpunk, sin embargo a pesar de lo trillada que pueda ser la serie, maneja temas como la conciencia, la unión entre la máquina y el hombre entre otras cosas Para los que ya vieron la serie, el final con los Tachikomas es inolvidable, no quiero dar muchos detalles de eso, pero es altamente recomendable.

La serie gira entorno de Motoko, normalmente ella se cuestiona muchas cosas relacionadas a quién es, y si posee un Ghost (un alma), otros temas que maneja son la concienca colectiva, el yo interno, el libre albredío, la transmigración de la conciencia, la singularidad, etc. Es una serie que no deben dejar pasar, y ahora con la precuela se explican muchas cosas del origen de la Mayor Kusanagi (así se refieren a ella sus colegas), a continuación el trailer:

Si no entendiste mucho del japonés, no te preocupes, yo tampoco, pero en forma resumida esta nueva y sorpresiva entrega es una precuela de la serie, se centrarán mucho en los pensamientos de Motoko y todo lo que sucede antes de  convertirse en un Cyborg.

La serie original es creada por Masamune Shirow, y dirigida en su formato digital por Mamoru Oshii. Hasta donde sé, no sólo el director será el mismo, también todas la voces del staff original están de vuelta, así que si no has visto la serie completa es hora de darle una oportunidad.

 

Fuente: sitio oficial

Estructura de un proyecto en Scala/Lift

Ya hemos visto cómo crear un Proyecto Web con Scala/Lift, nos toca hablar un poco de cómo está compuesto en general la estructura de este. Al principio puede ser un poco complicado si no vienes de programar en contenedores web, así que revisemos un poco cuáles son las convenciones a respetar:

- webapp
  | build.sbt
  - project/
    | plugins.sbt
  - src/
    - main/
      - scala/
        - bootstrap/
          | Boot.scala
        - org/
          - mysystem/
            - webapp
              | <CÓDIGO SCALA>
      - webapp/
        | index.html
        | <RECURSOS>
        - WEB-INF/
          | web.xml
    - test/
      - scala/
        - org/
          - mysystem/
            - webapp/
              | <PRUEBAS>

El proyecto puede lucer más o menos como el de arriba, lo importante a notar son las dos carpetas principales para poner nuestro código, todo lo que sea recursos html, javascript o imágenes van en la línea 13 y todo lo que sea código en Scala va en la línea 16. ¿Quién decide esta estructura? Cuando construímos nuestra aplicación usando el comando “./sbt” que lee el archivo build.sbt, usando la propiedad:

organization := "org.mysystem.webapp"

Esta define el directorio raíz, observa cómo para los directorios obtenemos los siguients paths “scala/org/mysystem/webapp” tanto para el código como para las pruebas en la carpeta “test/scala“, si aún te quedan dudas puedes descargar un template vacío desde la siguiente dirección. 

Fuente: Lift Web

Recreación digital de la actriz británica Audrey Hepburn

Audrey Hepburn

Quién diría hace unos años que delante de nosotros podríamos traer de nuevo a la vida, al menos digitalmente, a famosos artistas, cantantes y actores fallecidos; este es el caso del siguiente comercial para el Chocolate Galaxy (por cierto, muy rico). La joven actriz que vemos no es nada más y menos que Audrey Hepburn, famosa actriz británica-belga fallecida en 1993, muy conocida por su bella sonrisa, fue nombrada por la American Film Institute como la tercera mujer entre las más grandes estrellas femeninas de todos los tiempos, su forma de ser siempre se basó en la elegancia natural y sin mostrar interés en joyas ni vestuario:

Para la realización del comercial se buscó a una chica lo más parecida, al menos en cuerpo, ya que la cara fue totalmente reconstruída digitalmente para parecer lo más fielmente posible a la fallecida actríz, sólo por mencionar, se requirieron 4 animadores sólo para trabajar en la sonrisa. El resultado es bastante espectacular,  aunque los conspiracionistas dirían que gracias a estos avances a cualquiera pudieran crearle un video cometiendo algún crimen, es de notar el gran avance que hemos tenido en este rubro. En un futuro no muy lejano los personajes animados podrían sustituir en su totalidad a los actores.

Fuente: FayerWayer

Tutorial: Crear una aplicación Web con Scala / Lift desde cero

Continuando con los post del Web Server Lift con Scala, hoy mostraré cómo crear una aplicación Web desde cero y que podremos usar más adelante como un template en blanco para nuestros proyectos. Es necesario haber realizado el tutorial anterior para poder continuar.

Para empezar debemos crear una carpeta para nuestro proyecto, para efectos prácticos la llamaré “webapp” y dentro otra carpeta llamada “project“. Nuestro primer paso consiste en configurar el SBT (Simple Build Tool), esto se lograr creando el archivo plugins.sbt dentro de la carpeta de nuestro proyecto con el siguiente fragmento de código:

libraryDependencies <+= sbtVersion(v => v match {
  case "0.11.0" => "com.github.siasia" %% "xsbt-web-plugin" % "0.11.0-0.2.8"
  case "0.11.1" => "com.github.siasia" %% "xsbt-web-plugin" % "0.11.1-0.2.10"
  case "0.11.2" => "com.github.siasia" %% "xsbt-web-plugin" % "0.11.2-0.2.11"
  case "0.11.3" => "com.github.siasia" %% "xsbt-web-plugin" % "0.11.3-0.2.11.1"
  case x if (x.startsWith("0.12")) =>
    "com.github.siasia" %% "xsbt-web-plugin" % "0.12.0-0.2.11.1"
})

El código anterior se encarga de cargar el xsbt-web-plugin acorde a la versión que definas para Scala, para definir esto crea el archivo build.sbt, como he mencionado antes, este archivo carga todas las librerías necesarias, debe estar en raíz y contendrá lo siguiente:

organization := "org.webapp"

name := "My Wep App"

version := "0.1"

scalaVersion := "2.10.0"

seq(com.github.siasia.WebPlugin.webSettings :_*)

libraryDependencies ++= {
  val liftVersion = "2.5-M4"
  Seq(
    "net.liftweb" %% "lift-webkit" % liftVersion % "compile",
    "org.eclipse.jetty" % "jetty-webapp" % "8.1.7.v20120910" % "container,test"
  )
}

Algunos de los parámetros son autodescriptivos, los demás son propios de Scala como el manejo de colecciones “Seq“. Con esto tenemos configurada parte de la aplicación, para poder compilarlo ocupamos los archivos “sbt” y “sbt-launch-0.12.1.jar” (puede variar la versión) que encontrarás en la raíz del proyecto del tutorial pasado, copiamos dichos archivos a la raíz de nuestro proyecto y ejecutamos el siguiente comando:

./sbt

El comando anterior descargará todos los archivos necesarios para la versión de Scala que hayamos selecionado, al terminar entrarán automáticamente en el prompt, recuerda que aunque siempre ejecutes el comando, sólo descargará una vez los documentos. Desde la raíz de tu proyecto encontrarás una nueva carpeta, estas son las dependencias que se necesitan para ejecutar el lenguaje.

Ya casi tenemos listo nuestro ejemplo, nos falta definir nuestro contenedor para que recoja las peticiones usando Lift, básicamente el siguiente documento xml debe ser creado desde raíz en la siguiente ubicación: src/main/webapp/WEB-INF/web.xml y su contenido debe ser el siguiente:

<!DOCTYPE web-app SYSTEM "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
  <filter>
    <filter-name>LiftFilter</filter-name>
    <display-name>Lift Filter</display-name>
    <description>The Filter that intercepts Lift calls</description>
    <filter-class>net.liftweb.http.LiftFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>LiftFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
</web-app>

Nuestro siguiente documento define nuestra pantalla inicial y debe estar localizado en la siguiente dirección: src/main/webapp/index.html

<!DOCTYPE html>
<html>
  <head>
    <title>Welcome to Scala/Lift</title>
  </head>
  <body>
    <h1>Welcome to your Web Server</h1>
  </body>
</html>

Los Web Server con contenedores en Java funcionan gestionando las peticiones, en el caso de Lift debemos crear un documento que se encargará de esto, debe estar localizado en la siguiente dirección: src/main/scala/boot/strap/Boot.scala

package bootstrap.liftweb

import net.liftweb.http.{Html5Properties, LiftRules, Req}
import net.liftweb.sitemap.{Menu, SiteMap}

/**
 * A class that's instantiated early and run.  It allows the application
 * to modify lift's environment
 */
class Boot {
  def boot {
    // where to search snippet
    LiftRules.addToPackages("org.webapp")

    // Build SiteMap
    def sitemap(): SiteMap = SiteMap(
      Menu.i("Home") / "index"
    )

    // Use HTML5 for rendering
    LiftRules.htmlProperties.default.set((r: Req) =>
      new Html5Properties(r.userAgent))
  }
}

Usando Scala como lenguaje base, nuestro archivo boot se encargará de direccionar nuestras peticiones. Ya tenemos todo listo, desde la raíz de nuestro proyecto ejecutar los dos comandos:

./sbt
container:start

Ahora ya podrás acceder a tu proyecto desde http://localhost:8080/index, ten encuenta que los documentos en Scala deben ser compilados, a diferencia de los html que puedes modificar sin necesidad de levantar el servicio de nuevo.

Fuente:  Lift Web

Video: Google Glass a finales de año

No he querido hablar mucho acerca de Google Glass, pero es evidente que es algo que espero con muchas ansias desde hace tiempo y que dedicaré algunas líneas pronto. Les dejo un video que prepararon los chicos de The Verge donde entrevistaron parte del equipo al igual que una demostración de lo que es capaz:

 

 

Si todo va bien, tendríamos acceso público a finales de año, este mes fue la beta abierta a desarrolladores (más bien los que pudieron pagar unos cuantos miles de dólares) en San Francisco, CA. Si andas un poco perdido aquí un video mostrando algunas características del nuevo juguete de Google, llamado internamente Project Glass:

 

 

Fuente: The Verge