I think the UI revolution’s already here; now we see which ones bubble to the top!

This got me thinking about the criteria that may determine which RIA technology would be most successful.

I think there are a number of things that will determine which one will ultimately win, or at least become the dominant choice. At the moment I can think of three categories; Technology buy-in, Development environment and Data access capabilities and choice.

Technology buy-in

Some companies buy-in to a technology because they have always used that technology. For example, a company that have always used Java will be more likely to opt for the Adobe solution where they can write their server components using Java and their client in Flash/ActionScript/Flex (this terminology is still a bit unclear to me. I think this is why Adobe are renaming Flex Builder to Flash Builder) but a company that have traditionally used Microsoft products will undoubtedly go for Silverlight. More traditional web developers, who probably build upon the LAMP stack, that have been hand coding PHP on the server and JavaScript on the client tend to go for creating RIAs using Ajax.

Development environment

I believe that Microsoft have a massive advantage in having Visual Studio as a server and client IDE. It has it’s faults but in general it’s a fantastic development environment. Those choosing Flex (Java -> ActionScript/Flash) will more than likely choose the Eclipse IDE, which is powerful, but it’s ActionScript/Flex development tools are lacking maturity. I’ve recently used the Flash Builder 4 beta and it’s miles behind Visual Studio in terms of coding productivity features. I’ve heard that the Flex UI component development features may be better than Visual Studio’s support for Silverlight UI. The LAMP with Ajax stack suffers much the same problems as Flex with, as far as I know, Eclipse being the IDE of choice and client-side productivity tools still very much in their infancy. It’s clearly very difficult to write an IDE to enhance JavaScript/Ajax productivity.

Data access capabilities and choice

I think this has been one of the last things to be considered in the RIA stack. Previously browsers have locked down where you can get your data from. Developers were always trying to implement hacks to allow them to do things such as make a web request to a server on a different domain or cross-site scripting to implement HTTP streaming. As the web has opened up to the idea of Mashups, browser and RIA plugin vendors have had to change their stance on cross site security. It’s a difficult line to walk but I believe that the technology that makes retrieving data from multiple sources the easiest, without having to go via a proxy, will have a distinct advantage. Flash and Silverlight are winning the race at the moment with Silverlight’s use of security policy files and Flash’s support for master policy files. For the Ajax solution I still need to research information on HTTP cross domain access control headers and which browsers have implemented support for them. I still think there will be an argument for mashing up your data on the server and I have a blog post planned on RTRIA server technologies.

The important questions around RIA data are:

• Which RIA will be more efficient at consuming data?
• Which one will prove to be the most capable as a Real-Time Rich Internet Application (RTRIA)?
• Will RIA technology vendors try to lock developers into using a client-server technology stack, such as Adobe may be trying to do with LCDS and Flex, and will this put developers off?
• Is decoupling of server and client technology, and communication protocol, important? I think it is, do you?

Although RIAs have been around for a while now, as Patrick said, the race to dominate the Rich Internet Application Technology space is on.

Related posts:

1. Real-Time Rich Internet Applications (RTRIA)
2. Using Fiddler to trick Silverlight into allowing a crossdomain Web Request
3. How to install Caplin Systems’ Liberator Free Edition on Windows

The Code

First, and this is Important:

Now that you are aware of that, you will also need the Silverlight development environment. You can get everything you need via the Silverlight Getting Started page.

You’ve now got everything you need to run the RTRIA example. To run the sample application you should set the MSDNFlashRTRIAExample.Web project as the startup project and the MSDNFlashRTRIAExampleTestPage.html page as the startup page.

Setting up the solution to run the application

If you’d like to find out a bit more about the code then read on. If you’d rather jump straight into the code you can download it from the TweetStreamer Google Code project.

The streaming connection

The following extracts of code may be slightly modified but that has been done to be able to explain what the code does in general a bit better.

The following extract is used to establish a connection to the Twitter real-time data stream using a HttpWebRequest. The important thing to note is the use of request.AllowReadStreamBuffering = false; which is required since we are requesting a streaming feed. Without setting the AllowReadStreamBuffering property to false the ConnectionResponseCallback callback will not be invoked because the response will be continuously buffering.

Since the Twitter real-time data stream requires authentication, and we can’t set Credentials on the HttpWebRequest in Silverlight, the browser will prompt the user for a username and password.

