Visual Studio 2010 has simplified the numbers of editions
Good riddance to the Visual Studio 2008 mess of Team System x / Team Suite confusion.

But what's in each version?

Express
What's missing: Unit testing (use NUnit), add ins (not even Coderush Express), source control integration (use file system level tortoiseSVN).
Good for: simple home use, and even then a serious developer will find it lacking (esp no Resharpher/ CodeRush)

Professional
Has addins, MsTest unit testing, TFS integration.
The basic business version. In TFS, checkin policies enforcing code analysis are widely used, but you just can't use it here. You can only use standalone FXCop.

Premium
Has Code analysis (use standalone FXcop), code coverage, coded UI Tests, test impact analysis (new feature, looks promising).
I expect this will be the most common business version, certainly most useful for larger teams.
But it's 5 times the price of Professional for features which aren't that exciting.

Ultimate
Adds historical debugging (intellitrace, it rocks), load tests, manual tests (look good), uml diagrams (really nice), architecture explorer.
The big problem: it's over $11000 / euro12800. Ten times the price of Professional and twice Premium. Very few organisations are big enough to buy that.

Ultimate has some great features, but it's just too expensive. And Premium looks a little thin for such a big price jump.
For the next version, I hope Microsoft will drop a few features from Ultimate to Premium or even Pro.

I reckon intelliTrace and UML diagrams are the ones which would really gain some interest if more people could get their hands on them.

"Covariance" = specified or MORE derived type

So upcasting to a more basic class in polymorphism is covariant.         
object s = new string('a', 3);

But you couldn't do it for IEnumerables, even though it seemed safe. Well, now in .net 4 you can.

IList<string> stringList = new List<string>(); //will not compile in .net 1-3, but does in net 4 IEnumerable<object> objectList = stringList;Trivia: since .net 1, arrays were covariant.

object[] data = new string[3];
data[0] = "s";
data[0] = 1; //no compiler error- just a runtime ArrayTypeMismatchException

Now IEnumerable<T> and IQueryable<T> are covariant.

IList<Cat> cats = new List<Cat>();
//you can cast to IEnumerable (or IQueryable)
IEnumerable<Animal> pets = cats;
//but you cannot cast to the read-write classes
//IList<Animal> animals = cats; //compiler error

Covariant interfaces must be read-only (and not value types).

Contravariance = specified or LESS derived type
 

var cats = new List<Cat>();
//predicate is contravariant
cats.Find(HasFur); //private static bool HasFur(Animal animal)
//so is IComparable
cats.Sort(SortByName); //private static int SortByName(Animal x, Animal y)