Chakravarthy's Space : First

Standards @ Microsoft

Chakravarthy — Tue, 08 Jan 2008 07:08:07 GMT

With the new year roll out, Microsoft has initiated a new website with the caption as mentioned at the subject of this post. Yes, they are starting a new initiative with all the Standards that are in place with the industry giants and the best out of Individuals, Corporations, Acadmics, who not ... every one ..

http://www.microsoft.com/standards/ is the link for all such standards. The initial thought for this resulted from the Interop team. They have a separate home for them as http://www.microsoft.com/interop. The history has 2 yrs old story to come out with such standards towards Interoperability. And finally they are with the standards that are in best practice with industry.

I just started going through one by one.. did you ??

The importance of 'Return' keyword at JavaScript

Chakravarthy — Sat, 15 Sep 2007 12:26:53 GMT

Recently, while coding for a Text Field value padded with left zeros, realised the importance of the RETURN key word for the FUNCTION written in JavaScript. Before i mention the actual importance, let me describe you the situation.

Scenario: A Text box need to be padded with zeros and should have the length of 7 digits, even the data entered is less than 7.

Ex: When the key board input being 88, the text box should show 0000088. Note the ZEROs padded on left.

So, started with a JavaScript function as mentioned below

function PadZeros(x)
    {
        var v = x.value;
        while(v.length<7)
        {
            v = '0' + v;
        }
        var ss = document.getElementById(x.id);
        ss.value = v;
    }

After this, the text box is padding with ZEROs and the code is perfectly running. To allow this to code execute for any given text box, all you have to do is, add the ATTRIBUTE to that text box. And while adding keep one thing in mind that, we would be calling this function on BLUR, ie., LOST FOCUS of the text box. The code is as mentioned below.

            this.txtPCode.Attributes.Add("onblur", "PadZeros(this);");

Please note the 'this' keyword. The usage of 'this' keyword has many possibilities. Let me see that, one day will post where the 'this' keyword is used and their context. And also note that, neither the function is returning any value nor the text box is added with the code that handles the output of the function. Will come to that in short.

Every thing is working perfectly well and going on smooth. But suddenly, i realised that the text box is just padding ZEROs when there is no Input. I see all ZEROs in the text box as 0000000. Then came the real trick to the function.

function PadZeros(x)
    {
        var v = x.value;
        if(v.length == 0)
        {
            var vTe = document.getElementById(x.id);
            vTe.focus();
            alert('Please enter Provider Code .. ');
        }
        while(v.length<7)
        {
            v = '0' + v;
        }
        var ss = document.getElementById(x.id);
        ss.value = v;
    }

What do you see here is the mechanism to set the focus back to the text box. Great... but that even is not solving my purpose of leaving the text box blank when there is no input. This function is still adding ZEROs to no input and showing all ZEROs. Then came the purpose of the 'return' keyword. The entire requirement is simply solved by this keyword. All i've done is.. changed the code as mentioned below.

function PadZeros(x)
    {
        var v = x.value;
        if(v.length == 0)
        {
            var vTe = document.getElementById(x.id);
            vTe.focus();
            alert('Please enter Provider Code .. ');
            return false;
        }
        while(v.length<7)
        {
            v = '0' + v;
        }
        var ss = document.getElementById(x.id);
        ss.value = v;
        return true;
    }

At the code behind added 'return' as shown here

            this.txtPCode.Attributes.Add("onblur", "return PadZeros(this);");

That's all.. hoollaa... What do you say ?

Technorati Tags: JavaScript, PadZeros, return

C# 3.0 - What's New : {Implicit}-Part1

Chakravarthy — Fri, 24 Aug 2007 05:33:00 GMT

Recent development in my technical life is that, started working out with Orcas Beta 2. So, thought to blog about the latest happenings with C# language. The idea emerged to start a series of posts related to C# new features. This is the first of ever such kind of blogging specific to a topic.

C# 3.0 has many-a-new features. To start with, let me take a concept of Implicitly Typed Variables.

Implicitly Typed Variables

In the good old days, the developer has to worry about the type of the variable. Say for instance, whether to use long or double for a counter. Here all that we observe is that the language that is built upon is the type specific. Hence forth the developer is not required to define the type of the variable at the time of declaration, but it is the task of the compiler to decide what type of the object the variable is. All that the developer has to do is that, use the var keyword while declaring the variable, similar to that of JScript or Visual Basic style. Hey!!! Stop!!!!! don't get confuse with the type of VAR variables declared at JScript or Visual basic.

Let's first discuss the difference between VAR variables at JScript and VAR variables of C#

VAR JScript	VAR C#
This is of no type	The type of the variable is defined by the value declared and decided at the compile time
Technically have no type. Can consider of limited types, namely, string literal, numeric, boolean	Type agnostic, have specific predefined formats
Type conversion is coercion	Type casting is simple and handled by CLR
No mechanism for parsing	explicit functions for parsing to specific type

Now, let us see the difference between the language specific VAR of VisualBasic 6.0 and C# 3.0

