Contenido

*JS, el hijo bastardo entre Javascript y C

13 may

+ 1

No paran de salir herramientas para hacernos la vida más facil, aunque hay veces que para evitar aprender un lenguaje concreto tienes que aprender otro que te convertirá el código en este primero. Este es el caso de *JS, un lenguaje pensado para programar Javascript como si de C se tratara.

Por el momento es una versión beta que no permite trabajar con ella en el mundo real, pero que sirve para poner una serie de ideas sobre la mesa con las que mejorar nuestra programación de bajo nivel sobre Javascript.

Programación más eficiente

*JS ofrece un lenguaje tipado que permite especificar el tipo de variables que vamos a definir, lo que hará que la conversión a Javascript sea más robusta y  segura. Para ello usa las herramientas de más bajo nivel que Javascript puede ofrecer, haciendo que nuestro código roce la ilegibilidad extrema :D

Código *JS

struct Node {
  let Node *next;
  let int value;
}

let Node *head = new Node, *tail = head;

function Node * add (int value) {
  let Node * next = new Node;
  next->value = value;
  tail->next = next;
  tail = next;
  return next;
}

trace(add(1));
trace(add(2));
trace(add(3));

traceList(head->next);

function void traceList(Node * p) {
  while (p) {
    trace("Node at address: " + p + ", has value: " + p->value);
    p = p->next;
  }
}

Código Javascript

Una vez compilado el código anterior, nos quedaría en algo así que podría ser ejecutado por cualquier navegador…

const $U4 = U4;
var head = (malloc(8) >> 2), tail = head;
function add(value) {
  const $I4 = I4, $U4 = U4;
  var next = (malloc(8) >> 2);
  $I4[next + 1] = value;
  $U4[tail] = next;
  tail = next;
  return next;
}
trace(add(1));
trace(add(2));
trace(add(3));
traceList($U4[head]);
function traceList(p) {
  const $I4 = I4, $U4 = U4;
  while (p) {
    trace('Node at address: ' + p + ', has value: ' + $I4[p + 1]);
    p = $U4[p];
  }
}

Además, *JS nos ofrece herramientas como malloc() y free() (como en C) que nos servirán para gestionar la memoria que consumen nuestros scripts de forma explícita.

Participa, Hay 1 Comentario. →

TwitterWeek – 2012-05-13

13 may

+ 0

En mi twitter he publicado estos enlaces que creo os pueden interesar.

Participa, Hay 0 Comentarios. →

CamanJS, manipulación de imágenes mediante javascript

11 may

+ 1

CamanJS une dos de mis más grandes pasiones, la fotografía y el javascript. Y gracias a las nuevas tecnologías lo permiten hacer de una forma muy eficiente.

Gracias al uso de <canvas /> y su control mediante javascript nos permite disponer de una serie de métodos para dar efectos predefinidos o crear los nuestros propios de forma sencilla.


<-- cargamos la funcionalidad de camanJS -->
<script type="text/javascript" src="caman.full.min.js"></script>

<script type="text/javascript">
// Modificamos la apariencia de la imagen indicada.
Caman("images/example-image.jpg", "#example-canvas", function () {
    this
        .saturation(20)
        .gamma(1.4)
        .vintage()
        .contrast(5)
        .exposure(15)
        .vignette(300, 60)
        .render();
});
</script>

<canvas id="#example-canvas"></canvas>

Aunque la compatibilidad con los diferentes navegadores no es completa (obviamente) soporta una buena cantidad de navegadores (Google Chrome, Safari 5+, Firefox 4+, Opera 10+, Internet Explorer 9+) que junto a la completa documentación nos ofrece una herramienta más que interesante para trabajar con imágenes desde el navegador.

Participa, Hay 1 Comentario. →

-prefix-free, dí adios a los prefijos CSS

11 may

+ 5

Ayer vimos la cantidad de líneas de código que debemos incluir en nuestros CSS’s para disponer de ciertas funcionalidades en los diferentes navegadores, no es algo nuevo, hace ya tiempo nos quejábamos de ello. Y parece que a medida que van saliendo más y más propuestas por parte de los diferentes navegadores estos prefijos se están haciendo más y más populares.

El problema, radica en que dentro de X años esos prefijos dejarán de ser necesarios por que por lo general adoptan una nomenclatura estándar, lo que nos obligará a recorrer todos nuestros CSS’s para adaptarlos a los atributos del momento.

