I was trying to use a user control within a Sharepoint 2010 Visual Web Part and can’t seem to access any of the public properties of the user controls.

Casting the user control explicitly seem to do the trick. But I don’t want to do that every time!

What’s really happening

When I created the dependant user control that the visual web part require, VS2010 automatically create a special Sharepoint’s Control Template folder for me – which is kinda neat.

Worth pointing out that the User control has a ‘deployment location’ property where it says to which folder it’s going to be deployed to.

In the Visual Webpart, I’ve registered the user control as such.

<%@ Register Tagprefix="UserControl" TagName="NotificationList" Src="~/_ControlTemplates/WebParts/NotificationList.ascx" %>

Note that the source is _ControlTemplates rather than ControlTemplates. If I had omitted the underscore it wouldn’t work as there isn’t such folder in Sharepoint. I worked this out by looking at the path which the generated Visual Web Part bootstrapper point to .

If you look closer, Visual Studio 2010 doesn’t seem to like our user control registration.

It’s suggesting that it can’t find the control and decided to put the base class System.Web.UI.UserControl in our Visual Web Part designer class (*.ascx.design.cs). This is the culprit of why we can’t get the public properties/methods without explicit cast.

Seems the problem is caused by Visual Studio 2010 not having the same assumptions with the Sharepoint 2010 runtime. It’s really a VS2010 Bug.

VS2010 should’ve generated \_ControlTemplates\ in the first place when I create user controls. Alternatively, VS2010 should simply accept that ControlTemplates is a merely string token that will be converted to _ControlTemplates by Sharepoint 2010 runtime and take this account when generating the designer classes.

Solution

The solution is very simple:

1. Register the user control as above – i.e point src to ~/_ControlTemplates/ …
2. Simply rename the ControlTemplate solution folder in VS2010 to _ControlTemplate

As soon as I did this, VS2010 T4 template (which generates the designer classes) behaves properly and casts my user controls to the proper types.

Enterprises are concerned about the security and liability aspects of putting valuable information off-premise. How can we be sure that there are/wont be any no naughty codes from other accounts snipping through the cracks and stealing data. Enterprises want isolation. For the longest time, this isn’t possible (without using Azure Service Bus and hosting some parts of the services in a private cloud).

My motivation for the interest was slightly different and geared more towards being able to start developing in the Azure paradigms (roles) without being locked in into the Microsoft hosted Azure infrastructure. I wanted to be able to develop roles on the development fabric, put it into production on a Windows Server stack and when I need a lot more scalability, I’ll then put it up on the Microsoft hosted Azure infrastructure. For the longest time, this isn’t possible either.

In July 2010, Microsoft announced Azure Appliance. Something that Microsoft have said they would never do. Azure is going to be available on premise through the Azure appliance!

Private Cloud: Set affinity to local!

The Azure Appliance is essentially a private cloud solution from Microsoft. It’s going to consist of a full software, hardware including all the network stack. This is important to guarantee compatibility across different deployments. By the sound of things, when you’re buying one what you’ll get is a container full of servers just like the ones serving on the public cloud.

This, in essence, will give companies that extra comfort by letting them “own” (and pay for) the whole stack. It’s a true local affinity!

IT as a service

Microsoft have been pretty secretive to the details of how Azure work under the hood and it seems this announcement doesn’t change anything. It will come with a full service from Microsoft – which is a good thing; we don’t want the exponential growth of Azure to be impeded by the complexity of rolling out service packs to different Azure private data centers, which will be expensive for both Microsoft and their clients.

By the end of the day what you’re getting is a freakin’ huge computer(s) and a IT team to go along with it. Ebay is apparently one of the company who will get a taste of this sooner than other companies.

“Opening up” to scale out

Amazon and Google had a lot of advantages when it comes to building new datacentres. They start off by selling surplus computing time! Microsoft didn’t share the same advantages as they built Azure from the ground up. It’s expensive to expand and open up new datacenters. However through Azure Appliance, companies like Dell, Fujitsu, HP can order one, pay for it, add a few value-add offerings and start reselling azure cloud service offering.

What I really ’d like to see: Azure on the Windows Server App Fabric

I’m truly excited by this. However, I’m more excited about making sure that the role paradigm which I love is available to me without necessarily paying it based on usage. I’m skeptical whether the existence of Azure Appliance will change this (side note: the Development acellerator core package sounds promising but still too limiting).

What I really like to see is for Microsoft to bring Azure onto the App Fabric offering. When I say Azure here I do not necessarily mean the whole stack of hardware, network, virtualized environments, CDN, table storage and all that. I just mean the development paradigm with Web Roles and Worker Roles. When that happens, we can all forget about virtual directories or even IIS for that matter. All we care about is managing the different Roles and being able to move them in/out of different clouds.