private const string SPRITZER_URL = "http://stream.twitter.com/1/statuses/sample.json";

/// <summary>
/// Starts the connection to the Twitter real-time data stream.
/// </summary>
public void Connect()
{
    this.InternalConnectionStatus = ConnectionStatus.Connecting;

    try
    {
        HttpWebRequest request = (HttpWebRequest)WebRequest.Create(new Uri(SPRITZER_URL));
        request.AllowReadStreamBuffering = false;
        request.BeginGetResponse(ConnectionResponseCallback, request);
    }
    catch (Exception ex)
    {
        Debug.WriteLine(ex);
        this.InternalConnectionStatus = ConnectionStatus.Disconnected;
    }
}

Within the callback method we ensure that we are connected and then call the ReadResponseStream method which will not return until we call Disconnect().

/// <summary>
/// Called when the initial connection has been established.
/// </summary>
private void ConnectionResponseCallback(IAsyncResult asynchronousResult)
{
    try
    {
        HttpWebRequest request = (HttpWebRequest)asynchronousResult.AsyncState;
        using (HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(asynchronousResult))
        {
            if (response.StatusCode == HttpStatusCode.OK)
            {
                this.InternalConnectionStatus = ConnectionStatus.Connected;

                this.ReadResponseStream(request, response);

                if (this.InternalConnectionStatus != ConnectionStatus.Disconnecting)
                {
                    // unexpected status
                    Debug.WriteLine("unexpected connection status: " + this.InternalConnectionStatus);
                }
            }
            else
            {
                Debug.WriteLine("unexpected status code: " + response.StatusCode);
            }
        }

        this.InternalConnectionStatus = ConnectionStatus.Disconnected;
    }
    catch (Exception ex)
    {
        Debug.WriteLine(ex);
    }
}

In the ReadResponseStream method we continually read the stream until we are interrupted by the user setting the connection status to a value other than ConnectionStatus.Connected, by calling the Disconnect() method, or an exception is thrown whilst reading from the stream. For each read from the stream we parse the data to get the tweets from the real-time data feed in JSON format.

/// <summary>
/// Reads the information received from the Twitter real-time data stream.
/// </summary>
private void ReadResponseStream(HttpWebRequest request, HttpWebResponse response)
{
    byte[] buffer = new byte[65536];
    using (Stream stream = response.GetResponseStream())
    {
        while (this.InternalConnectionStatus == ConnectionStatus.Connected)
        {
            int read = stream.Read(buffer, 0, buffer.Length);
            UTF8Encoding encoding = new UTF8Encoding();
            string data = encoding.GetString(buffer, 0, read);
            ParseResponseChunk(data);
        }

        // need to call request.Abort or the the thread will block at the end of
        // the using block.
        request.Abort();
    }
}

The ParseResponseChunk checks the data it’s passed and ensures that the data contains at least one full status message (tweet). I’ll not go into the details of that here since it’s just a matter of string parsing.

I chose to use the JSON format simply because the content passed over the wire is smaller than the XML feed. This should mean that the application has to do less work to read all the data. What we really should also do is benchmark the deserialisation of JSON against the deserialisation of XML to see which performs best within a Silverlight application.

Deserialising the JSON

The following JavaScript JSON snipped shows an example of a single Tweet that we get back from the Twitter real-time data feed.

{
    "in_reply_to_status_id":9999999,
    "in_reply_to_user_id":00000000,
    "favorited":false,
    "in_reply_to_screen_name":"leggetter",
    "text":"@leggetter Wow! A Real-Time Rich Internet Application (RTRIA)",
    "id":2820354600,
    "created_at":"Fri Nov 4 09:39:33 +0000 2009",
    "truncated":false,
    "source":"<a href=\"http:\/\/tweetdeck.com\/\">TweetDeck<\/a>"
}

The JSON can be deserialised as an instance of a C# class using the DataContract attribute on the class and the DataMember attributes on properties.

using System;
using System.Runtime.Serialization.Json;
using System.Runtime.Serialization;
using System.ComponentModel;

namespace TweetStreamer
{
    [DataContract]
    public class StatusMessage : IStatusMessage, INotifyPropertyChanged
    {
        [DataMember(Name = "text")]
        public string Text {get;set}
    }
}