Para solventar prácticamente por completo ese problema aparece prefix-free, un librería Javascript que se encarga de gestionar estos prefijos por nosotros dejándonos a nosotros la nomenclatura estándar y él adaptándose al navegador que está visitando nuestra aplicación web.


// Nuestro CSS
border-radius: 1em; // Para cuando se cumplan los estandares.

// Resultado
-moz-border-radius: 1em; // Mozilla
-ms-border-radius: 1em; // Internet Explorer 8 (No soportado)
-webkit-border-radius: 1em; // WebKit y Safari

Como podemos ver el cambio es significativo, y únicamente hemos de añadir un fichero JS a la carga de nuestra aplicación web.

<script src="js/prefixfree.min.js"></script>

Compatibilidad

Actualmente está disponible para los principales navegadores, IE9+ Opera 10+, Firefox 3.5+, Safari 4+ y Chrome para escritorio y Mobile Safari, Android browser, Chrome y Opera Mobile para móviles.

Problemas detectados.

En CristaLAB comentaban que nos funcionan en:

  • CSS’s cargados mediante @include.
  • ficheros CSS’s locales en Chrome y Opera.
  • Estilos inline
  • y CSS’s de diferentes dominios

Aún así, el trabajo que nos ahorramos a largo plazo es realmente interesante para tenerlo en cuenta.

Participa, Hay 5 Comentarios. →

Diagnosticando errores javascript más fácilmente con Error.stack

11 may

+ 2

Hoy, IEBlog publica un artículo muy interesante sobre el tratamiento de errores en IE10 sobre Windows 8. Al parecer, este último incluye soporte para un nuevo atributo al objeto Error(), el Error.stack, que activado desde las Web Developer Toolbars de IE10 nos ayudará a detectar los errores de forma más rápida.

Error.stack en IE10
(Ver Imagen)

Como podemos ver, nos ofrece una información detallada del error, al puro estilo Java mostrando toda la traza del error producido. Por lo tanto, nuestros try/catch vendrán cargados con todo lo necesario para conocer la causa de nuestros problemas, además podremos limitar el nivel de profundidad de dicha traza mediante el atributo stackTraceLimit disponible de igual modo en el objeto Error(). Una funcionalidad muy interesante que seguro nos ayudará a solventar los problemas que nos encontremos en IE10 … que seguro que los encontramos :D

Participa, Hay 2 Comentarios. →

jQuery transit, transformaciones y transiciones CSS3

10 may

+ 1

jQuery.Transit, es un plugin de jQuery (1.4+) que nos permite trabajar con las diferentes transiciones y transformaciones de CSS3 mediante una simple nomenclatura.

Para ello, dota al atributo css() de una serie de parámetros que nos permite extender los estilos básicos tratados con jQuery.


("#box").css({ x: '30px' });               // Move right
$("#box").css({ y: '60px' });               // Move down
$("#box").css({ translate: [60,30] });      // Move right and down
$("#box").css({ rotate: '30deg' });         // Rotate clockwise
$("#box").css({ scale: 2 });                // Scale up 2x (200%)
$("#box").css({ scale: [2, 1.5] });         // Scale horiz and vertical
$("#box").css({ skewX: '30deg' });          // Skew horizontally
$("#box").css({ skewY: '30deg' });          // Skew vertical
$("#box").css({ perspective: 100, rotateX: 30 }); // Webkit 3d rotation
$("#box").css({ rotateY: 30 });
$("#box").css({ rotate3d: [1, 1, 0, 45] });

// Valores relativos
$("#box").css({ rotate: '+=30' });          // 30 degrees more
$("#box").css({ rotate: '-=30' });          // 30 degrees less

// No importa usar unidades
$("#box").css({ x: '30px' });
$("#box").css({ x: 30 });

// Multivalores
$("#box").css({ translate: [60,30] });
$("#box").css({ translate: ['60px','30px'] });
$("#box").css({ translate: '60px,30px' });

Todos estos helpers implementados en css() usan la funcioón $.fn.transition() que es la encargada de gestionar las animaciones aplicadas a estos nuevos parámetros.


