I have recently started to look at reusing a Silverlight 4 ViewModels in a WP7 applications. I figured this would probably be the easiest place to start since they are both Silverlight. I was recently asked what would it take to make a component reusable across Silverlight and WPF.  That figures right into my ViewModel sharing research. I will start by looking at different ways to share code across all three frameworks.  In a future post I will explore ways to reuse Xaml.

The Challenges

Let’s start off by examining the challenges associated with this task.  The first challenge is the fact that they are three different frameworks that are designed for three different use cases.  That means that any reusable code would have to be coded to the lowest common denominator.  In this case it means WP7.

For this post I don’t have any working code to share but I have been trying a few things.  One of the first things I ran into was in the System.ServiceModel namespace.  Each framework handles calling web services differently.  Silverlight and WP7 can only make calls asynchronously and WPF defaults to synchronous calls.  I am still working out how I want to handle this.  There are other challenges too, take third party libraries for instance.

Another challenge that you are going to face is keeping consistent namespaces across the frameworks.  If your organization has a strict naming convention then this could become a challenge.  Luckily you control what your namespaces are but it can become quite hairy if you are not careful. 

Third Party Libraries are usually compiled against specific runtimes.  The third party library that I consistently use when working with Xaml is the MVVM Light Toolkit.  Luckily the MVVM Light Toolkit is compiled against the different Xaml runtimes and the functionality is consistent across the frameworks.  But with other libraries you may not be as lucky.  Now it is time to talk about the different options available for reuse.

Copy and Paste

The most basic method is copy and paste.  This is a quick and dirty solution.  First you create a file that works in one framework.  Then you create that same file in the other projects copying the code from the original class to the new class.  The up side to this method is that you can tweak the code for each framework.  But red flags should be waving and alarms sounding.

Copy and paste architecture is NOT the key to a reusable strategy.  There is no means to update the code once it resides in each project since the code is not linked together. Any change would need to be propagated across the different files.  Which may be ok if there is one “shared” file and more than that and you are asking for a nightmare. In other words there is no maintainability or scalability with this option.

Add As a Link

The next option I explored is add linked files to the projects. For this method you create a class in on project and then add it as a link to another project.  In the “Add Existing Items” dialog you can navigate to the file you want to link and select “Add As Link” from the “Add” button dropdown.

You can tell the file is linked by the icon of the file in the linked project. With this solution there is only one physical copy of the file.  Each project then compiles the file against the proper framework. The up side to this approach is that there is only one file to maintain.  On the downside namespaces can become an issue. You may also have to use conditional compile tags if modifications are needed.  Conditional tag will allow for the use of different using statements when it comes to third part libraries as long as the internal namespaces are consistent.

Portable Library Tools

The final method I looked at was the Portable Library Tools from Microsoft. The Portable Library tools

is a new Visual Studio add-in from Microsoft that enables you to create C# and Visual Basic libraries that run on a variety of .NET-based platforms without recompilation. – Visual Studio Gallery Description

The add-in can be downloaded from the Visual Studio Gallery.  This method allows you to create a class library that can run against many of the .Net runtimes.  To accomplish this the class library compiles against a very restrictive version of the .Net framework.   This can be a challenge when planning out what to include in a reusable library.

Since this project is still in the CTP/Beta phase not all of the available frameworks libraries have been included. Most notably there is no odata support so you cannot create a reusable odata access library with this tool. According to the Q and A tab in the gallery there is a product road map that plans to include more of the framework.

On a side note it looks like this tool is part of the developer story for Windows 8.  Take a look at the response, on the Q and A Tab, to the “System.Threading.Thread problem” question.

We needed to remove explictly thread creation for a reason that we’re not ready to discuss yet (ask me again in 3 months).

Note that the Build Windows Conference is three months away.

Conclusion

Sorry there is not any working code for this post.  I am still mulling over how I want to accomplish my goals.  I wanted to put this together to organize my thoughts and get feedback from others who have tried for reusable nirvana.  One of the lessons that I have learned so far is be picky about what you include.  The different frameworks kind of take care of that for you by restricting what libraries are available.

The other early lesson I have garnered from my investigation is that you have to be more aware of Framework updates that could break your reusable code.  There is a lot of churn happening right now with Xaml frameworks (Silverlight 5 and WP7.1).   New releases may break what you are doing but they may also bring in more components that can be reusable! 

