Archive for October, 2005

GMail vs. Outlook: the verdict


It’s been about a month now since I
switched my entire environment from
Outlook to GMail
, so it’s time to do a quick check up.

Since a lot has been said about GMail, I will try to focus on details that
have never really been covered and explain in what ways they improved (or not)
my email-reading habits.

  • The first thing I noticed in my various labels and filters is that I
    seemed to receive a lot less email.  For example, where certain mailing-lists
    used to receive more than fifty messages a day, GMail showed me less than ten on
    a daily basis.  The answer was obvious, of course:  GMail displays the
    number of conversations, not messages, which makes me feel
    like I’m less overwhelmed.  Of course, it’s just perception, but perception
    is important when you are trying to keep up with the deluge of emails that hits
    you every day.

    Having said that, I wondered if the number of messages was
    not an important information that I’d like to have (and that GMail doesn’t
    provide), and so far, I am inclined to say I don’t really miss it and I can’t
    really think of a case where knowing how many unread messages are in a
    specific folder would dictate my decision to visit this folder or put off
    its consultation to a later date.
     

  • Conversations, conversations, conversations.  This is a direct
    follow-up to the point above, but no mailer has come close to successfully
    capturing the meaning of an email conversation.  GMail really nailed
    it, and compared to Outlook’s abysmal conversation approach (no indentation
    in the threads and you can’t even fold an entire thread, only the unread
    messages), it’s a breath of fresh air.
     
  • GMail’s spam filter is working very well.  I tried
    many spam filters
    over the years and while there are some really good solutions for Outlook and
    Thunderbird, GMail’s spam filter seems to be the best I’ve encountered so far, 
    and I know quite a few people who are using their GMail account as a pure spam
    filter (and eventually switched completely over).  My only complaint is
    that it doesn’t allow whitelisting (specifying that an email with certain words
    in the Subject or From will never be marked as spam) but GMail has been good at
    learning from my actions when I moved false positives out of the Spam folder.
     
  • GMail’s phishing detection is also very good, and is the reason why
    recommending GMail around me (especially to beginners such as my Mom) is a no-brainer.

    Not only are phishing emails clearly flagged, the URL’s they contain are
    also deactivated.  Outlook will soon provide a similar system, so I
    hope that some time in the near future, we’ll have completely curbed this
    plague.
     

  • One of the great impediment to comfortable email reading is quote
    handling (citing the previous messages of a conversation).  Outlook has
    one of the worst quoting mechanisms, both in reading (no colors) and writing
    (very hard to quote an email inline).  Thunderbird was a bit better in
    both areas (I especially liked the alternating colors depending on who was
    being quoted).  Again, GMail scores very high on this scale (slightly
    higher than Thunderbird) because quoted text is hidden by default.  GMail’s quoting mechanism is actually very clever since it will show the
    previous message as a "real" message but will hide its content if
    it’s being quoted again in that same conversation.  It’s hard to describe, but it works extremely
    well.  And of course, showing the hidden content is just a click away.
     
  • No catch up.  This is one of the things I miss and that pretty much
    any other email reader provides:  there is no direct "Catch up" button. 
    Instead, I need to click on Unread to select all unread messages, and then
    select "Mark Read" from the dropdown boxes.  That’s a lot of work if
    you do it often.
     
  • No "mark for follow-up" (the ability to tell the mailer to remind you to
    answer to a specific message by a certain date).  I was using this
    feature in Outlook quite a bit, and I miss it in GMail.  The Star system
    is a poor substitute, but it kind of does the job.
     
  • Resurrection of old threads.  This is another brilliant idea that
    captures very well how people use emails these days:  you read an email
    from a conversation, archive it when done and the entire conversation
    disappears from your Inbox.  Then if somebody sends another message in
    this conversation, the entire thread is brought back into the Inbox. 
    Simple and effective.
     
  • GMail is idempotent.  It’s a big word to say that I can read my
    GMail inbox from pretty much anywhere without any hassle.  It’s
    probably obvious for a Web-based client, but after so many years being
    shackled to Outlook (and therefore, only being able to read my email on a
    machine that has Outlook installed, and obviously not an anonymous one),
    it’s also quite refreshing.

Overall, the experience has been tremendously positive and GMail is more than
meeting my email needs, which I thought were pretty stringent.  And of
course, GMail is improving on a weekly basis, so there is a lot more to look
forward to.

Halloween in Azeroth


