The Road Ahead...

Projects to watch out

2009-05-03T04:04:00.000-07:00

These are some projects I have been watching for sometime now which can allow you to scale easily and at the same time provide flexibility. Three things that can help one to scale are partitioning, caching and queuing. A lot that happens inside a OS is queuing.

Gearman
It can be looked on as a load-balancer of sorts for your functions. The gearman simply interfaces the client(who wants to get a particular job done) and the worker. The best thing about gearman is, it allows both synchronous and asynchronous job calls. Lets say for instance there is a search query, where you have multiple shards from which you need to consolidate data. Through gearman you can make multiple job calls, and can do the processing in parallel. When all the workers have returned, all you need to do is consolidate the data. When the load is high, it will take time for your responses but the system can still handle it gracefully. When used with a cloud service like EC2, all you need to do is have a service monitor the jobs in queue and create new EC2 worker instances depending on the load. When the load is lower some of those instances can be killed.
What gearman doesnt as of now provide is (in the works):
1. broadcast (sending a message to all the workers) (useful for housekeeping)
2. persistence of unprocessed jobs i.e. saving of jobs after the gearman server has crashed

For using gearman one needs either an neutral encoding system or both client and worker has to use the same platform. They can either choose to use JSON(JavaScript Object Notation) due to its ubiquitous nature. Or they can choose to go for language neutral binary encoding format like

Thrift
This encoding format is used by Facebook for making RPCs. The encoding format supports versioning of data objects and also is language neutral. Its bindings for different language is still under development but is available for c++, PHP, Perl, erlang etc.. It also provides transport apart from deserialization/serialization of objects. The documentation for various language bindings is not great but one can understand by looking at their test code. Thrift has got somewhat influenced by google's protobuf. It also provides an interface for using a custom encoding/decoding format.

ProtoBuf
It is similar to thrift, but the only difference is it doesnt provide transport. It is open sourced by google. Different language bindings are available for this format, and some of them have been developed outside of google.

Both of them generate static code from a definition file for creating classes/types. When used with Gearman, these can provide queued language neutral setup of backend.

OOPS in Javascript: Part III

2009-04-11T07:50:00.000-07:00

Apart from using inheritance and prototype for defining an object, there is closure which is strong and often misused feature in javascript. It is one feature I love and knowingly or unknowingly everyone would have used this feature. It is something like whenever a function is defined inside another function, all the variables inside the parent function exists even after the parent function has returned. It is something in the lines of creating a parallel world each time you invoke a function.


/**
 * A simple example of closure
 */
var rank = 0;
function greet(name) {
    var my_rank = ++rank;
    /* adding a anonymous function to greet person after 5 seconds*/
    window.setTimeout(function() {
        alert("hi " + name + " you came in " + my_rank);
    }, 5000);
}

greet("ram");
greet("geetha");

To create a closure, two things are needed,
1. Creation of a function inside a parent function.
2. Send the reference of child function outside the scope of parent function.

Firstly all the variables declared inside a function can be accessed only inside the function, unless explicitly it is passed as a reference outside. In case of closure, all those variables the child function could access will live until its reference is not deleted.
Javascript as you know, doesnt want you to manage memory and uses garbage collection to free memory. All that the garbage collector is looking for is reference count of each instance, and in this particular case my_rank, name and also the anonymous function. It will not release these resources until there is a setTimeout trigger, and it removes the reference of this anonymous function.



class2 = function () {
    
};

class2.prototype = {
    manager : function (params, postcallback) {
                var my_dailog;
  var usr_callback = function(filename) {
   //make ajax call and get the content
                        my_dailog.hide();
  };
  //get user input from dailog,
  my_dailog = new Dailog({
   message : "Enter the name of the file",
   callback : usr_callback
  });
  my_dailog.show();
    },
    req : function() {
        var my_div = document.getElementById('status');
        var content_div = document.getElementById('content');

        my_div.innerHTML = "working...";
       
        var callback = function(params) {
            my_div.innerHTML = "Done.";
            content_div.innerHTML = params;
        };
        this.manager({
            url : "http://www.ajaxian.com"
        }, callback);
    }
};

var ob = new class2();
ob.req();

