Category Archives: Technology

Dojo & GWT – Templated Widgets

We had – and still probably have – a tough time porting Template-Based Widgets in Dojo for Google Web Toolkit.

The reason is – Templates defined attach-points and attach-events, variable names / function names that are to be made use of at runtime. However, GWT optimizes the Java function names and as such one does not know what will be the function name at runtime.

And hence the conflict and an area of problem.

The DWT team has posted a writeup at their blog that outlines the problem and proposed solution.

If you find the problem interesting or have an opinion, please do write in.

4-Sutras to work with JavaScript

(Sutra: noun, that which runs through and holds things together)

JavaScript is a fantastic language to work with. I will, personally, prefer to work with runtime dynamic language like JavaScript than compile-time feature constrained languages like C++ or Java (well, C# is still far richer than C++ and Java).

However, working with JavaScript is not – quote-unquote – trivial noting that majority of the developers start with C/C++ or languages evolved from them.

I’m not here to talk about JavaScript, but 4-Sutras that I’ve developed that one should keep in mind while working with JavaScript.

These sutras are:

  1. All data-types are infinitely flexible.
  2. All objects are infinitely extensible.
  3. Objects are associative arrays.
  4. It’s all about functions.

Let me explain them in some detail…

In JavaScript, we can provide more functionality to any data-types, including the predefined ones through the prototype object. Infact, there exists a JavaScript library with this very name. For example, we need to add a function insertAt to the Array object. Here’s how we can accomplish the task.

Array.prototype.insertAt = function(item, index)
  if(index >= 0 && index < this.length)
    this.splice(index, 0, item);

And then, I can do:

var a = new Array();
a.insertAt('two', 0);

alert('Item at index 0 = ' + a[0]);

So, what I meant in “flexible data-types” is that we can add (infact, remove and change as well, at will) the functionality to any data-type (native JavaScript object) irrespective of whether the code for the type is available or not. Isn’t it great?

Coming to the next point – properties / methods associated with any object (instance) is totally configurable. Assume that we have a reference obj to which we want to associate two properties – exx and vayee – and one method checkPoint, we can add that!

Note that this is different from the flexibility of the data-type. Here, only obj will have these properties, any other object obj2 will not have these properties and methods.

var obj = new Object();
bj.exx = "Value x";
bj.vayee = "Value y";

obj.checkPoint = function()
  if(this.exx && this.vayee)
    return true;
  return false;

What do you gain out of this? Well, this extensibility allows you to grow your objects – at runtime, on demand. And that’s one of the features that I love in JavaScript.

Everybody loves OOAD because it helps us relate programming to our real life – objects with attributes and functionalities. However, it fails to address one key issue – objects in real life grow. They grow as themselves not requiring a child. However, this is absent in almost all languages barring JavaScript and Smalltalk.

btw, do you remember Smalltalk? The world’s first object oriented language. But somewhere, C and C++ grew more popular and we really lost the fun and power of Smalltalk. Sad. :(

So, I am assuming that you’ve understood what I mean when I say that all objects are infinitely extensible.

Let me proceed to the next item. It may or may not be classified as a sutra, because it’s a very basic feature of JavaScript. However, we tend to forget about it while working with JavaScript. So, I thought about making it a sutra so that it’s not forgotten.

Objects internally are implemented as associative arrays, or whatever alternate name you want to use. The effect is that you can use any object in two ways, as given below:

var obj = new Object();
//Assigning as a property
obj.x = "Ex";

//Assigning as an associative array
obj['x'] = "Ex";

//Similarly, assining a function
obj.fn = function()
  alert('Hello, World!');

//And calling it

The two ways to work with properties, as given above, are identical. So, don’t worry if you do not know the name of the method or property at design time. Just store it in a variable and access it using the format given above!

Voila! So easy! And damn powerful! Isn’t it?

And finally, never forget about functions. JavaScript is all about functions – to start with and till the end!

The attributes associated with JavaScript functions are:

  1. Functions are the ways to create data-types: Encapsulation
  2. Functions can be nested, any level deep: Some kind of private functions?
  3. Functions can be used as simple functions as well as constructors
  4. Instance functions (associated with any object) can be called with any context, so that the value of this can be changed on the fly! Voila!
  5. And there’s a lot more magic that you can do with functions in JavaScript.

RIA, Web 2. 0 and Curl

In my previous posting on RIA, Web 2.0 et al, I mentioned about some frameworks and toolkits and runtime etc.

And then I get a comment from the Curl Team. Have a look at the comment here.

I still have not evaluated Curl but to get started with, looks interesting. So, at this point in time – I just mention about it that there exists something called Curl. :)

Whether it is suitable or not, or can it scale up to the requirements — I still have to evaluate.

Adobe Flex, RIA and Web 2.0

Last week I delivered a week long training on Adobe Flex 3 (yet again). Apart from the technologies – Adobe Flex and ActionScript – the training aimed to focus on Web 2.0 and RIA.

Web 2.0 and RIA, today, are more or less established philosophies.

However, what I think is that the world is heavily divided on which framework / toolkit to go for. Most of the web revolves around JavaScript & Ajax and/or Flash & ActionScript. Slowly and gradually, Silverlight & WPF/JavaScript seems to be making inroad on the development front – not quite sure how fast.

So, I thought let me try to compile a few frameworks (partial list inspired from the one at Wikipedia):

Barring Adobe Flex, all other frameworks use a common technology – JavaScript and Ajax.

However, some toolkits like Dojo uses / used Flash for offline storage. Some of them are moving to Google Gears for offline store.

And at the moment, I have to rush to the market… will build on this in my subsequent articles.

Dojo on Google Web Toolkit

My real love for GWT started only a couple of days ago… and it prompted me to get started with Dojo on GWT.

I have, so far, written a couple of core-classes in Java mainly to abstract out the interaction with JavaScriptObject.

My next target was to directly jump on to dijit, and start creating the UI. And then I realized that it uses mixins. And now I am left wondering what’s the best way to handle mixins.

For the new comers, JavaScript allows single inheritance but Dojo (and other libraries) make use of mixins to pseudo-inherit methods and properties from other objects by copying them to the sub-object.

In Java, this can be achieved only by making use of interfaces. The other possibility is to introduce a class between the parent and the child class that encapsulates the mixin objects.

I think the latter is a better approach. Simply expose the object or may be create delegate methods.

Let me think over it… what’s the best way to marry Java and JavaScript.

Google Web Toolkit

On Monday, I talked about the training on Visual Studio Team System 2005 Extensibility and I said that I would probably post across a sample piece of code.

But I did not get time.

What more interests me is the web. And there is Google Web Toolkit to help us write structured JavaScript in Java. Sounds great, isn’t it?

So, what I did was to quickly compile a couple of articles on GWT and post at Eduzine™ here and here.

Enjoy working with Google Web Toolkit, JavaScript and Ajax!

Windows Image Acquisition and Windows Portable Devices

I had been working with WIA (for Windows XP) and WIA 2.0 (for Windows Vista) to design an application to capture images.

WIA for Windows XP works perfectly fine. And WIA 2.0 is supposed to do the same on Vista.

And then, I hit a hurdle – WIA 2.0 always gives me “0 devices” while using EnumDevices method. Finally, I hit yet another set of documents – Windows Portable Devices (WPD) here.

What the heck! Do I need to rewrite the entire application for Windows Vista? What does Microsoft want? Spend all time and money only to rewrite entire code every time a new version is released from their side?

At times, I really hate to develop any application on Windows.

The only good thing, at least at moment as it seems, is .Net Framework. At least, there I need to do minimal work. I wish it was the same case elsewhere also.

Customizing Team Foundation Server

Yes, that’s what I am doing for couple of days.

No, it’s not about customizing how TFS works but looking at the integration points. In short, the TFS SDK.

The following items are the items on my radar immediately:

  • Customizing WorkItem Types
  • Creating custom fields
  • Creating custom UI controls during WorkItem display in Visual Studio
  • Creating custom check-in policies
  • And making all of them backed by some database?

Well, I have already worked with the first two items – creating custom fields and customizing WorkItem types, predominantly using custom fields and choosing the layout – several times.

Now, I need to master the remaining items.

And yes, it’s mainly for Edujini™, my baby. So, what I promise is that once I am through with my experiments, I will publish them at Eduzine™ and Edujini Downloads™.

Flex, Panel and Focus

I really can’t get this one working. And it’s really frustrating.

A very simple task… use tabs to change the focus across the panels. I have “tabEnabled = true” and “tabIndex = {appropriate-index}“. Still, a sad state. Now I am worried if the tab really works with Panel.

If you know the solution, please do write in. Well, I don’t even know if anybody is reading me!