A single Tweet, or in TweetStreamer a StatusMessage, can be deserialised using an instance of the DataContractJsonSerializer.

/// <summary>
/// Creates a single message from json string.
/// </summary>
/// <param name="messageData">The message data.</param>
/// <returns></returns>
private static IStatusMessage CreateMessageFromJsonString(string messageData)
{
    Debug.WriteLine(String.Format("Creating StatusMessage for: {0}", messageData));

    IStatusMessage message = null;

    using (MemoryStream stream = new MemoryStream(UTF8Encoding.UTF8.GetBytes(messageData)))
    {
        DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(StatusMessage));
        message = ser.ReadObject(stream) as StatusMessage;
    }

    if (string.IsNullOrEmpty(message.Id))
    {
        message = null;
        Debug.WriteLine("message had no ID. Assuming to be a delete message so nulling message object");
    }

    return message;
}

Binding the data to the grid

To bind the data to a DataGrid the grid needs to be defined in XAML. In addition we can specify the properties on the StatusMessage that we want to bind to columns. In the XAML below we are binding the CreatedAtString property to a Time column, a User.ScreenName to a User column, and a Text property to a Message column. Notice the cool binding of User.ScreenName. The StatusMessage.User property returns an instance of another class and we are actually binding to a property on the returned class.

<data:DataGrid Grid.Row="0" x:Name="Tweets" AutoGenerateColumns="False">
    <data:DataGrid.Columns>
        <data:DataGridTextColumn Header="Time"
            Binding="{Binding CreatedAtString}" />
        <data:DataGridTextColumn Header="User"
            Binding="{Binding User.ScreenName}" />
        <data:DataGridTextColumn Header="Message"
            Binding="{Binding Text}" />
    </data:DataGrid.Columns>
</data:DataGrid>

Next, the code to set up the binding and registering for StatusMessage updates using the StatusMessageReceived event. As you many have noticed, the StatusMessage object implements the INotifyPropertyChanged interface. This was used so that we could add each StatusMessage to an ObservableCollection<T> and then bind it to a DataGrid to display the Tweets in real-time.

Connection _twitterConnection;
ObservableCollection<IStatusMessage> _messages = new ObservableCollection<IStatusMessage>();
public MainPage()
{
    InitializeComponent();

    Tweets.ItemsSource = _messages;

    _twitterConnection = new Connection();
    _twitterConnection.StatusMessageReceived += new Connection.OnStatusMessageReceivedEventHandler
        (twitterConnection_StatusMessageReceived);
    _twitterConnection.Connect();
}

Finally, whenever we get a StatusMessageReceived callback we need to add the new StatusMessage to the ObservableCollection collection. This has to be done on the UI thread and via the Tweets.ItemsSource property or the UI will not update.

/// <summary>
/// Status message received event handler.
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
void twitterConnection_StatusMessageReceived(object sender, IStatusMessageReceivedEventArgs args)
{
    Dispatcher.BeginInvoke(() =>
        AddMessage(args.Message)
    );
}

/// <summary>
/// Adds a message to the observable message list which updates the UI.
/// </summary>
/// <param name="message"></param>
void AddMessage(IStatusMessage message)
{
    ObservableCollection<IStatusMessage> messageList = ((ObservableCollection<IStatusMessage>)Tweets.ItemsSource);
    messageList.Insert(0, message);
}

Hopefully this will have helped you understand how the Twitter real-time data stream is consumed and an example of how you can use it within a Real-Time Rich Internet Application. Now, why now download the TweetStreamer library and example application and have a play.

Download

You can download the source from the TweetStreamer Google Code project.

Screencast

This screencast was supposed to be short but ended up being just shy of 10 minutes. In it I provide some technical detail of how I built the application, show the basics of how Fiddler is used to give access to the Twitter real-time data stream, and give a demo of the application.

Related posts:

1. Real-Time Rich Internet Applications (RTRIA)
2. Using Fiddler to trick Silverlight into allowing a crossdomain Web Request
3. Which Rich Internet Application Technology will dominate?

How Silverlight makes a web request

If you were making a web request from Silverlight to download the following page:

http://www.leggetter.co.uk/2009/10/23/how-i-approach-problem-solving-in-code.html

The Silverlight runtime would first request