Next I will be looking to see how compatible Xmal is across the different frameworks. The ultimate goal is to develop a strategy that allows components to be used across Silverlight, WPF and Windows Phone.

This weekend was the second annual New England givecamp.  A weekend dedicated to helping out charities with technical projects.  These projects range from designing web sites to building out content management systems.  In addition to getting technical help there are seminars designed to help charities make the most of the technology they are getting.  This weekend there were sessions on content management, engaging social media, and others to help these organizations grow in a highly technological world.

First I would like to thank all the sponsors of providing the means to fuel all the activities this weekend.  What does it take to keep developers developing…..a lot of support so again thanks.

Next I would like to thank Jim O’Neil and Kelley Muir for organizing the event.  It may not have seemed it to you but to us it was very well organized.  Leaps and bounds over last year.  Which means next years should be spectacular…..no pressure!

The one thing you need to realize is that the word camp is in the title and camped we did.  A number of the volunteers camped out here at Microsoft’s New England Research and Development Center, affectionately known as NERD! Thank you Microsoft for letting us have run of your beautiful facility for the weekend. There was plenty of room for people to pull up a piece of the floor, grab a couch and pitch a tent……wait pitch a tent?  That’s right some people even pitch tents!

As I stated before it takes a lot of food to keep an Army of Techies moving.  The food this year did not disappoint!  We had  chowdah from Legals, sandwiches for Cosi and pizza from Naked. 

And when there was too much food what did givecamp do?  Give it away, of course, to a local shelter:

“took #givecamp leftovers, fruit, chips to CASPAR in Cambridge – shelter housing 100 tonight. Another way #negc2011 makes a difference.” @jimoneil

So here we sit, the morning of the final day.  Tech teams have 5 hours to get their projects done.  They are frantically racing to deliver quality projects to their charities.  The key word is quality.  The goal is to handover all the work to the charities so they can build upon a foundation laid out by their tech teams.

So until next year I leave you give camp with this quote

“Ladies and gentlemen, take my advice, pull down your pants and slide on the ice.” Dr. Sidney Freedman (M.A.S.H.)

And I would add

Get out of your office and do something nice!

Goals

The ultimate goal is to keep the UI specifics out of the view model.  This separation increases the reusability of the view models while at the same time allowing for maintainability and testability.  Another goal is to abstract out the launching of child windows so that they can be easily launched from any view.  A good example of this is an Error Window.  I will show an example of this in this post.

In this post I will show launching a dialog that requires passing data from the view. I will show an example that returns data from a dialog that the view model can consume. Finally I will show an example that takes my ReturnAction<T> object (described in my last post here) to handle passing data back including any exceptions.  You should be able to handle any situations by interchanging these building blocks. 

All of my child windows have their own view models so I am limiting the amount of code I place in my view’s code behind.  I am not an MVVM purist.  I believe you can put code in the code behind as long as you limit it to view specific code and do not do any business logic there.  In my case I will be setting properties on the DataContext (ViewModels).  I will also be closing the child windows from the code behind as you will see in later examples.

The Pieces

The first step is to abstract the launching of the dialogs.  To accomplish this I create a navigation service.  Here is the interface for my navigation service:

As you can see I have three different child windows in this demo, each requiring different data.  Note you could also add a method for navigating to other pages if you are using a Silverlight Navigation application.  This would allow you to navigate from page to page from the view models.

The actual implementation is responsible for launching the child windows passing any required arguments.  Here is what my implementation looks like:

Note the two different ways I am passing arguments to the child windows.  In the first method I am passing an exception to the constructor of the ErrorView child window.  I will then pass this parameter to the DataContext in the code behind of the ErrorView.  The second dialog takes no arguments and returns a message that gets displayed in the main view.  The final dialog takes a ReturnAction<T> which it uses to pass the results back to the main view.

The NavigationService is injected into the ViewModels  from the ServiceProviderBase through the ViewModel Locator (described in my last post here).  I treat the NavigationService just like I treat the my service wrappers from my service layer.  The NavigationService provides a service for the view model. 

A Reusable Error Dialog

One of the most common dialog in an application should be the error dialog.  There should be a mechanism to display friendly messages when an exception happens.  This is especially useful when fault exceptions come back from service calls.   I will be showing an example of this when I show the dialog that works with my ReturnAction<T>.  For now I am going to explain how I implemented the ErrorView dialog.