If for some reason, setTimeout's internal code fails to remove anonymous function's reference or doesnt have a mechanism to release its reference, all these variable will be like a zombie or in technical terms leaked memory. The problem will multiply when this function is called a hundred times, boggling down a lot of memory. This memory will never be claimed back until there is a window.unload. In the above example, all we are doing is try to get the name of the file so that it can be updated. Both manager and the req, functions are using closures, and if not handled properly can and will lead to a memory leak. The leak will only occur when there is a reference to anonymous function present outside of its scope. IE's internal handling of closures is somewhat different when compared with that of Firefox or Safari and also leaks a lot of memory.
Memory leak is not a serious problem for any page which doesnt live for a longer period of time. Detection of leaks are tricky with any language, and its very difficult to debug in complex applications. It is bad for an application like gmail which runs throughout the day. It is a good idea to reload the page over a period of time.

My experiments with ImageMagick

2008-08-27T22:15:00.000-07:00

I have been experimenting with ImageMagick for quite some time now. Its one of those great libraries one couldn't manage without and the best part is it just works. I had to write an implementation on top of ImageMagick, to draw styled text on image. Which i thought was pretty straight forward, and started to dig on the api docs of ImageMagick. In the end i finally found that, there was no implementation or function in api to wrap have different style of text in the same line. No big deal right, but then there are lot of subtleties which one will not realize until he/she is deep in it.
I then went over my normal ritual of getting the pseudo code(comments, i cant work without them). First i thought the only thing i ll have to do would be to wrap the text, and then set the height which is maximum for any style. There also was a straight forward api function call in ImageMagick (QueryMultilineFontMetrics). So i started not knowing what i was getting into. The wrap logic was something like,

1. you get the width of all the visible characters by making the api call,
2. now get all the words in the sentence/ paragraph
3. for each of those word add the width for each character and try to figure out whether it has surpassed the line width or not.
4. if it has start over on the next line, calculate the height needed.

To describe the above solution in one word, it is specious and it didnt work. Some of the characters were going outside the boundary. I didnt know a thing about typography and typefaces which in a way increased my curiosity. Here I was coding, without really knowing any fundamentals about the internals. I decided to give programming a pass and started reading about typeface and things related with it.
I have been using computer for more than a decade now, but one thing that has never interested me is fonts. I was finally coming to terms with my demons. As i read more about fonts, it became clear that there was a lot of thought, logic and research gone into it, so much so that it was a science as well as creative. I feel it is one of those things which stares right on our face, but we just dont realize it. The fonts are mainly categorized into monospaced (ones we see in code editors) i.e. all characters are equally spaced and have equal widths and what we normally write in paper is proportional typeface i.e. 'i' has a smaller width compared to 'W'. There is something else apart from these in the font, which created the bug in my code. They are the small pauses between two characters when they are rendered. My algorithm didnt include kerning(this is what the that hole is called) for calculations and resulted in text bleeding out. I had to slightly change my approach, and had to include this along, but since the font could be proportional or monospaced you dont really know that width. The only way you can do that is by making the query fonts call for the whole word, and use it for all the calculations. Apart from that i also found that QueryFontMetrics was trimming the space, and it had to be found out in a round about way.


use strict;
use warnings;
use Image::Magick;


