Google Closure’s idiocies: Ajax can’t be synchronous :(

While I love Closure tools and the possibility to write a better organized and OOP based JavaScript, I’m facing some weakness and inexplicable choices in the library. The last discover is that is impossible to make synchronous ajax call using the provided classes, since I didn’t find nothing about synch/asynch options by reading API reference, I took a look to the source (xhrio.js), and I noticed this:, url, true);  // Always async!

that true should be a parametric value which developers can set to true or false. Why forcing it to true???
I’m really disappointed :(

Custom JavaScript classes and packages using goog.provide() and goog.require()

I will repeat it until the dead, the real power of Goolge Closure is the mechanism and the tools behind it, not the classes and methods written for you, but the possibility to write your own better JavaScript code! Today I’m gonna show you how to create and use your custom JavaScript classes and to take the benefits of goog.provide() and goog.require() methods.
Ok, let’s suppose we are working on a funny and exciting project, like an online JavaScript game called “Js Monsters Battle” and let’s suppose the domain will be We love OOP, we love write js code, we love to have a well organized and document code, so we will begin by creating our packages, following the standard which establishes that the root of a package must be the reversed domain name, so in our example we will create this folders structure “/com/jsmonstersbattle/” and inside we will put our classes (and subpackages).
Since our game is a game about monsters, we will create the core package “monsters” in that directory and we will write the first base class called Monster. We will got the following: “/com/jsmonstersbattle/monsters/monster.js”, three folders and one js file. Yes, one JavaScript file for class, forget those huge files containing millions of functions, we are going to write better JavaScript code and thinking more like a Java developer. If you are concerning about file size and performances, don’t worry about it, the compiler will reduce and optimize the code for you (just before release the project). Ok, let’s take a look inside the Monster class (monster.js):


 * A common Monster
 * @constructor
 * @param {String} name
 * @param {String} age
 * @param {Number} level
com.jsmonstersbattle.monsters.Monster = function(name, age, level) {

    /** @private */ this._name = name;
    /** @private */ this._age = age;
    /** @private */ this._level = level;


* Returns an amount of damage points
* @return {Number}
com.jsmonstersbattle.monsters.Monster.prototype.attack = function() {

    return Math.round(this._level + this._age / 100) * 2000;


In the code above I defined a basic class called Monster, which is available under the package (namespace) com.jsmonstersbattle.monsters, declared using goog.provide(), then I created a constructor (by using the special jsDoc notation /** @constructor */) which receives three arguments and sets three private Monster’s variable (/** @private */), finally I defined a method attack which returns a number of damage points. Ok, by following the Monster’s example, we can now create as many classes and packages as we like, interfaces (using /** @interface */ and /** @impements */) and subcalsses (using the method goog.inherits()), let’s see briefly these implementation:

Extending a class:

* @constructor
* @extends com.jsmonstersbattle.monsters.Monster
com.jsmonstersbattle.monsters.UglyMonster = function(name, age, level, uglyness) {

    // call to Super, name, age, level);

    /** @private */ this._uglyness = uglyness;


// you can read the following as: "UglyMonster extends Monster"
goog.inherits(com.jsmonstersbattle.monsters.UglyMonster, com.jsmonstersbattle.monsters.Monster);

Creating and implementing an interface:

 * Evil interface.
 * @interface
function IEvil() {};
IEvil.prototype.doEvil = function() {};

* @constructor
* @implements {IEvil}
com.jsmonstersbattle.monsters.EvilMonster = function(name, age, level) {
    // some code here

com.jsmonstersbattle.monsters.EvilMonster.prototype.doEvil = function() {
    // IEvil implementation

Once we created all the necessary classes, we will put our “com” folder under “closure” folder. Then we will create a main js file which will includes all the code required to initialize and run the application, I called it “application.js” for convenience. This file will requires all the classes it needs by using goog.require():

// ...and so on!

After the import we will be able to use the classes, by referring them with the full qualified class name (“com.jsmonstersbattle.monsters.EvilMonster”), however since this means to write long strings, we can create references as the following:


var EvilMonster = com.jsmonstersbattle.monsters.EvilMonster;

// then...

var monster = new EvilMonster();

or use the JavaScript with operator:


with (com.jsmonstersbattle.monsters) {

    var monster = new EvilMonster();


…and this is all today, I hope you enjoyed my post ;^)

Don’t use the with operator nor take reference to fully qualified class name, otherwise you will get several errors if you use advanced compilation!

Automatically compile JavaScript applications using Google Closure and Ant

As I said on insideRIA, the power of Google Closure is represented by the additional tools provided by Google: the Java compiler (which compress and optimize your javascript files) and the python script (which calculates dependencies). This tools however are not so user friendly, because you have to rely on the terminal and invoke them through command lines, a pretty annoying procedure that can scare people which usually rely only on visual tools.
Fortunately is relatively easy to automatize this compilation, by using Ant (a Java-based build tool). Ant is included by default in Eclipse standard platform (anyway some stand alone Eclipse-based ide such Aptana don’t include it… it’s time to use such programs as Eclipse plugins!) and can be configured and used by simply writing an xml file formally named “build.xml“. A build file contains one root node “project” and at least one “target” node containing tasks to execute, tasks are a series of different operations that can be executed by Ant, such create/delete files and folders, zip/unzip a file, running scripts and more. To automatize the deployment of our JavaScript application, we will invoke the and the compiler.jar from Ant in a single statement, and we will print the result to a specific file.
To invoke a script, we have to use the exec tag and specify at least the param “executable“, which indicates the location of the script to execute, then by setting the parameter “output” the result returned from the script will be redirect to the specified file. Finally, to avoid undesired output in the file, such debug information and errors, we have to specify also a file which will receive this type of data by using the “error” parameter.
Since, paths to scripts and other files can be very long, we can create custom variables to hold these information and then reusing them in our script invocations. This is as simple as use the “property” tag and specify a “name” and a “value” attributes.
The following is an example of how a build.xml will looks like:

<?xml version="1.0" encoding="utf-8"?>
	name="Google Closure Ant Test" 
	<!-- Full path of the current project -->
	<property name="projectPath" value="/Users/davidezanotti/Documents/workspace/GoogleClosure" />
	<!-- Full path to Closure library -->
	<property name="closurePath" value="${projectPath}/closure" />
	<!-- List of javascript files to compile -->
	<property name="filesToCompile" value="${projectPath}/my-closure-app.js" />
	<!-- Full path to the compiler jar -->
	<property name="compilerPath" value="/Users/davidezanotti/Documents/closure-compiler/compiler.jar" />
	<!-- Full path to the compiled file (created if not defined) -->
	<property name="outputPath" value="${projectPath}/ant-generation.js" />
	<!-- Full path to the file which will contains debug output and errors -->
	<property name="logPath" value="${projectPath}/closure-compiler.log" />
	<!-- Compilation level -->
	<property name="compilation" value="WHITESPACE_ONLY" />
	<target name="JavaScript Compilation">
		<exec error="${logPath}" output="${outputPath}" executable="${closurePath}/bin/">
			<arg line="-i ${filesToCompile} -p ${closurePath} -o compiled -c ${compilerPath} -f '--compilation_level=${compilation}'" />

The build.xml above will first gathering all the necessary Closure files (dependencies) and then will compile the resulting js using a WHITESPACE_ONLY compilation. The result will be printed to the file “ant-generation.js” and the debug to “closure-compiler.log”.
To run the Ant process: right click on the build.xml and choose Run as Ant Build. This procedure can be also configured in order to execute all the task each time a file in the project is saved, but it’s not a great idea because the process can takes several seconds to complete.
If you want to learn more about Ant (I have to learn a lot too, since I never used it before :P), check the reference here:

goog.ui.TabPane: Create tabs with Google Closure

Hi everyone,
by starting with this post I would like to begin a series of posts dedicated to the new javascript library released by Google: Closure!
Today I will focus my attention on tabs creation, since this is maybe the most common user interface component in a web application.
In order to create Closure tabs, we need to import the base js file (/goog/base.js) and then require the class goog.ui.TabPane. Inside our head (or body) we will get the following:

Continue reading