You can see from the code above that I am passing the exception to the DisplayError method in my navigation service.  It then calls the constructor on the ErrorView passing the exception:

In the constructor I am casting the DataContext as an ErrorViewModel.  I the set a property, that I created, with that exception.  The DataContext is set in my Xaml (described in my last post here).  Through the magic of data binding the dialog calls ToString() on the exception and displays it to the user.  If the dialog looks familiar it is because it is the same one that gets created by the “Silverlight Business Application” template in the New Project dialog.  This shows how easily that can be adapted to fit this architecture.

Now to launch the dialog I bind a command to the button from the MainViewModel:

That is how easy it is one line of code (line 77).

Handling Return Data

The next example will show how I handle dialogs that need to return data to the underlying View/ViewModel.  In this example I am going to use the Messaging capabilities of the MVVMLight framework.  There is nothing fancy with how I create the dialog.  It is exactly the same way I created the ErrorView dialog above except that I am not passing any arguments. This is the dialog that gets launched:

I bind a command to the ‘Ok’ button from the ViewModel:

Here the Messenger class takes a MyMessage object and sends it out setting TheMessage property with the text in the TextBox. In the MainViewModel I subscribe to the message from the dialog.  It takes the MyMessage object and uses it to set a property on the MainViewModel that is bound to a TextBlock on the view:

The final thing to do is close the dialog.  Since we removed the click handler from the ‘Ok’ button, the code that usually closes the dialog no longer gets called.  So I subscribe to the same message in the dialog’s code behind.  In the Action of the message I call the code that closes the dialog.

One thing to note, it does not matter what you set DialogResult to.  We are not subscribing to the close event of the dialog.  We are handling any business logic (whether the user clicked ‘Cancel’ or ‘Ok’) through messaging.  It is up to the view models to take appropriate actions.  Theoretically you could hold off sending the message until a service returned and not do it right on the button click.  This would allow for a save action, for instance, to complete prior to closing the dialog.  But the decision to  close now resides with the view models and not the view.

An Alternate Way

The previous example is one way to get data back from a dialog.  Here is another way.  It is a combination of the ErrorView (getting an object in) and the last example getting data back.  In the ErrorView example I use the view code behind to set a property on the DataContext.  Here is an alternate way to accomplish the same task without using the code behind:

To understand what the ReturnAction<T> is look at my previous post here.  In a nutshell it captures a return object or and exception and allows the caller to create a call back method that gets called when the Notify method is called.  Here is the ReturnAction<T> getting created:

The constructor takes an Action callback which I will show in a few minutes.  In the dialog I create commands to bind to buttons on the dialog. For this example I simulate a message and simulate an exception being thrown:

(Note: I still have to use the Messenger to close the dialog).

In the MainViewModel I can now handle the action appropriately.  If there is a message I can display it and if there is an error I can handle it.

Conclusion

These example should give you some ideas as to how easy it is to use MVVM in your Silverlight Applications while dealing with Child Windows.  With a little bit of infrastructure in place you are able to work with different views passing data back and forth.

If you want to play with the code you can get it here.

In this post I will document an approach that I have used a couple of times that allows me to layer my Silverlight application in the way I would any other application.  That is the first trick to developing in Silverlight.  Treat the Silverlight part of the application as if it were is its own application, because it is! This holds true whether you are using RIA Services or getting your data from an external web service. By treating it as its own application you tend to bring in accepted coding practices but as I stated before there are some challenges.

For this blog I am going to use a project that I just started and will be working in my spare time.  I am building a File downloader to download content from Microsoft’s Mix11 Conference. This little project was inspired by a project Mike Taulty did for last year’s PDC.  I know that there are easier ways to download the video content from the conference.  Scott Hanselmen documents one such way by using the RSS feeds from Channel 9. This is more of an exercise to build an application that consumes an OData feed while at the same time maintaining an elegant solution.

Here is my initial layer diagram that I am working form:

These are the layers that I have come up with and will be working with through out this project.  I will be covering the details and interesting aspects of each layer in the following sections.

Presentation

I choose to use M-V-VM when I develop with Silverlight.  This pattern allows for separation of the UI markup from the functionality.  There are many frameworks that help out when working with MVVM.  The one I like to use the most is MVVMLight.  This is a nice light weight framework that contains a bunch of templates, some base classes and a messaging service.  Laurent Bugnion is even adding a light IoC container in the next version.  There are other frameworks that perform similar functionality and are just as good (Prism for one). I started using MVVMLight a few years ago and haven’t turned back since.