my ($my_styles);
$my_styles = {
    style1 => {
        font => "Arial",
        color => "#000000",
        size => "20"
    },
    style2 => {
        font => "Arial",
        color => "#00ff00",
        size => "25"
    }
};
#returns the image magick object after rendering the text, with given height and width.
#it truncates the paragraph after reaching the height limit.
#wraps the text, and also can support multiple styles in the same line
sub draw_styled_text {
    my ($text, $height, $width, $default_style) = @_;
    my $im = Image::Magick->new();
    my $last_pos = 0;
    my ($x, $y) = (0, 0);
    my %lines;

    $im->Set(
        size => $width . "x" . $height
    );
    $im->Read('xc:none');
    #format
    #sentence%%$$style_name$$sentence%%sentence
    #for each styled sentence
    my @sentences = split /\%\%/, $text;
    for my $sentence (@sentences) {
        my ($style_name, $style_details);
        $style_name = $default_style;

        if ($sentence =~ /\$\$(.*)\$\$([\w\W]*)/) {
            #get the style name,
            $style_name = $1;
            $sentence = $2;
        }
        #check length of the string
        unless (length $sentence) {
            next;
        }

        #get the style details,
        $style_details = get_style_details($style_name);
        $im->Set(
            font => $style_details->{'font'},
            pointsize => $style_details->{'pointsize'}
        );
        #wrap text
        my ($new_text, $line_height);
        my $space_width =  get_space_metrics($im);
        #annotate trims text. to avoid that check the no. of spaces in the begining and in the end.
        #space in the begining of the string
        if ($sentence =~ /^( +).*/) {
            $last_pos = $last_pos + ($space_width * length($1));
            $x = $last_pos;
        }
        
        ($new_text, $last_pos, $line_height) = Wrap($sentence, $im, $width, $last_pos);
        #space at the end of the string.
        if ($sentence =~ /.*( +)$/) {
            $last_pos = $last_pos + ($space_width * length($1));
        }

        #for each line
        for my $line (split /\n/, $new_text) {
            $y = $line_height unless ($y);
            my $arr;
            if (defined $lines{$y}) {
                $arr = $lines{$y};
            } else {
                $arr = ();
            }
            #write the line
            push @$arr, {
                x => $x,
                y => $y,
                text => $line,
                color => $style_details->{'color'},
                font => $style_details->{'font'},
                pointsize => $style_details->{'pointsize'},
                line_height => $line_height
            };
            $lines{$y} = $arr;

            $x = 0;
            $y = $y + $line_height;
        }
        $x = $last_pos;

        if ($new_text !~ /.*\n$/) {
            $y = $y - $line_height;
        } else {
            $x = $last_pos = 0;
        }

    }

    my $adjustment_y = 0;
    for my $y(sort {$a <=> $b} keys %lines) {
        my $arr = $lines{$y};
        my $max_height = 0;
        my $considered_height = 0;

        for my $line (@$arr) {
            if ($max_height < $line->{'line_height'}) {
                $max_height = $line->{'line_height'};
            }
            unless ($considered_height) {
                $considered_height = $line->{'line_height'};
            }
        }
        if ($considered_height != $max_height) {
            $adjustment_y += $max_height - $considered_height;
        }
        $y += $adjustment_y;
        for my $line (@$arr) {
            $im->Annotate(
                font => $line->{'font'},
                fill => $line->{'color'},
                pointsize => $line->{'pointsize'},
                text => $line->{'text'},
                x => $line->{'x'},
                y => $y,
            );
        }
    }
    #return
    return $im;
}

#im doesnt support space
sub get_space_metrics {
    my ($im) = @_;
    my $val = 0;
    #first get for a
    my $a_width = ($im->QueryFontMetrics(text => "a"))[4];
    my $a_with_space_width = ($im->QueryFontMetrics(text => "a a"))[4];
    $val = $a_with_space_width - (2 * $a_width);
    return $val;
}

sub Wrap {
    my ($text, $img, $maxwidth, $lastpos) = @_;
    my (@newtext, $pos);
    $pos = $lastpos || 0;
    my (@words, @lines, @char, $i, $word);
    @char = split //, $text;
    $i = 0;
    $word = "";

    for my $c (@char) {
        $i++;
        #get the word
        if ($c eq " " || $c eq "-" || $c eq "\n") {
            push @words, $word;
        } else {
            $word = $word . $c;
            if ($i >= scalar @char) {
                push @words, $word;
            } else {
                next;
            }
        }
        $word = "";
        #measure the length of current line
        my @metrics = $img->QueryFontMetrics(text => join("", @words));
        if (($pos + $metrics[4]) > $maxwidth) {
            $word = pop @words;
            push @lines, join("", @words), "\n";

            $pos = 0;
            @words = ();
            #check whether the size of  the word is greater than max width
            if ($word && ($img->QueryFontMetrics(text => $word))[4] > $maxwidth) {
                #force a line break and -
                my $splitword = "";
                for my $ch (split //, $word) {
                    #check whether the set is greater than max width
                    if (($img->QueryFontMetrics(text => "$splitword$ch-"))[4] > $maxwidth) {
                        push @lines, "$splitword-", "\n";
                        $splitword = "";
                    } else {
                        $splitword .= $ch;
                    }
                }
                if ($splitword) {
                    $word = $splitword;
                }
            }
            #push it to the current line
            if ($word) {
                push @words, $word;
                $word = "";
            }
        }
        #add the white space
        if (scalar @words) {
            $words[-1] .= $c if ($c eq " " || $c eq "-");
            if ($c eq "\n") {
                push @lines, join("", @words), "\n";
                @words = ();
            }
        }
    }
    #push the last remaining words
    push @lines, join("", @words);
    my $str = join "", @lines;
    my @arr = split /\n/, $str;
    #try to measure the width of the last line
    my @metrics = $img->QueryMultilineFontMetrics(text => $arr[-1]);
    $pos = $metrics[4];
    my $line_height = $metrics[5];
    unless (scalar @arr > 1) {
        $pos += $lastpos;
    }
    return ($str, $pos, $line_height);
}