In the few years I’ve been working as a software engineer, I have had the chance to be a part of different types of companies; From the small startup in the creative space, to the more corporate large-ish public facing .com company.

I remember a few months into working at the small startup, I told everyone that I was applying for a job in consulting. They happily offer to write me a letter of recommendation, despite the little value it might have had since the company was just starting out. In the end, I stayed there for 2 years before I feel it was really the time for me to move on.

Another job was not as supportive; I had the idea of starting a public facing blog for the development team. The response was rather cold, “what good could it bring? first, we potentially will share knowledge to competitors, and second, other company might steal our smartest devs!”. This tells so much about the company’s vision towards personal development. “Keep them from growing [externally], otherwise people will leave!”

This view is definitely not shared across the industry. Take Twitter, PlanCast, Klout as an example. The dev teams are helping each other out to overcome technical challenges. Or companies like Facebook who open sourced most of their underlying technologies. Or even companies like Microsoft which promoted the use of public blogs, podcasts, videos to share knowledge.

Call me naive, but I feel those days when employees work 40 years with only one company are over. Employment is now about sharing mutual respect, growing together and potentially –at some point- moving on to the next bigger better things.

I truly believe in these day and age, any one company could only be a part of one’s career for so far. There’s going to be a time where the employee will outgrow (or be outgrown) by the company. At that point in time, he/ she will  find themselves in a position where they will bring so much more value to a different company.

Good companies, however, will grow organically with the employees. These companies understand that the only way for them to be successful is to grow their people both from an internal career ladder and external; encouraging their people to bring impact to the public, gaining the community respect and reputation in the process.

Companies have to remember that to be great, one has to be surrounded by other great people.

NB: the picture above is showing my employer is highlighting one of my personal web venture on their news page.

A little problem on Windows

I found one potential stumbling block, which is in order to talk to Cassandra I will need to build a ‘proxy class’ to handle the de/serialization for me. Cassandra uses a protocol called Thrift. So I will need a proxy class that can serialize my objects to something that fits into the Thrift protocol. This can be done by using the Thrift executable. One little catch: currently there isn’t a version built for Windows.

Side note: What is Thrift and does it really not run on Windows?

I was slightly unsure if Thrift was a separate executable that needs to be run on the server and acts as a mediator between my .Net app and Cassandra. But soon I found out it is just a protocol that Cassandra make use of.

As you see below, Cassandra is running on Windows and binding Thrift successfully to localhost.

The Thrift executable, however, is a code generator of some sort that produce a language specific proxy class/driver/client/interface code that handles the communication between our app and cassandra. This is the bit that currently not available in Windows.

Solution: Generated Cassandra interface

There’s already a generated Cassandra interface for C# on Google Code, however using it feels pretty clunky as shown here:

System.Text.Encoding utf8Encoding = System.Text.Encoding.UTF8;
long timeStamp = DateTime.Now.Millisecond; 

ColumnPath nameColumnPath = new ColumnPath()
	{
		Column_family = "Posts",
		Column = utf8Encoding.GetBytes("name")
	}; 

//Insert the data into the column 'name'
client.insert("Blog",
	"first-blog-post",
	nameColumnPath,
	utf8Encoding.GetBytes("Ronald Widha"),
	timeStamp,
	ConsistencyLevel.ONE); 

A cleaner solution: FluentCassandra

Alternatively, one could use FluentCassandra. This eliminates the need of using the generated Cassandra interface (which may become obsolete should the a new version of Cassandra is released and using a newer version of Thrift protocol), or even the need to run Thrift executable.

I haven’t looked at the implementation of FluentCassandra yet, so I don’t know how easy it would be to support future versions of the Thrift protocol.

The same code above could then be re-implemented like the following:

var family = db.GetColumnFamily<UTF8Type, UTF8Type>("Posts");

dynamic post = family.CreateRecord(key: "first-blog-post");

// create post details
dynamic postDetails = post.CreateSuperColumn();
postDetails.name = "Ronald Widha";

db.Attach(post);
db.SaveChanges();

I got the sample code working using Apache Cassandra 0.6.2 and FluentCassandra 2010-06-22.

*All code shown here are modified from Nick Berardi’s example posted in coderjournal.

I’ve been playing around with MongoDB, a no SQL database just like Facebook’s Cassandra. This morning I heard about Nick Berardi’s posts about running Cassandra on Windows and decided to do some reading on it.

In the process I’ve found some useful links

• Download latest stable release of Apache Cassandra
• Cassandra jump start for the Windows developer, which covers the installation and configuration steps

At this point I realize “yikes, do I have to have the terminal window open to run Cassandra”. Upon quick search I found another Nick’s excellent post:

• Running Cassandra as a Windows service

