I don’t get irritated easily but I have observed a growing trend recently
that is driving me absolutely nuts:  upgrade nags.

Well, to be precise:  upgrade nags without any possibility to turn them
off.

You know, these dialog boxes that pop up whenever you launch the application
and that let you know that a new version of the application is available. 
The arrogance of the authors of these programs is absolutely baffling, and they
should know by now that you don’t get mindshare by forcing products down users’
throats.

Here are the worst offenders as of today:

• Yahoo Messenger.  It didn’t used to be the case, but their
  recent "Yahoo Messenger with Voice" is obviously so important to them that
  they absolutely want you to install it, whether you have a microphone or not
  (or whether you want it or not).  Look, Yahoo, I like your client and you are welcome to let me know a new
  version is available, but how about a checkbox to allow me to pass on this
  great offer, uh?  Because right now, I am migrating away from Yahoo
  Messenger and urging my friends to do the same.
   
• Acrobat Reader.  A veteran in the art of irritating users,
  and it’s only getting worse as time goes by.  The most disturbing part
  is that the recent versions are actually worse than the previous ones: 
  longer start-up (do I really need all these plug-ins?  And why would I
  care about all these patents you filed?), pathetic scrolling and window
  management, miserably slow searching.  They must have seen that their
  users were reluctant upgrading, so they found the best way to make you: 
  a forced upgrade nag.  Keep up the good work, guys. 
• iTunes.  Probably the worst offender.  Why? 
  Because it suffers from the same problems as Acrobat Reader plus the fact
  that every new version seems to restrict your rights on your own songs
  further.  When you upgrade iTunes, you can never really be sure that
  your iPod is not going to be wiped clean of songs or whether some of the
  songs you didn’t buy through the iTunes store won’t mysteriously stop
  playing.  Of course, it doesn’t exactly help either that the Apple forums opted out of Google, so searching for answers to your iPod problems will typically not yield anything. And finally, here is the
  latest offense
  to date.

Any other?

I was in Paris and London this past week, here are a few random thoughts…

• I tamed jet lag.  I have traveled internationally so
  many times that by now, I have it down to an art. Here are a few simple
  rules:

  * Start shifting your time before leaving your country.  Stay up
  late (very late) and don’t sleep in too much.  Note that the point is
  not really to make yourself tired so you will sleep on the plane (which
  doesn’t help at all with jet lag) but just to start adjusting to your new
  time in your own environment.

  * On your first day in the new country, don’t nap, don’t sit
  (especially on comfortable couches), and don’t go to bed before 10pm.

  Also, try not to abuse coffee:  the more you confuse your stomach with
  unusual quantities of drinks and meals taken at odd times, the harder it
  will be for your body to get used to your new schedule.  Ideally, you
  simply want your metabolism to believe that instead of a 24-hour day, you
  are just going through a 33-hour day and that your sleep pattern doesn’t
  need to be altered to handle it.

  That’s it.  Follow these simple instructions and even a nine hour time
  difference will have absolutely no effect on your body.
   

• I flew on one of Virgin Atlantic’s latest aircrafts on the way back, and
  it featured the best entertainment system I have seen on an international
  flight by far:  about fifty movies to choose from, entire seasons of TV
  series, news, games, etc…  It’s all there.  You can also pause,
  rewind and fast forward everything at leisure.  Absolutely fantastic if
  you’re not the reading type on planes.
   
• Cell phone interoperability has come a long way and works close to
  perfectly now.  My trusted 6630 (which took the pictures above) worked beautifully and never lost GSM
  connectivity.  I actually travel with two phones and interestingly,
  they picked two different roaming carriers while in France (Orange and
  Bouygtel).  This is quite puzzling since both are Cingular, but it was
  a good opportunity to experiment.  No surprise there:  both phone
  calls and SMS worked seamlessly, the only glitch being that one of the two
  carriers refused to give me caller ID.  Not a big deal.

  I also experimented with sending SMS messages back to the US and between England and France,
  and everything worked fine.  Better:  even EDGE performed beautifully
  and allowed me to connect to the Internet through the Bluetooth modem while
  riding the Eurostar on my way to London (except in the tunnel, of course,
  but my phone quickly regained coverage when we came out and latched on O2 on
  the British territory).