sub get_style_details {
    my ($style_name) = @_;
    return $my_styles->{$style_name} if defined $my_styles->{$style_name};
    die "style doesnt exist";
}

P.S.ttt...:
I couldnt find a lot of solutions in web to suite my requirements, and that's one of the reason why i am sharing the solution. The code though is not neat, and there could be other optimizations that can be done, but at the very least it works and can be used as a base for further refinements.

download the source code here: Perl WordWrap for ImageMagick

Five9s Availability - Is it too much to ask for?

2008-06-06T12:00:00.000-07:00

Imagine logging into GMail, and suddenly getting a Oil change page. No way thats gonna happen now right?? Nearly 4 years back I used to see this page quite often, but over a period of time GMail has certainly matured as a product. They are still adding features seamlessly and making releases without any downtime of the service. That makes me look in awe at many services which achieve this and I sometimes wonder what it takes to achieve 99.999(Five9s) i.e. approximately 6 minutes of downtime in a year.

Message from ABC: OOPS, No donuts for you.
Developer of ABC: The possibility of this is infinitesimally small and guess what, Shit happens!!!
User: Damn!!! It always happens when I am in middle of something important
But hey why go through such a ordeal.. Let me try XYZ...

Real donuts for guessing the service ;)

Why?

For starters, if there are lot of outages users will loose trust in the service and might start looking at it as a liability. Twitter is a classic example of that. I would hate to see GMail go down while i am using it. In the Web 2.0 world there are lot of 'me too' services to take your place, the only differentiator can in many instance be speed and availability of your service.
This is normally in a later stage of a start-up as feature takes precedence over availability. But a use of little common sense initially will prolong the availability issues.

Why measure?

It is always better to measure than not to. It can be used to compare the availability of service month over month and progress made in terms of availability. In extreme cases, one can boast in some scalability and availability conference. ;)

Why Five9s and not any other number?

Six minutes of downtime is not very huge and not very small, though this depends on the type of outage and service. Choose a number that suits your goals. It is also a measure of availability of service during its business hours(24x7 for most web 2.0 startups). It is a number which is quite difficult to achieve but not impossible. Every year very few services achieve Five9s. Personally I look at it as a benchmark as only a selected few make it to this league.

The downtimes can be categorized into two, viz. predictable and unpredictable ones.

1. Unknown/Unpredictable ones
a. DB/web server needing a restart(often with windows based environs.)
b. Hardware failures
The service should have at least have two point of failures for the whole service to fail completely. It pays to have redundancy but its expensive too. RAID depending on the configuration will only protect the data, but the time required to recover from such a disaster and to go up online again will be huge. Its better to have another redundant h/w and s/w which is hot swappable. This will require a lot of design and architecture considerations. Its always better to assume that some failure like this will always happen and being prepared to tackle it. It is not financially viable for many early stage startups to have redundancy for everything, but being prepared for such a eventuality will not hurt the company.

c. A spike in traffic, taking everything down with it.
Its difficult to be prepared for spike, it is given that there will at least be one spike in a year you cant handle. Having a architecture and design for rainy days will pay off in the longer run. Services like Amazon EC2 will certainly help in handling spike, but it all depends on the preparedness for a spike.

d. Some goofy in datacenter, restarts the server by accident (I am not making it up. it has happened twice.)
To avoid such a scenario don't have your server in India, unless you are having redundant counterpart elsewhere. Not kidding!!! India is light years behind for providing any serious hosting services. If at all you want to have a server in India for various reasons, avoid resellers. If the number of servers are more go for a co-location.

continued...

OCC Mumbai Meet

2007-11-04T07:19:00.000-08:00

Off late I have come to notice the number of startups in India are increasing. Last Year the number of Startups could be counted, but now there is a explosion in the number of startups. Thanks mainly to Web 2.0
Here are some of the pics of OCC and Barcamp Mumbai I had visited.

Funny!!!

2007-10-11T07:27:00.000-07:00

I found this advertisement while reading a blog, and i found this add by google funny.....

The First Step

2007-10-06T12:42:00.001-07:00

