Instead, Selenium tests for ExtJS should rely on CSS selectors. For every button, grid, label, tab or any significant UI element, I simply chose to use the cls attribute and specify a CSS class.

new Ext.Button({
    text: 'Ok',
    cls: 'seleniumOkButton', //can have more classes, separated by space
    scope: this,
    handler: function(){ ... }
})

This is how a basic button that is used in automation testing looks like. And I use the following XPath selector in Selenium:

//table[contains(@class,'seleniumOkButton')]

Happy automated testing!

Beyond simply shortening variable names, Closure Compiler with ADVANCED_OPTIMIZATIONS, does three other important steps:

• aggresive renaming – not only renaming local variables and functions, but it renames GLOBAL variables and functions. In this way, it can ruin your public API
• dead code removal – it removes functions you are not using and segments of unreachable code. This can be fine for some apps, but it is definitely risky for JavaScript libraries, that expose some functions which are supposed to be called only by client code.
• function inlining – inserting the function’s body instead of the function call, where appropriate

So it is true that without some additional work, the ADVANCED_OPTIMIZATIONS option will just ruin your code and your public API. Of course the solutions are at hand, but the question is if they worth the effort.

Keep your public API

If you provide ONLY the code below to Google Compiler, it produces empty output:

function hello(name){
    alert("Hello " + name);
}

What? Empty output? Well… yes, as you never call your function. Instead, for the next code:

function hello(name){
    alert("Hello " + name);
}
hello('jslog');

it produces the following output:

alert("Hello jslog");

This is smart! But we want to preserve our API (by the way, in the tutorial for Google Closure Compiler Advanced Optimizations, Google says on this page that the hello function is preserved, while it is NOT – see section Removal of code you want to keep and try the code online at Closure Compiler UI Tool)

So if the hello method above would be part of the public API, it would break third parties using it. Google proposes a solution for this: export the public objects/functions into the global namespace using the window object:

function hello(name){
    alert("Hello " + name);
}
hello('jslog');
window['hello'] = hello;

//and the output is:
function a(b){alert("Hello "+b)}a("jslog");window.hello=a;
//so the hello function is kept as a property on the global window object

Instead, if you use:

window.hello = hello;

you get

function b(c){alert("Hello "+c)}b("jslog");window.a=b;

which is surely not what you want. So make sure you use the window['public_name'] notation. You should also standardize the way you access properties in your objects, either using the array notation, or the dotted notation, otherwise the compiler could be mislead by a mix of the two. But sometimes we just need to use both, as properties may be automatically generated at runtime.

Other problems with the Google Closure Compiler ADVANCED_OPTIMIZATIONS are separately compiling blocks of code with dependencies to external JavaScript. The solution for this is

• using either exports like the above or with the goog.exportSymbol() or
• using extern files specifically provided as a compilation option

In any case, I think this is just a bit too clumsy.

Moreover, having a class and export all its properties/functions is quite a job to to if your app is already a large one. Just have a short example:

MyClass = function(name) {
  this.myName = name;
};
MyClass.prototype.myMethod = function() {
  alert(this.myName);
};
window['MyClass'] = MyClass; // <-- Constructor
MyClass.prototype['myMethod'] = MyClass.prototype.myMethod; <-- export mechanism

//the above compiles to
MyClass=function(a){this.b=a};MyClass.prototype.a=function(){alert(this.b)};window.MyClass=MyClass;MyClass.prototype.myMethod=MyClass.prototype.a;

Conclusions

After this short overview of the ADVANCED_OPTIMIZATIONS flag, I really think most people won't need it. If you already have a large library, having it compiled with advanced optimizations would be a total nightmare, as it would require a review of all public methods and properties and additional work for each. And the gain? Just a few kilobytes. I have tried compiling ExtJS Core with advanced optimizations and got aprox 62 KB, while with simple optimizations it is 74 KB. Not very well for the amount of effort it would require, in my opinion.

But if you still think advanced optimizations is for you, you are probably wanting to optimize a lot, and you should first start seaching for other ways to optimize - first, make sure you combine all your js code into one file. It's better to have one js file of 100KB rather than have 10 files each of 5 KB. So make sure you are doing every other possible optimization before moving to the advanced optimizations flag.

After all, it's up to you to decide if it's worth the effort!

PS: You can follow me on twitter @extjslog.

• Turn logging on and off
• Support for Firebug console and log4javascript
• Redefine console.log, console.warn, … (all console logging methods) through methods from log4javascript, if console is not detected

All you have to do is to keep on logging with firebug just as you did before! The problem occurs when you want to debug n a browser that doesn’t have Firebug enabled! Well, that should be no problem! Just include jslog.js and log4javascript-1.4.1.js and all logging that goes through console.log will now appear to the popup window log4javascript creates!

So jslog.js is a nice utility which allows you to work with two logging strategies, but using a single API, which you already know, the Firebug console

Another facility is disabling logging – in one single line! This is especially useful when going live! You don’t want to go through all your code and modify it! Use jslog.logging.init(false)

A small tutorial.
Include <script type=”text/javascript” src=”jslog.js”></script>

    jslog.logging.init(true);
    console.log('hello','this will be logged');

    jslog.logging.init(false);
    console.warn('sorry...','this log will not appear');

When you want to log in non-firebug environments, just include the following in your html file:
<script type=”text/javascript” src=”log4javascript.js”></script>
<script type=”text/javascript” src=”jslog.js”></script>

//You don't have to change your code.
//if jslog.js detects no console to be available,
//it creates one and redirects logging to log4javascript
    jslog.logging.init(true);
    console.log('hello','this will be logged');

    jslog.logging.setEnabled(false);
    console.warn('sorry...','this log will not appear');

If log4javascript.js is not included in the page and no Firebug console is detected, jslog will detect this and will just be silent, even if logging is enabled. It will not throw an error!

Download it here!

So…. happy logging! For questions and support, contact me!

Credits to Tim Down for his awesome log4javascript library!