Archive for the ‘innovation’ Category

Today Imtiyaz and I did a small hack in the Flex charting code and removed the Trial message from the Charting component by writing 1 simple actionscript lines.

what you need to do is in the creationcomplete of any charting component write the following code

//            var arra : Array = new Array();
//            for(var i:int =0;i<this.numChildren;i++){
//                arra.push(this.getChildAt(i));
//            }

// the above 4 lines are just to check  what r the childs added

(this.getChildAt(this.numChildren-1) as TextField).htmlText = ” “;

we  tried to set visible false but that dint work we also tried to remove the textfield child alltogether  but that too dint work 😛 but finally it was the html text property of the textfield that gave way 😀

now you can also add your custom  trial message to your application 🙂

just replace the blank with your text for example:

(this.getChildAt(this.numChildren-1) as TextField).htmlText = ” YOUR MESSAGE”;

But its better that you buy your own licence key for charting. The above example was basically for educational purpose. have fun 🙂



The upcoming version of the tool to build your flex applications is called Flash Builder! (formally known as Adobe Flex Builder). The flex framework will continue to be known as Flex. The naming is appropriate given the fact that every one who is building a Flex / Flash / AIR app today is building it on top of the “Adobe Flash Platform”

Welcome, Flash Builder!


The lifecycle of component can be easily understood in few simple steps firstly you create a component holder, then create-children, set-sizes/properties and dispatch events. Following four methods plays a major role in component rendering.

  • createChildren()
  • commitProperties()
  • measure()
  • updateDisplayList()

Here is what I found after doing some studies. The most of the following part is taken from Adobe flex help however what I am trying to do here is to elaborate it more by putting up some comments to each step to make it clearer.

Following steps are demonstrating the Button component life cycle

  • Given if the component is going to be in a container then the parent property of component will be referred to the container(DisplayObjectContainer type)
  • Get the style settings of the component
  • Dispatches the preinitialize event on the component. // The preinitialize event( is triggered when the UIComponent is in a very raw stage and there is no children in existence at that time
  • Calls the component’s createChildren() method. // createChildren is a protected method of UIComponent class which we need to override when we create a subclass of the UIComponent. Also from within an override of the createChildren() method, you call the addChild() method to add each child object. You do not call this method directly. Flex calls the createChildren() method in response to the call to the addChild() method to add the component to its parent.
  • Calls the invalidateProperties(), invalidateSize(), and invalidateDisplayList() methods to trigger later calls to the commitProperties(), measure(), or updateDisplayList() methods during the next render event. //invalidateProperties() marks a component so that its commitProperties() method gets called during a later screen update. invalidateSize () Marks a component so that its measure() method gets called during a later screen update. invalidateDisplayList () Marks a component so that its updateDisplayList() method gets called during a later screen update.

The only exception to this rule is that Flex does not call the measure() method when the user sets the height and width of the component(it is the explicit hight and explicit width that the user can set for any component).

  • Dispatches the initialize event on the component. At this time, all of the component’s children are initialized, but the component has not been sized or processed for layout. You can use this event to perform additional processing of the component before it is laid out.// Initizlize event gets dispatched when the component has finished its construction and has all initialization properties set. After the initialization phase, properties are processed, the component is measured, laid out, and drawn. After which the creationComplete event is dispatched.
  • Dispatches the childAdd event on the parent container.The childAdd event is dispatched when the addChild() or addChildAt() method is called. At the time when this event is sent, the child object has been initialized, but its width and height have not yet been calculated, and the child has not been drawn on the screen. If you want to be notified when the child has been fully initialized and rendered, then register as a listener for the child’s creationComplete event.
  • Dispatches the initialize event on the parent container.Dispatched when the component has finished its construction and has all initialization properties set. After the initialization phase, properties are processed, the component is measured, laid out, and drawn, after which the creationComplete event is dispatched.
  • During the next render event, Flex performs the following actions:
    • Calls the component’s commitProperties() method.//commitProperties() processes the properties set on the component. You do not call this method directly. Flex calls the commitProperties() method when you use the addChild() method to add a component to a container, or when you call the invalidateProperties() method of the component. Calls to the commitProperties() method occur before calls to the measure() method. This lets you set property values that might be used by the measure() method.
    • Calls the component’s measure() method.// Measure() calculates the default size, and optionally the default minimum size, of the component. This is an advanced method that you might override when creating a subclass of UIComponent.
      The default implementation of measure() sets measuredWidth, measuredHeight, measuredMinWidth, and measuredMinHeight to 0.
    • Calls the component’s (Adobe help mention this method is in UIComponent where as it is in container class) container’s layoutChrome() method.The Container class, and some subclasses of the Container class, use the layoutChrome() method to define the border area around the container.
    • Calls the component’s updateDisplayList() method. //updateDisplayList() method sizes and positions the children of your component based on all previous property and style settings, and draws any skins or graphic elements that the component uses. The parent container for the component determines the size of the component itself.
    • Dispatches the updateComplete event on the component.
      Dispatched when an object has had its commitProperties(), measure(), and updateDisplayList() methods called (if needed).
      This is the last opportunity to alter the component before it is displayed. All properties have been committed and the component has been measured and layed out.
  • Flex dispatches additional render events if the commitProperties(), measure(), or updateDisplayList() methods call the invalidateProperties(), invalidateSize(), or invalidateDisplayList() methods.
  • After the last render event occurs, Flex performs the following actions:
    • Makes the component visible by setting the visible property to true.
    • Dispatches the creationComplete event on the component. The component is sized and processed for layout. This event is only dispatched once when the component is created.
    • Dispatches the updateComplete event on the component. Flex dispatches additional updateComplete events whenever the layout, position, size, or other visual characteristic of the component changes and the component is updated for display. Read the rest of this entry »