September 3rd:
0825 hrs: 30 pair of eyes zeroin on a location, and are carefully calculating their next move. From the look of their eyes one could tell that they wont hesitate to kill if it is necessary. Chaos erupts as it comes to a halt and people are in a frenzy to board. With room only for a dozen, somehow all 29 of them make it. My jaws dropped, my shoulders sagged and my legs felt loose when I suddenly realised that I have to go in such a train daily to reach my office.
0855 hrs:
After watching 4 trains pass by, I summoned all the strength and courage to actually approach the train. I was pushed aside by a set of very decent looking hooligans when the next train came. After that movement, I really became one of them and any one could see the same fire in my eyes.
I finally got in and felt elevated about the herculian task I had just finished, but to my dismay I found the challenge had just began as I was standing in way of people who wanted to get down
at the next station.

October 1st:
0840 hrs: Nearly ##(couldnt count because of my concentration) pair of eyes zoomin on a location
and I made it(dont know about the rest as I was the first).

After a month, I started enjoying the whole experience. In retrospect I feel, the first step is often the most difficult and the most important one to take. Things do get easier as time goes by.

I dont know when I will be taking my first step.

Changed Address!!!!

2007-09-30T06:59:00.000-07:00

The idea of buying my domain had been there in the back of my mind for quite some time.
Finally I bought one and have changed the blog address from pvsun.blogspot.com to blog.pvsundarram.com.
All the old links will still work!!!!.
Looking forward to buy more in the future....

Missed it this time!!!

2007-09-30T06:36:00.000-07:00

I went for a walk in the ground near my house, and I found lots of people working on something huge. After looking more closely, I couldnt determine what they were really trying to do. As Ganesh chathurthy was nearing, the artists were adding finishing touches to what they were doing. I could hardly believe my eyes, when I saw what they did just after 10 days. It was like a full blown ship!!!!

This photo was taken at 00:30 hrs from a distance of more than 400 meters and the place was still buzzing with people.

If you are wondering where this photo is coming from, you can check zoom.in.
Tags: ganpathy

OOPS in JavaScript : Part II

2007-08-10T12:33:00.000-07:00

In JavaScript we might not need inheritance all the time but as the applications gets complex we might need more structuring of code and also for reusing it. Inheritance according to Mozilla's documentation states that we need to copy the prototype of the base class to the Sub Class. You might ask why. The reason is 'Prototype' is nothing but the Structure of a object and this structure is shared across all the instances of the Class. When a property is added to a object dynamically, it is only for that particular object and not the whole class. On the other hand, when a property is added to the prototype, that property gets added in all the instances of that class. This might sound a little confusing, but thats the way the language works.
We will have to be very disciplined when we are writing a application partly because the language is dynamic and very flexible. We should follow some good practices while doing inheritance,
1. Avoid adding of properties to objects inside the functions dynamically(that includes the constructor) and always add them to the prototype object. In this case we might not be utilizing the full power of JavaScript, but then all the properties will not get inherited. The properties which are dynamic in nature does not get copied to its subclass.


BaseClass Definition
:
:
myFunction : function(){
    this.newProperty = 0;
},
:
:

2. A very common mistake one can make is after inheriting, they replace the prototype of the subclass object.


inherit(BaseClass, SubClass);
SubClass.prototype = {
:
:
};

3. Avoid adding properties to prototype of BaseClass after inheritence, it makes the code very confusing and unreadable to others. But it will get reflected in the SubClass.


inherit(BaseClass, SubClass);
BaseClass.prototype.xyzProperty = QWER;

There are many approaches to do a extend, but it is very difficult to do a true extend in a dynamic language, because properties can be added dynamically. One should take a approach depending on the way they organize their code.
Now after knowing the donts, we will have to write our own extend function or use a function from any library you like. I am not going to re-invent the wheel(I might be taking a fairly similar approach), I will just explain the extend function of YUI.
Original Code


extend: function(subc, superc, overrides) {
        if (!superc||!subc) {
            throw new Error("YAHOO.lang.extend failed, please check that " +
                            "all dependencies are included.");
        }
        var F = function() {};
        F.prototype=superc.prototype;
        subc.prototype=new F();
        subc.prototype.constructor=subc;
        subc.superclass=superc.prototype;
        if (superc.prototype.constructor == Object.prototype.constructor) {
            superc.prototype.constructor=superc;
        }
    
        if (overrides) {
            for (var i in overrides) {
                subc.prototype[i]=overrides[i];
            }

            YAHOO.lang._IEEnumFix(subc.prototype, overrides);
        }
    }