http://www.leggetter.co.uk/clientaccesspolicy.xml

If this request fails it will then request

http://www.leggetter.co.uk/crossdomain.xml

If both of these requests fail (return a 404 HTTP status) the Silverlight runtime will not allow you to make your web request. *

* Note: The web request failure due to a failure to download a security policy file can manifest itself in a number of ways. I’ll try to remember to put a post up about this later.

The clientaccesspolicy.xml file is Microsoft’s own security policy file. The crossdomain.xml file is used by Adobe Flash but is also supported by Silverlight. For more information see master-policy file.

Now that we’ve got the background information out of the way we can get on to the interesting stuff.

An example using the Twitter Streaming Feed

If you wanted to write your own Real-Time Rich Internet Application (RTRIA) that consumed data from the Twitter real-time data stream you’d be stuck. Well, you’ll be stuck until Twitter puts a security policy file up **. Until then you can trick the Silverlight runtime by using Fiddler to detect the security policy file request and fake a response.

** The following URLs are where Twitter would put their security policy files should they decide to allow cross domain access. Please not that you’ll be prompted for your Twitter username and password if you click on them by the browser because you need to sign in with valid twitter credentials to access the twitter stream domain: http://stream.twitter.com/clientaccesspolicy.xml and http://stream.twitter.com/crossdomain.xml)

To do this you will need to set up an AutoResponder in Fiddler that intercepts the request for the security policy file by the Silverlight runtime and returns a fake security policy file. In the example below I have an AutoResponder set up for http://stream.twitter.com/crossdomain.xml.

Using Fiddler to AutoRespond with a fake Security Policy File

Here’s an example of a crossdomain.xml security policy file which grants access to requests from all domains.

<?xml version="1.0"?>
<!DOCTYPE cross-domain-policy
  SYSTEM "http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd">
<cross-domain-policy>
  <allow-access-from domain="*" />
</cross-domain-policy>

Once you’ve set up the AutoResponder start Fiddler. Then start your Silverlight application that is trying to stream data from Twitter and bingo! You should have real-time data from Twitter in your RIA – a Real-Time Rich Internet Application (RTRIA).

Fiddler HTTP Proxy Screencast

Related posts:

1. How to make a cross domain web request with SilverLight 2
2. Which Rich Internet Application Technology will dominate?
3. Real-Time Rich Internet Applications (RTRIA)

I mentioned RTRIAs for the first time back in April 2009 in a post called “What is the real-time web” on the Caplin Systems Platformability blog, and since then there has been a real-time web explosion. The “real-time web” is now the buzz phrase around the Internet that everybody is jumping on. Back in April I set up a Google Alert for the term “real-time web”. Back then I got maybe one Google Alert a day for this term, probably less. Now, I get at least two dense emails a day from Google with people using the term for all sorts of things; real-time web stats, real-time analytics, real-time search, rssCloud, pubsubhubbub, the list goes on. This is not the real-time web! Whilst some of the things on this list will help  the web become truly real-time (rssCloud and pubsubhubbub may even form the back bone), none of these things give the user a truly real-time web experience.

My opinion about what the real-time web is has not changed from that first blog post. For me, it’s not just about data being available as soon as it’s been published. In this situation the user still has to actively make a request to see if any data is available. Instead it’s about making a single request for data (a subscription) and that data being pushed to your RIA to be consumed by the application user in real-time. Quite a few applications have implemented a polling solution (more on this later) but the experience presented to the user is not truly real-time.

"Real-Time?"

In my opinion the only way to guarantee being able to deliver truly real-time data (TRTD) to a web application is by maintaining a streaming connection to the source of the data using a continuous streaming HTTP connection. Most web applications use a technique called polling or long polling to retrieve their data which means that although the data is initially “fresh”, within seconds it could be out of date, or more information may be available. I’ll discuss server technologies further in a later post.

At the moment there are a number of technologies that allow you to develop RTRIAs. Ajax, Silverlight and Flash are the three mainstream solutions. The core barriers to RTRIAs are the scalability of server technology and access to truly real-time data.

Related posts:

1. Which Rich Internet Application Technology will dominate?
2. Using Fiddler to trick Silverlight into allowing a crossdomain Web Request
3. Wikipedia now has a definition for Real-Time Web

