Jesse Liberty - Silverlight Geek

iPhone to Windows Phone 7 – Diving Deeper

Jesse Liberty — Sat, 04 Sep 2010 12:38:13 +0000

In this tutorial, we’ll expand upon the work done in the previous tutorial and we’ll look more closely at a few key issues.

MVVM

As an iPhone Developer your thinking is adapted to and influenced by the Model-View-Controller pattern. The very good news is that the pattern for Windows Phone 7 (WP7) development, MVVM, is very closely related to MVC.

Wikipedia notes that MVVM evolved at Microsoft out of the Model-View-Presenter pattern developed by Martin Fowler, which was based, in turn on MVC. The originators of MVVM often refer to it as a specialization of Model-View-Presenter. Wikipedia goes on to say,

Largely based on the Model-view-controller pattern (MVC), MVVM is targeted at modern UI development platforms… in which there is a User Experience (UX) developer who has different requirements than a more “traditional” developer (i.e. oriented toward business logic and back end development). The View-Model of MVVM is “basically a value converter on steroids” meaning that the View-Model is responsible for exposing the data objects from the Model in such a way that those objects are easily managed and consumed. In this respect, the View-Model is more Model than View, and handles most if not all of the View’s display logic (though the demarcation between what functions are handled by which layer is a subject of ongoing discussion and exploration).

It is important to understand that MVVM and Silverlight co-evolved, each influencing the other, and thus the “hand in glove” fit between them is no coincidence.

In MVVM both the View and the Model are identical in meaning to what they mean in MVC

The ViewModel is the Model of the View, that is, it is an abstraction of the view and, most important, (just about) all the user-generated view code is kept in the view model (rather than in the code-behind for the View as can also be done in WP7 programming). Numerous writers have commented that the VM is really a specialized controller that acts as a data binder and converter; changing Model information in to View information, and passing commands from the View that may affect the Model.

Three Core Concepts

We’ve been talking about n-tier development, decoupling, scoping, visibility and related topics since at least 1990. I’m pretty sure that when they were cracking the Enigma machine in World War II, they discussed decoupling the code-breaker module from the UI (did they have UI then?)

MVVM, at its heart has three core concepts:

Core Concept #1: Separate your User Interface concerns (View) from your Business objects and behaviors (View Model) and from your data/persistence layer (Model).

Core Concept #2: Don’t Look Up.

We tend to conceptualize the View at the top, the ViewModel in the middle and the model at the bottom. The View can know about the ViewModel, the ViewModel about the Model, and the Model, like the cheese, stands alone.

Core Concept #3 – And this is the killer: Binding.

In MVVM the mechanism for the ViewModel to provide data to the View, is for the View to set the ViewModel as its DataContext. That is so cool; it takes a while to realize the implications. Further, we don’t just bind data, as I’ll show below.

[ click on any image to see it full size ]

Why Would You Want To Do That, & What Does It Cost?

The huge advantages of MVVM (and MVC) are that

you write less code
you have enormously increased the testability of your application.

It is a bear to try to test a UI object because the pesky UI gets in the way. ViewModels have no UI, they have just the things you want to test: “does it behave as expected? and is the data correct at any given instant?”

So, the cost is negative; that is, by adopting MVVM you don’t work harder, you work less, and in exchange for doing less, your code is easier to write, to read, to maintain and to test. Not bad.

Concrete Guidelines

Because MVVM is somewhat new, and because I’m totally disinterested in pilpul I will arbitrarily suggest the following guidelines:

Do not bother with MVVM for any program that takes less than 1 hour to write.
Move as much logic as possible from the view to the VM, but try not to become obsessed
Use a MVVM library (life is short!) We’ll use the (free) MVVM Light Toolkit in this series.
Chillax

Creating An MVVM Application

Let’s return to the application started in the previous tutorial, and add two-way binding so that we can update the records. That will give us an opportunity to examine, in a bit more detail, the responsibilities of the Model, ViewModel and View, and will allow us also to talk a bit more about event handling.

Because we are early in the tutorials, there is value in starting from scratch. Create a new project of type MVVMLight (WP7) [If you don’t see this option you do not have the MVVM Light Toolkit installed.]. Call your new application i2w_CustomerData

Here, for your cut and past convenience, is the Xaml from the example in the previous tutorial, except that I’ve removed the bottom two rows (Notes and Male/Female) and added a button (Next)

Creating the Model

Once again, we’ll create a Customer.cs class in the model,

 public class Customer
 {

     public string First { get; set; }
     public string Last { get; set; }
     public string Address { get; set; }
     public string City { get; set; }
     public string State { get; set; }
     public string Zip { get; set; }
     public string HomePhone { get; set; }
     public string WorkPhone { get; set; }
     public string Fax { get; set; }
     public string WorkEmail { get; set; }
     public string HomeEmail { get; set; }
     public bool IsMale { get; set; }
     public string Notes { get; set; }
     public int CreditRating { get; set; }
     public DateTime FirstContact { get; set; }
     public DateTime LastContact { get; set; }

     public Customer(
         string first,
         string last,
         string address,
         string city,
         string state,
         string zip,
         string homePhone,
         string workPhone,
         string fax,
         string workEmail,
         string homeEmail,
         bool isMale,
         string notes,
         Int16 creditRating,
         DateTime firstContact,
         DateTime lastContact)
     {
         First = first;
         Last = last;
         Address = address;
         City = city;
         State = state;
         Zip = zip;
         HomePhone = homePhone;
         WorkPhone = workPhone;
         Fax = fax;
         HomeEmail = homeEmail;
         WorkEmail = workEmail;
         IsMale = isMale;
         Notes = notes;
         CreditRating = creditRating;
         FirstContact = firstContact;
         LastContact = lastContact;
     }
}

This time, however, let’s add to the model and create a collection of customers,

public class CustomerCollection
{
    private readonly List< Customer > _customers = new List< Customer >();

    public CustomerCollection()
    {
        GenerateCustomers( 500 );
    }

    public List< Customer > Customers
    {
        get { return _customers; }
    }