/*
   $('...').transition(options, [duration], [easing], [complete])
*/
$("#box").transition({ opacity: 0.1, scale: 0.3 });
$("#box").transition({ opacity: 0.1, scale: 0.3 }, 500);                         // duration
$("#box").transition({ opacity: 0.1, scale: 0.3 }, 'fast');                      // easing
$("#box").transition({ opacity: 0.1, scale: 0.3 }, 500, 'in');                   // duration+easing
$("#box").transition({ opacity: 0.1, scale: 0.3 }, function() {..});             // callback
$("#box").transition({ opacity: 0.1, scale: 0.3 }, 500, 'in', function() {..});  // everything

Funciona en: IE 10+, Firefox 4+, Safari 5+, Chrome 10+, Opera 11+, Mobile Safari

Un plugin de esos que te ayuda a hacer las cosas más faciles, de los que nunca viene mal conocer :D

Participa, Hay 1 Comentario. →

Usando la Javascript Fullscreen API

9 may

+ 8

Si conoces Facebook, conocerás el nuevo sistema de visualizado de imágenes que permite, entre otras opciones, ver la imagen a pantalla completa, pero cuando decimos pantalla completa, es a pantalla completa, usando toda la pantalla, no usando el tamaño del elemento Window como lo usábamos antes.

¿Como es posible?

Pues debido a la implementación de la Javascript Fullscreen API :D .
Una implementación, introducida por Apple en el Safari 5.0 para los tags <video /> y que fue bien acogida en la comunidad de desarrolladores, lo que hizo que Mozilla se añadiera con una propuesta más firme en la que se extendía su uso a cualquier elemento del DOM. Y para consolidar esta buena idea, la W3C metió mano y definió la primera propuesta para estandarizar esta funcionalidad.

¿Como lo usamos?

Después de comprobar que el navegador del usuario dispone de dicha funcionalidad (que por ahora son Google Chrome 15+, Safari 5.1+ y Firefox 10+) ejecutamos la llamada RequestFullScreen() que nos cambiará a modo pantalla completa.

var docElm = document.documentElement;
if (docElm.requestFullscreen) {
    docElm.requestFullscreen();
}
else if (docElm.mozRequestFullScreen) {
    docElm.mozRequestFullScreen();
}
else if (docElm.webkitRequestFullScreen) {
    docElm.webkitRequestFullScreen();
}

Una vez ya en pantalla completa, el navegador no solicitará si deseamos permitir que el dominio sobre el que usamos dicha funcionalidad debe tener permitido el uso de la Fullscreen API.

Para detectar el estado de nuestra pantalla completa disponemos del evento fullscreenchange que nos permitirá detectar un cambio sobre esta funcionalidad. Pudiendo conocer en todo momento si estamos en modo normal o modo pantalla completa.


document.addEventListener("fullscreenchange", function () {
    fullscreenState.innerHTML = (document.fullscreen)? "" : "not ";
}, false);

document.addEventListener("mozfullscreenchange", function () {
    fullscreenState.innerHTML = (document.mozFullScreen)? "" : "not ";
}, false);

document.addEventListener("webkitfullscreenchange", function () {
    fullscreenState.innerHTML = (document.webkitIsFullScreen)? "" : "not ";
}, false);

Y además, disponemos de una pseudo-clase CSS que nos permite condicionar ciertos aspectos de nuestra pantalla completa.


html:-moz-full-screen {
    background: red;
}

html:-webkit-full-screen {
    background: red;
}

html:fullscreen {
    background: red;
}