The next key to an elegant solution is to use a ViewModelLocator.  There are a few schools of thought when it comes to binding ViewModels to Views.  Some new them up in the constructor of the Views.  The problem with this is that there is no design time feed back using this method.  Others like to declare the binding in Xaml.  This is similar to how I do it except that I bind to a property in my ViewModelLocator.  With a ViewModelLocator you can control the lifetime of the ViewModel (new instance for each load or created once for the lifetime of the application).

Here is my ViewModelLocator:

Here you can see that I am using my locator class to inject a dependency into my ViewModel (I may changes this in the future to use the Simple IoC class from the MVVMLight framework).  I create an entry in a Resource Dictionary for my locator class.  So binding the ViewModel to the View is as simple as this:

In my ViewModelLocator you should notice a class called ServiceProviderBase.  You may be asking yourself what purpose does this serve.  I will tell you.  As you recall from our layer diagram our data access services live in another project. This class serves a factory for serving up our services.  In order to have design time data a DesignServiceProvider is created. Let’s take a look at the base class:

As you can see it is implemented a Singleton and which instance to serve up is determined in the CreateInstance method.  This method determines if it is design time or run time and serves up the proper provider.  That rounds out my Presentation Layer except for some Resources and Value Converters (the other things that make the UI elegant).

Model

You can’t have MVVM with a Model.  If you did you would VVM and that just does not look balanced! In this project I am not doing anything fancy.  I did decide to create a model that is separate from the model that is generated from the service proxy.  This will allow me to switch out the service layer implementation (say when the next conference happens) with little impact to my presentation layer.  I handle the mapping in the service layer. That concludes the model layer, I will now return you to your regularly scheduled program…..I told you not too exciting.

The Commons

When I am developing Silverlight application, I find that there are some classes I can’t live without.  These classes are needed in all the layers so I like to pull them out to a separate project that can be referenced throughout the application.  Someday I may even create my own open source collection of these things.  One of the biggest short comings of the Silverlight framework is a means to convert an IEnumerable into an ObservableCollection.  ObservableCollection’s are used to bind collections to the ItemsSource property of ItemsControls.  The observable part is what allows for updates to be delivered to the UI when something changes.  So I implement this as an extension method in my common project.  This is the kind of stuff that I like to put in.

One of the key things needed to separate out the services from the rest of the application is to have a means handle the asynchronous nature of service calls, especially when they are happening in a different dll. How does that presentation layer know when the service call they made is finished?  I have seen a few different ways to handle this including creating events in my service layer that the ViewModels cans subscribe to.  This is kind of like recreating the functionality in the proxy.  This approach can complicate things when it comes to unit testing.  The approach I like to take is to build out an object that contains a callback action.  This approach is similar to the approached outlined by Ben Day in his post Silverlight Asynchronous WCF Calls Without Ruining Your Architecture. Here is my implementation of his ReturnResult object:

The premise is that this object will be passed into all service calls.  When the service returns the Notify method is called with either the results or and exception.  The ViewModel can then handle this.  This brings us to our Service Layer.

The Serivce Layer

This is the layer that is responsible for ferrying the data between the source and the Presentation Layer.  The source can be anything from an RSS feed to a SOAP Service or in our case an OData feed.  Here I am abstracting out the how the data is retrieved allowing the Presentation Layer to concentrate on presentation.  I start out by creating a ServiceBase that is responsible for instantiating the proxy.  Here is my ServiceBase for the Mix11 OData feed:

I then create a design time service that returns design data and I create an actual runtime service.  In Silverlight all service calls return void.  The magic happens in the callback method.  How do I get access to my ResultAction<T> object in the callback method?  With a proxy created from a web service all the service method calls have an overload that takes an object that is available in the callback.  all you have to do is cast it as the ReturnAction<T> and be on your way.  I could not find such a thing when dealing with the DataServiceCollection<T> object used to pass queries to the OData service.  So I created my own caller that inherits from DataServiceCollection<T> and has a property to hold any state that must persist after the call returns.  Here is my caller:

And here is an example of this class in action pre call:

and post call:

This also shows the ReturnAction<T> class in action.  All my services implement interfaces that are used by the Presentation Layer in the ServiceProviders.  The Service Layer allows for many different data sources.  Adding/subtracting sources or even changing source will not have any affect on the Presentation Layer as long as they adhere to the contracts set forth in the interfaces.

Conclusion

This is a good place to stop for this post.  In this post I have laid out a layered architecture that can help developers build elegant Silverlight solutions.  I have addressed some of the pitfalls associated with Silverlight development and proposed solutions to those pitfalls that have worked for me.  As I get further along in my quest for building this downloader I will write further post that other may find useful.

The first question to as is why do I care about the Windows credentials of the user?  The simple answer is that I am building an internal Line of Business (LOB) application and I want to use Windows Authentication .  This makes sense.  If your company does not have a federated solution so that you can use claims base security, then Windows Authentication is the next best thing. 

Start out by creating a Silverlight application using the defaults, letting the template create the web application for you.

The first thing that you want to do is set up the web application to restrict users from accessing your web resources (xap files, .svc files, etc…).  To do that add the following code to your web.config file:

Obviously you would restrict the “allow” to specific domains and add a deny key for all other users.  You can restrict down to the folder level, allowing different access rights to different folders.

Now you are ready to create the a service.  For this example I am did a simple “Hello User” service.  It has a single method that returns the Windows Identity of the user making the call.

Ok the service method is configured, you need to modify service configuration in the web.config.

The key to this is the “security” configuration in the binding.  Once the service is configured you add a reference from the Silverlight client just like you would normally do.  There is nothing else you have to do.

My coworker then came back and said, “Our services are hosted on a different server this surely this won’t work in that situation?”  So I added another web application created an identical to the service I created in the original web application.

What do you think happened?  The same results. So it didn’t matter what server the services were on a different servers.

In this situation the client technology doesn’t matter.  The client could be WPF or even Winforms.  The key is your service configuration.

The message that they are sending is choose the technology that bests fits your situation.  They are also saying the Microsoft is committed to advancing development tools for both technologies. Based on this article here are my predictions for announcements for MIX11:

• Emphasis on Silverlight 5 may pale in comparison to HTML5 and WP7.  By the mere fact that they sent this message out they are trying to prevent another storm they received by downplaying Silverlight at PDC10. Also by announcing the SL5 Beta prior to the conference they are taking away some of the thunder that they like to have at these conferences.  So where is the thunder…..
• Thunder #1 tooling for HTML5. Microsoft has already started to support tooling for HTML5.  Expression Web 4 SP1 now supports HTML5.  But where is the support for ASP.Net?  I think you will hear about the .Net Framework vNext (4.5 or 5.o).  So I am going to guess it is going to be a point release to 4.5.  They may not have a beta/CTP ready yet but one would soon follow.
• Thunder #2 a new/updated version of the WP7 SDK.  There are two major release of the Windows Phone operating system coming up, Mango in the fall and WP8(?) sometime next year (to coincide with Windows 8). Here is what I would expect to here around these updates
• Full IE 9 (already announced for the Mango release) but with full support for in browser Silverlight applications!
• Upgrading the OS to Silverlight 5. Right now it is a hybrid of SL3 and SL4 with some phone functionality thrown in.
• Enterprise support (most likely would be in the release after Mango) for deploying internal corporate applications.  Also support for enterprise IT organization to control phone functionality in order to more align with corporate IT policies.

It will be interesting to see what comes out of next week.  Like I said these are my predictions and I am sticking to them…..but since I don’t work for Microsoft I have no way of know what they are really going to do.  I wish that I was going to MIX11 because no matter what they announce it is going to be an exciting place to be. I guess I will just have to watch the Keynotes online!

I wanted to comment but decided that a post would be better. I can expand on my thought as to why repositories work.  The first comment that I want to make is problem should dictate the architecture.  To make a blanked statement that repositories are bad may close the door on certain solutions.  In some instances implementing repositories may over architect the solution but is some instances it may be the right thing to do.

I am working on a side project where I have implemented repositories.  I chose this solution because I have two different data sources.  I have data in a database and I am also using the Netflix OData Service. The repositories allow me to abstract out the OData calls.  My business layer can now work it a MovieRepository (data from OData) and a repository that gets data from my database.  The business layer can then aggregate the data from the two sources and pass it to the Presentation layer.