    public void GenerateCustomers( int howMany )
    {
        var firsts = new List< String >
                     {
                         "Abe",
                         "Alice",
                         "Barry",
                         "Basha",
                         "Charlie",
                         "Colette",
                         "David",
                         "Davida",
                         "Edgar",
                         "Elizabeth",
                         "Frank",
                         "Fran",
                         "George",
                         "Gary",
                         "Harry",
                         "Isaac",
                         "Jesse",
                         "Jessica",
                         "Kevin",
                         "Katrina",
                         "Larry",
                         "Linda",
                         "Mark",
                         "Melinda",
                         "Nick",
                         "Nancy",
                         "Oscar",
                         "Ophilia",
                         "Peter",
                         "Patricia",
                         "Quince",
                         "Quintina",
                         "Robert",
                         "Roberta",
                         "Shy",
                         "Sarah",
                         "Tom",
                         "Teri",
                         "Uberto",
                         "Uma",
                         "Victor",
                         "Victoria",
                         "Walter",
                         "Wendy",
                         "Xerxes",
                         "Xena",
                         "Yaakov",
                         "Yakira",
                         "Zach",
                         "Zahara"
                     };

        var lasts = new List< String >
                    {
                        "Anderson",
                        "Baker",
                        "Connors",
                        "Davidson",
                        "Edgecumbe",
                        "Franklin",
                        "Gregory",
                        "Hines",
                        "Isaacson",
                        "Johnson",
                        "Kennedy",
                        "Liberty",
                        "Mann",
                        "Nickerson",
                        "O'Dwyer",
                        "Patterson",
                        "Quimby",
                        "Richardson",
                        "Stevenson",
                        "Tino",
                        "Usher",
                        "Van Dam",
                        "Walker",
                        "Xenason",
                        "Yager",
                        "Zachery"
                    };
        var streets = new List< String >
                      {
                          "Ash",
                          "Beech",
                          "Cedar",
                          "Dogwood",
                          "Elm",
                          "Filbert",
                          "Ginkgo",
                          "Hawtorn",
                          "Ironwood",
                          "Juniper",
                          "Katsura",
                          "Lilac",
                          "Magnolia",
                          "Nectarine",
                          "Oak",
                          "Palm",
                          "Quince",
                          "Redwood",
                          "Sassafrass",
                          "Tupelo",
                          "Vibrunum",
                          "Walnut",
                          "Yellowwood",
                          "Zelkova"
                      };
        var cities = new List< String >
                     {
                         "Acton",
                         "Boston",
                         "Canton",
                         "Dell",
                         "Everstone",
                         "Flintwood",
                         "Gary",
                         "Houston",
                         "Imperial",
                         "Jackson",
                         "Kalamazoo",
                         "Levinworth",
                         "Macon",
                         "New York",
                         "Oak Hill",
                         "Paducah",
                         "Quinzy",
                         "Rochester",
                         "South Falls",
                         "Terra Haute",
                         "Union",
                         "Victoria",
                         "Waipio",
                         "Xenia",
                         "York",
                         "Zanesville"
                     };
        var isp = new List< String >
                  {
                      "ATT",
                      "Verizon",
                      "Hotmail",
                      "Gmail",
                      "Sprintnet",
                      "Yahoo"
                  };
        var states = new List< String >
                     {
                         "AL",
                         "AK",
                         "AS",
                         "AR",
                         "CA",
                         "CO",
                         "CT",
                         "DE",
                         "FL",
                         "GA",
                         "HI",
                         "ID",
                         "IL",
                         "IN",
                         "IA",
                         "KS",
                         "KY",
                         "LA",
                         "ME",
                         "MD",
                         "MA",
                         "MI",
                         "MN",
                         "MS",
                         "MO",
                         "MT",
                         "NE",
                         "NV",
                         "NH",
                         "NJ",
                         "NM",
                         "NY",
                         "NC",
                         "ND",
                         "OH",
                         "OK",
                         "PA",
                         "RI",
                         "SC",
                         "SD",
                         "TN",
                         "TX",
                         "UT",
                         "VA",
                         "WA",
                         "WI",
                         "WY"
                     };

        var random = new Random();
        for ( int i = 0; i < howMany; i++ )
        {
            string first = firsts[ random.Next( 0, firsts.Count ) ];
            string last = lasts[ random.Next( 0, lasts.Count ) ];
            int streetNumberInt = random.Next( 101, 999 );
            string streetNumber = streetNumberInt.ToString();
            string zipCode = random.Next( 10000, 99999 ).ToString();
            string homePhone = random.Next( 200, 999 ) + "-555-"
                               + random.Next( 2000, 9099 );
            string workPhone = random.Next( 200, 999 ) + "-555-"
                               + random.Next( 2000, 9099 );
            string fax = random.Next( 200, 999 ) + "-555-"
                         + random.Next( 2000, 9099 );
            string homeEmail = first + "@"
                               + isp[ random.Next( 0, isp.Count ) ]
                               + ".com";
            string workEmail = last + "@"
                               + isp[ random.Next( 0, isp.Count ) ]
                               + ".com";
            bool isMale = ( random.Next( 1, 3 ) ) % 2 == 0
                              ? true
                              : false;
            var creditRating = ( short ) random.Next( 100, 800 );
            var firstContact = new DateTime( 2010, 1, 1 );
            DateTime lastContact = DateTime.Now;

            _customers.Add(
                           new Customer(
                               first,
                               last,
                               streetNumber + " "
                               +
                               streets[
                                       random.Next(
                                                   0, streets.Count - 1 )
                                   ]
                               + " Street",
                               cities[
                                      random.Next( 0, cities.Count - 1 )
                                   ],
                               states[
                                      random.Next( 0, states.Count - 1 )
                                   ],
                               zipCode,
                               workPhone,
                               homePhone,
                               fax,
                               homeEmail,
                               workEmail,
                               isMale,
                               "No notes at this time",
                               creditRating,
                               firstContact,
                               lastContact ) );
        }
    }
}

The constructor of this class generates 500 random records and places them in a List. the class consists of a public property, Customers, that returns the collection, and otherwise nothing but the method, GenerateCustomers, which mixes and matches names, cities, etc. to create records.

Data

It is tempting to create a search function and an update, but that complexity can wait for a later tutorial. Let’s keep things simple and just display the records one after the other.

The work of controlling the View is done in the ViewModel which will implement the INotifyPropertyChanged Interface.

Interfaces

An Interface is a contract that a class implements. The Interface itself is declared with members, much like a class, but the members are not implemented. The Interface dictates what an implementing class will provide, and clients of the implementing class can count on those elements being present. In this example, the binding mechanism depends on the VM

How You implement An Interface

You fulfill the contract by implementing all the methods and events of the Interface. That is, if the interface looks like this:

interface Writeable
{
   void Read();
   void Write();
}

(and notice that the interface does not have to begin with a capital I, though just about every interface from Microsoft does: INotifyProopertyChanged, IEnumerable, IClaudius…)

There is no implementation in the interface itself (nor does it have a return value or a public/private designation). If your class states that it imlements this interface3, it must supply a body for both methods,

class foo : Writeable
{
   public void Think()
   {
      System.DialogBox.Show("I Think Therefore I Might Be");
    }

   public void Read()
   {
         System.DialogBox.Show("So Many Books, So Little Time.");
   }

   public void Write()
    {
       System.DialogBox.Show("To err is human, to write, divine.");
     }
}

The implementing class is of course free to add additional methods and events.

For more on delegates please see the C# documentation or my books Programming C# and Learning C#.

In this case, the INotifyPropertyChanged interface has only one member, the event PropertyChanged. While it is up to you how you implement this event, you must follow its declaration, passing in an object and an instance of PropertyChangedEventArgs. The PropertyChangedEventArgs class has one member that you must provide: the name of the property that has changed. In our case, we want to say that every property has changed rather than sort through which properties are different in the new record vs. the old.

How You Declare the Interface

Add the interface you wish to declare you implement after declaring the class from which you derive:

public class MainViewModel : ViewModelBase, INotifyPropertyChanged

Implementing the View Model

The ViewModel in this case derives from ViewModelBase supplied by the MVVM Light Toolkit, which also implements INotifyPropertyChanged, so the declaration shown above is legal but redundant.

The base class follows the common idiom and implements a method RaisePropertyChanged that takes a property name and passes it along to the event (after doing some housekeeping that need not concern us now).