After checking the arguments, they create a new dummy class. The prototype of Super Class is then copied to this dummy class. The reason being that in JavaScript everything is a reference and if the prototype of Super class is copied directly to the Sub class, then the Sub Class and the Super Class will be referring to the same prototype. This can be catastrophic. For this we will have to separate the prototype of Sub Class and the Super Class. While inheriting, we will have to call the constructor of the Super Class to initialize. Thats why they are adding a property superclass and assigning the constructor to its prototype's constructor. Apart from that, the guys at yahoo have made sure that derived object has all the enumerated functions when it is overridden(this is a problem in IE). Not only we are reusing the code, we are also reusing the research that went into building the library. And if they had not documented(comments) it in their code, it would have probably never been discovered by others.
Tags |- sun | pvs
| oops | javascript

After a long time.....

2007-08-10T04:55:00.000-07:00

Finally after a month of inactivity i am back...
I couldnt manage to come online for the past one month(i dont know how I survived this) partly because i quit my job at tutorvista..
I had not at all planned it... but it happens to everyone of us all the time...
Now my mind is vascillating between working in a startup and start something on my own...
Tags |- sun | pvs
| |

OOPS in JavaScript : Part I

2007-07-03T22:11:00.000-07:00

Every one of us knowingly or unknowingly uses OOPS in JavaScript. Every function and every global variable we add in the script is actually a property of window object. The DOM API is also a very powerful API which we extensively use. There are no Classes( in actual sense ) in JavaScript.
But first one should understand why we go for OOPS, two of the main reasons i see are code maintainability and extendability. For instance YUI Library is extensively used by many big sites, the code is getting reused everywhere and libraries like the yui-ext are extending it and taking it to the next level. And thats power... General developer mentality is "i'll do it myself"... Its very natural, but has its side effects of reinventing the wheel again and if we are going to take the same approach i don't think there is a point in reinventing it.... Better would be extend the code that is already there( should be well written and extendable ;-) ) and take it to the next level...
OOPS is intended for greater flexibility and maintainability, that IMO is achievable in JavaScript.

Classes
There are no classes in real sense of the word in JavaScript. Every function, every property( except the native ones like number, string... ) are objects. Any function can be a constructor to the class. All functions are a instance of Function.


/**
 * @class MyClasss
 * @constructor
 * This is my class constructor
 * @param {Object} argument1 first argument for configuring properties of the objects
 */
function MyClass (argument1)
{
    //some constructor code
    this._config = argument1 || {};
}

The properties to the object can be added in run-time. The prototype property determines the initial structure of the object( thats why they call it prototype and it is a property of Function ). But it is a good practice to define all the properties that will be used in the prototype object. Which can be added like this


/**
 * @method MyClass
 * this is my first method
 */
MyClass.prototype.myFunction = function () {
    alert('hello world');
};
/**
 * @type String
 * @property name
 * name of the instance
 */
MyClass.prototype.name = '';
/**
 * @private
 * @type Object
 * @property _config
 * configuration object
 */
MyClass.prototype._config = null; //default value

Here if you notice it is practice and not a must because properties to the objects can be added on the fly thats why all the objects are unique and thats why there are no classes in JavaScript. If you see the above code, the property _config is marked private but it is not actually private. In JavaScript there are no scopes for properties of objects. To put it differently all properties of an object are public.
Whatever has been done so far is just for making the code extendable. There are other approaches to OOP like


var myObj = {}; // one way to create a new instance
//adding method to the object
myObj.myFunction = function () {
    alert('hello world');
};

But the biggest problem with the above approach is it is not extendable.
One can also add static properties to the class.


/**
 * @method MyClass
 * my static method
 * @static
 */
MyClass.myStaticFunction = function () {
    alert('my static function');
};

If you notice closely we are not adding this property to the prototype object but we are adding to the 'MyClass' itself. This is shared across all the instances of the MyClass. The use of 'this' in static methods will refer to MyClass and not the instance and also reference to any other static property via 'this' is not possible. Now that we have created a class-like structure we can now create instances of the MyClass.


//creating a new instance.
var myObj = new MyClass();

The 'new' operator creates a new object with the structure of MyClass.prototype and then calls its constructor viz. MyClass. The constructor does some initialization and the object is returned to myObj. In JavaScript objects are passed by reference. Here i am not passing the parameter in the constructor. It is not mandatory to pass the required arguments to any function( including constructor ). The memory will not get released if there are any references to that object.
If you notice carefully we are actually adding properties to the prototype object on the fly. You can access the properties of 'myObj'.