Write a piece of code that prints all odd integer numbers between 1 and 99

This really isn’t a difficult question but it still requires some thought. When I’m posed with any question I like to break things down into their constituent parts.

Here’s the process I went through:

Okay, so I’ll define two variables for a start and end value and there’s going to have to be a loop.

int startValue = 1;
int endValue = 99;
for(int i = startValue;
     i <= endValue;
     i++)
{
   // work out if "i" is an odd number
}

Now, for the odd number detection. And… after a few umms and errrs … I’m going to have to mod 2 (%2) the current value of i to work out if the value is odd. More … umms and errs. Okay, I’ve finally worked out that if something mod 2 is not equal to 0 it’s clearly an odd number. This took me longer than it should have but never mind. Once I’ve detected if i is an odd number I’ll then put the odd number into a list for use later.

int startValue = 1;
int endValue = 99;
IList<int> oddValues = new List&lt;int&gt;();
for(int i = startValue;
     i &lt;= endValue;
     i++)
{
   if(i%2 != 0)
   {
      oddValues.Add(i);
   }
}

Those of you that are good at these little puzzles, or just think this is way too easy, might already be screaming at me about one of the following:

• Why are you using a IList, why don’t you just print the value?
• Odd numbers are always 2 apart so why aren’t you just increment i by 2 using i+=2?

I admit it, I missed the second point and that is a bit silly of me. However, what I have starting doing is separating the concerns of the piece of code. The code does two things; it detects the odd number and it prints the odd numbers. Those are two very distinct things. So, my code now looks like this:

int startValue = 1;
int endValue = 99;
IList<int> oddNumbers = new List&lt;int&gt;();
for(int i = startValue;
     i &lt;= endValue;
     i++)
{
   if(i%2 != 0)
   {
      oddNumbers.Add(i);
   }
}

string oddNumbersList = string.Join(",", oddNumbers.ToArray());
Console.WriteLine(oddNumbersList );

I’m now going to refactor this further so I’ll put the two different pieces of functionality into different methods. I’ll rename the i, startValue and endValue variables to be something a bit more useful; say numberToCheck, startNumber and endNumber. I’ll also create another helper for the odd number checking named IsOddNumber:

IList<int> GetOddNumbersBetween(int startNumber, int endNumber)
{
   IList oddValues = new List&lt;int&gt;();
   for(int numberToCheck = startNumber;
        numberToCheck &lt;= endNumber;
        numberToCheck++)
   {
      if(IsOddNumber(numberToCheck) == true)
      {
         oddValues.Add(numberToChecki);
      }
   }
   return oddValues;
}

bool IsOddNumber(int number)
{
   return (number % 2 == 1);
}

void PrintOddNumbersBetween(int startNumber, int endNumber)
{
   IList<int> oddNumbers = GetOddNumbersBetween(startNumber, endNumber);
   string oddNumbersList = string.Join(",", oddNumbers.ToArray());
   Console.WriteLine(oddNumbersList);
}

Let’s say I then notice the second point you’ve been screaming at me about (Odd numbers are always 2 apart so why aren’t you just increment i by 2 using i+=2) that I mentioned above? In practice I should notice this sort of thing either when I give the code a complete review, or one of my peers spots it. When I see this problem I decide to update the for loop, as noted, and I then see that I possibly don’t need the if(IsOddNumber(i) == true) statement. Although it would pain me to do this, since it’s a lovely little method, I would need to consider deleting it. But then it strikes me, I’m no longer just solving the “odd numbers between 1 and 99 problem” so I can’t just assume that the startNumber is going to be an odd number. I need to make sure that it’s an odd number so I’ll create another small utility method for that called EnsureOddNumber which will check if the value passed is an odd number, and if not return the next odd number (I’d like to rethink the name of this method).

IList<int> GetOddNumbersBetween(int startNumber, int endNumber)
{
   startNumber = EnsureOddNumber(startNumber);

   IList<int> oddValues = new List&lt;int&gt;();
   for(int numberToCheck = startNumber;
        numberToCheck &lt;= endNumber;
        numberToCheck+=2)
   {
      oddValues.Add(numberToCheck);
   }
   return oddValues;
}

int EnsureOddNumber(int number)
{
   if( IsOddNumber(startNumber) == false )
   {
      startNumber++;
   }
   return startNumber;
}

