I recently picked up a copy of "Upgrade Your Life: The Lifehacker Guide to Working Smarter, Faster, Better" by Gina Trapani and quickly figured out three ways to optimize my email.

1) Color Code Email Sent Directly To You

If you click on Tools > Organize in Outlook, you'll notice the following pane:

Click on the Turn On button next to "Messages sent only to me now appear Blue".
Now all the email directly emailed to you will be highlighted.

2) Create a "Message Sent Directly To You" Rule

In this rule, it will look for messages not addressed to me, however the messages with my name (JL or Jean-Luc) will remain in the inbox.

3) Create a Facebook/Twitter Rule

I find myself getting a lot of "noise" email from Twitter and Facebook - I want to know what's going on (new friends adding me, messages, ect) but want to avoid jumping into the inbox everytime a message pops up. I've added the major Facebook aliases (groupmaster+mdvvmuv_@facebookmail.com, confirm+mdvvmuv_@facebookmail.com, notification+mdvvmuv_@facebookmail.com, ect).

Everything looks good so far. If you have a handy tip to optimize your own email, post it in the comments!

In the Part 1, I talked about some of the applications you can build for the Zune today, and specifically, my plans to create a wrapper for the Zune user card Web service using LINQ to XML. Note that this is a quick and dirty class I baked in a couple of hours. If you are looking for a more robust implementation, be sure to check out Mehfuz's WebLog - specifically his posting on integrating REST with LINQ to XML, and his custom LINQ.Flickr provider. Let's take a look at the namespaces:

          
            using System; using System.Collections; using System.Collections.Generic; using System.Linq; using System.Text; using System.Xml.Linq;
        

You'll notice that System.Linq (to access the core LINQ functionality) and System.Xml.Linq (to access LINQ to XML) are included as namespaces. Then a class called ZuneCard is defined and a bunch of public auto-implemented properties are defined (a feature of C# 3.5 - each property corresponds to a node in the Zune Card XML tree):

            
              namespace ZuneCardApi
{ publicclass ZuneCard
{ //
Exposed Propertiespublicstring id
{ get; set; } publicstring label
{ get; set; } publicstring firstName
{ get; set; } publicstring status
{ get; set; } publicstring tileBig
{ get; set; } publicstring tileSmall
{ get; set; } publicstring name
{ get; set; } publicstring location
{ get; set; } publicstring bio
{ get; set; } publicstring backgroundLarge
{ get; set; } publicstring backgroundSmall
{ get; set; } publicstring totalPlays
{ get; set; } 
          

Then ZuneCard is implemented and the tag parameter is passed (corresponding to the user's Zune tag). The XDocument object is used to load in the XML data for the user card. Note that this operation happens only once, then the data can be manipulated and queried to your heart's content in memory (which has performance benefits) .

          
            public ZuneCard(string tag)
{ XDocument zCardXml = XDocument.
Load(@"http://zcards.zune.net/zcard/usercardservice.ashx?zunetag="+ tag);
        

Next, we need to call our LINQ queries. Essentially, we are transversing the nodes of our XML tree (found here) starting at the user node. Anonymous Types (another C# 3.5 feature) are used liberally here (as you can see below):

            var
user = from
u in zCardXml.Descendants("user")
select new {
_id = u.Element("id").Value,
_label = u.Element("label").Value,
_firstName = u.Element("firstName").Value,
_status = u.Element("status").Value,
_tileBig = u.Element("image").Value,
_tileSmall = u.Element("image").Value
}; var userData = from
uD in zCardXml.Descendants("userData")
select new {
_name = uD.Element("name").Value,
_location = uD.Element("location").Value,
_bio = uD.Element("bio").Value,
_backgroundLarge = uD.Element("image").Value,
_backgroundSmall = uD.Element("image").Value,
_totalPlays = uD.Element("totalPlays").Value
}; 
          

foreach (var
u in user)
{ id = u._id;
label = u._label;
firstName = u._firstName;
status = u._status;
tileBig = u._tileBig;
tileSmall = u._tileSmall;
} foreach (var
uD in userData)
{ name = uD._name;
location = uD._location;
bio = uD._bio;
backgroundLarge = uD._backgroundLarge;
backgroundSmall = uD._backgroundSmall;
totalPlays = uD._totalPlays;
} } } }

I'm a big fan of the Zune (I own four of them, believe it or not) - so as a developer, I'm naturally inclined to think about novel ways to write applications for the device. There are several different approaches I've uncovered so far:

• Creating games and applications using XNA Game Studio 3.0. How about a Zune Clock?
• Using Hidden Zune Client APIs
• Creating Custom ASP.NET Zune Badge Controls
• Programming against the Zune Card Web Service
• ...can you think of any others?

In this blog post, I will focus on the before last bullet point - how to create a API wrapper for the Zune Card Web service. To access the Zune user card service, simply point your browser to the following URL (including your Zune Tag - in my case, stormpixel):

http://zcards.zune.net/zcard/usercardservice.ashx?lcid=1033&src=external&zunetag=stormpixel

You'll notice that the Zune Card (zCard) is based on a custom XML schema. The uri provides a link back to the user card service. The id denotes the Zune user id. The firstName, status message and tile images are self-explanatory. The manifest contains additional information about the user, badges, playlists, contact information and preferences:

I've created a preliminary API wrapper using LINQ to XML to access the information contained in the Zune cards. To access information about a Zune card, you can instantiate a variable of type "ZuneCard", passing into it the zune tag of the user. Once the object has been instantiated, you can then pull in user properties and collections (deserialized for your convenience). The example below is a console application where I'm querying the ID for the user stormpixel:

          
            using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace DisplayZuneCard
{ class Program
{ staticvoid Main(string[]
args) { ZuneCard zuneCard =new ZuneCard("stormpixel");
Console.WriteLine(zuneCard.id); Console.ReadLine(); } } } 
        

If I run the application, I get the console window shown below. In the next blog post, I'll explain in more detail how I implemented the API.

Yesterday, Joel Semeniuk asked if I could dig up a list of resources showing the business momentum of Agile methodologies. I was able to pull three core resources off the web, most notably on SlideShare.com (note: if you ever need to deliver a presentation in front of a group of people, check out the website. It has two great features in my opinion - a search bar to find presentations based on the text contained within, and an option to download .ppt files). Here they are:

http://www.slideshare.net/melnik/empirical-evidence-of-agile-methods-190997/
http://www.slideshare.net/sgreene/salesforcecom-agile-transformation-agile-2007-conference
http://www.infoq.com/articles/agile-alliance-survey-2006;jsessionid=7F263F7EC87B20F4F440448A732B6FC0
http://www.agilemodeling.com/essays/proof.htm

The best one out of the pack was delivered by Grigori Melnik (from the Microsoft Patterns and Practices group) - he spoke recently at the Patterns and Practices Summit in Quebec. Here are some of the facts that stood out:

• Growth of Agile in Banking (Lloyds), Transportation (CP Rail) and Communication (Telus) sectors (from a 2005 study) 
• From a Melnik/Maurer study in 2005, Agile as a methodology provides a job satisfaction rate of 29.4% (as opposed to 9.9% non-Agile)
• From a 2007 study, of 1700 people polled, 37% adopted Scrum (followed closely by 23% - Scrum/XP hybrid)

Rather than repeat what's on the slides - here is an interactive version of the deck to check out:

| View | Upload your own