myObj.myFunction();

Tags - sun pvs oops javascript

Whiteboard / Chat released....

2007-06-27T08:27:00.000-07:00

We released the Whiteboard / Chat after working for more than 50 days( & nights ofcourse)...... Anyone can check the new Chat and Whiteboard @ tutorvista.com and by clicking on the 'Try it Now!' button.
Tags |- sun | pvs
| TutorVistaNow

Coding conventions and practices.

2007-06-10T05:55:00.000-07:00

Lately i have become a big fan of javascript for its flexibility and expressiveness. It is fragile(depends heavily on the programmer) but a very expressive language. And halfway down the product i have come to realise that its expressiveness and flexibility makes reading of someone else's code difficult. But in a team, the team has to follow similar set of conventions so that everyone else's code doesnt look odd to each other in the team. And this is very important in a very small team, where this can lead to altercations. To avoid such a situation, we have adopted our own set of coding conventions inspired from Java Coding conventions and the one from Douglas Crokford.
The main inspirer had been the YUI library, though one looking at their code closely could find out that there are subtle differences but at a higher level they all look the same. At YUI library they spend a lot of time(i guess) to make the code look fabulous and elegant. Any code starts with looking elegant but later becomes very ugly and unmaintainable, but no one can avoid such a situation. At that point of time someone has to step-in and say, the code has to look elegant and maintainable and refactor the code. This does take time but is very useful in the long run when the product matures its maintainability becomes more important or the other alternative will be to rewrite the whole product from scratch(This happens in most companies). With a very short product deadlines it becomes very difficult to do so, but we will have to set ourselves some time for looking back at what we did and correct the things we would have knowingly or unknowingly done the wrong way.
Tags |- sun | pvs
|

'>returnable

2007-05-19T00:56:00.000-07:00

Bhasker V Kode alias Bosky has written a nice and very useful library for delivery of content and the best part is its very easy to use. I have added the returnable widgets to my blog. as you can see that u can add just about anything to that widget..
I have added an iframe to view the returnable.org just hover over it to see the widget at work...

to add it i have included the javascript file in my template, and added this returnable tag and viola!!!!!.... It just works.....

great work bosky!!!!!keep ur gud work going!!!!

Tags - widget bosky returnable sun pvs

An Irony.....

2007-05-04T06:25:00.000-07:00

I saw the site of The Ajax Experience Conference by Ajaxian.com which hardly has any AJAX Eperience in the site.......

My post at the startup blog

2007-04-18T12:31:00.000-07:00

Just Thinking Aloud........

I saw my friend bhasker edit some of his files in his desktop, and then was pushing the files to his webserver hosted at godaddy. Then something struck me................. more

Tags |- sun | pvs

actionscript 3.0 and sockets.

2007-03-03T12:09:00.000-08:00

While doing scheduling i learnt a lot about what not to do. Looking at it now, i feel that scheduler had been a victim of premature optimization. I wanted to make it really fast and went all out to do just that. And tried optimizing everything rite from the begining, and ended up screwing the readability and maintainability of the code. As time passed changes started becoming difficult, and the optimizations that were done initially became pointless. I then realised that i should have done optimization after the basics were finished.

I then started working on client(again), the one which i had left unfinished. After looking at the stats provided in adobe site, we decided on flash player v8. This supports actionscript 2.0. Main reason for choosing flash was that it was truly platform independent(unlike java ;-) ), and it could open sockets. The class XMLSocket in actionscript 2.0 adds a null byte(/000) to the end of any string it sends via the socket. The server which was reading it did not understand, and treated this as end of XML stream, and used to throw back xml-not-well-formed-error. I was breaking my head for the reason why this error message was coming from server. Then finally after some investigation we found 2 things which made xmlsocket unusable for client,
1> it doesnt support xml v1.0.
2> it adds null byte(/000) to the end of the string.
finally dumped actionscript 2.0 and then did one test in actionscript 3.0 and it just worked without any problems(used Socket and not XMLSocket).
Tags |- sun | pvs
| actionscript

Been Long Time

2006-11-19T14:10:00.000-08:00

Its been a long time since i blogged... part of the reason being i was working on a scheduler.... once i finish the framework for scheduler, i ll be back with what i was trying to do, and whatever i had learnt the hard-way while solving an age old problem of scheduling......
Tags |- sun | pvs

a nice video i liked and links.....

2006-10-26T22:52:00.000-07:00

Web marketing ideas and tips(101)