Personalmente, creo que es una funcionalidad muy interesante y me ha llamado mucho la atención que se haya movido tan rápido y que podamos usarla con tantos navegadores en tan poco tiempo. Aunque al parecer, Microsoft aún no tiene claro si lo va a implementar debido a que Windows 8 ya está pensado para trabajar con Internet Explorer 10 en modo pantalla completa siempre… otra vez :(

Más Info

Participa, Hay 8 Comentarios. →

Detectando inserciones DOM con Javascript y animaciones CSS

8 may

+ 3

Ayer, David Walsh nos mostraba una técnica para detectar elementos insertados en nuestro DOM mediante animaciones CSS. Para ello usaremos javascript, pero no el elemento “deprecated” DOMNodeInserted de la DOM Event Reference.

Veamos el código

<ul id="parentElement"></ul>
<style type="text/css">
/* Definimos las animaciones */

/* La estándar */
@keyframes nodeInserted {
from { clip: rect(1px, auto, auto, auto); }
to { clip: rect(0px, auto, auto, auto); }
}

/* La de Firefox ¬¬ */
@-moz-keyframes nodeInserted {
from { clip: rect(1px, auto, auto, auto); }
to { clip: rect(0px, auto, auto, auto); }
}

/* La de WebKit ¬¬! */
@-webkit-keyframes nodeInserted {
from { clip: rect(1px, auto, auto, auto); }
to { clip: rect(0px, auto, auto, auto); }
}

/* La de IE ¬¬!! */
@-ms-keyframes nodeInserted {
from { clip: rect(1px, auto, auto, auto); }
to { clip: rect(0px, auto, auto, auto); }
}

/* La de Opera ¬¬!!!*/
@-o-keyframes nodeInserted {
from { clip: rect(1px, auto, auto, auto); }
to { clip: rect(0px, auto, auto, auto); }
}

/*
Definimos las duraciones
para toooodos los navegadores
*/
#parentElement > li {
	animation-duration: 0.001s;
	-o-animation-duration: 0.001s;
	-ms-animation-duration: 0.001s;
	-moz-animation-duration: 0.001s;
	-webkit-animation-duration: 0.001s;

	animation-name: nodeInserted;
	-o-animation-name: nodeInserted;
	-ms-animation-name: nodeInserted;
	-moz-animation-name: nodeInserted;
	-webkit-animation-name: nodeInserted;
}

</style>
<script type="text/javascript">
	var insertListener = function(event){
		// Detectamos el nombre de la animación lanzada
		if (event.animationName == "nodeInserted") {
			console.warn("Another node has been inserted! ", event, event.target);
			}
		}

// Asociamos los la anterior funcionalidad al evento "animationstart"
document.addEventListener("animationstart", insertListener, false); // standard + firefox
document.addEventListener("MSAnimationStart", insertListener, false); // IE
document.addEventListener("webkitAnimationStart", insertListener, false); // Chrome + Safari
</script>

Como podemos ver en el código, la técnica usada pasa por definir las animaciones CSS (en todos y cada uno de los navegadores, bufff! ) a las que se les asigna un nombre, después, usando la gestión de eventos asociamos (otra vez para los diferentes navegadores ¬¬) la función insetListener() que se encargará de comprobar que al accionar el evento animationstart se esté accionando la animación previamente definida. A nivel académico, me parece realmente interesante, aunque quizás un poco laborioso para implementar en el día a día.

Participa, Hay 3 Comentarios. →

Separación por frecuencias en Photoshop

8 may

+ 1

Soy de los que creen que una fotografía se ha de vender, y venderla no me refiero a cobrar por ella, sino a que ha de entrar por los ojos, y si para ello hay que retocarla usando Photoshop pues a retocar se ha dicho. Esto no quiere decir que haya que descuidar otros factores importante a la hora de tomar la fotografía, pero si que puedes condicionar dichas tomas a las posibilidades que después te permite el procesado.

Una de las técnicas que más uso en mis fotografías, sobretodo por la versatilidad del método y lo poco destructivo que és es la separación en frecuencias de la imagen.

¿De donde sale esto?

Por allá del Diciembre de 2008, Omar Josef (un crack del retoque digital) publicó un video explicativo de como trabajar fotografías haciendo de estas una separación en dos “frecuencias”.

¿Que es eso de la separación en frecuencias?

Básicamente y para entenderlo fácilmente, podemos decir que toda imagen se compone de dos frecuencias:

  1. Baja, o colores.
  2. Alta, o texturas.

De esta forma, podremos trabajar cada una de las frecuencias por separado sin alterar la otra.

¿Como lo hacemos?

El sistema que nos muestra Omar, basado en generar el Paso Alto de la imagen usando de base la frecuencia baja es el sistema menos destructivo para la imagen y nos permite disponer de una división perfecta en estas dos frecuencias.

capas
(Ver Imagen)

Para ello, después de haber abierto la fotografía en Photoshop, creamos dos nuevas capas copias de la fotografía (CTRL + J (CMD + J en OSX)). A la de abajo la llamamos baja y a la de arriba, la llamaremos alta.

Una vez creadas, seleccionamos la capa baja y le aplicamos un desenfoque gaussiano.

