miércoles, 31 de julio de 2013
Cómo desproteger archivos PDF
TV On The Radio : nouveau single en écoute
lunes, 29 de julio de 2013
Así se ven los usuarios de las distribuciones de Linux
Porque aunque todas estén basadas en Linux, cada distribución es única y ofrece características especiales a sus usuarios. ¿Les parece que la imagen dice la verdad? Vía: Twitter Otros llegaron buscando:feedly com 14azzgy
Este artículo Así se ven los usuarios de las distribuciones de Linux fue publicado originalmente en Punto Geek.
Todos los Ipsum en un solo lugar
Todos conocemos Lorem Ipsum, ese texto en latín que utilizamos en wireframes y maquetas de sitios web o aplicaciones para tener una vista previa de como se vería el diseño con algo de texto en el, aunque existen otras alternativas más gráficas que también nos pueden ayudar en el proceso. Bueno, resulta que Lorem Ipsum [...]
Este artículo Todos los Ipsum en un solo lugar fue publicado originalmente en Punto Geek.
Top 20 des films à (re)voir l’été
Chromecast hackeado: está basado en una versión reducida de Google TV
GTV Hacker ha realizado un exploit para el Chromecast que le ha permitido acceder al dispositivo con permisos de administrador y realizar una inspección del mismo. Sus conclusiones son muy interesantes: no es un dispositivo basado en Chrome OS sino que es Android, concretamente una versión reducida del Google TV.
La semana pasada, durante el evento de presentación de Android 4.3 y la nueva Nexus 7, los chicos de Google nos sorprendieron con un gadget que no esperábamos: el Chromecast, un dongle que conectado a nuestro televisor nos permite hacer streaming de contenidos web desde nuestros dispositivos móviles o nuestro PC y verlo cómodamente en nuestra televisión. Además de un buen precio, 35 dólares, Google nos comentó que el Chromecast era un dispositivo que se apoyaba sobre Chrome OS; sin embargo, desde GTV Hacker apuntan a algo muy distinto: han hackeado el dispositivo y lo que se han encontrado es Android, concretamente trazas de Google TV.
GTV Hacker, tal y como publica en su web, ha desarrollado un exploit que les permite acceder al dispositivo con privilegios de administrador y, a partir de ahí, han realizado un análisis de lo que encierra este dispositivo low-cost para hacer streaming desde nuestros ordenadores personales y dispositivos móviles hacia nuestro televisor del salón de casa.
Teniendo en cuenta lo que vimos en la presentación de la semana pasada, uno podría esperarse que los hallazgos confirmasen que el Chromecast se apoyaba en Chrome OS (que fue lo que se anunció cuando se presentó el dispositivo); sin embargo, que lo que se hayan encontrado esté más cercano a Android es bastante singular y, sobre todo, distante con el discurso oficial de los chicos de Mountain View. Concretamente, de esta versión de Android se habrían eliminado Bionic y Dalvik y, además, se habrían encontrado bastantes trazas de código que este grupo había encontrado en el Google TV. Por ejemplo, el bootloader o los scripts de arranque son iguales que en el set-top-box de Google.
¿Y cambian las cosas sabiendo que Chromecast es una especie de Google TV modificado? Realmente, cara al usuario las cosas no cambian mucho y, realmente, es algo que a primera vista les da un poco igual y seguirán viendo Chromecast como un curioso gadget con el que ver en la televisión vídeos y otros contenidos a los que acceden con sus tabletas o con sus ordenadores personales. Sin embargo, cara a los desarrolladores, el trabajo realizado por la gente de GTV Hacker es muy interesante y su exploit permitirá estudiar al dispositivo con mucho detenimiento y explorar todas sus posibilidades.
Si recordamos a Kinect, gracias a trabajos de investigación como estos, un dispositivo concebido para jugar se ha convertido en la base sobre la que se desarrollan proyectos de lo más variado e, incluso, es la base sobre la que se apoyan startups para desarrollar productos y servicios. Chromecast es un dispositivo que cuesta 35 dólares, un precio muy asequible que no supone una barrera de entrada; si además se puede exprimir y, por ejemplo, se desarrollan hacks que permitan explotar su potencial, el dispositivo se podría hacer extremadamente popular y, quizás, podría seguir los pasos de Kinect como base para muchos proyectos.
 |