bool IsOddNumber(int number)
{
   return (number % 2 == 1);
}

void PrintOddNumbersBetween(int startNumber, int endNumber)
{
   IList<int> oddNumbers = GetOddNumbersBetween(startNumber, endNumber);
   string oddNumbersList = string.Join(",", oddNumbers.ToArray());
   Console.WriteLine(oddNumbersList);
}

Now, when I look at this code I get a warm feeling because I feel that it solves the problem, it’s well engineered, the concerns are separated and the code is completely self documenting.

There are a few comments that people may have here:

The question asked specifically to print odd values between 1 and 99 and you’ve done more than was required.

Although my answer does satisfy the original question have I over engineered things? The question does specifically ask us to print odd values between 1 and 99 so maybe I should have created a function that just satisfied that requirement.

void PrintOddNumbersBetween1And99()
{
   for(int i = 1;
        i <= 99;
        i+=2)
   {
      Console.WriteLine(i + " ");
   }
}

And I’d have to admit that this very short piece of code exactly answers the question. But I’d also argue that there is very little chance of this code being reused. Don’t get me wrong, you definitely shouldn’t over engineer things but there should be some scope for code reuse.

For such a simple problem you’ve over engineered this.

or

There’s a better solutions that that… it’s not efficient

Is creating four methods over engieering? Does my code require any comments to provide documentation? There may well be a more performant solution to this, but that’s not my point. My point is the way of approaching a question: the thought processes involved in understanding the problem and breaking it down to separate concerns, making it easy to read, reusable and self documenting. If the code that worked out the odd numbers is not efficient it could easily be changed in one place without impacting the interface, the other methods within the class, or the overall functionality.

Some people may jump to the simplest solution but I think the way i’ve described approaching and solving the problem demonstrates good practice. If I’m completely honest I would normally approach the development of something such as this by writing a test case first since I practice TDD but that can wait for another blog post.

Related posts:

1. Problem solving lessons relearnt

    if (Request.Url.ToString().StartsWith("http://www."))
    {
        Response.StatusCode = (int)System.Net.HttpStatusCode.MovedPermanently;
        string responseUrl = Request.Url.ToString().Replace("http://www.", "http://");
        Response.Redirect(responseUrl, true);
    }

So, if somebody types in http://www.getgravatar.com (see it works) or anything with a “www.” in the URL they will be redirected to a non-www page. However, the redirect seemed to go to the correct URL but with port 20000. I’ve no idea why this is so I had to add a special case in to remove the port.

    if (Request.Url.ToString().StartsWith("http://www."))
    {
        Response.StatusCode = (int)System.Net.HttpStatusCode.MovedPermanently;
        string responseUrl = Request.Url.ToString().Replace("http://www.", "http://");
        responseUrl = responseUrl.Replace(":20000", "");
        Response.Redirect(responseUrl, true);
    }

I’ve not read up to see if this is expected but I thought it was quite unexpected and may be of use to somebody else in the future.

Related posts:

1. Windows Azure – 503 Service Unavailable

Problem

So, I followed the instruction from the blog and uploaded the package and configuration file, waited for the staging application to get into a runnable state, and clicked on the staging link…

Windows Azure – 503 Service Unavailable

Clearly not a good thing! In addition to this error I occasionally got a random network error or a full-on connection error reported by the browser.

I tried googling for this error but there was nothing about this problem after deploying to the real Windows Azure hosting (the cloud). As far as I can tell there’s no way of getting any debug information or logs to work out what’s going wrong. Maybe this is something that Microsoft will add later on?

Solution

Then it struck me that I hadn’t actually set up any kind of TableStorage on my Windows Azure hosting so I removed all mentions of storage and database connections from the MVC application. This included editing Web.config and removing the following.

• The <section name=”authenticationService” type=”System.Web.Configuration.ScriptingAuthenticationServiceSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35″ requirePermission=”false” allowDefinition=”MachineToApplication” /> section element.
• The <connectionStrings> element
• The <membership>element
• The <authentication mode=”Forms”> element
• The <profile> element
• The <roleManager>element

Update: I’ve found that without the <authentication>element I started getting the error below so you may want to instead replace it with :

CCT: Role instances did not start within the time allowed. Please try again. If you continue to encounter this behavior please try shutting down the Development Fabric.