gaussiano
(Ver Imagen)

Deberemos buscar un valor en el que desaparezcan las texturas y únicamente podamos ver los colores que componen la fotografía (suelo usar valores de entre 2 a 8 dependiendo de la foto).

gaussiano2
(Ver Imagen)

Ya tenemos la frecuencia baja lista, ahora vamos a por la alta.

Para ello, primero seleccionamos la capa alta y vamos a Imagen > Aplicar Imagen…

aplicar-imagen
(Ver Imagen)

Una vez en esta ventana, indicamos que vamos a usar la capa baja, que queremos invertir el canal RGB usando un método de fusión de Añadir al 100% de opacidad y una escala de 2 (como vemos en la imagen :D ).

aplicar-imagen2
(Ver Imagen)

y ya con esto, tenemos un paso algo aplicado en función de nuestra capa baja.

Solo tendremos que cambiar la capa alta al modo de fusión, luz lineal para poder disfrutar de la separación por frecuencias completa.

luzlineal
(Ver Imagen)

Voala! ¿Sencillo no?

¿Para que me puede servir esto?

Desde que aprendí a usarla le he dado varios y muy diferentes usos, desde quitar arrugas, granitos, pelos,… en retratos a mejorar en enfoque de los cráteres de la luna. Solo hay que saber sobre que frecuencia trabajar para conseguir el resultado deseado.

¿Mejorar el enfoque?

Hay muchas técnicas para mejorar el enfoque de una fotografía, ojo el post-procesado no hace maravillas, el enfoque es algo de lo que hay que tener especial cuidado en el momento de la toma de la fotografía. Con la separación por frecuencias, podemos contrastar las líneas que forman las texturas y así hacer que estas se marquen más, dando una sensación de enfoque muy limpio y solo aplicado a la capa alta.

Hay que tener en cuenta que todo procesado para sacar más información de donde no la hay, ya sea enfoque como exposición generará un ruido antiestético que conviene evitar, así que ojo!.

Para mejorar el enfoque usando esta separación por frecuencias, deberemos utilizar una capa de ajuste “Brillo/Contraste” que marcaremos como “Usar heredado” como vemos en la foto.

contraste
(Ver Imagen)

Mediante el dial de “contraste” iremos incrementando el enfoque de nuestra imagen. Importante, aplicar la capa de ajuste únicamente a la capa alta (usando ALT entre las dos capas).

Ojo! Hay que tener presente que dependiendo del valor usado en el desenfoque guassiano se aplicará más o menos incremento en el enfoque mediante el contraste, generando más molesto  ruido.

Actualización

Erkua me pasa otro vídeo, esta vez de Edu Gomez en el que además de contárnoslo de una forma muy didáctica nos muestra las diferencias que podemos tener si trabajamos en modos 8 y 16 bits. Gracias! :D

Participa, Hay 1 Comentario. →

SASS, extiende tus CSS’s

7 may

+ 9

Cuando estás ante un proyecto medianamente grande, o repetitivo, nos encontramos con código que fácilmente se vuelve susceptible de convertirse en una maraña de líneas que en meses vas a ser incapaz de descifrar. Si además ese código, lo estás usando en otras páginas con pequeñas variaciones, nos encontramos que cualquier cambio provocará que tengas que perder más tiempo del estrictamente necesario, para solventar estas situaciones aparece SASS.

SASS  (Syntactically Awesome StyleSheets) es una herramienta externa a tu aplicación WEB que nos permitirá disfrutar de las CSS’s extendidas con las que siempre hemos soñado, añadiendo anidamiento de elementos, variables, extensión de selectores y muchas cosas más. Sin duda nos permite trabajar con las CSS’s a otro nivel.

/* Variables */
$blue: #3bbfce;
$margin: 16px;

.content-navigation {
  border-color: $blue; /* Usamos la variable */
  color:
    darken($blue, 9%); /* Usamos la variable */
}

.border {
  padding: $margin / 2; /* Usamos la variable */
  margin: $margin / 2; /* Usamos la variable */
  border-color: $blue; /* Usamos la variable */
}

¿Como funciona?

A simple vista podemos ver que el código CSS que estamos escribiendo no es para nada estándar y si lo pruebas en tu navegador hará caso omiso de él, por eso debemos hacerlo pasar previamente por SASS para que convierta dicho código en algo que el navegador pueda comprender.

