More on Javascript Inheritance

I changed the syntax of the Mocha Inheritance code a bit, to what I think you'll agree is easier to read:

Function.prototype.inherit = function(fnc) {

    var constr = this;

    var Constructor = function(){

        if (fnc)

            fnc.apply(this, arguments);

        constr.apply(this, arguments);

    };

    Constructor.prototype = new (fnc || this)();

    Constructor.prototype.constructor = fnc || this;

    return Constructor;

 };

Prototype inheritance reduced to the max :-)

Mocha Inheritance

In its current incarnation, Javascript prototype inheritance has some shortcomings. In particular, prototypes do not inherit their parent's constructor and methods in child prototypes can not dynamically access an inherited method they override.

After Hannes' and Jürg's suggestions for improvements to Dean Edwards' Base Class approach to Javascript inheritance, I made an attempt to solve the problem by focusing more intensely on fixing Javascript's prototype inheritance than adding class sugar around it.

What I came up with is this:

Mocha Inheritance does its magic in these 20 lines of code:

Function.prototype.inherit = function(inherit) {

    var fnc = inherit ? this : function(){};

    inherit = inherit || this;

    var Constructor = function(){

       inherit.apply(this, arguments);

       fnc.apply(this, arguments);

    };

    Constructor.prototype = new inherit();

    Constructor.prototype.constructor = inherit;

    return Constructor;

 };

 

 Function.prototype.applySuper = function(method,obj,args) {

    var that = this;

    do {

       if (that.prototype[method] && that.prototype[method] != obj[method])

          return that.prototype[method].apply(obj,args);

       that = that.prototype.constructor;

    } while (that != Object);

 };

Creating a new prototype "Mensch" with mocha inheritance from "Animal":

var Mensch = Animal.inherit();

Letting a previously created constructor "Mensch" mocha inherit from "Animal":

Mensch = Mensch.inherit(Animal);

And here an example of a Mensch method "evolve" that overrides what it inherits from Animal, but still manages to do nothing different:

Mensch.prototype.evolve = function(){

   return this.constructor.applySuper('evolve', this, arguments);

 }

With some more syntactic sugar around it, I think this is quite a nice approach.

http://dev.helma.org/wiki/Mocha+Inheritance/

Helma 1.5.3

Helma 1.5.3 makes dynamically loaded code repositories available immediately after the app.addRepository() statement and offers improved logging behavior along with several small bug fixes.

http://helma.org/download/

http://helma.org/download/changelog/1.5.3/

Fresh Rhino on Safari

The 5th edition of David Flanagan 's Javascript - The Definitive Guide is now also available on Safari and I have it on my online bookshelf :-)

I must admit that when I started reading the 5th edition, I quickly started to look forward to the 6th edition, although the 5th edition is well worth getting for anybody that works with Javascript.

The 5th edition seems to do some selective catching up and shies away even from Javascript 1.6 additions that look certain to be part of ECMA-262 version 4. Apparently, David Flanagan drew a carfully drafted line for what he wanted to include in the 5th edition and was thinking ahead to the 6th edition already. That's not a bad thing, of course. The result is a very clean 5th edition.

Too bad E4X ended up getting buried in the Client-Side section. I hope the 6th edition will treat it as an extension to Core Javascript instead. Hopefully, including mentioning it in the Literals section and in chapter 3, even-though it is an optional "standard extension".

One of the things that makes this book so great is the fact that it cleanly separates between the browser/client side and the core language, making it the best companion when working in Rhino based environments on the server-side such as Helma .

Naturally, when working in an environment like Helma, the limitations on using the newest language extensions do not apply, and the 5th edition doesn't quite cater to this niche as well as it could.

So, basically, I hope for a bit more "Rhino" in the 6th edition of the "Rhino book" ;-) ...and maybe even a chapter on existing server-side frameworks.

Truly Hooverphonic!

The belgian group Hooverphonic was clearly the highlight of this years Mont-Soleil Open Air Festival ! I already really liked their last album No More Sweet Music , but seeing them perform live was even more impressive. Unlike many groups these days, which can't match the quality of their recordings outside the studio, Hooverphonic's performance was excellent!

Helma 1.5.2

Hot on the heels of Helma 1.5.1 and in order to clear the slate for Helma/Rhino 1.6, which will bring us E4X support amongst other goodies, Helma 1.5.2 has been released , fixing a potentially annoying error logging issue.

RFC 4329 application-ecmascript

From RFC 4329 - Scripting Media Types ...

Various unregistered media types have been used in an ad-hoc fashion

   to label and exchange programs written in ECMAScript and JavaScript.

   These include:



      +-----------------------------------------------------+

      | text/javascript          | text/ecmascript          |

      | text/javascript1.0       | text/javascript1.1       |

      | text/javascript1.2       | text/javascript1.3       |

      | text/javascript1.4       | text/javascript1.5       |

      | text/jscript             | text/livescript          |

      | text/x-javascript        | text/x-ecmascript        |

      | application/x-javascript | application/x-ecmascript |

      | application/javascript   | application/ecmascript   |

      +-----------------------------------------------------+



   Use of the "text" top-level type for this kind of content is known to

   be problematic.  This document thus defines text/javascript and text/

   ecmascript but marks them as "obsolete".  Use of experimental and

   unregistered media types, as listed in part above, is discouraged.

   The media types,



      * application/javascript

      * application/ecmascript



   which are also defined in this document, are intended for common use

   and should be used instead.



   This document defines equivalent processing requirements for the

   types text/javascript, text/ecmascript, and application/javascript.

   Use of and support for the media type application/ecmascript is

   considerably less widespread than for other media types defined in

   this document.  Using that to its advantage, this document defines

   stricter processing rules for this type to foster more interoperable

   processing.

>>> Helma 1.5.1 ready to download