Entries Tagged 'General' ↓

There are a lot of “ways” to implement inheritance in javascript thanks to the Constructors prototype property, and a lot of people has implemented amazing abstractions where is possible to call Parent Constructor methods etc.

I’m not saying these abstractions are the best way to code in Javascript (just ask the Yahoo guys), since Javascript object oriented nature was not thought to do it so. But sometimes it makes easier for not Javascript devs to work.

One of these abstractions is Simple Inheritance by John Resig.

I think is really cool because of its simplicity: a few lines of clean code that let you do things in Javascript you shouldn’t be doing :)

Let’s see it:

/* Simple JavaScript Inheritance
 * By John Resig http://ejohn.org/
 * MIT Licensed.
 */
// Inspired by base2 and Prototype
(function(){
  var initializing = false, fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/;
  // The base Class implementation (does nothing)
  this.Class = function(){};

  // Create a new Class that inherits from this class
  Class.extend = function(prop) {
    var _super = this.prototype;

    // Instantiate a base class (but only create the instance,
    // don't run the init constructor)
    initializing = true;
    var prototype = new this();
    initializing = false;

    // Copy the properties over onto the new prototype
    for (var name in prop) {
      // Check if we're overwriting an existing function
      prototype[name] = typeof prop[name] == "function" &&
        typeof _super[name] == "function" && fnTest.test(prop[name]) ?
        (function(name, fn){
          return function() {
            var tmp = this._super;

            // Add a new ._super() method that is the same method
            // but on the super-class
            this._super = _super[name];

            // The method only need to be bound temporarily, so we
            // remove it when we're done executing
            var ret = fn.apply(this, arguments);
            this._super = tmp;

            return ret;
          };
        })(name, prop[name]) :
        prop[name];
    }

    // The dummy class constructor
    function Class() {
      // All construction is actually done in the init method
      if ( !initializing && this.init )
        this.init.apply(this, arguments);
    }

    // Populate our constructed prototype object
    Class.prototype = prototype;

    // Enforce the constructor to be what we expect
    Class.prototype.constructor = Class;

    // And make this class extendable
    Class.extend = arguments.callee;

    return Class;
  };
})();

Ok, nothing extremely different from other implementations, what makes it easier to understand.

The 3 points I really like about it are:

    /xyz/.test(function(){xyz;})

That’s the way it checks the environment supports functions decompilation, in case it does and the code this._super() is found in the current object property code (of course, has to be a callable object), then the same named method will be called in the Parent Constructor when calling this object property.

    Class.prototype.constructor = Class;

That’s not needed from the functional point of view but it makes our Constructors more reliable.

    if ( !initializing && this.init )
        this.init.apply(this, arguments);

This condition makes possible the init method to be called just once on object creation via the new operator, since the way the Constructor prototype object is created consists in copying the object generated by new this() call (let’s say a “Parent Class” object).

One thing we could improve would be to name the Class.extend method like this:

    "use strict";
    Class.extend = function extend(prop) {
        var _super = this.prototype;

so we could do this:

    // And make this class extendable
        Class.extend = extend;

in order to avoid the deprecated arguments.callee property.

Another not JS nature improvement would be to clone every “[object Object]” or “[object Array]” property, instead of making objects to inherit shared references properties, so each instance would have an independent copy of these properties. In anycase I don’t think this makes a lot of sense…

Ayer me encontré, visitando una página de un canal de televisión, el siguiente fragmento de código:

        var cintilloDirecto = jQuery('div[id=cintilloDirecto]');
        if( cintilloDirecto )
        {
            var isEmpty = jQuery(cintilloDirecto).find('a img').attr('src').match('empty.gif');
            if(isEmpty == null){jQuery(cintilloDirecto).parent().removeClass('hidden')}
        }

el cual, además de utilizar un nombre de variable bastante discutible “cintilloDirecto” (quién no esté de acuerdo que lea cualquier libro acerca de código legible o técnicas de programación y exponga de manera clara su punto de vista) demuestra una terrible falta de “saber lo que se está haciendo”.

Para empezar la función global jQuery no tiene que ser aplicada una y otra vez sobre un objeto devuelto por la misma. Y lo peor de todo es la comprobación de la siguiente condición:

        var cintilloDirecto = jQuery('div[id=cintilloDirecto]');
        if( cintilloDirecto ) // cintilloDirecto nunca va a ser un falsy value

Ya que jQuery siempre devolverá un “jQuery object” incluso cuando el css selector utilizado no concuerde (match) con ningún elemento presente en el DOM.

De modo que el código refactorizado quedaría algo así:

        var directo = jQuery( '#cintilloDirecto' );

        if( !!directo.find( 'a img[src="empty.gif"]' ).length ) {
            directo.parent().removeClass( 'hidden' );
        }

Cómo decía por ahí un tweet que leí una vez: “Un bebé ballena muere cada vez que un backend developer programa frontend.” ;)