UIkit: Genial framework liviano y responsive para crear tus sitios web
UIkit es un nuevo framework modular gratuito para crear interfaces web de forma muy sencilla, y lo mejor es que está centrado en ser liviano y responsive. Además tiene un customizer online que nos permite personalizar las plantillas y descargar el CSS de forma muy simple, pudiendo elegir paletas de colores, ancho del diseño, tamaño [...]
Este artículo UIkit: Genial framework liviano y responsive para crear tus sitios web fue publicado originalmente en Punto Geek.
Elysium
En su segunda película como director, Neill Blomkamp se mantiene fiel a sí mismo desarrollando un emocionante relato de ciencia-ficción que sirve, a la vez, como perfecta metáfora de la realidad social a la que nos ha llevado la recesión económica mundial.Aquellos que vayan al cine pensando que Elysium va a ser como una especie de puesta al día de District 9, en la que los extraterrestres se han intercambiado por humanos atrapados en su propio planeta, podrían tener algo de razón. Pero lo cierto es que Neill Blomkamp consigue anticiparse al espectador, construyendo un relato que, aunque circula por lugares comunes a su ópera prima, consigue superarlo para elaborar un relato globalizado que trasciende culturas y fronteras. La mayoría de las veces, tomar como elemento de partida un conflicto local contribuye a hacer que el relato llegue con más fuerza al público internacional. En sentido inverso, cuando se intenta tratar temas más universales con la intención de tener más alcance, se obtienen productos impecables, pero carentes de alma y personalidad. El principal logro de Elysium es que cualquier espectador se puede sentir identificado con sus personajes, independientemente de cual sea sea su cultura y si país de origen poruqe todos hemos estado, en mayor o menor medida, oprimidos en algún punto de nuestra historia.
La verosimilitud de los personajes y la contundencia del relato permiten que incluso aquellos que no sean aficionados al cine de ciencia-ficción puedan entender lo que Blomkamp, autor también del guión, trata de transmitir con su película. La eficacia del reparto —en el que además de Matt Damon y Jodie Foster, recupera a Sharito Copley —que fuera protagonista de District 9—, integrando actores latinoamericanos como Diego Luna, Alice Braga o Wagner Moura, está poderosamente apoyada en el fabuloso diseño de producción de Philip Ivey —también lo fuera de District 9—, que da más importancia a la funcionalidad que a la estética, pero sin sacrificar por ello las dos atmósferas tan opuestas y marcadas de los dos mundos que se muestran. De esta manera se enriquece considerablemente una película que mantiene también un encomiable equilibrio entre ese relato de acción y ciencia-ficción que promete y la crítica social y política que acaba siendo.## Guiños y referencias
Si en el diseño de la plataforma espacial a la que denominan Elysium, salta a la vista el guiño a 2001: A Space Odyssey, menos evidentes son sus vínculos con Metropolis, aunque mucho más profundas. En un principio da la impresión que se pretende mostrar cómo entraron en decadencia aquellas fabulosas ciudades imaginadas por Fritz Lang para nuestro futuro pero, por otro lado, también refleja aquel mundo que en su película estaba dividido en dos grupos sociales en el que los trabajadores estaban condenados a vivir en ciudades subterráneas, mientras que los privilegiados disfrutaban de una forma de vida hedonista en la superficie. Los primeros son lo que residen aquí en esa superficie superpoblada del planeta, disfrutando los segundos de un entorno aislado, en perfecta armonía y en continua órbita alrededor de la tierra, como si de un nuevo satélite se tratara. Las alusiones a la película mudo de 1927 no quedan ahí, pero no quiero pecar de spoiler.
Me siento obligado, eso sí, a señalar también alguna conexión con aquellos mundos distópicos imaginados por Philip K. Dick. Alusión por inspiración, que no por plagio, exento aquí el protagonista de la esquizofrenia a la que abocaba a sus personajes el autor de novelas en las que se inspiraron títulos como Blade Runner, Total Recall, Minority Report o Scanner Darkly.
Spanish Revolution
En el apartado artístico sobresale la intensa banda sonora de Ryan Amon, en la que es su primera incursión en el cine. Su partitura oscila entre el tono industrial y agresivo que caracteriza las secuencias de acción, con un tono más lírico y hasta new age, en consonancia con la dualidad que propone ese mundo desolado en el que viven unos y la ansiada armonía que se respira en los otros. Una armonía artificial, claro está, como la falsa seguridad en la que vivía la sociedad en los tiempos previos al estallido de la recesión económica mundial, metáfora que se esconde detrás de este futuro distópico, tan apocalíptico y decadente para unos como beneficioso y saludable para otros. Un mundo que, dado el predominio del español por encima de otros idiomas, se me antoja alusivo al movimiento indignado español, más que a la primavera árabe, y en le que los enemigos del pueblo no son otros que la policía y la burocracia, el sistema político y la corrupción en al que sigue instalado en este futuro no tan lejano en le tiempo y tan cercano en el sentimiento.
Las evidencias son claras, desde la actitud de los policías, representados en la película por robots que no atienden ha razones, hasta la capacidad de los políticos para traicionarse unos a otros en función de sus necesidades. Incluso ese entorno ideal que parece diseñado siguiendo el patrón de esas urbanizaciones ubicadas en campos de golf, parece aludir a la burbuja inmobiliaria, como también hacía recientemente otra película como Rango. ¿Acaso no has vivido (o sido testigo) de agresiones policiales como las que experimenta Max (Matt Damon)? ¿No te suena ese antipático lema de "tolerancia cero" —cuando o veo en algunos hospitales en referencia a los familiares de pacientes me pongo literalmente enfermo? ¿No está dibujado el personaje de John Carlyle (William Fichtner) en función de muchos grandes empresarios —en la línea de, por ejemplo, Sheldon Adelson— que no les importa en absoluto los daños colaterales de sus negocios con tal de seguir haciendo caja? ¿Acaso no representa el personaje interpretado por Jodie Foster un perfecto alter ego de Esperanza Aguirre —azote de la privatización a toda costa en la política española? Sí, algunos dirán que lo personalizo con figuras de mi entorno, pero convencido estoy de que cada cual podrá buscar los equivalentes al suyo. Al fin y al cabo, (casi) todos estamos gobernados, de una u otra manera, por el mercado económico, más que por los gobiernos que "hemos sido obligados a escoger".
Activismo desencantado
Por último, destacar la coherencia en la resolución de la película, que no terminando mal, tampoco se ajusta exactamente a los finales convencionales made in Hollywood, reforzando la verosimilitud de su mensaje. Quizás un servidor hubiera preferido que la película fuera más activista. Que incitara con más fuerza a un despertar del ciudadano, al menos una vez establece que la metáfora se refiere a la crisis económica a la que nos ha llevado la corrupción política y la tiranía del vil metal. También es posible que la última parte de la película resulte algo condescendiente con esa verosimilitud que ha mantenido con bastante coherencia a lo largo del relato, pero el hecho de que el perfil de Max se aleje nuevamente del típico héroe del que habrían abusado en un blockbuster al uso, redime al director de cualquier concesión al espectáculo y la exhibición gratuita, que son contadas y perfectamente digeribles.8Neill Blomkamp repite su fórmula ofreciendo una película de acción y ciencia-ficción, tras la que no esconde otra cosa que una metáfora contra los gobiernos que nos han llevado a la recesión económica. Los que no vean la metáfora no se sentirán en absoluto defraudados, dado que consigue articular esta premisa a través de un relato sencillo, pero perfectamente coherente, emocionante y contundente. Y los que esperaban algo más que un relato distópico también podrán discutir y reflexionar con las premisas que plantea un título que acaba constituyéndose como una perfecta muestra de cine indignado.
 |