Maybe we really live in a connected world after all.
 

To make good on my
threat, here are a few thoughts on the
C# 3.0 features that I
find interesting, along with a grade and a few thoughts:

Implicitly typed local variables:    A

I have been asking for this feature in Java for years.

Why do I need to
write:

Account a = new Account();
Employee e = (Employee) employees.get("John")

Instead of

a = new Account();
Employee e = employees.get("John")

Can’t the compiler figure this out for me?  Of course, it can.

Generics solve the second case, but they add more type inference envy than
ever:

List<Map<String, Name> employess = new ArrayList<Map<String, Name>>();

Surely we can do a bit better than that, right?

Well, that’s exactly what type inference will bring you.  Combine strong
typing with a strict application of the DRY principle and you get the best of
both worlds.

Extension methods:    C

This feature lets you add methods to a class outside the definition of that
class.  The syntax is a bit peculiar:  you add this to the first
parameter of your method:

public static int ToInt32(this string s) {
  return Int32.Parse(s);
}

I prefer Ruby’s syntax for this:

def string.toInt32()
  …
end

Note that this feature doesn’t break encapsulation:  extension methods
don’t have access to private fields or methods of the class they extend. 

As for the feature itself, I have to admit it frightens me somewhat (both in
Ruby and C# 3.0) because it becomes really hard to know exactly the
contract that classes abide by, and also where the extra definitions are coming
from.  I have to admit that over the years, I have grown quite fond of
Java’s rigid "one public class per file" rule and I’m afraid that extension
methods might resurrect the C++ header nightmares that haunted C++ programmers
for decades. 

On the other hand, this kind of
extensibility opens the door for some very interesting tricks, such as the ones
used by Ruby on Rails to exercise its magic (more on that in another post).

Time will tell.

Lambda Expressions:    B+

I have no doubt that functional programmers are screaming in frustration to
hear the term "lambda expression" hijacked to mean "closure".  Let’s put
the intellectual debate aside and observe that closures are extremely useful. 
C# already had a head start over Java with delegates and is now pulling further
ahead with closures.  Let’s hope Java will follow suit.  The C# syntax
is fairly straightforward:

(int x) => x +
1

defines a lambda
expression that accepts an integer parameter and returns that parameter
incremented by one.  You can then pass this lambda expression around as
real object.  I am quite looking forward to using this feature more.

Query
Expressions:    C-

This feature is
also referred to as LINQ for "Language Integrated Query".  The idea is to
allow a certain subset of relational language inside C#:

customers.
 
Where(c => c.City == "London").
 
SelectMany(c =>
      c.Orders.
      Where(o => o.OrderDate.Year == 2005).
      Select(o => new { c.Name, o.OrderID, o.Total })
 
)

If we have learned anything from Java’s struggle with
object-relational mappers, it’s that embedding SQL in your code is usually a bad
idea, so I’m having a hard time seeing the point in furthering the practice by
making it a syntactic part of it.  I am predicting a very grim future for
this feature.

Object
Initializers:    B+

This feature
helps reduce the clutter of your classes by waiving the declaration of simple
constructors:

public class Point
{
int x; int y;
public int X { get { return x; } set { x = value; } }
public int Y { get { return y; } set { y = value; } }
}
Point p = new Point { X = 0, Y = 1 };

In this example,
Point declares two properties but does not include any constructor that accepts
either of these properties  Yet it is
possible to create a Point object and to initialize these properties in
one statement.  Quite a relief from the verbosity of this.name = name that
plagues Java.  Notice also how well this feature plays out with C#
properties (another top priority on my Java wish list).

Conclusion

There are so many new features in C# 3.0 that
statistically, you are guaranteed to hate at least half of them. 
Interestingly, feature excess has certainly not dampened the popularity of C++,
quite the contrary, so if Microsoft can guarantee that C# 3.0 will be completely
backward compatible with C# 2.0, I am predicting that it will have a great
future.   And a lot of detractors.