menome

I personally think that facebook's best days are past it, and that with its IPO, we are coming to the peak of the latest tech bubble.

The highest risk element of Facebook's transition to a company from a philosophy, is the fact that Mark Zukerberg has never had a major failure, and has absolute control over facebook. Zukerberg does not answer to the board, he does not answer to his soon to be shareholders: making the firm effectively a dictatorship.

Dictatorships tend to do well in the short term (<10 years) but typically fail in the longer term because no one can effectively challenge the founder, who invariably come to believe their own infallibility.

Dictatorships are particularly vulnerable to changing business conditions - facebook was founded under a fairly specific set of conditions in which the 'web browser' as accessed from a personal computer was the dominate platform. Things are moving away from this model and while facebook has taken steps to mitigate its weakness in the mobile area (instagram acquisition - although it far overpaid for that company), its not natively a 'mobile' player.

The market that facebook grew into is also growing up and moving on. As the quality of the facebook environment has declined through its founder's mad rush to force people to share more, myself and many of my associates have simply stopped using it. Zukerberg has proven he is more interested in his mission to 'change the world' through radical transparency than actually providing his customers a value-add service. Zukerberg drives development of his site often against his customers wishes - the latest items being frictionless sharing and the forced use of timeline.

When you look at facebook now, the noise far eclipses anything of value that can be found on the site. The newsfeed is drowning in vapid meaningless re-posts from its poorly thought out and executed open graph automatic sharing system. Companies that rushed to leverage to this concept are re-evaluating their investment in it - because a post that is 'automatically' shared using facebooks open graph is of far less value to both the person doing the sharing and the audience than a manual post shared from someone take the time to consider the value of the information before passing it along.

Zukerberg has lost site of the thing that made his site successful - connecting people together and allowing them to simply and effectively share information.

The other major factor in facebooks success was built around the notion of status. Accumulating friends and status is a key element of the site's lock on its customers. The introduction of automatic sharing, while it helps facebook appear to have more 'active sharing' going on, actually significantly detracts from the status associated with manual sharing. If someone shares something of value, and people 'like' that share, that makes the person feel good and want to share more. Having a 'bot' effectively 'share' automatically every article a person reads simply generates noise and devalues the overall act of sharing. The noise drowns out any information of real value that the site accumulates. This means that attempts to monitize the site through integration with search, external sites or selling ads will fail as well because the noise that Facebook generates will make it very difficult to produce high quality results - its a simple matter of garbage in/garbage out.

Regardless of the eventual fate of facebook - regrettably Zukerberg himself will be set for life. Even if he drives Facebook into the ground, he and the early investors who bought Facebook on the secondary market will have made enough money by selling their shares off to the willing millions who will no doubt swarm in to acquire shares in a venture whose actual value has yet to be proven..

As with the 'housing boom' of 2007, the investors buying overvalued properties will be the ones who eventually find out what Facebook is really worth..

While I am a long time fan of Apple, I am also a Waterloo University graduate and a Canadian: so it has been disappointing to have watched the rapid fall of Research In Motion over the last five years. I had hoped that RIM would have been able to mount an effective response to the competition new entrants have brought to its market.

Instead, Rim's fall from being the dominant player in the smartphone market to having its market collapse to its recent collapse to a mere 9% in the US seems to have happened overnight. What happened and why has RIM not been able to respond effectively to the challenges it faced in a changing marketplace?

The story starts in 2005 when the company was arguably at its peak. At that time, the smartphone market was really a one player game, with RIM's Blackberry being by far the dominant player.

Other devices were available at the time, such as Microsoft which debuted the Windows Mobile 2003 smartphone platform in 2003, with HTC being the largest provider of hardware for the platform. The Microsoft offerings were quite weak at the time, and were not a competitive threat to RIMs offering.

As with many successful technology companies founded in the late 1980s early 1990s, RIM based its market squarely on business, as businesses were the only ones at the time who could justify to paying the high costs necessary to purchase and operate technology at the time.