alt="Click for bigger image (4 megs)"
/>

I was quite a bit surprised to find pumpkins everywhere in the main cities of World of Warcraft today.

This was already funny it itself, but the Warcraft developers didn’t stop there: if you talk to an
inn keeper, you can “trick or treat” and you will then receive either a candy or a wand.

The wand will randomly turn one of your party member into a pirate, a ninja, a skeleton, a worm, a miniature cat,
and many more possibilities that I haven’t discovered yet
(click on the picture above for a larger image). At any rate, this little patch
is causing hilarity throughout the various realms.

The Blizzard developers are having way too much fun.

Sun starts thinking about the Next Java. Microsoft delivers it.

It’s not without a certain sense of irony that just as Gilad Bracha, Sun’s
language expert, starts
blogging
about the next Java
, Microsoft publishes the specification for what will
become

C# 3.0
.  Interestingly, these two pieces of news are a pretty good
illustration of how the two companies work.

Gilad’s post discusses the possibility of adding a new bytecode to Java’s
virtual machine:  invokedynamic.  If you put aside the
obligatory Microsoft jabs that all Sun employees seem to feel forced to include
in their posts (it’s probably in their employment contract) and the fact that
accusing Microsoft of coming up with non-standard terminology while Java came
with its own term reinvention (why Generics and not Templates?) is quite ironic
in itself, the entire entry is really focused around this simple consideration: 
what are the repercussions of adding invokedynamic to the Java Virtual
Machine?

I’ll let the experts discuss between themselves, but I can’t help making two
observations:

  • Adding a byte code is the ultimate backward compatible change.
     
  • invokedynamic is really not that big a deal.  Groovy, JRuby,
    Jython, and many other existing scripting languages have shown that dynamic
    invocation support at the virtual machine level is not all that important.

Still, it’s quite discouraging to hear from Gilad that should this change be
approved, it wouldn’t make it into Java before the next next (that’s two
"next")
version of Java. Probably at least two years in the future.

And on the other side of the fence, you have Microsoft, which used its own process to find a heir
to the very successful C#:  work behind closed doors and when done, publish
it and tell the world "this is it".

It’s easy to hate this approach, but there is also a lot to like about it. 
While I share some sympathy for Gilad’s fondness of committees (his
words), my experience has taught me that committees just don’t work for
languages.  Successful languages are not created:  they just happen. 
And there’s not much you can do to drive that process.

Does this mean I like all the new C# 3.0 features?  No. And actually, C#
3.0 has so many new features that statistically, you are guaranteed to hate at
least half of them, but this is an approach that has been pretty successful for
C++, and I expect the same success for C# 3.0.

I can’t help giving credit to Microsoft for coming up with so many
innovations and such a rebel attitude.  I am predicting that C# 3.0 will
usher us in the fifth generation language era and that all the features they are
adding to C# 3.0 will be the new reference against which future languages will
be judged.

There is a lot to say about these new features but going over them would make
this post too long, so I’ll save this for a future entry.

 

Announcing TestNG 4.0

I am very happy to announce the immediate availability of
TestNG 4.0
There are a lot of improvements and new features in this release, so we decided
to skip to a major version (actually, we considered calling it version 5, but it wouldn’t have been fair to JUnit ;-) ).

The change log is included below, but I’d like to take this opportunity to
discuss one of the new features:  Data Providers.

TestNG lets you specify parameters to your test methods, and their values are
then defined in testng.xml.  This approach works fine in simple cases but
is not enough when:

  • You need to pass complex objects.
  • These parameters need some complex logic to be created.

Data Providers address these two problems and also let you specify as many
sets of parameters as you want, so that your test methods will be invoked
several times, each time with a different set of parameters.

Here is an example:

// This test method declares that its data should be supplied by the Data
Provider
// named "test1"
@Test(dataProvider = "test1")
public void verifyData1(String n1, Integer n2) {
  System.out.println(n1 + " " + n2);
}

// This method will provide data to any test method that declares that
its Data Provider
// is named "test1"
@DataProvider(name = "test1")
public Object[][] createData1() {
  return new Object[][] {
    new Object[] { "Cedric", new Integer(36) },
    new Object[] { "Anne", new Integer(37)},
  };
}
 

This code will cause the method verifyData1() to be invoked twice,
once with "Cedric", 36 and then with "Anne", 37.