While I’ve got those 2 projects downloading on the background, I just realize the C# code needed to connect to Cassandra (through an intermediary service called Thrift)looks quite ugly.

And I found Nick’s Fluent Cassandra project:

• First Fluent Cassandra Application part 1
• First Fluent Cassandra Application part 2

Which one do you like better the iOS4 icons or WP7 Metro UI – panoramic ‘live tile’?

These last couple of days, I feel like I’ve been bombarded with editorial content pressuring people on becoming a Ghost user, deactivating and even quitting Facebook altogether.

The general concern seem to be at 2 levels: firstly, privacy settings on facebook is getting complicated, leaving most people in the dark. Combined with the fact that the default value is so open to the public, most people don’t know anymore what they’re sharing publicly.

Secondly, there’s a growing privacy concern about the fact that Facebook is starting to share its data through the OpenGraph API and also partnership like Pandora and Docs.

I heart knobs

I actually thought the granular privacy settings was awesome, and left wanting more. Being able to set up what you want to share per person, list, network, is like an IT admin way of configuring role/group based authorization and permissions. These are the thing that us as developers have to deal day in day out: data normalization, categorization, tagging and how we use it.

Imagine having the control of configuring to share my private statuses with the people I care about, my ‘Family’ list and ‘Close Friends’ list, unless if these people are also listed under ‘Work’.

I love having the ability to configure to share photos from work to everyone, including people from the office’s network.

I love it and I want more control!

don’t know about you, but I actually like having all these knobs to tweak!

OpenGraph and sharing Social Data

The same applies to the OpenGraph initiative and FB’s vision on sharing social data. I agree with FB’s vision to leverage all my investment on Facebook. I’ve added people that I know personally, curated the ones that I know online, tag, categorize them into lists, and set up shares and permissions around them. Not a small investment to make!

Applications like Foursquare should stick to location based services, Flickr should stick to organizing photos. These apps should leverage all my lists, my behaviors, my likes to create a better experience for me.

What I care though is control and ownership. I want to be clear what I’m sharing with each one of these services. I want to also make sure that I own these data and can choose to opt out if I no longer feel comfortable for one reason or the other. This is something that Facebook doesn’t do well (at least…yet).

My My profile preview as seen by Dad 
I want this kind of preview with data shared with other sites

Facebook still need to listen ..

I won’t quit Facebook, but I still wish Facebook would listen the outcry.

I appreciate the fact that not everyone has an IT flare in them. Try to do a search on YourOpenBook.org “skipping work” and you will know what I mean. Facebook need to cater to these people. They’re (probably ) the majority of FB users.

YourOpenBook.org proposal how privacy settings should be. 

I want Facebook to be simple to most users, and continue on providing the high degree of controls for the likes of me.

However, Facebook need to always put the casual users interest at best, because some of these people are the reason to why I use facebook in the first place.

The Problem: communications between controls

Because of the compositional nature of WebForm, we tend to build functionalities in web/custom controls. All are nice and well until some of these controls need to pass data between each other, then it gets complicated really fast.

The complexities come from the fact that we often rely on some piece of data fetched by some control at some point in time in the past to be used by another control at a different point in time. May not be too hard, but it’s really not a nice problem to solve, and often leave us scratching our head “do we put this onPreInit, PageLoad, onDataBind or where??”.

The Solution: Message Bus

The Webforms MVP framework introduce a concept of Message Bus which allows each of the Presenters (thus Controls) to publish and subscribe messages.

You may ask “okay, you can publish and subscribe. What difference does it make between storing the message in the viewstate, query strings or even doing a direct set on to the property of a control. You’d still need to work out the order to which the message can be passed, right?”.

No. The beauty of the message bus is it coordinates the publishing of the messages quite efficiently. The algorithm is simple:

Anytime a message is published, the message will be sent to all its subscribers.
If a new subscriber just joined in, it will get all the previous messages.

Simple but very effective! By using the message bus we decouple each of the presenters and all communication will go through the message bus.

Example: Ultimate Fighting Controls

The example shows two controls sending messages between each other through the message bus. The essence of the examples are really just these two lines:

Messages.Subscribe<PunchMessage>(punch => View.Model.Status = GetStatus(punch));

This line shows that the Presenter subscribes to any messages of type ‘PunchMessage’ and execute a callback function for every message that fits the criteria.

Messages.Publish(new PunchMessage(e.Puncher));

This line is to publish a message with some parameters read from the button click eventargs.

Isn’t that awesome?

Slightly more than a year ago, I wrote two posts on opting for MVC pattern on Asp.net Webform (Asp.Net MVC without using ‘the framework part1 and part 2: a good example of unit testing). A few months ago, I heard about Tatham Oddie’s project WebForms MVP, which until yesterday I totally forgot about. All thanks to @mosessaur’s tweet, I decided to have a quick look at it and really loving it!