VAR in VB (but not .NET)	VAR in C# 3.0
By definition, these are Variant	Type of the variable is defined at the compile time
Could be any allowed type from with in the known types of the language	Type is decided by the value associated with the variable
Largest among all the known data tydpes	Size depends on the type of the value initialised

To summarize, the variables declared in C# 3.0 are type specific, thou used the key word VAR, during the declaration. Thus, we can conclude that the compiler is the responsible point to decide the type of the variable. Hence we can say with comfort that, the variables from C# 3.0 are Implicitly Typed variables.

Some examples as mentioned below.

            var vIntVal = 10; // This will be the System.Int32 type
            var vLongVal = 10000000000; // This will be the System.Int64 type
            var vDoubleVal = 10.0; // This will be the System.Double type
            var vFloatVal = 10.0f; // This will be the System.Single type
            float vFlVal = 10.0f; // Thou defined using float key word, but inherits from Struct System.Single 
            var vStrVal = "String Value ";  // This will be the System.String type

So, from the above declarations, it is pretty clear that the variable is defined by the value associated during the declaration. The type is not just limited to the kind of data types as explained above, but you can extend this to any type of the variable that you use while writing code for iterations, similar such as foreach. Below is the example for other known types.

            foreach (var vTable in ds.Tables) // Implicitly declared a variable of Data Table Type
            {
                foreach (var vRow in ((DataTable) vTable).Rows) // Implicit declaration of DataRow variable
                {

                }
            }

By using such, one can extend any extent. The limit is the imagination of the developer. What do you say?

Source:

1) http://cobdev.cob.isu.edu/psb/jscript/306.htm for JScript
2) http://www.1sayfa.com/1024/diger/vb/ch07.htm for Visual Basic 6.0 Datatypes

del.icio.us Tags: CSharp, 3.0, Code, Tips, Implicit

Tafiti Search Engine from Microsoft

Chakravarthy — Fri, 24 Aug 2007 03:10:10 GMT

Tafiti, which means "do research" in Swahili, is an experimental search front-end from Microsoft, designed to help people use the Web for research projects that span multiple search queries and sessions by helping visualize, store, and share research results. Tafiti uses both Microsoft Silverlight and Live Search to explore the intersection of richer experiences on the Web and the increasing specialization of search.

My experience with Tafiti is awesome. It is a great visual treat. The features as of now I found to be great is the type specific.

In other words, as you could see here when you search for any topic, you could filter them specific to the icon displayed here. You could filter the RSS feeds, Blogs, Images, News, as of now. Probably, they would come out with lot more.

All these days am a die-hard fan of godark.us due to the search in black for google, not any more. Secondly, am not sure about the content relevance percentage of the search. Time will prove the statistics.

Apart of that it also has the mechanism to save the search onto the right side of the visible area.

So that you don't require remember for a specific search.

True that, it installs the Silverlight component. But silver light is going to be the future for streaming videos on web.

And one more thing, can I consider this as stack of my searches????

What do you say?

del.icio.us Tags: SilverLight, Tafiti

Runtime Polymorphism

Chakravarthy — Mon, 20 Aug 2007 11:00:50 GMT

One of the frequently seen situations from a technical standpoint in a large scale of Business Layer objects is, invoking methods from different objects when they contain same method name. Today, am going to make it simple to give an example for Runtime Polymorphism. Leave your comments if am mistaken

At this stage, I don’t think to mention about "Polymorphism", as hope that you are aware of how polymorphic behavior can be fused using C#. If you want a start up, in simple words, implementation of one Method with many definitions, as mentioned below.

class Employee
{
/// <summary>
/// Invoked for the Regular salaried employes
/// </summary>
/// <param name="intEmpId">Employee ID</param>
/// <param name="intAbscentDays">Number of days</param>
/// <returns></returns>

public long CalculateSal(int intEmpId, int intAbscentDays)
{
return (GetEmpSal(intEmpId) * (GetWorkingDays(DateTime.Now.Month) - intAbscentDays));
}

/// <summary>

/// Invoked for the employees, who work as Daily wage
/// </summary>
/// <param name="lSalPerDay">Salary per day</param>
/// <param name="intDays">For number of days</param>
/// <returns></returns>
public long CalculateSal(long lSalPerDay, int intDays)
{
return lSalPerDay * intDays;
}
}

A simple way of invoking is as mentioned below.

Employee eTe = new Employee();

long lSal = eTe.CalculateSal(124, 2);
long lSal = eTe.CalculateSal(678.35, 18);

So, by now, you are clear how to write polymorphic method and as well as how to use. Let’s jump to how you can make the Runtime Polymorphism.

To continue the discussion, first we need to know that there are 2 basic types of polymorphism. They are, Overloading, referred as Compile time polymorphism, and Overriding also called as Run-Time polymorphism. What you have seen above is the first kind of polymorphism. The second type is referred as late binding. In other words, the selection of the method for execution at runtime depends on the reference of the actual object that is triggering the invoking of the method. Now let's explore that with some example.

