Non-Secured ,Semi Secured & Most Secured companies to work with in India

Non-Secure IT companies in India

1) IBM --- Right now this is the most firing company for IT professionals. In the last 6 months, this company has fired nearly 20% of their employees because of BG check and performance issues. This is the most insecure company from an IT professional's point of view. They don't have any strategic plans at HR policies regarding employee security. No appraisals (maximum 10%).


2) TCS --- Previously its an government IT Company . Now a days TCS also becoming firing IT company. Recently they fired on 500 people.( the people below 2 years of experience) and TCS lost so many projects recently( especially British Telecom Projects).


3) Accenture --- This is second top most firing company. The firing rate is around 5%. This depends upon outsourced projects; they have a unique system where Accenture development centers around the world bid for a project coming into the company. Currently Philippines centre is taking the cake and the Indian centers are in a firing mode.


4) WIPRO --- Firing people with very frequent back ground checks and firing them with out even experience letters and relieving letters (will mention as terminated from services)but will promise the employees that they will retain them. After the project is over they will fire away. Will threaten of criminal cases against such employees if they oppose the move and has also filed against some.


6) Intel --- Recently joined the league. Running in heavy losses, hence firing 3000 employees in the Bangalore center in a phased out manner.


7)CSC --- Excellent package but fires folks in Background check and those on bench regularly. Recently fired 400+ employees from its subsidiary Covansys.


8) Satyam --- Currently stopped firing. The Attrition rate is very high. No firing from 2009 jan until now when 1000 employees were fired in Hyderabad.


9) Patni ---- They fired so many employees that currently they are facing understaffing and deficiency with number of employees. Very high attrition rate.


10) Keane India ---- This USA based company is always involved in firing employees. Although they proudly say that they don't have hire and fire policy. Recently they fired Java and as 400 professionals after which most of the employees have started to pack their bags. Employees change this company within 1 year.


*************So take care before accepting offers from these companies.


Secure IT companies in India


1) Microsoft --- Has projects till 2050.


2) EDS --- Most secure company in India. Not laid off any of its employees even during 2001. Has lots of projects in Defense and financial areas


3) HP --- Dream Company. In-house and outsourced projects


4) Infosys --- Dream Job. On a way to achieve the status of a secured, stable Govt. company. but the real problem is all with the work culture


5) AOL, Google and Yahoo - Best companies to work with, great job satisfaction as well as great salary and work environment. Rarely fires an employee. As they are internet based companies' they offer lots of opportunities to grow.


6) HCL -- A good company to be in. Called as a "retirement company."


7) HSBC--- This is the most secure company. It has never fired any employee, even when they know that the employee is showing fake experience.


8) CTS --- The Best Service based Company in today’s IT industry round the Globe which never fired a single employee even during recession, but the real problem is with the attrition rate which is about 29% by the end of dec 2010


9) Aricent--- a communication based software company, has never fired any employee and gives great perks & incentives, lot of projects in kitty. Minimal level of attrition.


10) KPIT Cummins Info systems Limited ---- This is the most secure company not known to many. It has presently acquired CG Smith, Bangalore and has lots of projects in pipe line. Acquisitions plans will continue.

Lambda Expressions Document

I am pasting the link that contains the Lambda Expressions document.

https://docs.google.com/leaf?id=0B9TnMbt-PylYMjBjNjgzYWUtNGJmYi00ZWQ3LThlNTctM2FmY2Q1MDVlZWQ3&hl=en_US

Download the document for better alignments.

Lambda Expressions

Linq is always associated with Lambda Expressions. In .NET 2.0 we have the concept of Anonymous Methods that allows you to write function body inline without the need of writing a delegate function. Lambda Expression of .NET 3.5 is too concise the concept of Anonymous function writing.
Let us take a look of how to write Anonymous methods in C# 2.0.

int i = this.compute(10);

private int compute(int value)

{

return (value + 2);

}

It is very normal example of a function call. The compute function is called when the line i=this.compute(10) is called. We can replace the above code with inline anonymous function like this:

//C#

delegate int DelType(int i);

DelType dd = delegate(int value)