RIMs business model was made up of the following key elements:
- Sale of Blackberry phone hardware
- Sale of the BES (Blackberry Enterprise Server)
- Sale of licenses for connecting the Blackberry device to the BEZ server
- Sale of application development tools that allowed third party developers to write applications for the Blackberry platform

RIMs business model as such was directly tied to the high margins afforded by dealing with business customers, who were at the time essentially a captive market. A key competitive advantage in the RIM model was the Blackberry Enterprise Server, which gave IT departments complete control exactly what corporate users were able to do with their devices.  (More)

Hearing about Steve Jobs passing away today saddens me. Steve Jobs is the reason I have the career I do. He and Apple are the threads that connect all the events bringing me to where I am today.

In high school, I spent countless hours hanging out at Birch Business systems, the local Apple dealer in Barrie at the time. I am sure I drove Mr Birch crazy constantly bugging them to work on the latest Apple product.

 (More)

Another item we are researching are social graph and network analysis.

Here are some resources that are proving useful:

• Mining and analyzing online social graph data
• Pajek network analysis tool

We also might try to use SQL server integration services (SSIS) as a first pass on a simple relationship analysis. Turns out that SSIS has the ability to do parallel operations, and can now call out to external libraries through c#. This means it may prove possible to stage the data required to feed some of these analysis tools and execute them from SSIS.

I will be doing some further work on testing this approach fairly soon.....

The best organizational behaviour model I have found for use in the Menome project is Stafford Beer's Viable Systems Model. Its based on management cybernetics, and while The Brain of the Firm was first published in 1972, it was (and still is) amazingly ahead of its time.

I won't attempt to explain viable systems model in detail here here, but it offers some excellent ideas for how to effectively model and organization and more importantly for the Menome project, how to model metrics around organization and divisional health and communications flow in an organization.

 (More)

Now that we are making excellent progress on the core menome engine, I have been back doing research on the analysis and classification of content.

I recently read a fantastic article in the Economist on the subject of the application of topic models to organizing scientific publications.

This approach appears to be a perfect fit for what I have been looking for, as it basically seems to take the essence of a document, and renders it into 'topics' (or as I would call them memes ;-).

It then becomes possible to derive relationships between documents. The authors have also extended the model to show how topics evolve over time. They have also produced source code, and have links and references to source code written by others for generating topic models.

 (More)

Silverlight textboxes have the annoying 'feature' of not updating their bound properties until after you tab out of them. From a UI perspective, this is incredibly irritating. However, the web to the rescue again: this bit of code from this blog post attaches a property to the silverlight textbox that forces an update as text is entered.

/// <summary>
/// Supports a PropertyChanged-Trigger for DataBinding
/// in Silverlight. Works just for TextBoxes
/// (C) Thomas Claudius Huber 2009
/// http://www.thomasclaudiushuber.com
/// </summary>

public class BindingHelper{
  public static bool GetUpdateSourceOnChange
    (DependencyObject obj)
  {
    return (bool)obj.GetValue(UpdateSourceOnChangeProperty);
  }

  public static void SetUpdateSourceOnChange
    (DependencyObject obj, bool value)
  {
    obj.SetValue(UpdateSourceOnChangeProperty, value);
  }

  // Using a DependencyProperty as the backing store for ?
 public static readonly DependencyProperty
 UpdateSourceOnChangeProperty =
      DependencyProperty.RegisterAttached(
      "UpdateSourceOnChange",
      typeof(bool),
      typeof(BindingHelper),
      new PropertyMetadata(false, OnPropertyChanged));

  private static void OnPropertyChanged
    (DependencyObject obj,
    DependencyPropertyChangedEventArgs e)
  {
    var txt = obj as TextBox;
    if (txt == null)
      return;
    if((bool)e.NewValue)
    {
      txt.TextChanged += OnTextChanged;
    }
    else
 {
      txt.TextChanged -= OnTextChanged;
    }
  }
  static void OnTextChanged(object sender,
    TextChangedEventArgs e)
  {
    var txt = sender as TextBox;
    if(txt==null)
      return;
    var be = txt.GetBindingExpression(TextBox.TextProperty);
    if (be != null)
    {
      be.UpdateSource();
    }
  }
}