Let us take a small class, as mentioned below with few properties. This class acts as a base class for us.

    public class EmpNames
    {
        public string FirstName { get; set; }
        public string MiddleName { get; set; }
        public string LastName { get; set; }
    }

We will now inherit this into the following classes. Observe that the both classes doesn't have any direct relation with each other and can be instantiated as is.

    /// <summary>
    /// This class calculate the wages for given number of days
    /// </summary>
    public class Wages : EmpNames 
    {
        /// <summary>
        /// This will calculate the wages for the employees
        /// </summary>
        /// <param name="Params">Wage per Day, Number of Working days in a month</param>
        /// <returns> WagePerDay * WorkingDays </returns>
        public double CalculateSalary(ArrayList Params)
        {
            return double.Parse(Params[0].ToString()) * int.Parse(Params[1].ToString());
        }
    }


    /// <summary>
    /// This class will calculate the salary
    /// </summary>
    public class Salried : EmpNames
    {
        /// <summary>
        /// This will calculate the salary for the employees
        /// </summary>
        /// <param name="Params">Working days Per Month, Leaves, Salary Per Month</param>
        /// <returns> Full Salary in case no value for Leaves. Other case, (SalaryPerMonth/WorkingDays) * (WorkingDays - Leaves) </returns>
        public double CalculateSalary(ArrayList Params)
        {
            double dSal=double.Parse(Params[2].ToString());
            int intLeaves = int.Parse(Params[1].ToString());
            if (!intLeaves.Equals(0))
            {
                int intWrkDays = int.Parse(Params[0].ToString());
                dSal = (dSal / intWrkDays) * (intWrkDays - intLeaves);
            }
            return dSal;
        }
    }

Now that we have these two classes, We can write our code to instantiate them as individual. But the point of this post is to describe the "RunTime Polymorphism". Before we go further, note that, each class has the method "CalculateSalary" and as they are not directly related, you can instantiate them with out any hassle.

            EmpNames empObj;

            ArrayList alValues = new ArrayList();
            alValues.Add(30); //Just add all the fields as this

            bool bSalaried = true; //am using this variable for validation of emp

            if (bSalaried) //Validating whether Salaried or Wages 
                empObj = new Salried();
            else
                empObj = new Wages();

After executing the above lines of code, you are sure about the type of the variable empObj. This is Runtime initiating the object. But this is not the purpose of our current topic.

            double dVal;

            //The below line will throw compile time error
            //dVal = empObj.CalculateSalary(alValues);
            dVal = ((Wages) empObj).CalculateSalary(alValues);

What do you see from the last line of the above code? Did you find that the method invoked is from a class type. Now, think that, what if the class is being instantiated as Salaried and the last line is being invoked?

This is called as RunTime Polymorphism.

del.icio.us Tags: Runtime Polymorphism, CSharp, Tips

-----------------------
Declaimer: What ever you read here is out of my own experience. No one shall be made responsible for the contents and issues that are mentioned here. If you have something to share in person on this post, pl drop me a mail at dskcheck@gmail.com with the title in the subject.

PaaS or SaaS

Chakravarthy — Thu, 26 Jul 2007 12:37:52 GMT

There is a big debate going on with these two buzz words. Before we get to the point of this post, let's first examine what they are... and what they mean by to the development force.

SaaS : By definition it goes like this, Software As A Service. In the good olden days, we are used to think the application as whole system and all the modules have to function only with in. But as the technology evolved and the new horizons are leading the development process to newer levels, we got a new dimension as "Web Service". This concept then further raise the functionality of the individual modules belonging to the big application turn into smaller parts of reusable components by other applications as well. Resulting the module as a service altogether for any and every consumer application.

This left the architects to view their application in smaller, exportable as well as consumable by different vendors or applications. This led to the concept of designing every application to foresee the reusability and come up with a kind of an architecture, so that every module inside the application is targeted as service. Hence the concept of "Software as a Service"

PaaS : By definition it goes like this, Platform As A Service. In the recent days, the paradigm of application switched over from an individual point of a specialized vertical to the combination with the external functionality as well. As mentioned above, the applications started consuming the Services from external world and expanding their domain functionality. The industry is not just satisfied there with.

Some thing more wanted and flexibility with in the application brought the idea of "Platform neutral" into limelight. Resulting that the application concept attain the new veneer. The architects started visualizing the need for the application platform, as a whole, to be flexible enough to work as a service. Leading to the new scope of web availability to every anonymous user.

-------------------------------------------

This is my first post that ever made me to think very deeply and came out of my own words... How is this ?

del.icio.us Tags: SaaS, paaS

Technorati Tags: PaaS, SaaS

Posting from Live writer

Chakravarthy — Thu, 21 Jun 2007 07:45:37 GMT

This is my first post from Live Writer Version 1.0.

My first Post

Chakravarthy — Fri, 19 May 2006 12:57:00 GMT

Today, i'm going to talk about "XML DOM functionality in .NET applications" for the first time at B.NET offline meeting. Inspired by Ken Getz talking about the same such, decided to talk with B.NET offline meeting and mentioned that all credit goes to Ken.