{

return (value +2);

};

int i = dd(10);

In the 2nd Case we can see that just declaring a Delegate and giving instance of that delegate type we can easily manage to write anonymous methods. .NET 3.5 puts forward this concept a little more compact. We can take the use of => operator which is introduced in .NET 3.5. It gives more flexible and easier way to write expression. Lambda Expressions can be used in the previous case to get the result like this:

delegate int DelType(int i);

DelType d = value => value + 2;

int i = d(10);

Thus the delegate type is assigned directly. The meaning of the line value =>value + 2 is just similar to declaring a function. The first value indicates the arguments that we pass in a function and the one after the "=>" operator is the body of the function. Similarly if we want we can feed in as many arguments as we want to. Just in the following examples:

// Method with 2 arguments

delegate int DelType(int i, int j);

DelType d = (value1,value2) => value1 + value2;

int i = d(10,20) // Returns 30

In this example we passed in 2 arguments to the function and returns the result. You may also wonder how I can write a lambda expression when your function body takes more than one expression. Don’t worry, it’s simple. Take a look at the following example.

// Multiline Function Body

delegate int DelType(int i, int j);

DelType d = (value1,value2) => {

value1 = value1 + 2;

value2 = value2 + 2;

return value1 + value2;

};

Thus we see writing Lambda expression is very easy. This comes very handy when working with linq, as most of the extension methods that are associated with Linq takes function delegates as arguments. We can pass simple delegate function body easily to those functions to perform work easily.

Generic Lambda Expression

However, whenever a lambda expression is required, we need to define a delegate type for this. This is very awkward and less productive. .NET 3.5 introduces generic delegate which simplifies the lambda expression much better and simpler. It provides two pre-defined generic delegates Func and Action. Using these delegates, you do not need to explicitly define a delegate. The difference between Func and Action is the return type. Func supports return type however Action supports methods with void return type. These delegates provide a set of pre-defined signatures that are ready to use.

// Pre-defined Func delegates

delegate TResult Func();

delegate TResult Func(T1 arg1);

delegate TResult Func(T1 arg1, T2 arg2);

delegate TResult Func(T1 arg1, T2 arg2, T3 arg3);

delegate TResult FuncT1 arg1, T2 arg2, T3 arg3, T4 arg4);

// Pre-defined Action delegates

delegate void Action(T1 arg1);

delegate void Action(T1 arg1, T2 arg2);

delegate void ActionT1 arg1, T2 arg2, T3 arg3);

delegate void ActionT1 arg1, T2 arg2, T3 arg3, T4 arg4);

As mentioned above Func and Action provide very lighter syntax which avoids the need to declare a Delegate type for a lambda expression. Code 1 shows the usage of Func.

// Code 1

// Generic Lambda Expression Usage

Func Square = x => x * x;

int result = Square(4);

Console.WriteLine(result); // 16

Delegate type declaration is not necessary when using generic lambda expression. In Code 1, you can see that Func Square provides parameterized type for the expression x => x * x;. This enables the C# compiler to infer the type detail of x. Note that delegate type declaration also provides type details to C# compiler, however this syntax improves developer productivity. This satisfies factor #3 Parameterized types. Let us see one more example (Code 2) using generic lambda expression which satisfies next two functional factors.

// Code 2

// Generic Lambda Expression Usage

List primes = new List();

List primeCubes = new List();

// adding set of values to primes

primes.Add(2); primes.Add(3); primes.Add(5); primes.Add(7);

// iterate through primes elements and calculate cube and

// add it to primeCubes using Action action

primes.ForEach(x => primeCubes.Add(x * x * x));

foreach (int i in primeCubes)

{

Console.WriteLine(i);

}

ForEach in .NET 3.5 generic collections requires Action type, here Action. The line primes.ForEach(x => primeCubes.Add(x * x * x)); shows how C# 3.0 allows you to easily pass a method as an argument to a method. Here x => primeCubes.Add(x * x * x) function is passed as argument. This proves that C# 3.0 satisfies functional factor #4 high order function. In this example, you can also see the immutability nature of .NET 2.0's collection types so that I have used one more List type primeCubes.