The View: Webform as a template engine

Asp.Net Webform is designed to be a Smart UI platform. What that means, it more than just layout engine…alot more! Just look at controls such as ObjectDataSource, UpdatePanel or any other Asp.Net Ajax Control Toolkit controls, they are much richer than just UI elements but also dictate behaviors.

In the WebFormsMVP framework, Asp.Net Webform is meant to be used as just a templating engine. I’m not saying that you can’t, but better not to unless if you have strong reasons (such as using ready made controls etc). The goal is to push as much smartness to the presenters.

The view then becomes really simple.

<form id="Form1" runat="server">
  <% // Model is a strong type property bag for the data binded to the view %>
  <%= Model.Owner %>
  <%= Model.Description %>
</form>

If you look at the Default.aspx code above, it looks similar to what classic Asp or Asp.Net MVC view would look like. What’s worth noting is the property Model which is a property bag to access the model binded to this view (popularly known as View Model).

The type of the property Model is defined through Generics in the base class of the page. So in the code behind we will have the following:

 public partial class Default : MvpPage<WorkModel>
 {
     protected void Page_Load(object sender, EventArgs e)
     {
     }
 }

MvpPage and MvpUserControl base classes are a part of the WebFormsMVP framework and takes a type of T.  The WorkModel  in this case contains the .Owner and .Description properties.

Also note that the code behind is practically empty (in a slightly more complex – real life scenario, code behind will contains event propagation: button has just been clicked, etc)

The Presenter listens to the View

Model View Controller prescribes that the controller should be the first class citizen in responding to any requests.  However, in Model View Presenter, the View takes on this responsibility. The view propagates the events to the Presenter. Presenter will decide what need to happen next (read more: Difference between MVP and MVC).

Therefore you will have the following Presenter class. Notice how in the constructor we subscribe to the View’s Load event and react upon it.

 // notice the base class which takes the T of the view
 public class DefaultPresenter : Presenter<IView<WorkModel>>
 {
     // required constructor by the base class
     public DefaultPresenter(IView<WorkModel> view) : base(view)
     {
         // subscribe to the view's events :
         // in this case the Load event
         View.Load += View_Load;
     }

     // required method by the base class
     public override void ReleaseView()
     {
         // clean up the delegate by detaching it
         View.Load -= View_Load;
     }

     // the core logic of the app where the Model is instantiated, fetched
     // and binded to the view
     private void View_Load(object sender, EventArgs e)
     {
         View.Model.Owner = "Ron";
         View.Model.Description = "to blog about WebFormMVP";
     }
 }

Presenter and View binding

There are 4 different ways of binding, 2 of which I have little knowledge about. So let me explain to you the two that I know:

1. Convention – By default, the WebFormsMVP framework look for the Presenter class with the same type name as the View (with the word ‘Presenter’ as the suffix). It also tries to find it in different namespaces.

   for e.g view with type Default will be looking for a class called DefaultPresenter

2. Attributes – I could also explicitly map the View to the Presenter by using an attribute like so:

[PresenterBinding(typeof(DefaultPresenter), ViewType = typeof(IView<WorkModel>))]

Conclusion

WebFormMVP framework allows nice clean separation just like Asp.Net MVC without necessarily throwing away all our investment on web controls. We get the productivity from the compositional nature of web controls when we need it, and still get the clean separation of the MVP pattern – without as much work as doing everything yourself.

Once we start looking into Cross Presenter Messaging, things will get even more interesting. I bet you that this very feature will get rid of the complexity of the usual page life cycle.

Let me support that argument: alot of times, asp.net page lifecycle becomes an issue when we’re dealing with controls having to rely on data that is fetched by another control and not being ready at a particular stage in a page lifecycle. Cross Presenter Messaging will eliminate the problem by providing a publisher/subscriber mechanism to pass around data between all these web controls without having too much knowledge of the inner mechanics of how they individually work. More on that later.

I used Asp.Net 4.0 with WebFormsMVP CTP 7

The thing with Vista and Win7; it seems the free amount of harddrive space left exponentially  depleting as soon as it reaches less than 5% of its overall capacity. Not sure if it’s because of superfetch, or some other app that’s causing it. But I have this issue more than once now.

Anyways, I need to free up my harddrive and not just by 10s GB. I need serious cleaning up! I’ve been always using my trusty PC Mag DiskPie2 to check which folder worth the attention. What I don’t realize, this pre ntfs disk tool does not recognize >4GB file.

DiskPie2

Here comes Windirstat. With data visualization that looks like NDepend, it comes and save the day. Upon loading up I suddenly realize that Calibre produced a 150GB html file while trying to convert a pdf to an epub file so I can read it on the IPad.

Similar app is also available on the Mac OSX: Disk Inventory X