There are a lot of website tutorials, videos etc about GIT (the files version control system). Surfing during a couple of hours I found a couple of very interesting git tools and goodies.

TIG: you can get it in Ubuntu like this: sudo apt-get install tig
Is a quite nice command tool that lets you explore you’re git repositories in a more comfortable way than the plain git commands like git status, show etc.

and a git auto completion script: http://gist.github.com/58383

In Anycase, every day I Keep On learning more a more About GIT, and really love it.

Regards,
Daniel

Today I was trying to install the ruby application dependencies manager Bundler http://gembundler.com/index.html in my Ubuntu like this:

 gem install bundler

As you have noticed is a ruby gem. The installation guide was pretty accurated, the problem came with the actual mysql lib dependency that I had in my Fikket source code.

The Bundler command “bundle install” could not get it working.

Solution: installing the libmysqlclient15-dev

And everything was ready to go. So if you have this problem when doing: gem install mysql –> install first the mysql dev library!

Regards!

Daniel

PS: In dev env I was only using sqlite, that’s why before using Bundler I didn’t have to fight against the mysql lib installation.

He estado echando un vistazo al framework Zend de PHP. La documentación no está “mal del todo”. Ahora eso sí, nada que ver con Symfony (me refiero a para bien o para mal), y ahora explicaré por qué (conste que puede ser que la mitad de lo que digo sean barbaridades porque no conozco ni el 5% de Zend).

1. Es un framework de PHP más que un framework de desarrollo genérico. ¿Por qué? Pues porque mayormente se trata de una librería de clases muy útiles y por lo visto bien desarrolladas, pero no está enfocado a facilitarte el resto de tareas repetitivas aparte de la implementación en sí de un proyecto. Como por ejemplo: el despliegue, la estructura del mismo etc.
2. La documentación a mi entender deja que desear (aunque hay cosas mucho peores por supuesto). No es comparable a la que puedes encontrar en el sitio y la comunidad de Symfony.
3. La configuración de un sitio con este framework me da a mí que te la tienes que trabajar tú solito. Otra gran diferencia respecto a Symfony o Ruby on Rails.

Pero vamos, que tampoco soy yo nadie para echarle tierra encima al Framework. Seguro que en seis meses hablamos y os digo todo lo contrario.

Un saludo, y en seis meses hablamos.

Durante los dos últimos días me he estado peleando con la instalación de vncserver en Dreamhost. La cual no tiene ningún problema y con un simple apt-get install vncserver, todo va rodado. El problema viene después.

Por algún motivo que escapa a mi vago conocimiento de sistemas, la instalación es correcta pero los escritorios virtuales que obtengo no son accesibles desde el cliente xvncviewer. Todo esto me refiero mediante ssh en mi servidor ps de Dreamhost.

Tras comprobar que en mi portátil funciona sin problema, me estoy planteando que el problema viene de alguna configuración en el apache de Dreamhost que no me permite crear adecuadamente los escritorios.

Cualquier sugerencia es bienvenida. Para comenzar mi andanza en el maravilloso mundo de VNC leí un par de artículos y la documentación que aparece en la página de realvnc.

Os animo a darme una pequeña lección acerca de este software y su configuración ;) ¡Bienvenida sea!