Junction brings Rhino on Rails to Helma

Steve says he switched the server-side implementation of Trimpath Junction to run on top of Helma . So, using Steve Yen's Junction, we'll soon have Rhino on Rails running as a Helma app.

What is this now? Junction on Helma? Or Helma on Junction? My head is spinning. Well... Rhino on Rails, anyway :-)

Helma 1.6 is ready!

Go grab it here! This release makes building server-side applications with Javascript more powerful and more flexible than ever.

See the change log for a full overview of all the enhancements. Highlights include support for getters/setters and E4X with the new Rhino 1.6, subskins and macro pipes/filters as additions to the skin rendering framework , and various new HTTP-related features .

Have fun exploring this Helma release and we hope you'll share your experiences with us on the mailing list and the IRC channel .

Rhino 1.6R6 with E4X fix and patches for Helma

Rhino 1.6R6 has now been released . The older Rhino jar that is part of the current Helma 1.6 package contains a E4X bug that prevents attribute support from working properly. To use E4X with Helma, you therefore need to replace that jar with the newer version.

While all Helma related patches that were pending at the time have been committed to Rhino 1.6R6 in June, there since has been one more Helma related patch that didn't make it into the Rhino 1.6R6 release version.

So, here's a version of the Rhino 1.6R6 containing that E4X fix and the pending Helma related patch:

http://helma.zumbrunn.net/downloads/rhino16r6patched/rhino.jar

With that patched version placed at ./lib/rhino.jar of your Helma installation, you can now enjoy E4X in your server-side Javascript and for example turn your skins into XML objects. With the code below, you could then access a skin "foo.skin" as XML object using this syntax: this.views.foo

/**
 * Object containing the collection of available views
 * 
 * @type Object
 */
Mocha.prototype.__defineGetter__('views',function() {
    var views = {};
    var protos = this.getPrototypeChainAsNames();
    var that = this;
    for (var proto in protos) {
        for (var skin in app.skinfiles[protos[proto]]) {
            if (!views[skin]) {
                views.__defineGetter__(skin,
                function(){ 
                    var s = skin; 
                    var obj = that; 
                    return function(){ 
                        return new XML(obj.renderSkinAsString(s)); 
                    }; 
                }());
            }
        }
    }
    return views;
})

/**
 * Returns the prototype chain as a string array of prototype names
 * 
 * @return Array
 */
function getPrototypeChainAsNames(){
    return this.getPrototypeChain().map(
                function(proto){ 
                    return / (\w+)\]$/(proto.toString())[1];
                });
}

/**
 * Returns the prototype chain as an array
 * 
 * @return Array
 */
function getPrototypeChain(){
    var protoChain = [];
    var proto = this.__proto__;
    do {
        protoChain.push(proto);
        proto = proto.__proto__;
    }
    while (proto != Object.prototype)
    return protoChain;
}

Keeping track of localhost:8080

Apparently delicious: http://localhost:8080/

Hold the whole program in your head, and you can manipulate it at will

Paul Graham, Holding a Program in One's Head :

"Your code is your understanding of the problem you're exploring. So it's only when you have your code in your head that you really understand the problem."

"Distractions are bad for many types of work, but especially bad for programming, because programmers tend to operate at the limit of the detail they can handle. The danger of a distraction depends not on how long it is, but on how much it scrambles your brain. A programmer can leave the office and go and get a sandwich without losing the code in his head. But the wrong kind of interruption can wipe your brain in 30 seconds."

"The more succinct the language, the shorter the program, and the easier it is to load and keep in your head. You can magnify the effect of a powerful language by using a style called bottom-up programming, where you write programs in multiple layers, the lower ones acting as programming languages for those above."

Yep.

>>> JSONPath and CouchDB