Use the title and meta description tags as wise as possible. They are your best choice of avoiding supplemental pages. Try to make each page with it’s own unique title and description, and never repeat more than 20-25% of the title and description tags content on different pages. Use a limited number of characters (8-10) in the title tag, and put the most important of them, relevant to each page, at the beginning.

A blog just about google products

Google has created some pages for the upcoming Halloween. On Google Video, you can find 14 short videos, including a teaser for "Hood of Horror". Google Books features a big list of famous scary stories, like Bram Stoker's Dracula or Mary Shelley's Frankenstein.

benchmark of languages.....

2006-10-25T23:45:00.000-07:00

While googling i found this....

Check it out..
Tags |- sun | pvs
| benchmark | language speed

good jokes i found while googling

2006-10-25T01:13:00.000-07:00

# Me: "What compiler do you use?"
# Him: "Well, Qbasic is my favorite."
# Me: "Nobody over the age of eight uses QBasic for serious purposes."
# Him: "But they made windows with QBasic."

I have a small anecdote of what happened in my class in our college.
Student: M'am, can you suggest any topic for my project?
Teacher: I ll have to think about it. But i dont have time.
Student: Please tell it to now, so that i can start working on it.
Teacher: Why dont you do VOICE CHAT IN TAMIL.
Student: Mam!!!But...
We were all laughing by then.

check it out
funny | jokes | sun | pvs

6 Must have Tools for web2.0 application development

2006-10-23T04:40:00.000-07:00

For proper development of any application, a developer needs an editor and debugger. PHP and javascript are the technologies i am considering for serverside scripting and client side scripting respectively.
First lets look at the editors that are available for free.
1. vi
Who can ever forget vi. Thats one of the best editors i have ever seen in my life. Any one familiar with *nix would have used this editor. This can be your choice of development if you want a fast, simple ,small editor then vi is just the right editor for you. But it takes time for you to get used to it.
2. PHPDesigner 2005
This is a good editor to start off with, if you want an editor not taking much resources but still helpful, this is just right for you. I have seen the later versions of phpdesigner, which i found very buggy and taking too much resources. This version is best of the lot.
3. PHPEclipse (php)
If you want an IDE, then you can go for phpeclipse plugin for eclipse. I have used the plugin from zend, its very buggy and is not that good. PHPEclipse plugin has been there for a long time compared to the zend plugin, and has matured over the time. You can find a tutorial for installing phpeclipse here .
4. JSEclipse (javascript)
This is a plugin to eclipse ide.There is a community version available for this plugin. It uses almost all the features of eclipse.If you are planning to use it for commercial purpose i'd suggest you buy it.
5. Aptana (javascript)
There is a aptana plug-in for eclipse. This comes bundled with some of the most used AJAX libraries like yahoo,dojo... Even this plugin uses all the features of eclipse.
After choosing the editors, we need to choose some tools for debugging.
6. DBG Debugger(PHP)
This debugger has to be installed in your webserver. The debugger client is built in phpeclipse plugin. There is a tutorial for howto install dbg debugger here.
7. Firebug extension for firefox (javascript)
This extension is very useful in debugging javascript. You can also use venkman javascript debugger, but i found firebug to be more useful and faster when compared to venkman.
8. Live HTTP Header extension for firefox
This is very useful for debugging web2.0 based applications. This extension is useful for monitoring the http requests going out from the browser. There is a replay feature in this extension which is very useful.
9. IETab extension for firefox
This extension is a very useful extension, for viewing how the site behaves in ie. It basically creates a new tab where ie is embedded in it. This will reduce a lot of pain especially when you dont want to switch windows while using firefox.
10. Server Switcher extension for firefox
This extension is very useful for switching between the developer server and the live server. This will help reduce a lot of time and irratation while development.

By choosing a suitable editor and the above tools, the application development becomes a lot easier. There are other editors and tools which i havent mentioned. most of them i think were redundant or werent that good when i had used it.

happy ajaxing!!!!
Tags :
web2.0 | ajax tools | editor |sun | pvs

Funny link on web2.0

2006-10-23T02:10:00.000-07:00

While googling i found this oliver widder's blog. it was funny and different....
|sun | pvs

DataStructures and algorithm

2006-10-15T21:38:00.000-07:00

This blog is an effort to help people understand the basics of programming, data structures and algorithms. This blog doesnt have any mathematical equations,this blog is purely for programmers.....A must read for anyone trying to learn datastructures

read more | digg story |sun | pvs