Los mayores robos de datos en la historia reciente de la tecnología
¡Glups! Visto así, acojona: Los mayores robos de datos de la historia reciente, una brillante infografía de Popular Science.
El premio «gordo» se lo lleva Sony con el famoso robo de datos de 75 millones de cuentas en la PlayStation Network, seguido de Evernote, Living Social y Ubisoft.
En la historia menos reciente también figura el robo de 92 millones de cuentas de AOL en 2004.
Los anillos de Saturno, Titán y Encélado a contraluz
PIA08235: Candle in the Dark - Contraluz en Saturno
La Imagen Astronómica del Día de la NASA de hoy viene del baúl de los recuerdos digital de la sonda Cassini, pues es una imagen tomada por su cámara de campo estrecho el 10 de junio de 2006.
En ella se ven parte de los anillos de Saturno, y sus lunas Titán y Encélado prácticamente a contraluz, ya que el ángulo que formaba el Sol con Cassini respecto a las dos lunas era de 160 grados.
Titán es la más grande de las dos, tanto en la foto como en el MundoReal™, con 5.150 kilómetros de diámetro, mientras que Encélado sólo mide 505 kilómetros, aunque como la Cassini estaba a 5,3 millones de kilómetros de Titán y a «tan sólo» 2,4 millones de Encélado el primero tiene una resolución de 32 kilómetros por pixel en esta imagen, mientras que el segundo está a 23 kilómetros por pixel.
La luz que se ve alrededor de Titán es la luz del Sol dispersada en su atmósfera, mientras que la tenue atmósfera de Encélado no se ve, aunque sí se pueden apreciar los chorros de vapor de agua que escapan de su interior.
Es precisamente la posibilidad de que haya agua líquida en Encélado la que ha llevado a algunos científicos el lanzamiento de una misión con el objetivo de intentar encontrar vida allí, aunque dado el estado actual de las cosas, es una misión que tardaremos muchos años en ver…
Si es que alguna vez la vemos.
- Encélado iluminado por el Sol y Saturno, Encélado de cerca, y Sobrevolando Encélado, más sobre esta intrigante luna.
Oppo se suma a la carrera fotográfica con el N-Lens, futuro rival del Galaxy Camera
Filed under: Telefonía, Cámaras digitales
Como bien nos dice su propia denominación, el N-Lens será un dispositivo claramente enfocado al segmento fotográfico, aunque sus miras apuntarán mucho más alto. Según la firma china, el N-Lens está llamado a convertirse "en el buque insignia más importante para Oppo en adelante", aunque no está nada claro si será un teléfono o una cámara pura y dura con capacidades multimedia y sociales avanzadas.
Continue reading Oppo se suma a la carrera fotográfica con el N-Lens, futuro rival del Galaxy Camera
Read | Permalink | Email this | Comments
Crear aplicaciones para iOS sin saber de programación con AppArchitect
Hoy en día en internet existen tantas herramientas que hasta podemos crear aplicaciones móviles sin saber absolutamente nada de programación, y la herramienta que les quiero comentar hoy es AppArchitect, una plataforma que nos permite crear aplicaciones para iOS sin saber de programación. Lo primero que tenemos que hacer es crearnos una cuenta en AppArchitect [...]
Este artículo Crear aplicaciones para iOS sin saber de programación con AppArchitect fue publicado originalmente en Punto Geek.
viernes, 26 de julio de 2013
Consiguen implantar falsos recuerdos en ratones
¿Alguien recuerda las míticas películas de los años 80-90 en las que el protagonista sufría un “lavado de cerebro” que hacía que todos sus recuerdos desaparecieran o fueran sustituidos por otros completamente diferentes? A medida que avanza la ciencia, parece ser que esas películas no estaban tan lejos de la realidad. Hoy se ha conocido [...]
Este artículo Consiguen implantar falsos recuerdos en ratones fue publicado originalmente en Punto Geek.
Hardware reconfigurable: proyectos creativos basados en FPGAs
Si bien Arduino y Raspberry Pi se han hecho muy populares entre los aficionados a la electrónica, las FPGAs siguen siendo un componente clave desde hace más de 20 años. Repasamos algunos proyectos creativos que podemos encontrar en la red y que giran alrededor de estos dispositivos.
Proyectos como Raspberry Pi y Arduino se han convertido en la base sobre la que se apoyan muchos desarrolladores, ingenieros y aficionados a la electrónica y al hardware para realizar proyectos de todo tipo y, por supuesto, para desarrollar prototipos de sistemas mucho más complejos. Otros dispositivos que, desde hace más de 20 años, también son una pieza clave en el ámbito del diseño electrónico son las FPGA (Field-Programmable Gate Array); unos dispositivos de propósito general que nos ofrecen un hardware totalmente reconfigurable que podemos adaptar a nuestros proyectos y que, incluso, son la base para muchos proyectos catalogados de "alto secreto".
¿Qué es una FPGA?
Las FPGAs son dispositivos programables que en su interior encierran "multitud de puertas lógicas" que inicialmente están desconectadas y que, gracias a lenguajes de descripción de hardware (HDL), los diseñadores pueden configurar las conexiones entre estas puertas y así construir todo tipo de sistemas electrónicos. Esta forma de diseñar sistemas electrónicos es muy interesante puesto que ofrece mucha versatilidad a la hora de trabajar (programamos describiendo el comportamiento del sistema) y vuelve complicada la ingeniería inversa porque no es sencillo averiguar el conexionado interno de la FPGA.
Si bien analizando la placa de un sistema realizado con componentes comerciales alguien es capaz de obtener esquemas y planos para copiarlos, con una FPGA esto no es nada simple porque llegaremos a un punto que veremos una "caja negra" cuyo organización interna deconocemos. De hecho, si buscamos casos de uso de las FPGAs por la red encontraremos a la mismísima NSA usando este tipo de componentes para desarrollar sus equipos o, por ejemplo, a la Dirección General de Seguridad Exterior de Francia (su servicio de espionaje) usar esta tecnología para fabricar su propio supercomputador para interceptar comunicaciones.
Las FPGAs son utilizadas hoy en día en un amplio abanico de proyectos, son materia docente en muchas universidades de todo el mundo (particularmente es algo que recuerdo con mucho cariño) y también siguen siendo la base sobre la que se apoyan muchos entusiastas del diseño del hardware con multitud de proyectos creativos.
¿Y qué proyectos creativos basados en FPGAs podemos encontrar? ¿Qué cosas podemos hacer con este tipo de dispositivos?
Recrear máquinas arcade clásicas
Hasta que en 1975 Midway Games lanzó al mercado Gun Fight (que fue el primer arcade en usar un microprocesador), todas las máquinas arcade desarrolladas hasta ese momento se habían construido mediante lógica discreta; es decir, mediante circuitos TTL básicos. Teniendo en cuenta este dato, no es raro encontrar proyectos que reviven a los clásicos de la primera época de las máquinas arcade en sistemas basados en una FPGA. De hecho, como también es posible emular en una FPGA un procesador, también llegamos a encontrar recreaciones de máquinas arcade de todas las épocas.
Si somos aficionados a los videojuegos y también nos apasiona el mundo del diseño de hardware, construir una réplica en hardware de estas máquinas arcade puede ser un buen proyecto que emprender, tanto para aprender como para divertirnos (una recreación de Pac-Man fue, precisamente, mi trabajo de curso junto a dos compañeros más cuando estudiábamos VHDL).
El Pacman orginal, el Space Invaders o Asteroids son algunos de los juegos clásicos que podemos implementar en una FPGA pero si queremos transformar una FPGA en una máquina arcade versátil también tendremos la opción implementando una versión hardware del emulador MAME.
gui ambros en Flickr
Reconstruir consolas de videojuegos
Hemos hablado de computadoras, microprocesadores y máquinas arcade como ejemplos de proyectos creativos que podemos abordar con una FPGA y con los que podremos pasar un buen rato a la vez que aprendemos y experimentamos con el apasionante mundo del diseño de hardware.
Ya que estamos mirando al pasado y la historia de la tecnología, las consolas clásicas de videojuegos también forman parte de los proyectos que se suelen desarrollar usando FPGAs y son muchos los usuarios que han dedicado tiempo a construir réplicas de consolas como la NES, la Nintendo GameBoy, la Mega Drive de Sega o, incluso, la Jaguar de Atari.
Micah Elizabeth Scott en Flickr
Construir un microprocesador
Un microprocesador está compuesto por millones de transistores que, a su vez, implementan puertas lógicas que sirven para construir los distintos subsistemas que forman parte del procesador. Dicho de otra forma, si un microprocesador es un dispositivo electrónico digital entonces está formado por una combinación de puertas lógicas y se puede implementar sobre una FPGA.
Evidentemente, construir sobre una FPGA un procesador como los nuevos Intel Haswell es un proyecto prácticamente inalcanzable pero, como ejercicio para aprender más, construir procesadores clásicos o históricos es algo bastante más común y en la red podemos encontrar buenos ejemplos. El Zilog Z80, el Motorola 68HC11, el Intel 4004 o el mítico Motorola 68000 son algunos procesadores que se han implementado, años más tarde, en FPGAs y que, por tanto, se han construido usando lenguajes de descripción de hardware.
Emular computadoras legendarias
Teniendo en cuenta la potencia que puede tener una FPGA y la capacidad que tienen estos dispositivos, de la misma forma que podemos emular un procesador clásico también podemos ampliar el alcance y emular un computador completo en un único chip. En usos convencionales, las FPGAs son la base para desarrollar SoCs (Systems on a Chip) y, extendiendo este modelo, en la red podemos encontrar reconstrucciones de todo tipo de computadoras clásicas.
El Apple II, el Commodore 64, el ZX Spectrum, los computadores PDP, el Apple I, el supercomputador Cray, el Commodore PET o la Atari ST son algunas recreaciones construidas sobre una FPGA.
 |