The usage of the BindingHelper-class is very simple. Just add it to your project, insert a matching xmlns to your XAML file that contains the CLR-Namespace the BindingHelper-class is in. When that is done, you can simply set the UpdateSourceOnChange-Property on a TextBox to true, and if the Text-Property is databound, you?ll have a Data Binding that will update its source on every PropertyChange. Like in WPF.

<UserControl ?
 xmlns:local="clr-namespace:BindingHelperExample">
 <Grid x:Name="LayoutRoot">
 ?
 <TextBox Text="{Binding FirstName, Mode=TwoWay}"
 local:BindingHelper.UpdateSourceOnChange="True" />
 ?
 </Grid>
</UserControl>

I have been working on setting up an odata based connection between a silverlight application and a sharepoint document library. I can't say enough about how great the new sharepoint as an odata source is - it is a fantastic concept, and the ability to query into a sharepoint library using a REST style call and have it return odata is quite simply brilliant.

Doing this from Silverlight worked fine when I was first setting it up as a simple test using a code behind page. When I refactored to MVVM pattern, I started running into the Invalid Cross-Thread access exception.

The cause of this is related to doing the async call from a different thread than the Silverlight UI is running on, so while the call would still go through properly, the exception would hit when the Viewmodel would try to update the UI bound to its properties.

The resolution to this is to add the dispatcher.invoke call to the Model on the async Callback. The other trick seems to be to use the Deployment.Current.Dispatcher.BeginInvoke instead of the Application.Current.RootVisual.Dispatcher.BeginInvoke method as per this post on the ado.net dataservices forum.

We are moving ahead on the project, and it is going extremely well.

I have been looking for good ways of implementing the algorithms we will need for some parts of this, and found Seth Juarez blog through listening to a .net rocks podcast on the subject of machine learning:

http://www.sethjuarez.com/

He has produced an open source .net library for marking up objects with attributes, and then using those objects to produce a model to answer a question.

http://machine.codeplex.com/SourceControl/list/changesets

 (More)

On further research, we found that the Prism framework is not quite ready for version 4 silverlight. The Prism team are currently revamping Prism to use MEF (Managed Extendability Framework) and while they have begun producing code drops (they are on Drop 3), these are still in alpha, so we can't use them yet.

So to bridge the gap while the Patterns team works towards full release, we decided to use the MVVM Light framework from Laurent Bugnion of Galasoft. It provides a simplified version of Prism's feature set, and has proven to be a great framework to work with.

MVVM light provides:

• Commanding - RelayCommand object that can be used with Sivleright 4 button commands, and has an extension that bridges other controls that don't yet have commanding
• Messaging - A great messenger framework for decoupling viewmodels from each other by sending messages instead of binding
• Blend support - MVVM light has been built with Blend support in mind, and works very well with Blend. This gets around another deficiency in the current Prism implementation, which doesn't play well with Blend.
• ViewModelBase - base class for viewmodels
• Templates - for Blend and Visual studio. It also include some code snippets to help with code writing.

I would recommend using MVVM light if you are looking for a good, simple way of making MVVM easier and more clear to work with. It works extremely well with MEF - we have now refactored a complex Silverlight application to use MVVM light and MEF in less than a week.

Sean Wildermuth has a great 4 part example series on using MVVM light with MEF to build an MVVM based Silverlight application. The source included with the examples also has a fantastic error handling, status message and centralized IsBusy indicator setup that leverages the MVVM messaging framework.

We have been doing extensive development using Silverlight, and have run into some barriers with the design of the application we are working on. Some of the issues we were able to mitigate with MVVM pattern. However, as the app has become more complex, dependencies have crept in between the viewmodels and the parent application.We are also running into trouble managing commands and events associated with the application - how do you have several components subscribe to the same event set without having to connect viewmodels together?