sass style.scss:style.css

Con este pequeño comando, que ejecutaremos desde nuestra consola (o script destinado a poner nuestras aplicaciones en LIVE), obtendremos un código CSS estándar y listo para que se use en tu aplicación.

¿Que podemos hacer con SASS?

Lo conocí hace un año y algo y la verdad es que aparte del uso académico que le dí en su momento no he vuelto a hacer nada con él, pero bueno, tampoco estaba haciendo nada con nada :D

Entre las funcionalidades que nos ofrece hay que destacar las 4 más importantes (para mi):

  1. Variables (POR FIN!! :D )
  2. Anidamiento
  3. Funciones
  4. Herencia de selectores

Variables

El uso de variables, nos permite preparar el código para realizar cambios rápidos en caso de necesitarlo, y poder cambiar en un sitio un valor que usaremos en muchos lugares de nuestro código. Vamos, que nos permite convertir un lenguaje de marcado por uno de programación, esto a los más puristas no les gusta, pero a mi me encanta poder facilitarme el trabajo de dentro de unos meses :D

// Variable Definitions
$page-width:    800px;
$primary-color: #eeeeee;

body {
	width: $page-width;
	color: $primary-color;
}

Anidamiento

El anidamiento es algo más personal, a mi particularmente me gusta por que visualmente el fichero de trabajo nos permite ver el código de forma más cómoda y clara, además si quiero aplicar un estilo concreto para un submódulo dentro de un módulo, lo tengo más sencillo a la hora de buscar la línea dentro del código y así incluirlo.

body {
  font: {
    family: sans-serif;
    size: 30em;
    weight: bold;
  }
}
#contents {
  width: $page-width;
  #sidebar {
    float: right;
    width: $sidebar-width;
  }
  #main {
    width: $page-width - $sidebar-width;
    background: $primary-color;
    h2 { color: blue; }
  }
}

#footer {
  height: 200px;
}

Funciones

En la página oficial, los llaman mixins, pero vamos que son funciones de toda vida que defines previamente y cuando los necesitas los añades dentro de un selector, al igual que las variables las definimos previamente y las tenemos disponibles en todo nuestro código, la principal diferencia con la variables es que estas permiten recibir parámetros y así alterarse en función de ellos.

// Definimos table-base
@mixin table-base {
  th {
    text-align: center;
    font-weight: bold;
  }
  td, th {padding: 2px}
}

// Definimos left
@mixin left($dist) {
  float: left;
  margin-left: $dist;
}

#data {
  @include left(10px); // Cargamos left() con parámetro
  @include table-base; // Cargamos table-base
}

Herencia de selectores

El nombre de herencia de selectores, es mio, quizás no sea el más apropiado, pero me recuerda mucho a la jerarquia de plantillas de lenguajes como Django, pero en versión lite y CSS. Se basa en la capacidad de definir nuevas selectores CSS e indicar fácilmente que deben compartir los estilos CSS del selector que indicamos, vamos que creamos un selector “hijo” que nos indica quien es su “padre” al que se parece salvo algunas pecualiaridades.

// Definimos los estilos para .error
.error {
  border: 1px #f00;
  background: #fdd;
}

// Definimos los estilos de .badError
.badError {
  @extend .error; // Indicamos que use los estilos de .error
  border-width: 3px;
}

¿Como instalarlo?

SASS, está desarrollado en Ruby, por lo que necesitarás disponer de él en tu sistema, y mediante el sistema gem es tan sencillo como ejecutar el siguiente comando:

gem install sass

¿Como usarlo?

Para diferenciar los ficheros .css que usará nuestra versión final de los ficheros de código que usaremos para desarrollar nuestra aplicación web, se propone un estándar con la extensión .scss. De esta forma, dispondremos de una versión de desarrollo para nosotros completamente independiente de la que usaremos en nuestro entorno de producción, y ahí ya podremos comprimirlo y convertirlo en una maraña de letras ilegible :D

Mediante el comando sass de nuestro sistema convertiremos un fichero .scss a .css con la siguiente estructura:

sass --watch style.scss:style.css

Más Información

Si te apetece conocer más sobre esta herramienta te recomiendo que revises la siguiente información:

Participa, Hay 9 Comentarios. →