Of course, this data can come from more complex places, such as a file, a
database or the network.  Since the creation of the parameters is done in
Java, anything is possible.

This is a big release for the TestNG team, and it wouldn’t have been possible
without a lot of hard work from Alexandru Popescu and Hani Suleiman. 
Thanks guys!

TestNG 4.0 can be downloaded on http://testng.org
and the Eclipse plug-in has also been uploaded to the update site.  Here is
the change log:

Change log for TestNG 4.0

Core:

  • Fixed: suite methods now invoked only once in a hierarchy
  • Added: @DataProvider and @testng.data-provider
  • Fixed: Interleave order now respected for before/afterClass methods
  • Added: Can now invoke java -jar testng-4.0.jar <…>
  • Added: Support for BeanShell
  • Added: Method Selectors (IMethodSelector)
  • Fixed: In the absence of dependencies, @Configuration methods respect
    inheritance
  • Fixed: Bug in multithreaded dependencies on methods
  • Fixed: dependsOnGroups wasn’t working on regular expressions
  • Fixed: Bug in <package> when directories contain spaces in their names
  • Fixed: Introduced a JDK5 dependency in the JDK1.4 build (getEnclosingClass())
  • Fixed: Output directory in ant task was not honored if it didn’t exist
  • Fixed: Problem with timeout according to
    http://forums.opensymphony.com/thread.jspa?threadID=6707
     

Eclipse plug-in:

  • Fixed: Wasn’t handling linked directories correctly
  • Fixed: Bug in QuickFix implementation
  • Added: Quick Fix for JUnit conversion (Annotations and JavaDoc)
  • Fixed: Methods Run as TestNG test
  • Added: Package level Run as TestNG test
  • Fixed: Resources from the linked directories are using a wrong path when
  • passed to command line TestNG

IDEA plug-in:

  • Added: Support for JDK 1.4 (both projects and IDEA itself)
  • Fixed: Classes that contained only configuration were ignored

Mobile Monday at Google

Google is hosting this month’s Mobile Monday tonight, and the topic is
"Mobile Search".  Since we are merging this event with SD Forum, we are
expecting a pretty big crowd, so if you are interested in knowing what’s
happening in this area or you just want to hang out and discuss mobile topics,
stop by!

The event starts at 6:30pm and you can find all the details on the speakers
and the directions here.

See you tonight!

 

Java in Action

I am flying to Orlando, Florida, tomorrow, for
Java in Action.  The
TestNG presentation is Wednesday, and I
guarantee that it will drastically change the way you think about testing.

Hope to see you there!

 

Utility of the week: TaskSwitchXP

I enjoyed playing with
Entbloess but
more for its aesthetic value than its practicality.  With
TaskSwitchXP, I might have
found a task switcher that is actually better than Windows’ default one.

TaskSwitchXP has many features, but there are really two that I already
started getting quite used to:

  • A bulleted list of the available tasks, as shown above. 
    Windows’ default task switcher only shows you icons of the tasks, and will
    only display text when you put the focus on one of them.  With
    TaskSwitchXP, you can see the name of the tasks right away and navigate
    there in a completely foolproof way (you can also use the mouse and multiple
    selection).
     
  • Being able to move any task to the system tray.  Not all
    programs let you minimize them in the tray and end up taking up an entire
    slot in the task bar, which can become sparse pretty quick.

You don’t really realize how much you depend on task switching until you try
another utility than Window’s default one.  And when you do, the first
thing you really want is for the behavior to be exactly the same.  Not only
do I use Alt-Tab and Alt-Shift-Tab a lot, I now have very
precise expectations on the stacking order of my windows.

I use both Windows XP and Linux at work, and I realize this fact the hard way
every day whenever I try to task-switch on KDE.  Not only is the task
switcher ugly and very hard to use (very small icons), it uses a stacking order
logic that I still haven’t been able to completely figure out.

As far as I can tell, TaskSwitchXP is completely compatible with the default
task switcher and it also adds interesting features like being able to switch
only between the instances of your current window (for example, you are in a
FireFox window and you want to switch to another FireFox windows).  The
default hotkey for this functionality is a bit awkward, so I ‘ll probaby want to
change it (TaskSwitchXP is completely configurable), but once I have found one
that I want, I will probably start using this feature a lot.

I’m curious to revisit this choice in a few weeks and find out if I have
gotten hooked to it.  In the meantime, try it, it’s small, inconspicuous
and completely free.