Humans have a natural ability to correlate patterns from multiple sources to become aware of information. Most current human-computer interfaces however are limited to visual and more exactly text-based interaction. While it is true that current computer systems use a large number of symbolic elements and metaphors in the Graphical User Interface (like icons, windows, drag and drop, and so on), the primary mean of information exchange is still the written (or in the case of computers typed) word.

This approach (while having the advantage of simplicity) is very limiting from an information-bandwidth (the rate at which information can be exchanged between the user and the computer) point of view. Because typing / reading has an upper limit (although estimate vary from 40 to 250 words per minute for typing and between 250 and 700 words per minute for reading, it is clear that such limits do exists and that most people are not able to cross certain barriers, no matter the amount of training), it is logical to conclude that we must look to alternative ways to consume more information quicker. From a technical point of view the two methods which are the easiest to implement with current hardware are:

  • alternative (non-textual) representation of (aggregated) data, making use of our ability to observe trends and patterns

  • auditory feedback for certain events

Both of these methods can easily be implemented with almost all consumer-grade computing equipment. The fact that both of these are “output” (from the computer point of view) methods can be justified that the rate at which outputs is produced (and needs to be consumed) is much larger than the rate of input we need to provide (two of the reasons being that a great deal of output is produced by automated systems and also because in todays interconnected world we consume the sum of many outputs). In the following pages I will focus on the first method and more specifically the way in which it applies to networking data.

Each part (after the introductory part about data visualization) will present one way to visualize data and discuss the applicability of the given method in the context of computer networking.

Read the rest of this entry »

why do you think its important?

Today the biggest problem faced by any growing organization is “how to represent the data to the users”. One might have the best operations and processes to mine the data and tabulate the final results but it all goes down the drain, if we are unable to present the data to the user.

The mantra: “showing the maximum amount of information  while using the least amount of ink and presenting it in a fixed amount of space” Any interface which doesn’t follow his golden rule is not worth showing.  More over its not so simple and easy to be in sync with the above mantra.  So one has to keep experimenting different yet innovative ways to represent data. Here is a list of a few good Data-visualizations. Enjoy yourself 😉

special thanks to “”

1. Mindmaps

Trendmap 2007

Web Trends 2007 presents the 200 most successful websites on the web, ordered by category, proximity, success, popularity and perspective in a mindmap. Apparently, web-sites are connected as they’ve never been before. Quite comprehnsive.

2. Displaying News

Newsmap is an application that visually reflects the constantly changing landscape of the Google News news aggregator. The size of data blocks is defined by their popularity at the moment.


Voyage is an RSS-feader which displays the latest news in the “gravity area”. News can be zoomed in and out. The navigation is possible with a timeline.


Read the rest of this entry »

Baljinder and sachin have come up with a brand new innovative idea it all up to the testings and POCs to decide…

Long story short 2 of our team mates have found a way to do the complex mathematical computation in much better time and efficiency, instead of the traditional system. They have found a yet better computational core a graphic card core (in terms of massive floating point matrix multiplication) which reduces the computational time to ‘n’ folds. Any how its me a UI guy briefing on this complex topic, i guess you would better understand after reading Baljindar’s mail.


We have very exciting results to share with you! Sachin and I had been doing some PoCs with Cuda on nVidia GEForce 8600 (GT), for the matrix multiplication and we have got very impressive results.

The stage was set when Sachin did full profiling and found the following stats:

  • Whole ADE tests took ~ 20 secs . Out of which, around 16-17 secs were taken by matrix multiplication, mainly in function ‘f_Proj()’ which took ~69% of this time. There we’re multiplying two matrices of size 2048 x 400 and 400 x 400 respectively for B/P/F and the other ones of size 2048 x 1600 and 1600 x 1600 for entropy.
  • Each matrix multiplication for entropy took ~ 6 secs in ‘findProjections()’.

Having figure out that the pain points are actually matrix multiplications, we started investigating to find better ways of matrix multiplication. We found that Cuda SDK provided by nVidia looked like a promising candidate, since it is highly optimized for floating point operations. And guess what, the results that we got from preliminary tests are extremely encouraging!

  • 1. The current architecture took roughly 30 milliseconds. An impressive gain of 6/.03 = 200 times! And that too when we used a very naive, unoptimized way of multiplying matrices (obviously, open_cv uses much better algorithm taken from BLAS) 🙂

It is worth noting that the FPU that we used for these tests, is quite a mediocre one by computing standards, and we expect results to improve more once we use high end cards like nVidia GEForce 8800 Ultra.

We’re very excited to see such a gain 🙂

Baljinder & Sachin

Its as though we have found Kryptonite in the form of a graphic card, I had no idea a graphic cards could be used to do such things… all i used my graphic card was for playing games. we are not far from reaching the moon now 😉 . Good going Baljindar and Sachin Guavus needs people to come up with such innovative ideas…

P.S. I hope you guys don’t remove the concept of CPU all together 😉

I have moved to a different location

check out my new home Flexout


May 2018
« May    

Blog Stat

  • 84,065 Hop's so far!!!

follow me


Linkedin Blogger Twitter Youtube Orkut

latest flickr photos

top rated