Handlebars.js – a Behind the Scenes Look
Handlebars has been gaining popularity with its adoption in frameworks like Meteor and Ember.js, but what is really going on behind the scenes of this exciting templating engine?
In this article we will take a deep look through the underlying process Handlebars goes through to compile your templates.
This article expects you to have read my previous introduction to Handlebars and as such assumes you know the basics of creating Handlebar templates.
When using a Handlebars template you probably know that you start by compiling the template's source into a function using Handlebars.compile() and then you use that function to generate the final HTML, passing in values for properties and placeholders.
But that seemingly simple compile function is actually doing quite a few steps behind the scenes, and that is what this article will really be about; let's take a look at a quick breakdown of the process:
- Tokenize the source into components.
- Process each token into a set of operations.
- Convert the process stack into a function.
- Run the function with the context and helpers to output some HTML.
The Setup
In this article we will be building a tool to analyze Handlebars templates at each of these steps, so to display the results a bit better on screen, I will be using the prism.js syntax highlighter created by the one and only Lea Verou. Download the minified source remembering to check JavaScript in the languages section.
The next step is to create a blank HTML file and fill it with the following:
<!DOCTYPE HTML> <html xmlns="http://www.w3.org/1999/html"> <head> <title>Handlebars.js</title> <link rel="stylesheet" href="prism.css"></p> <script src="prism.js" data-manual></script> <script src="handlebars.js"></script> </head> <body> <div id="analysis"> <div id="tokens"><h1>Tokens:</h1></div> <div id="operations"><h1>Operations:</h1></div> <div id="output"><h1>Output:</h1></div> <div id="function"> <h1>Function:</h1> <pre><code class="language-javascript" id="source"></code></pre> </div> </div> <script id="dt" type="template/handlebars"> </script> <script> //Code will go here </script> </body> </html>
It's just some boilerplate code which includes handlebars and prism and then set's up some divs for the different steps. At the bottom, you can see two script blocks: the first is for the template and the second is for our JS code.
I also wrote a little CSS to arrange everything a bit better, which you are free to add:
body{ margin: 0; padding: 0; font-family: "opensans", Arial, sans-serif; background: #F5F2F0; font-size: 13px; } #analysis { top: 0; left: 0; position: absolute; width: 100%; height: 100%; margin: 0; padding: 0; } #analysis div { width: 33.33%; height: 50%; float: left; padding: 10px 20px; box-sizing: border-box; overflow: auto; } #function { width: 100% !important; } Next we need a template, so let's begin with the simplest template possible, just some static text:
<script id="dt" type="template/handlebars"> Hello World! </script> <script> var src = document.getElementById("dt").innerHTML.trim(); //Display Output var t = Handlebars.compile(src); document.getElementById("output").innerHTML += t(); </script> Opening this page in your browser should result in the template being displayed in the output box as expected, nothing different yet, we now have to write the code to analyze the process at each of the other three stages.
Tokens
The first step handlebars performs on your template is to tokenize the source, what this means is we need to break the source apart into its individual components so that we can handle each piece appropriately. So for example, if there was some text with a placeholder in the middle, then Handlebars would separate the text before the placeholder placing it into one token, then the placeholder itself would be placed into another token, and lastly all the text after the placeholder would be placed into a third token. This is because those pieces need to both retain the order of the template but they also need to be processed differently.
This process is done using the Handlebars.parse() function, and what you get back is an object that contains all the segments or 'statements'.
To better illustrate what I am talking about, let's create a list of paragraphs for each of the tokens taken out:
//Display Tokens var tokenizer = Handlebars.parse(src); var tokenStr = ""; for (var i in tokenizer.statements) { var token = tokenizer.statements[i]; tokenStr += "<p>" + (parseInt(i)+1) + ") "; switch (token.type) { case "content": tokenStr += "[string] - \"" + token.string + "\""; break; case "mustache": tokenStr += "[placeholder] - " + token.id.string; break; case "block": tokenStr += "[block] - " + token.mustache.id.string; } } document.getElementById("tokens").innerHTML += tokenStr; So we begin by running the templates source into Handlebars.parse to get the list of tokens. We then cycle through all the individual components and build up a set of human readable strings based on the segment's type. Plain text will have a type of "content" which we can then just output the string wrapped in quotes to show what it equals. Placeholders will have a type of "mustache" which we can then display along with their "id" (placeholder name). And last but not least, block helpers will have a type of "block" which we can then also just display the blocks internal "id" (block name).
Refreshing this now in the browser, you should see just a single 'string' token, with our template's text.
Operations
Once handlebars has the collection of tokens, it cycles through each one and "generates" a list of predefined operations that need to be performed for the template to be compiled. This process is done using the Handlebars.Compiler() object, passing in the token object from step 1:
//Display Operations var opSequence = new Handlebars.Compiler().compile(tokenizer, {}); var opStr = ""; for (var i in opSequence.opcodes) { var op = opSequence.opcodes[i]; opStr += "<p>" + (parseInt(i)+1) + ") - " + op.opcode; } document.getElementById("operations").innerHTML += opStr; Here we are compiling the tokens into the operations sequence I talked about, and then we are cycling through each one and creating a similar list as in the first step, except here we just need to print the opcode. The opcode is the "operation's" or the function's 'name' that needs to be run for each element in the sequence.
Back in the browser, you now should see just a single operation called 'appendContent' which will append the value to the current 'buffer' or 'string of text'. There are a lot of different opcodes and I don't think I am qualified to explain some of them, but doing a quick search in the source code for a given opcode will show you the function that will be run for it.
The Function
The last stage is to take the list of opcodes and to convert them into a function, it does this by reading the list of operations and smartly concatenating code for each one. Here is the code required to get at the function for this step:
//Display Function var outputFunction = new Handlebars.JavaScriptCompiler().compile(opSequence, {}, undefined, true); document.getElementById("source").innerHTML = outputFunction.toString(); Prism.highlightAll(); The first line creates the compiler passing in the op sequence, and this line will return the final function used for generating the template. We then convert the function to a string and tell Prism to syntax highlight it.
With this final code, your page should look something like so:
This function is incredibly simple, since there was only one operation, it just returns the given string; let's now take a look at editing the template and seeing how these individually straight forward steps, group together to form a very powerful abstraction.
Examining Templates
Let's start with something simple, and let's simply replace the word 'World' with a placeholder; your new template should look like the following:
<script id="dt" type="template/handlebars"> Hello {{name}}! </script> And don't forget to pass the variable in so that the output looks OK:
//Display Output var t = Handlebars.compile(src); document.getElementById("output").innerHTML += t({name: "Gabriel"}); Running this, you will find that by adding just one simple placeholder, it complicates the process quite a bit.
The complicated if/else section is because it doesn't know if the placeholder is in fact a placeholder or a helper method
If you were still unsure about what tokens are, you should have a better idea now; as you can see in the picture, it split out the placeholder from the strings and created three individual components.
Next, in the operations section, there are quite a few additions. If you remember from before, to simply output some text, Handlebars uses the 'appendContent' operation, which is what you can now see on the top and bottom of the list (for both "Hello " and the "!"). The rest in the middle are all the operations needed to process the placeholder and append the escaped content.
Finally, in the bottom window, instead of just returning a string, this time it creates a buffer variable, and handles one token at a time. The complicated if/else section is because it doesn't know if the placeholder is in fact a placeholder or a helper method. So it tries to see if a helper method with the given name exists, in which case it will call the helper method and set 'stack1' to the value. In the event it is a placeholder, it will assign the value from the context passed in (here named 'depth0') and if a function was passed in it will place the result of the function into the variable 'stack1'. Once that is all done, it escapes it like we saw in the operations and appends it to the buffer.
For our next change, let's simply try the same template, except this time without escaping the results (to do this, add another curly brace "{{{name}}}")
Refreshing the page, now you will see it removed the operation to escape the variable and instead it just appends it, this bubbles down into the function which now simply checks to make sure the value isn't a falsy value (besides 0) and then appends it without escaping it.
So I think placeholders are pretty straight forward, lets now take a look at using helper functions.
Helper Functions
There is no point in making this more complicated then it has to be, let's just create a simple function that will return the duplicate of a number passed in, so replace the template and add a new script block for the helper (before the other code):
<script id="dt" type="template/handlebars"> 3 * 2 = {{{doubled 3}}} </script> <script> Handlebars.registerHelper("doubled", function(number){ return number * 2; }); </script> I have decided to not escape it, as it makes the final function slightly simpler to read, but you can try both if you like. Anyways, running this should produce the following:
Here you can see it knows it is a helper, so instead of saying 'invokeAmbiguous' it now says 'invokeHelper' and therefore also in the function there is no longer an if/else block. It does still however make sure the helper exists and tries to fall back to the context for a function with the same name in the event it doesn't.
Another thing worth mentioning is you can see the parameters for helpers get passed in directly, and are actually hard coded in, if possible, when the function get's generated (the number 3 in the doubled function).
The last example I want to cover is about block helpers.
Block Helpers
Block helpers allow you to wrap other tokens inside a function which is able to set its own context and options. Let's take a look at an example using the default 'if' block helper:
<script id="dt" type="template/handlebars"> Hello {{#if name}} {{{name}}} {{else}} World! {{/if}} </script> Here we are checking if "name" is set in the current context, in which case we will display it, otherwise we output "World!". Running this in our analyzer, you will see only two tokens even though there are more; this is because each block is run as its own 'template' so all the tokens inside it (like {{{name}}}) will not be part of the outer call, and you would need to extract it from the block's node itself.
Besides that, if you take a look at the function:
You can see that it actually compiles the block helper's functions into the template's function. There are two because one is the main function and the other is the inverse function (for when the parameter doesn't exist or is false). The main function: "program1" is exactly what we had before when we just had some text and a single placeholder, because like I mentioned, each of the block helper functions are built up and treated exactly like a regular template. They are then run through the "if" helper to receive the proper function which it will then append to the outer buffer.
Like before, it is worth mentioning that the first parameter to a block helper is the key itself, whereas the 'this' parameter is set to the entire passed in context, which can come in handy when building your own block helpers.
Conclusion
In this article we may not have taken a practical look at how to accomplish something in Handlebars, but I hope you got a better understanding of what exactly is going on behind the scenes which should allow you to build better templates and helpers with this new found knowledge.
I hope you enjoyed reading, like always if you have any questions feel free to contact me on Twitter (@GabrielManricks) or on the Nettuts+ IRC (#nettuts on freenode).