// MainViewModel.cs
public void Next()
 {
     _currentCustomer = _customerCollection.Customers[++_currentOffset];
     base.RaisePropertyChanged("Name");

When the event is called, the named property updates, using the data context in the view code behind,

// MainPage.xaml.cs
void MainPage_Loaded(object sender, System.Windows.RoutedEventArgs e)
 {
     vm = new MainViewModel();
     DataContext = vm;

In our case, the data context is the ViewModel itself. That works because the VM has properties for each of the controls on the page,

//MainViewModel.cs
 public string Address { get { return _currentCustomer.Address; } }
 public string City { get { return _currentCustomer.City;  } }
 public string State { get { return _currentCustomer.State; } }
 public string Zip { get { return _currentCustomer.Zip; } }
 public string WorkPhone { get { return _currentCustomer.WorkPhone; } }
 public string Fax { get { return _currentCustomer.Fax; } }
 public string WorkEmail { get { return _currentCustomer.WorkEmail; } }
 public string Name { get { return _currentCustomer.First + " " + _currentCustomer.Last; } }

Notice that this time we’re wrapping all the properties rather than using a pass through to the customer collection.

Here is the complete code for the ViewModel,

using GalaSoft.MvvmLight;
using i2W_CustomerData.Model;

namespace i2W_CustomerData.ViewModel
{
    public class MainViewModel : ViewModelBase
    {
        private int _currentOffset = -1;
        private readonly CustomerCollection _customerCollection = new CustomerCollection();

        public string Address { get { return _currentCustomer.Address; } }
        public string City { get { return _currentCustomer.City; } }
        public string State { get { return _currentCustomer.State; } }
        public string Zip { get { return _currentCustomer.Zip; } }
        public string WorkPhone { get { return _currentCustomer.WorkPhone; } }
        public string Fax { get { return _currentCustomer.Fax; } }
        public string WorkEmail { get { return _currentCustomer.WorkEmail; } }
        public string Name { get { return _currentCustomer.First + " " + _currentCustomer.Last; } }

        private Customer _currentCustomer;
        public Customer CurrentCustomer
        {
            get { return _currentCustomer; }
        }

        public string ApplicationTitle { get { return "iPhone To WP7"; } }

        public string PageName { get { return "Customer"; } }

        public MainViewModel()
        {
            _currentCustomer = new Customer();
            Next();
        }

        public void Next()
        {
            _currentCustomer = _customerCollection.Customers[++_currentOffset];
            base.RaisePropertyChanged("Name");
            base.RaisePropertyChanged("Address");
            base.RaisePropertyChanged("City");
            base.RaisePropertyChanged("State");
            base.RaisePropertyChanged("Zip");
            base.RaisePropertyChanged("WorkPhone");
            base.RaisePropertyChanged("Fax");
            base.RaisePropertyChanged("WorkEmail");
        }
    }
}

And, finally, here is the complete source for the code behind for the MainPage.xaml

using i2W_CustomerData.ViewModel;

namespace i2W_CustomerData
{
    public partial class MainPage
    {
        private MainViewModel vm;

        public MainPage()
        {
            InitializeComponent();
            Loaded += MainPage_Loaded;
        }

        void MainPage_Loaded(
             object sender, System.Windows.RoutedEventArgs e)
        {
            vm = new MainViewModel();
            DataContext = vm;
            Next.Click += NextClick;
        }

        void NextClick(
           object sender, System.Windows.RoutedEventArgs e)
        {
            vm.Next();
        }
    }
}

Before we wrap this up, let’s focus in on the keyword event. As an iPhone programmer, there is an intuitive, almost visceral sense of what an event is, but the keyword has a very specific meaning in C#. To understand that, we have to back up and look at delegates.

Event Handling and Delegates

When a head of state dies, the president of the United States typically doesn’t have time to attend the funeral personally. Instead, he dispatches a delegate. Often this delegate is the vice president, but sometimes the VP is unavailable and the president must send someone else, such as the secretary of state or even the “first lady.” He doesn’t want to “hardwire” his delegated authority to a single person; he might delegate this responsibility to anyone who is able to execute the correct funeral-protocol. The president defines in advance what responsibility will be delegated (attend the funeral), what parameters will be passed (condolences, kind words, warnings to potential usurpers), and what value he hopes to get back (good will, oil). He then assigns a particular person to that delegated responsibility at “runtime” as the course of his presidency progresses.

Some of the material in this article was stolen borrowed adapted from Programming C# 5th Edition.

[Note, I’m a big fan of our president, this picture is offered with affection. It is a small, articulated action figure given to me for my last birthday, taken in front of an intentionally soft image of the capital ]

I Made The Button, You Handle What Happens When It Is Clicked

The programmer who creates a control such as a button often will not be the programmer who puts that button into an application. The control writer defines what events the control will support (click, selection changed, etc.) and the control user defines what happens for the events the control user is interested in responding to. Note that the control user need not react to every event, but on the other hand, adding a button that doesn’t react to being pressed is frowned upon. The way the control user indicates what is to happen is to write a method that will handle the event, and then tell the event which method to call when that event is “fired.” It does that with delegates.

In C#, as in Cocoa Touch, delegates have the responsibility for taking action on behalf of other objects. In C# however, delegates are created within a class, and that class is not the delegate.

Delegates

Technically, a delegate is a reference type used to encapsulate a method with a specific signature and return type (and even more technically, the return type is not part of the signature of a method).

You can encapsulate any matching method in that delegate.

An event is just a delegate that has been constrained in a few useful ways. For example, while a delegate can be used to invoke a method anywhere, events can only be invoked by the object that declares them (that is to say, if the button has a click event, only the button can raise that click event.)

Great SL Competency Test Part 1 (Answer)

Jesse Liberty — Wed, 01 Sep 2010 18:40:34 +0000

On August 23rd I published part 1 of The Great Silverlight Competency Test. The key tasks were to…

…write a Silverlight program mimicking a problem report system, that allows you to go to your db and call up a record by phone number and view and/or edit all of the following fields. Do not implement membership or roles feel free to prepopulate the db with randomized data.

Full name
Address
Email(s)
Phone(s)
Date of first contact
Date of last contact
Reason for calling (1 of 5 possible)
Product (1 of 20 possible)
Computer(s) running on
Description of problem

The idea was to be able to do this in under an hour. This posting will review one solution.

The Database

To begin, I created three tables and a view in a new database called Customers

Customer
Product
Reason
CustomerView

The customerView joins the three tables, allowing the tables to be normalized, but simplifying the data retrieval.

The Application

I chose to create a Business Application as they are born with significant database support. This created two projects, BusinessApplication1 and BusinessApplication1.web (okay, not the best naming).

Within the .web project I chose Project->Add New and selected Data in the templates and then ADO.NET Entity Data Model. I chose to base it on my database and picked the CustomerView, generating an Entity Data Model named CustomerView.edmx and with it CustomerView.Designer.cs.

I then returned to Add->New and added a WCF Data Service. With this in hand, I turned to BusinessApplication1 (the client) and added a Service Reference to the new WCF Data Service. Great, I can get the data.

The UI

To keep the UI very simple, I created a grid with three rows, the bottom of which houses a grid with the rows for the form, itself having two columns. Each item in the second column is bound to a property of the page,

The Code

When the user enters a phone number and presses the button, a query is created and executed asynchronously. [Note, this code is insufficiently bullet-proofed]

private void ExecuteQuery( object o, object routedEventArgs )
{

    _customers = new DataServiceCollection< CustomerView >();
    _customers.LoadCompleted += CustomersLoadCompleted;
    var svc =
        new CustomerViewEntities(
            new Uri( "http://localhost:52878/CustomerViewService.svc" ) );

    IOrderedQueryable< CustomerView > query = from c in svc.CustomerViews
                                         where c.phone == Phone.Text
                                         orderby c.last , c.phone
                                         select c;
    _customers.LoadAsync( query );
}

When the data is loaded I extract the first (and only) record and assign values to the properties,

void CustomersLoadCompleted( object sender, LoadCompletedEventArgs e )
{
    if ( _customers.Continuation != null )
    {
        _customers.LoadNextPartialSetAsync();
    }
    else
    {
        CustomerView cust = _customers[ 0 ];
        First = cust.first;
        Last = cust.last;
        Address1 = cust.address1;
        Address2 = cust.address2;
        City = cust.city;
        State = cust.state;
        Zip = cust.zip;
        PhoneNumber = cust.phone;
        FirstContact = cust.firstContact;
        LastContact = cust.lastContact;
        Reason = cust.reason;
        ProductName = cust.productName;
        Computer = cust.computer;
        Problem = cust.problem;
    }
}

Each property has a backing variable and calls the PropertyChangedEventHandler to notify the UI that it has been updated. For example,

 public string PhoneNumber
 {

     get { return _phoneNumber; }
     set { _phoneNumber = value; OnPropertyChanged("PhoneNumber"); }

 }

Score Yourself

Created a database	10 points
Relational db with 2 or more tables and normalized	+5 points
Accessed the db through a web service of any kind or through another sustainable approach	10 points
Mapped the UI to bound data	20 points
Selected data in the db with a where clause that used the phone number using LINQ or a SPROC	15 points
Display worked as you intended	20 points
Your program works and does what it should reliably, handling missing records and entry errors	20 points

I made up these numbers and criteria, so please remember that it is the journey, not the destination that counts.

Note, I’ve not made the source available as I’ll be tinkering with it and then releasing it with a video.

A Program I Want

Jesse Liberty — Tue, 31 Aug 2010 15:32:33 +0000

I want a program that I can say “Watch what I do to this file” (change properties, unblock, etc.) and then be able to say “now do this for all the other files in the directory.” Can’t be too hard to write, can it?

The Great Silverlight Competency Test [2]

Jesse Liberty — Mon, 30 Aug 2010 14:30:00 +0000

This is the second of twelve questions in The Great Silverlight Competency Test – each of which I believe a competent Silverlight Programmer ought to be able to complete within no more than 1 hour.

Each of the twelve tests will appear on Monday, a viable solution will be provided 10 days later on the following Wednesday.

The solution I provide will tell you how to self-score your own solution (each on a scale of 0-100), and at the end I’ll try to provide a metric for the entire experience. 25 points for each bug you find in my code!

On the honor system you may post your scores into the book giveaway and I will give one of the top scorers a copy of the book. (Microsoft employees not eligible, void where prohibited, yadda yadda).

Please feel free to help one another by discussing the problem, ideas and questions in the comments for each exercise.

[ First posting in series here ]

Competency #2 (of 12)

Create a custom button that has non-standard visual behavior when you hover over it, and when you click it but which otherwise acts exactly like a button.

Demonstrate in a working program.

Note: No further clarification will be provided, design as you see fit.

Tag-based Feeds

Jesse Liberty — Sun, 29 Aug 2010 18:12:09 +0000

In this posting I will show how to create Feedburner feeds based on queries in Word Press using the Feedburner plugins.

Begin by setting up your full site feed on Feedburner.

Next, modify the Feedburner plugin as described by Brad Grier here.

For each tag you want a feed for

Go to Feedburner and paste the full feed name in this format: jesseliberty.com/?tag=hvp
Click Next
Of the three choices, pick the third, with the specific feed
Click Next
Note the feed address that is provided for you on the next screen (e.g., http://feeds.feedburner.com/JesseLibertyHVP)
On the final screen you can subscribe to that feed

That’s it, you’re done!

How I Learned To Stop Worrying and Get Organized

Jesse Liberty — Sun, 29 Aug 2010 15:02:59 +0000

I have ADD, (“oh look, something shiny!”) which means getting organized is a challenge, and making sure I can put my hands on any given piece of information a huge life-long effort, but technology has helped a lot, and after trying, discarding, returning to and otherwise manipulating every conceivable combination, I have a system that works so well i thought I’d share it.

Organizational Systems

This posting is about handling ToDo items and Appointments. A second organizational area is email and notes and a third is office organization. These will be handled in subsequent posts.

Here is what I do. I won’t try to justify any of it as it will take too long and sound idiotic…

To Do

I use different software on different platforms, but what is critical is that they are all synchronized all the time. If not, I’m dead.

I buy the basic premise of Getting Things Done, as I understand it, which is:

If you try to keep track of everything you have to do in your head, you’ll always be doing the wrong thing and forgetting the most important thing. Thus you need a system that you totally trust to be reliable, into which you can put tasks and forget them until they appear, ready for you to take action. You should never be looking at a task that isn’t ready for action, and you should be seeing the most important task you can take action on right now.

The key to making GTD work, which took me a long time was to stop putting deadlines on things that didn’t have real deadlines. My fear was that without a deadline I’d forget about it. Bzzzz. Still your turn. With everything having a deadline, everything got ignored and was “late.”

Much better is to give a deadline when you absolutely must, and then set a sufficient reminder, but, to make this work you must schedule at least one (better two) times a day when an alarm goes off to remind you to review your focus tasks. Set up right, focus shows you the 3-5 tasks that are

Most important to do now
Actionable now (no point seeing something you can’t take action on

My system is to use three criteria for making the focus list:

Due today or over-due OR
Marked top priority (saved for the very rare)
Marked Next Action

To make this work I use the following fields in my various platform-specific tasks lists (all of which are synch’d through Toodledo

Date Time Start/Due

Few tasks are designated with a due date, and even fewer with a start date (don’t start before this date) but those that are have real deadlines.

[Click on image for full size]

Status

The statuses that I use are

Next Action – Move to focus list
Active – Do this as time allows
Planning – No action, still in planning stage
Waiting – Dependent on an action by someone else
Hold – No action for now
Postponed – No action for foreseeable future
Reference – No action ever but need to have this in the list for some reason

Of these, The first four are used a lot, the last three rarely.

Priority

Low
Medium
High
Top

Top is reserved and used only for those things that have to go on the focus list right now. Especially rare as that is what Next Action is for.

Context

Computer
Phone
Out
Redmond
Wife
None

Context tells me where I have to be to be able to do this task. None means anywhere. Nice thing about this is when I’m in Redmond (e.g.,) I can just see those things that I need to do there.

Folder

Admin
Learning
IT
Projects
Personal

This is an arbitrary way to divide up my tasks. IT is any computer fussing. Projects is the center of attention except on weekends when it switches to personal. I can filter out by folder so that helps a lot.

Creating and Maintaining Tasks

Key to making this work is that I can enter a task from anywhere, see my tasks anywhere and fuss with them at a very convenient place.

See them anywhere

I can see a synchronized task list on my phone [Tasks or Toodledo] , on the web [Toodledo] and on my computer [TaskAngel].

I can enter at each location with the above software as well, and I tend to “fuss with” the tasks using Task Angel as computers beat phones every time for that sort of thing.

Doing the Most Important Things, Except…

Based on the rules above (focus list has only Next Action or Top Priority or Due) I will be working on the most important task at any moment. But then there are those things that linger, that are medium priority, never feel like they make next action and have no due date. They can sit for months. Thus, I’ve added my own task which is around the first of the month those tasks bump up one level of priority (Medium –> High –> Top) and so nothing sits on the task list for more than a few months even if it is trivial. A hack, but it seems to work.

Mail It In

One of the great features of toodledo is I can send myself a mail (I use a pre-canned message that I leave copies of in my drafts folder) for new tasks, so if I’m not at a convenient location I can just mail the task to myself and it appears in the folder “Inbox” with some indication of priority and if there is a due date.

Phone It in

Similarly, if I’m in the car, I can call Jott, and dictate the to-do item. Works great.

Supplement

The key supplement to all this is an alarm at 9am and 2pm to remind me to review the FOCUS tasks. Since I’m not putting due dates I can’t set alarms on many tasks, but twice a day review solves that problem cleanly.

Migrated from 32 bit to 64 bit – Wow!

Jesse Liberty — Sun, 29 Aug 2010 13:37:47 +0000

Made a quick and dirty video about it… Be sure to watch in full screen.

i2W: An iPhone Developer’s First Windows Phone 7 Application

Jesse Liberty — Fri, 27 Aug 2010 16:26:57 +0000

Go to first Tutorial

In this tutorial we will build a meaningful, and nontrivial Windows phone 7 application. This will give us the opportunity to explore layout controls, interactive controls, Visual Studio and a good bit more.

[Updated 8/30/2010]

Let’s start by taking a look at the application were going to build.

The application opens with a form, and that form is populated by data binding.

Note: All images are cropped. To see the full size (but still cropped) version, double click on the image

Let’s walk through the creation of this first demo program step by step.

A Word On The Development Environment

Before we begin, let me note that I make the assumption that you are a professional iPhone developer, and thus are not afraid to invest in purchasing the right tools.

While, as noted in the previous tutorial, it is possible to write Windows Phone 7 applications using Visual Studio Express, I will demonstrate using Visual Studio 2010 Ultimate.

In addition, as a practical matter, MVVM (the principle design pattern for Windows Phone 7) is easiest when supported by a library, and so I will use the free MVVM Light Toolkit.

Additionally, you’ll notice that my screen shots include a menu member Resharper and/or Code Rush; using one of these two supplements to Visual Studio is not required, but they do provide a far more efficient programming experience.

Visual Studio, Expression Blend, XCode and Interface Builder

It is tempting to draw a parallel in which Visual Studio maps to XCode and Expression Blend maps to Interface Builder. This isn’t wrong so much as incomplete, because you can create your entire interface in Visual Studio (and many folks do) but for more advanced UI development, Blend is the tool of choice. We could start off by creating the form itself in Blend (and some would argue we should) but we’ll keep things simple by doing all our work for now in Visual Studio, introducing Blend in a following tutorial.

Solutions, Projects and Files, Oh My

To begin, open Visual Studio, click on New Project and in the left pane (Templates) choose Visual C# and then Silverlight For Windows Phone 7. In the right hand side, choose the MVVM Light Toolkit. Give Visual Studio 2010 a few minutes to settle down and you’ll find that Visual Studio 2010 and the MVVM Light Toolkit have cooperated to create a project with numerous files and folders. You can see these in Solution Explorer window, which is typically on the upper left hand side of your development environment and which you can open either from the menu (View->Solution Explorer) or with the hot keys that are shown on the menu.

Because all such windows can be opened from a menu, I will eschew walking you through each, and will only point out those menu choices which may be otherwise confusing.

For now, we’ll ignore the Properties and Reference items (though feel free to explore on your own, just take a compass and plenty of rope and you’ll be fine).

The key files we care about right now are MainPage.xaml and, under the ViewModel folder MainViewModel.cs. The former, MainPage.xaml has an associated code behind file which you can expose with the very familiar turn down.

Double click on MainViewModel.cs to populate the edit windows. Your initial view will be a split pane with the design view on one side and the code view on the other. The code view, in this case, will be populated with a good bit of Xaml. We’ll close the Xaml window for now to focus on the Design view.

A Very Quick Tour of Visual Studio

To close the Code View make sure the Design View it is on the left (you can switch it with the double arrow button between the panes) and then click the double-arrowhead to close the code view. Finally, make sure that the Properties window is visible on the right (F4) and the toolbox is pinned open on the left ( Control-Alt-X). In the illustration below, I’ve labeled 7 areas. Let’s go over them one by one:

Area 1 is the toolbox. Note that at the upper right hand corner (circled) are three symbols. The first allows you to

Area 2 is the Application String and Area 3 is the Page Title string; we’ll return to these shortly.

Area 4 is the ContentPanel and we’ll be doing most of our design work here.

Area 5 is the Solution Explorer, which is above the Properties window by convention (you can of course move any window to any position)

The properties window is divided into area 6, where the name of the selected object is set and where you can switch the properties window from Properties view to Events view (more on events later in this tutorial). Area 7 is where the properties are set (you can see some of the Text properties exposed in this illustration).

Note the arrows emanating from the design panel. The upper two are used to switch between Code and Design when one of the windows is hidden. The lower three split the window vertically or horizontally, and reveal (or hide) the right hand (or lower) window respectively.

Above all of this is the menu and of course the most important menu entry is Help, which offers a variety of ways to receive help. To see one of its most powerful features at work, place the cursor anywhere in the RowDefinition keyword (approximately line 47) and press F1. The first time you press F1 you’ll be asked if you want to use local or internet help. If you have an internet connection, by all means ask for online help. A browser window will open with help on the RowDefinition keyword. Sweet.

As of this writing the on-line help file has tabs for each supported language. We’ll use the C# tab (which will set the C# tab for the entire page and which is sticky and thus persists to the next time you open the window).

Each entry follows the pattern of identifying the class, the namespace and assembly (we’ll cover both as we go). Syntax is demonstrated by language, and the Remarks section provides detailed information and links to related topics.

The examples section follows the Remarks section and provides copyable code to get you started.

After the Examples come the Inheritance Hierarchy, showing where your class fits in, and notes on Thread Safety, Platform, Versions and, finally a See Also section for related topics.

You also have much of this information locally in Silverlight.chm – a Windows Help file that was loaded when you installed Silverlight.

Creating The Form

Let’s return to the project and begin to create the form. For now we’re going to do all the work in the design view, though you’ll see later that everything done in Design view instantly updates the Xaml view, and vice versa.

Layout Controls

It is common to distinguish those controls used for layout from those used for interacting with the user, though the distinction is, in truth arbitrary. In any case, there are quite a few layout controls, though the two we care most about are the Grid and the StackPanel.

The Grid is the most powerful and (nearly) ubiquitous layout control – something of a UITableView on steroids. Click in the Content Panel (area 4 above) and the edges of the Grid that was placed there for you will light up. Move your cursor in the margin and lines will appear. Click and horizontal lines become rows, vertical lines become columns. You’ll want to create two columns (the left taking about 1/3 of the grid) and 8 rows of approximately equal size.

Click in the Grid and notice that the properties window has a ColumnDefinitions property and a RowDefinitions Property. Here you can make the spacing more exact. You can do so with precise sizes (e.g., 25px) or with percentages, or with relative sizing (e.g., 2* and 3* will create two columns with the first taking 2/5 of the available space.). I chose 1* (which you can shorten to *) and 2* for the columns, and seven rows of 1*.

You can of course open these instead of creating the rows and columns first in the designer.

Setting the Application Name and the Page Title

Click on the Application Title or the Page Title (areas 2 and 3 above)

We’ll use the left column for the prompts. Drag a TextBlock (used for displaying text) into the first row (row offset 0), first column and place it more or less in the center. Then switch over to the properties window and set the following properties:

Name=NamePrompt (In area 6 above)
Common::Text=Full Name
Layout::Width=auto
Layout::Height=30
Layout::HorizontalAlignment=Right
Layout::VerticalAlignment=Center
Margin=5
Layout::Padding=0
Layout::MinWidth=30
Layout::MinHeight=30
Layout::MaxWidth=0
Layout::MaxHeight=0
Layout::Grid.Column=0
Layout::Grid.Columnspan=1
Layout::Grid.Row=0
Layout::Grid.Rowspn=1

Adding the Remaining Prompts

Drag six more prompts onto the form, setting them identically, except for the Text and the Row. The rows will be 1,2,3,4,5 and 7 and the Text will be

Street Address
City, State, Zip
Phone
Fax
Email
Notes

You can leave all the rest alone except that under Text you’ll want to click the Bold button and you’ll want to set the prompt names (or use the default as the only reason to have meaningful names is when you need to address the objects programmatically, which we won’t do with these labels) and don’t forget to set the Grid.Row appropriately.

The row you skipped will be used for the Male & Female RadioButtons without a prompt.

The fact that so many of the properties are identical may be giving you the willies. Not to worry, we can fix this with Styles, a topic taken up in a future tutorial. The complete Xaml is below, to facilitate cut and paste.

Adding the Input Controls

Next, you’ll want to add the input controls. Add TextBox objects to rows 0,1,3,4,5 and 7 . Set the following properties:

Name=Name (or StreetAddress, etc.)
Common::Text=Full Name (or street address, etc.)
Layout::Width=300
Layout::Height=70
Layout::HorizontalAlignment=Left
Layout::VerticalAlignment=Center
Margin=5
Layout::Padding=0
Layout::MinWidth=30
Layout::MinHeight=30
Layout::MaxWidth=0
Layout::MaxHeight=0
Layout::Grid.Column=0
Layout::Grid.Columnspan=1
Layout::Grid.Row=0
Layout::Grid.Rowspn=1

Using the Stack Panel

You skipped over the input control for row 2 (the third from the top) because you want to place three text boxes in that row (for city, state and zip, respectively). If you just set all three to the same row and column they will appear on top of one another. What you want is to “stack” them, but in this case not one on top of the other, rather one next to the other.

Drag a StackPanel onto the form and set its properties as follows:

Common:Orientation = Horizontal

Layout::HorizontalAlignment=Stretch

Layout::VerticalAlignment=Stretch

Margin=0

Layout::Padding=0

Layout::MinWidth=0

Layout::MinHeight=0

Layout::MaxWidth=Infinity

Layout::MaxHeight=Infinity

Layout::Grid.Column=0

Layout::Grid.Columnspan=1

Layout::Grid.Row=0

Layout::Grid.Rowspn=1Setting the Horizontal and vertical Alignments to stretch with no margin causes the StackPanel to expand to fill the cell. Next, place three TextBox controls within the StackPanel (on top) and set their properties as follows:

Name=City
Width=150
Height=70
HorizontalAlignment=Left
VerticalAlignment=Bottom
Margin=0,0,0,5
Text=City
Name=State
Width=74
Height=70
Margin=0,0,0,5
Text= State
Name=Zip
Width=93
Height=70
Margin=0,0,0,5
Text= Zip

Notice that controls within the StackPanel do not need Grid coordinates.

Finally, you’ll want to add the two RadioButtons in row offset 6. Again create a StackPanel, and within the StackPanel place two RadioButton controls:

Name=Male
Content=Male
GroupName=Sex
IsChecked=True
Name=Female
Content=Female
GroupName=Sex
IsChecked=False

The GroupName creates a Radio Button Group allowing the buttons to be mutually exclusive.

That is your UI.

Running the Application

Before we go any further, if you haven’t yet done so, run the application. You can do this by clicking Build->Rebuild Your First Application (or control-shift-B) and then clicking Debug->Run (F5) or you can skip the first step and just run, as that will force a rebuild. Your application will come up in the emulator, with populated fields! Hoo ha!

When you are done enjoying the first version of your app, stop debugging (press the stop debugging button on the toolbar or Debug->Stop Debugging) but do not close the emulator. The emulator takes a while to “boot up” and you can leave it running; it will attach to your program each time you rebuild and re-run.

Data Binding

Unfortunately, we are rarely called upon to populate a form with known values. Somewhat more common is to populate the form from data, often data retrieved from a database, possibly via a web service. We won’t worry about how to retrieve the data in this tutorial, but let’s take the plunge into Data Binding – the technology of telling the View how to obtain the data it needs. Since we are doing this with MVVM, we’ll have the ViewModel obtain the data from the Model, message it as required by business rules and then use binding to allow the View to have no code in the MainPage.xaml.cs file. (This greatly assists with testing).

To make this work we need to do two things:

Create data in the Model
Create the View Model with public properties to which each control can bind
Update the View…

Ok, Three Things, we need to

Create data in the Model
Create the View Model with public properties to which each control can bind
Update the View setting each control’s binding
Set the data…

Four things! Yes! Four things…

Create data in the Model
Create the View Model with public properties to which each control can bind
Update the View setting each control’s binding
Set the data context
Pretty Red Uniforms

Create Data In The Model

While in a “real” application you’ll get your data from a data source such as a web service (which may in turn get the data from a database) for now we’ll create an instance of a “Customer” class right in local code. Create a Customer.cs class in the Model folder that looks like this:

using System;

namespace Your_First_Application.Model
{
    public class Customer
    {

        public string First { get; set; }
        public string Last { get; set;  }
        public string Address { get; set; }
        public string City { get; set; }
        public string State { get; set; }
        public string Zip { get; set; }
        public string HomePhone { get; set; }
        public string WorkPhone { get; set; }
        public string Fax { get; set; }
        public string WorkEmail { get; set; }
        public string HomeEmail { get; set; }
        public bool IsMale { get; set; }
        public string Notes { get; set; }
        public int CreditRating { get; set;  }
        public DateTime FirstContact { get; set; }
        public DateTime LastContact { get; set; }

    }
}

C# For Objective-C Programmers

These are called “automatic” properties. When you write

public string First { get; set; }

the compiler treats it exactly as if you had written

private string _secretvariable
public string First
{
   get { return _secretVariable; }
   set { _secretVariable = value; }
}

That is, it is as if you had created a backing store for the value (in this case the string _secretVariable) and the get accessor returned that value. The set accessor sets the value of the backing store to the value passed in to the set accessor. Here’s how you use either form

First = "Mary";        // call the setter
//....
string fn = First;     // call the getter

The first line calls the setter and the string Mary is passed in as value.

The second line represents intervening code.

The third line uses the getter to retrieve “Mary” and assign it to the local string variable fn.

Why Not Use Fields?

If we’re using automatic properties, why not use public fields? Jon Galloway points out that this is a common question and that one of the better answers was given by Scott Guthrie:

Note about that we aren’t actually adding any logic in the getters/setters of our properties – instead we just get/set the value directly to a field. This begs the question – then why not just use fields instead of properties? Well – there are a lot of downsides to exposing public fields. Two of the big problems are: 1) you can’t easily databind against fields, and 2) if you expose public fields from your classes you can’t later change them to properties (for example: to add validation logic to the setters) without recompiling any assemblies compiled against the old class.

Finishing the Customer Class

With the properties in place we need a way to generate an instance. Best would be if we didn’t have to have an instance to create one, and so we’ll add a static method that returns a pre-filled instance. Static methods can be called on the class rather than on an instance (as you’ll see in just a moment).

public static Customer GetCustomer()
{
    var newCust = new Customer(
        "Martha",
        "Washington",
        "1640 Pennsylvania Avenue",
        "New York",
        "NY",
        "11214",
        "617-555-4663",
        "781-555-9675",
        "212-555-5353",
        "jesseliberty@jesseliberty.com",
        "none",
        false,
        "VIP - Treat nicely",
        700,
        new DateTime(1955,07,10),
        new DateTime(2010,06,06));
    return newCust;
}

This method does nothing more than to create an instance of the class, populate its fields and then return that instance. You would never do this in production code, but it does give us an instance of the Customer class as if we had obtained it from a web service. All that is missing is the constructor that we’re calling (that takes a value for each property),

public Customer(
    string first,
    string last,
    string address,
    string city,
    string state,
    string zip,
    string homePhone,
    string workPhone,
    string fax,
    string workEmail,
    string homeEmail,
    bool isMale,
    string notes,
    Int16 creditRating,
        DateTime firstContact,
        DateTime lastContact )
{
    First = first;
    Last = last;
    Address = address;
    City = city;
    State = state;
    Zip = zip;
    HomePhone = homePhone;
    WorkPhone = workPhone;
    Fax = fax;
    HomeEmail = homeEmail;
    WorkEmail = workEmail;
    IsMale = isMale;
    Notes = notes;
    CreditRating = creditRating;
    FirstContact = firstContact;
    LastContact = lastContact;

}

That’s the model.

The ViewModel

The job of the ViewModel is to manage this data, bind it to the view and handle user input and user actions. We’ll postpone a discussion of user input and user actions until a future tutorial, but let’s create the view model with public properties for each of the values in the Customer that we want to display in the view. Here’s the complete MainViewModel.cs file

using GalaSoft.MvvmLight;
using Your_First_Application.Model;

namespace Your_First_Application.ViewModel
{
    public class MainViewModel : ViewModelBase
    {
        public string ApplicationTitle
        {
            get { return "Your First Application"; }
        }

        public string PageName
        {
            get { return "Customer"; }
        }

        private readonly Customer cust = Customer.GetCustomer();

        public string Name { get { return cust.First + " " + cust.Last; } }
        public string Street { get { return cust.Address; } }
        public string City { get { return cust.City; } }
        public string State { get { return cust.State; } }
        public string Zip { get { return cust.Zip; } }
        public string Phone { get { return cust.WorkPhone; } }
        public string Fax { get { return cust.Fax; } }
        public string Email { get { return cust.WorkEmail; } }
        public bool IsMale { get { return cust.IsMale == true; } }
        public bool IsFemale { get { return !IsMale; } }
        public string Notes { get { return cust.Notes; } }
    }
}

The first two public properties are put in place by the MVVM Light Toolkit, the 11 at the bottom are the properties to which we’ll bind the 11 user controls.

Setting the Data Context

Notice that the values that we’re binding to are values on the customer object. How will the UI elements know what object has these properties? That is handled by the Data Context property of the control, or its container (grid) or the container’s container (the page). With MVVM Light Toolkit this work is done with the DAtaContext Locator object, which you’ll find was declared in the Xaml file,

DataContext="{Binding Main, Source={StaticResource Locator}}">

This declaration was created for you by the MVVM Light Toolkit and so you do not have to worry about it; it just works.

Binding at the UI Level

It is time to bind the controls to the properties in the ViewModel. Return to the View and click on one of the TextBox controls. Delete the content and select binding. The dialog that opens will ask which public property you wish to bind to.

The tiny gold barrel on the line with the Text property indicates that you have a known data source. The dialog box that opens has four tabs:

Source
Path
Converter
Options

Source is the data context (though you can have other sources, a topic for a later tutorial)

Path is the property to which you’ll bind

Converter allows the binding object to convert the type and/or to format the data

Options is where you pick one of the three types of binding:

One Time
One Way
Two Way

OneTime binding sets the binding and shuts down the binding connection.

OneWay binding is for read-only data

TwoWay binding allows the user to update the data you are displaying. We’ll look at TwoWay binding in an early upcoming tutorial.

Creating the UI in Xaml

While drag and drop and setting properties works very well, you may find that your friends who do Silverlight programming do not take advantage of this. Rather they write these simple UI designs directly in the Xaml. This is very much an artifact of the days in which coding the Xaml directly was the only option, but you may be interested in how to do such a thing. Easy, peasy. Return to the split screen and examine the Xaml that was generated. Change the Xaml and see how the UI changes. Change the UI and see how the Xaml changes. Here is the complete Xaml for our page,

You can obtain the complete source code for this application here.

Avoiding Property Wrappers

An argument can certainly be made that too many of the properties in the ViewModel are nothing but pass-through wrappers for the same properties in Customer. You can avoid that by making a Customer object a public property of the ViewModel and then binding to that directly. If you prefer that style, you would want to change the ViewModel to look like this:

public class MainViewModel : ViewModelBase
{
    public string ApplicationTitle
    {
        get { return "Your First Application"; }
    }

    public string PageName
    {
        get { return "Customer"; }
    }

    private   Customer cust = Customer.GetCustomer();
    public   Customer Cust { get { return cust; } }

    public string Name { get { return cust.First + " " + cust.Last; } }
    public bool IsMale { get { return cust.IsMale == true; } }
    public bool IsFemale { get { return !IsMale; } }
}

You’ll need to update the Xaml file to bind to WorkPhone and WorkEmail (as the ViewModel is no longer translating for you).

Finally, you’ll need to bind explicitly to the Customer property for most of the fields, and to the ViewModel for the couple (Name and Male/Female) that will use Properties on the VM rather than on the Customer

public MainPage()
{
    InitializeComponent();
    var vm = new MainViewModel();
    DataContext = vm.Cust;
    FullName.DataContext = vm;
    Male.DataContext = Female.DataContext = vm;
}

We create an instance of the ViewModel, and then set the DataContext of the View to the Cust property of the ViewModel. We then set the DataContext of FullName to the ViewModel instance, and finally we set Male.DataContext and FemaleDataContext to the vm as well.

Mind Map

This is the kind of thing that people who like this kind of thing like.

[Click on the map to see it full size]

Go to next tutorial

The Open Source Project Spec: With Reference To Me

Jesse Liberty — Thu, 26 Aug 2010 21:03:00 +0000

http://WithReferenceTo.Me

The application that we’ll be developing in the next phase of the HVP will allow the user to record and then look up everything that happened from day to day.

With this application, each day you can record:

Music you listen to
Pictures you take
Who you sent and received email from
Who you chatted with
Where you were and where you went
Notes you make about the day
Accomplishments
Insights and ideas
People you meet…

you get the idea.

Some of this is recorded automatically for you while the application is running. Some you enter. Some will be manual today with a goal of making it automated in future versions. The data you record will be local to your phone unless you choose to upload it to the (to be created) web site.

Plus ça change…

Yes, this is a change in the vision for the next phase, but I think it will better illustrate

The phone functionality
Transmedia Storytelling
Coding for WP7

Development Schedule

Item	Working Due Date
Graphic Design	October 29
Initial MVVM Design	October 29
Begin coding and unit tests	October 29
First release	November 20
Interim release	December 3
Interim Release	December 17
Code Complete – Alpha	January 2
Bugs Fixed – Beta	January 9
Release Candidate	January 16
First Release	Feb13, 2011

NB: due to scheduling conflicts, this is a 1 month delay in the project.

This work is licensed under a Creative Commons license.

Programmer Superstitions

Jesse Liberty — Thu, 26 Aug 2010 13:10:49 +0000

There are a number of practices that we engage in –– no, that we cling to, and defend, and teach to others, – that amount to magical thinking, or at best, rational failure.

This is often just fine, no harm done (other than to our self-image as rational geeks) but some of these totemic-rituals are stumbling blocks in our ability to produce reliable software.

From time to time we might want to stop and question our most cherished assumptions to see if we’ve fallen into any of these traps:

Secrecy and Mystery
Ancestor Worship
Apophenia
Argument From Authority

Secrecy and Mystery: Data Hiding

I’ve been writing in and teaching C++ and C# for twenty years. I know well the iron-clad rule of object -oriented programming that class data should be hidden (private) and accessed through either a property (C#) or an accessor function (C++). Thus:

public class Employee
{
    private string name;
    public string Name
    {
       get { return name;}
       set { name = value;}
    }
}

There are good reasons for this rule. Data hiding makes for a better decoupling of classes, and allows the programmer to intercept the access of private data and apply rules or other processing. It is possible, for example, to check whether the client accessing a value has the correct permissions to see or modify that value, and also to massage the data in appropriate ways.

But look closely at the example shown above: it is not unusual. The backing data is stored as a private local variable, and full access is provided with a get and a set accessor, neither of which do anything but return or set the value. That is, the accessors add no immediate value at all. The typing penalty is solved with automatic properties,

public class Employee
{

    public string Name
    {
       get; set;
    }
}

But to some degree this just hides the problem. After all, why not write

public class Employee
{
    public string Name;
}

Don’t panic when you see this; consider that there is little difference from the automatic property and it is a heck of a lot more straight forward.

The last, desperate excuse, as you will find in many computer books, including my own (I add with some chagrin), is that making the backing variable private (or using automatic variables, and changing them when needed) allows you to change how you store the data without breaking any client of your Employee class. You could, for example, decide some time in the future to retrieve the name from a database.

The rational part of me suspects that the number of person hours wasted, both by all the hocus pocus of properties is swamped by any possible benefit. And, yet, I can’t quite bring myself to eschew the properties.

The problem is that can’t justify my reluctance rationally. Either this is a superstition, or more likely, it is the Asch conformity effect, in which students were shown three lines, one distinctly longer than the other, but confederates of the experimenter in the audience insisted that the shorter was longer. If three confederates or more made the false assumption, the subjects were likely to go along more than a third of the time(!)

Ancestor Worship

Let’s take an example where we are not only being irrational, but also making our lives harder and our code more expensive to write and to maintain.

You may want to sit down for this one, but I’m going to dare to ask: why do we insist that C-derived languages (such as C#) continue to be case sensitive? Other than paying homage to Kernighan and Ritchie I believe I can safely say after 20+ years of writing in C, C++ and C# that the disadvantages of case sensitivity swamp the advantages.

The only clear advantage I have ever found is the ability to have make the name of a property be the PascalCase version of the camelCase name of the backing variable

private int age;
public int Age { get { //... } set { //.... } }

In exchange for that convenience, we enjoy hours of debugging, trying to find where we inadvertently introduced a new variable or method name because of a misplaced shift-key.

And even in the best case, the argument is obsolete, as the convention now is to use an underscore

private int _age;
public int Age { get { //... } set { //.... } }

Has any bright graduate student done research on the cost/benefit of case sensitivity? Is there any rational reason that in 2010 C# continues this ‘“tradition”’ that was established 30+ ago? Or might it be a lingering fear of showing disrespect to the icons of our industry; the mighty heroes who created the C family, defeated Troy and bequeathed us the scriptures by which we live?

Or Maybe Not…

There is an argument that case sensitivity makes more sense with some human languages other than English, and may even make sense as an optimization for some data structures, such as hash tables. Such arguments, however, speak to the need for an optimizing compiler to handle the issue; there is no reason for the language to do so.

C++ programmers like to suffer anyway, so this just feeds the beast.

Ancestor Worship II

Here’s another example of latent ancestor worship (or at least of very old habits dying hard). There is a wonderful myth that American standard rail road tracks are the width they are (4 feet, 8.5 inches) because that is the way they built them in England, which the English did because that is the way they were gauged by the first tramways, which in turn was done because that is the width of wagon wheels created to fit in the wheel ruts in old English roads that were in turn dug by by Imperial Roman Chariots.

The myth has tremendous lasting power (you can find it all over the net) because it feels right (expectation bias?) . We do that kind of thing a lot; we build the streets of Boston on old cow paths; we unconsciously follow old patterns, even when those patterns no longer make sense or are necessary.

How many times have you seen (or written) code like this:

for ( int i = 0; i < innerArrayLength; i++ )
{
    for ( int j = 0; j < outerArrayLength; j++ )
    {
        myArray[i][j] = i * j;
    }
}

Why are the counter variables i and j? Old cow paths. It turns out that in Fortran (remember Fortran? Remember Eisenhower?) the integer variables were the letters I through N (which comes from an even older tradition of mathematicians using i to n as subscripts for integers), and, well, we just got into the habit. This one is fairly harmless, a ritualized and vestigial part of the programming mind that we’re surprisingly reluctant to let go of.

Pattern Recognition

One of the most powerful forms of magical thinking is Apophenia: seeing patterns or connections in random data. The tendency towards Apophenia is probably hardwired into the human brain; it is the price we pay for the very advantageous human ability of pattern recognition (an adaptive part of our intelligence that helps us know when to run and when to hunt) but it can also lead us astray (arguably it is the basis of our belief in many pseudo-sciences).

Apophenia is certainly pervasive in consulting. A classic example was the tendency to study “’excellence’” in successful companies in the 1980s; trying to extract those apparent essential elements that lead to success.

Unfortunately, not only was it far more complex and difficult for other companies to reproduce success following these patterns, even the iconic companies themselves felt the worm turn over time. They kept repeating their patterns, but the outcomes were different. What went wrong?

It was not clear that the patterns of ‘“excellence”’ we were “seeing” in successful companies (great customer service, their caring attention to employees and attention to details) were as easily connected with success as we had thought. Correlation is not always causation, as we so often learn (post hoc ergo propter hoc).

Argument From Authority

Argument from Authority, to disagree with Samuel Johnson, is the true last refuge of scoundrels.

Some years ago I testified as an ‘“expert witness’” in a civil lawsuit, at which the opposing ‘“expert witness”’ asserted that the ‘“failure”’ of the project could be attributed to a lack of strict compliance with the ISO 9000 standard.

Smart people can have a reasonable discussion about whether ISO 9000 will improve the likelihood of success on very large projects (e.g. , the software for the mission to Mars). I personally would not like to work on a software project that is managed using anything like such a bureaucratic, heavyweight, inflexible, document-intensive, rigid processes, but that does not necessarily mean that I can prove that no project would ever benefit from it.

I had no hesitation, however, in asserting under oath, that the fact that various authorities asserted this was the right process for every project was abject nonsense. I went on, at the arbiter’s insistence, that my personal assessment was that a project with ten developers would benefit from strict adherence to ISO 9000 like a drowning man would benefit from being thrown an anchor. It was my opinion that knee-jerk reliance on a process like ISO 9000 to guide you through each project is a form of Apophenia; the connection between the pattern of ISO 9000 compliance steps and success, however measured, is imaginary. And, I concluded, supporting that theory with Argument From Authority was, at the least, irrational.

Looking where the light is

There is an old joke about a man searching for his keys under a street lamp. He lost the keys in the alley behind him, but this is where he can see.

In our desperate attempt to gain control over very complex processes, with so much money at stake, and so many examples of previous failures, we often fall victim to seeing apparent patterns (be they processes or otherwise) where they do not exist. We examine various projects and say:

“’Ah ha! I see why this project worked and that one didn’t: the difference was too much/ (too little) analysis (/ design) (/ documentation) (/ process) (/ oversight) (/ communication).

And all we have to do is increase/ (decrease) the number/ le (length) (/ duration) (/ sequence) (/ complexity) (/ formality) of the meetings (/ documents/ ) (diagrams) (/ studies) (/ sign-offs) , etc.

These false patterns lead us astray; offering us the promise that if we paint by the numbers, we too can be Renoir. It may be, however, that the variables of successful process are far more complex; including, if we are terribly unlucky, factors over which we have little or no control; or, only marginally better, factors over which we will have no control until our tools and technologies mature.

Or, it may just may be that some developers are better at the ‘“art”’ of programming and shipping product; and that the old adage ‘“’tis a poor carpenter who blames his tools”’ applies to software as well as it does to other crafts.

The Scientific Method

Over the years, at least to some degree, society has given up many (though not all) of its superstitions when presented with more compelling alternatives. One of the most effective techniques for distinguishing between superstition and truth (or some approximation of truth) is the scientific method; in short, controllable, measurable, reproducible effects that are disprovable.

It’s hard to do that sort of thing when you’re trying to hit a deadline, and it’s particularly hard to sort out all the alternatives when there are so few objective comparisons.

When was the last time you were able to find anything like an objective answer to the question “which is better: Java or .NET?” (Please don’t write in, my mailbox fills quickly).

It is particularly interesting that the work done at Universities and Research Centers is often not only unrelated to, but totally disparaged by, the folks who write code for a living. That is not the way things work in other Engineering fields and I’m not convinced we can afford the disconnect for much longer.

We seem to be writing 21st century software with a 12th century mindset and that can’t be good.