The application's Xap file has also grown to be fairly large, and it will be necessary to split the application up into separate chunks that are loaded only when required. Our current structure will not allow this.

Upon doing research into how to address these issues, I discovered the Prism framework from the Microsoft Patterns and Practices group. This appeared to be a great way to address a number of the issues.

Prism is a framework for composing applications from separate modules. It contains an approach for injecting components into others using the Unity framework (also a patterns and practices framework) to eliminate dependencies. It also has a very nice looking commanding approach implemented through an event aggregator publish/subscribe mechanism.

However, during reading through commentary on Prism, I also found the Managed Extendability Framework, from a different part of Microsoft which looked initially like it was a competing approach to solve similar issues.

Microsoft often does things like this (take the whole Linq/ Linq-SQL/Ado.net entity framework/Windows Communication foundation maze as an example...) in which they come out with several almost the same but not completely technology bits that overlap. Inevitably one of the approaches will be adopted at the expense of the other, which forces developers who adopted the wrong one to refactor to the winner.

 (More)

We were interviewed by Craig Bator PM of the Quest for Canada's Smartest IT.

We talk about the philosophy we use at Matrix for building an agile IT and software development team that works directly with leadership to meet the ever changing needs of the business.

See it here: http://smartest-it.ca/craigs_chronicles.aspx

WCF is a great technology, but it is difficult to configure, and often the error messages are cryptic - if in fact you can get it to return exceptions at all.

Fiddler is a great way to debug WCF based services, but even that sometimes doesn't work if you are using the visual studio/cassini based web host.

Fortunately, adding the following code into your web.config file will put any exception information into a log file:

 (More)

We are now finally underway building the first version of what will become the Menome system.

One of the things we needed was a way of clustering points on a map. The idea is to reduce the number of points as the user zooms out by combining points together to keep performance up and to reduce map clutter.

The algorithm operates by creating a 'screen grid' and passing this to the server. As the user zooms and moves around the map, the boundary window they are looking at in lat/long, the height and width of the current window in pixels and the zoom level are passed to the server.

The first level of filtering happens on the SQL server by doing an intersection of the boundary window with the point geography stored in the SQL server.

Points inside the boundary are returned to the web server, where above a given zoom threshold (10 for now), they are passed through the clustering class. The clustering class works by creating a grid out of the current window. Two nested loops are created, which loop through the grid cells. Each points coordinates converted from lat/long to pixel, and checked against the current grid cell. Points found in the same grid cell are grouped together into a single point, and stored into the grid cell list indexed by the X and Y cell index multiplied together.

Fortunately, Johannes Kebeck has posted an algorithm for doing this on his fantastic blog The algorithm he presents is setup to return javascript, and is written in VB, so we changed it slightly to return a SiteLocationPoint object and to operate in C#, since that is the language we are using for the application we are building.

We have turned this into a class, which takes a list of points, and returns a list of clustered points. The main change we had to make to the algorithm itself was modifying the it to use a Dictionary to store the clustered points in the gridCells object instead of a jagged array, which cannot be declared dynamically in C#.

We used a dictionary with the X*Y grid cell as a key for storing/extracting points in a given grid cell. The other modification we need to make, which I will post once we figure it out, is a way of changing the clustering density.

Click more to get the source code.

 (More)

In order to produce a single view of GIS data derived from multiple sources, it is necessary to abstract the rendering of the data from the actual datasources. This is similar to the concept of a Services Oriented Architecture in which business data are rendered from their system domain to a domain specific language that suits the needs of the enterprise.

The term that is given to the systems required to perform the rendering function are called ?stacks? in the GIS world.
The Stack typically is composed of: Spatial Database, Internet Mapping Server (map services), Mapping Client, and Web Mapping Client.
There are a few different technology streams available for provisioning stacks. I have been doing research into the different stacks available for service enabling GIS data. (More)