Lack of Setting Priorities for Conflict Resolution

Remember the days of the PDA?

Remember when software and devices could be configured on how to handle conflicts?

Users got to choose whether the PDA overwrote the Desktop, or if the Desktop overwrote the PDA, or if copied to each other regardless of whether they were duplicates or not.

Looking back on those days, it is a wonder how that level of control so easily got taken away from the user without anyone realizing it or raising a fuss about it.

Think about it for a moment.

The major feature request users want is "bi-directional synchronization".

They want changes from one service brought over to another one automatically without having to worry about it.

Unfortunately, it is not as easy or simple as it sounds because these services rarely, if ever, talk directly with each other.  

EXAMPLE: FACEBOOK

• Users want Facebook friends, their emails, phone numbers, work status, etc... all pulled over and whenever it changes, they want it changed in their address book.
• If someone gets un-friended, perhaps users want that contact removed from their address book.
• The problem is that, of course, is Facebook's lack of pulling that data out (see my post.....)

EXAMPLE: LINKEDIN

• Contacts are often changing their job history and users want their address book to be able to stay on top of those changes.
• But what if a contact changes jobs or got promoted or moved to another department? 
  • Perhaps the user manually updates that contact's information with new phone numbers and email addresses within their personal system.
  • Since it is the contact's responsibility to update their profile, there is the potential that LinkedIn still has old, outdated data. 
  • If synchronization was set up, how can the user be sure that their address book's new information will not get overwritten by the old data?

In order to resolve this lack of communication between the various social networks, several third-parties services have popped-up to act as intermediaries.  These centralized servers import data from the various networks which allow either exporting manually or through API calls.

Regardless of the method, the bottom-line is that, either way, bi-directional is just not possible.

• What happens when that central server sees conflicting data?
  • That is where the problem truly exists- when multiple services talk to each other and users no longer have the option to decide which service takes priority.
• Who determines what should be kept and what can be overwritten?
• Who decides whether something should be added or disregarded?
• How does the user know which service or data is the most accurate or up-to-date?
• What happens with partial and incomplete data?
• If the data gets imported instead of synchronized, does the service add it as additional data or overwrite the existing data? 
• If it is added, how is the user supposed to know which is the most accurate and up-to-date data?

Since users expect to just "work", they don't want to think about these types of things.  When phone numbers get duplicated, email addresses get overwritten, and contacts get lost, they don't care how it happened, they just want it back the way it was so they can fix it themselves.

From what I have seen, it doesn't.  It treats it more like an import.  Unfortunately, that means that, in the import, if a contact already exists, all it does is ADD the existing information to that contact.

Without actually running the synchronization, there is no way for users to really know, and that should scare them.