Through the Specification Pattern I can pass my queries to the repositories and not litter my BLL with data access specific code.  The other thing that I was able to do was to create a database table that had a sampling of the OData data.  I built a repository around that since it adheres to the interface for the OData repository, I can switch them out without a code chance.  I use Unity to inject the repositories into the business layer so switch is as easy as changing the config file.  Now I have a data set to work with in situations where the OData service is not available. 

Repositories also allow me to go to one place to modify my data access code.  The key to using repositories is to have a good infrastructure in place in order to facilitate ease of development.  With right pieces in place adding functionality to an application should take no additional time.  A team from Microsoft – Spain put together the Domain Oriented N-Layered .NET 4.0 Sample App.  This is a great example of the use of Repository and Specification patterns.

Conclusion

The problem with patterns is we tend to over use them or adjust the situation to fit them.  The real skill of the developer is to know how to adapt them to the situation so that they become part of the solution and not part of the problem.

Log Entry to the Rescue

The first step is to come up with the schema that you want to use to store your log information.  Here is the entity of that I am going to use in the example for this post:

CustomLogEntry log = new CustomLogEntry();
log.Message = txtLog.Text;
log.Categories.Add(Category.General);
log.Priority = Priority.Normal;
log.MyStuff = string.Format("This is my stuff {0}", txtLog.Text);

I am capturing the data that is part of the LogEntry object plus I added my own column called MyStuff.  This could have been arbitrary data but LogEntry contains the data I want to capture. Plus you can use the Severity to filter what gets log.

Since I want most of the data from the LogEntry object I created my own entry object that inherits from LogEntry:

By inheriting from LogEntry I get all the goodness of the default logging framework and the ability to extend it to my will. 

Who is Listening

Now that I have my LogEntry object I have to create my trace listener to write it out to the database.  The logging block use trace listeners to direct the entries to the appropriate destination.  You set up logging categories that can have 1 to many trace listeners.  The category allows you to filter out what gets sent to the listener based on the severity.  Next comes the listener.  My listener inherits from CustomTraceListener. Which is pretty basic.  There are three methods that you need to override TraceData, Write, and WriteLine.  In the TraceData method you determine if data coming in is of type CustomLogEntry.  if it is you pass it to the write method that implements the call to the Entity Framework.  Here is my custom listener:

Here I am mapping my CustomLogEntry to my entity.  Optionally I could use a mapper or create a POCO Entity that inherits for LogEntry by modifying the T4 template.  I should also abstract out the data call to a repository so that I could easily switch out the implementation.  I did not do these things because this was a prototype to see how easily I can log data to a custom schema.

Configuration Time

Ok the pieces are now in place, what do I do.  The Enterprise Library come with a great tool for setting up the configuration.  Right click on the configuration file and select “Edit Enterprise Library V5 Configuration”:

Here you can wire up your listener to which ever category you want. Here my listener is wire to the General Category

I won’t get into how to get your custom listener to display here but the Hands on Labs do a good job explaining this.

Log That Message

Now all you have to do is log messages.  Here is a code snippet that does just that:

   CustomLogEntry log = new CustomLogEntry();            log.Message = txtLog.Text;            log.Categories.Add(Category.General);            log.Priority = Priority.Normal;            log.MyStuff = string.Format("This is my stuff {0}", txtLog.Text);

Summary

That is all there is to it.  There are other improvements that could be made but for the most part this should show you the control that you have when it comes to where you send your log information.

The source code for this example can be downloaded here.

So what do we have here. This is a list of resources that I have found useful.  This is not an all encompassing list and I am sure that there are better resources (feel free to send me your favorites in the comments)

Start here: http://www.silverlight.net/

The Future of Microsoft Silverlight: http://www.microsoft.com/silverlight/future/ The Future of Microsoft Silverlight

Silverlight 5 Plans Revealed: http://timheuer.com/blog/archive/2010/12/02/silverlight-5-revealed-at-firestarter.aspx?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+timheuer+%28Method+%7E+of+%7E+failed+by+Tim+Heuer%29

Silverlight Firestarter: http://www.silverlight.net/news/events/firestarter/

Good MVVM Video: http://jpapa.me/pdc10kungfu Associated blog post – http://johnpapa.net/silverlight/pdc10kungfu/

Good blogs (from Microsoft people):

• John Papa – http://johnpapa.net/
• Tim Heuer – http://timheuer.com/blog/
• Mike Taulty – http://mtaulty.com/communityserver/blogs/mike_taultys_blog/default.aspx
• Jesse Liberty – http://jesseliberty.com/ (More Windows Phone 7 now)
• Pete Brown – http://10rem.net/