I’m guessing that not all of these elements actually need to be removed but doing so resulted in the MVC ASP.NET application working in Windows Azure.

Update 2: ServiceDefinition.csdef

If you happen to get network timeouts or 404 network connection issues it’s worth checking your ServiceDefinition.csdef to make sure that you’ve got port 80 configured. I noticed that mine had updated to port 8080 so obviously I couldn’t access the staging site on port 80 like I was trying. If you do have the port set to something else other than port 80 you can use that port to access your application but the ServiceDefinition.csdef does have a comment in there telling you your application should be on port 80 so you are probably best to stick with that.

<!– Must use port 80 for http and port 443 for https when running in the cloud –>
<InputEndpoint name=”HttpIn” protocol=”http” port=”80″ />

Related posts:

1. Response.Redirect in Windows Azure
2. System.Security.SecurityException: That assembly does not allow partially trusted callers
3. Linkstation NAS Folder share with Windows Vista

System.Security.SecurityException: That assembly does not allow partially trusted callers

In my application I’m using Castle Windsor for dependency injection and when trying to resolve a service using:

IGravatar gravatar = MvcApplication.Container.Resolve<IGravatar>();

I received this message. To solve things I needed to update the WebRole element in the ServiceDefinitions.csdef file so that enableNativeCodeExecution is enabled.

<WebRole name=”TwitterGravatarMVC” enableNativeCodeExecution=”true”>

I found the solution, detailed above, on the Azure Services Platform Developer Centre forum.

Related posts:

1. Windows Azure – 503 Service Unavailable

For some people this statement holds true. They don’t want to do or think about work outside of their 9:00 to 5:30 job. There is a definite line to be drawn. For other people, such as Ian Sanders, work is enjoyable because he’s working on things he’s passionate about. Ian integrates work and life because he enjoys what he does and understands the benefits it provides. Many other people feel the same way and Ian interviews a select few in his book.

In “Juggle! Rethink work, reclaim your life” Ian discusses the motivations behind his choice to live in the “scrambled up world of work” where he integrates work and life. He provides hints and tips on how he, and others including Gary Vaynerchuk (a personal favourite of mine), manage to “live the juggle life” and the benefits that this provides. Being a juggler certainly isn’t all plain sailing and the book also covers valuable information on the challanges and extra responsibilities that you may face if you make take the plunge.

Ian’s first book, “LEAP!: Ditch Your Job, Start Your Own Business & Set Yourself Free“, introduced some similar concepts to those covered in Juggle!. I actually read Juggle! before I read LEAP! and there is some crossover, but not enough to take anything away from either book. Juggle!, in contrast to the title of Ian’s first book, even suggests you should consider staying with your current employer and suggests way of negotiating or fashioning a role and a lifestyle that suits you.

Juggle! Rethink work, reclaim your life contains 198 pages packed with thought provoking content and discussion. The book is very accessible and contains short, informative and well structured sections and chapters. So much so I would almost class the book as a reference and I’ll certainly be going back again to read through the a number of chapters or work my way though some of the great lists that Ian has compiled in the near future.

Relevant links:

• Ian Sanders website
• Ian Sanders Blog
• Juggle! Rethink work, reclaim your life on Amazon.co.uk
• Ian’s first book LEAP!: Ditch Your Job, Start Your Own Business & Set Yourself Free on Amazon.co.uk

No related posts.

The definition is short and sweet:

Real-time web is the concept of searching for and finding information online as it is produced. Advancements in web search technology coupled with growing use of social media enable online activities to be queried as they occur.

A traditional web search crawls and indexes web pages periodically, returning results based on relevance to the search query. The real time web delivers the most popular topics recently discussed or posted by users. The content is often “soft” in that it is based on the social web – people’s opinions, attitudes, thoughts and interests – as opposed to hard news or facts.

At present there is no mention of the technology behind the real-time web. Nothing about Twitter and FriendFeed helping to form the definition.

Do you agree with this definition? What web 2.0 platforms do you think have helped define what “real-time web” is? What technologies do you believe have pushed the “real-time web” into such prominence?

Related posts:

1. Bing.com round table
2. Caplin Systems Blog Post – What is the real-time web?
3. Microsoft Bing.com round table thoughts