Other Silverlight Blogs:

• Adam Kinney – http://adamkinney.com/blog/
• Wyn Apse – http://geekswithblogs.net/WynApseTechnicalMusings/Default.aspx

Good Book: http://www.amazon.com/Silverlight-4-Action-Pete-Brown/dp/1935182374/ref=sr_1_1?ie=UTF8&s=books&qid=1290136534&sr=8-1

This book has gotten a lot of good reviews from some respected people in the Silverlight Community: http://www.amazon.com/Silverlight-4-Unleashed-Laurent-Bugnion/dp/0672333368/ref=sr_1_4?ie=UTF8&qid=1293027056&sr=8-4.  The author is also responsible for MVVMLight http://www.galasoft.ch/mvvm/getstarted/.

Again these are just some of the resource I continually go back to.  Enjoy

For reference I have copied the data stream that kellabyte would like to consume:

• Email
• News (RSS)
• Social (Twitter, etc)
• Calendar
• Media (music, video)
• Documents
• Web
• Instant Messaging

The first hurdle is the Cloud. All this data would have to live behind some service (the Cloud) in order to be consumed seamlessly by different devices. Outside of techies there are very few people who feel comfortable storing all their personal data on the cloud (you can’t tell that by what people post on face book). When it comes to non social website data it can become an issue of privacy. The mental hurdle is a little less for an average person compared to large corporations. Losing control of where their proprietary data resides does not sit well for most CIOs.

Next all applications would have to be delivered as Software as a Service (SaaS) or Software plus Services. In this space you have Google Docs and Microsoft Office Live have made strides in the documents, email and calendar. But other providers need to be on board with developing SaaS. Should there be some overarching framework to ensure interoperability? Most would say that is what Service Oriented Architectures are trying to do but most organization struggle with developing pure SOA.

Moving to the cloud requires bandwidth both in the mobile space and in the ISP space. All these bits moving back and forth are going to eat up the current bandwidth that a common users has. A lot of AT&T customers currently complain about lagging networks think what would happen if everyone started moving to the cloud. The technology is catching up with services like FIOS and 4G mobile networks. Is it hard to imagine T1 lines to everyone’s home? This plays into the user experience. Usability will help drive adoption but it will also deter users as well. That is why there needs to be a strong infrastructure.

What would be the next hurdle that would need to be jumped, cost? Infrastructure changes require millions and millions of dollars. Application development requires funding. Hardware to support such a reality cost money. So what is the cost benefit analysis for companies that would under takes such an endeavor, the service providers, software makers, and application developers alike? Will there be a large enough user base to support such a capital undertaking? What kind of psychological barriers to adoption that need to be overcome.

Another technological challenge is security. I alluded to it before in that large corporations are reluctant to move to the cloud. Most of the infrastructure in existence was not developed with security in mind. Just think about what built in security mechanisms we have in TCP. A lot of the security we have has been bolted on as an afterthought. Moving to the cloud introduce a whole new round of privacy concerns. Unfortunately there are bad people in the world that are looking for opportunities to steal your data. I believe that until there is some strong belief of security is there gaining wide spread adoption will be a challenge.

The final challenge I want to address is the social aspects of this interconnectivity. Yes we interact socially through services like Twitter and Facebook but we lose out on the human interaction. We become tied to our devices so that we never unwind. This could lead to burn out if you don’t have a nontechnical outlet. You need something that requires you to become disconnected. Here is a personal experience. A group of coworker came around to my desk and asked who is up to going to lunch. I was game so off we went. As soon as we left the building out came the devices to check work emails. Really we weren’t gone 5 minutes. They couldn’t put down their devices for 30 minutes to enjoy lunch. Which goes to show that if they lost connectivity they would have major withdrawals. Is that a good thing?

There are the challenges so what are the benefits? For one, the prospect of the technology excites me. This opens a whole new line of thinking about how interact with the world around us. I believe that there are productivity gains to be had by being interconnected. I am also excited to see how we would interact with these technologies. The possibilities are endless and we are in an age of technological advances that will allow us to push the envelope.

I really enjoyed reading kellabyte’s post and really got me thinking as to what it would take to make interconnectivity a reality. I look forward to more debate on the topic.