Earlier this year I worked on an exciting product called the Runtime Page Optimizer (RPO). Originally written by the guys at ActionThis to solve their website’s performance issues, I had the opportunity to develop it with them and help turn the RPO into a product that works on any ASP.NET website.

How RPO works

At its heart the RPO is a HttpModule that intercepts page content at runtime, inspects it, and then rewrites the page so that is optimized to be downloaded to the client. Because the RPO is a module it can quickly be added to any existing ASP.NET website, creating instant performance improvements.

What RPO optimizes

The RPO does three things to speed up a web page:

• Reduces HTTP requests  Reducing the number of resources on a page often produces the most dramatic improvement in performance. A modest sized web page can still take a significant amount of time to load if it contains many stylesheets, scripts and image files. The reason for this is most of the time spent waiting for a web page to load is not for large files to download but from HTTP requests bouncing between the browser and the server. The RPO fixes this by intelligently combining CSS and JavaScript text files together and merging images through CSS spriting. Fewer resources means less time wasted from HTTP requests and faster page loads.

• Compresses Content RPO minifies (whitespace removal) and zip compresses JavaScript and CSS files, as well as the ASP.NET page itself. Compression reduces page size, saves bandwidth and further decreasing page load times.

• Caching The RPO ensures all static content has the correct HTTP headers to be cached on a user’s browser. This further decreases "warm" page load times and saves even more bandwidth. When resources change on the server, the client-side cache is automatically refreshed.

Other stuff

• Every site is different so the RPO has extensive configuration options to customize it to best optimize your ASP.NET application. RPO has been used on ASP.NET AJAX, MVC, SharePoint, CRM, EpiServer and DotNetNuke websites.
• Lots of thought has been put into performance. The RPO caches all combined content and supports load balancing. Once combined content has been cached the only thing that happens at runtime is lightweight parsing of HTML, which is darn quick. I know because I wrote it that way [:)]
• The RPO supports all browsers, including new kid on the block: Chrome. RPO is even smart enough to take advantage of features only available in certain browsers and supply specially customized content to further improve page load times.
• The industrious people at RPO are making a version for Apache.

Working on the RPO was a great experience. Some very smart people are behind it and everyone contributed something unique to make RPO the awesome tool that it is today.

RPO is out now and a fully featured trial is available at getrpo.com. Check it out!

Update:

I noticed there is a question about the RPO on StackOverflow (I've been using StackOverflow a lot lately, excellent resource). The question discussion has some positive comments from users who have tried the RPO out.

This is an ActionResult I wrote to return JSON from ASP.NET MVC to the browser using Json.NET.

The benefit of using JsonNetResult over the built in JsonResult is you get a better serializer (IMO [:)]) and all the other benefits of Json.NET like nicely formatted JSON text.

public class JsonNetResult : ActionResult

{

  public Encoding ContentEncoding { get; set; }

  public string ContentType { get; set; }

  public object Data { get; set; }

  public JsonSerializerSettings SerializerSettings { get; set; }

  public Formatting Formatting { get; set; }

  public JsonNetResult()

  {

    SerializerSettings = new JsonSerializerSettings();

  }

  public override void ExecuteResult(ControllerContext context)

  {

    if (context == null)

      throw new ArgumentNullException("context");

    HttpResponseBase response = context.HttpContext.Response;

    response.ContentType = !string.IsNullOrEmpty(ContentType)

      ? ContentType

      : "application/json";

    if (ContentEncoding != null)

      response.ContentEncoding = ContentEncoding;

    if (Data != null)

    {

      JsonTextWriter writer = new JsonTextWriter(response.Output) { Formatting = Formatting };

      JsonSerializer serializer = JsonSerializer.Create(SerializerSettings);

      serializer.Serialize(writer, Data);

      writer.Flush();

    }

  }

}

Using JsonNetResult within your application is pretty simple. The example below serializes the NumberFormatInfo settings for the .NET invariant culture.

public ActionResult GetNumberFormatting()

{

  JsonNetResult jsonNetResult = new JsonNetResult();

  jsonNetResult.Formatting = Formatting.Indented;

  jsonNetResult.Data = CultureInfo.InvariantCulture.NumberFormat;

  return jsonNetResult;

}

And here is the nicely formatted result.

{

  "CurrencyDecimalDigits": 2,

  "CurrencyDecimalSeparator": ".",

  "IsReadOnly": true,

  "CurrencyGroupSizes": [

    3

  ],

  "NumberGroupSizes": [

    3

  ],

  "PercentGroupSizes": [

    3

  ],

  "CurrencyGroupSeparator": ",",

  "CurrencySymbol": "¤",

  "NaNSymbol": "NaN",

  "CurrencyNegativePattern": 0,

  "NumberNegativePattern": 1,

  "PercentPositivePattern": 0,

  "PercentNegativePattern": 0,

  "NegativeInfinitySymbol": "-Infinity",

  "NegativeSign": "-",

  "NumberDecimalDigits": 2,

  "NumberDecimalSeparator": ".",

  "NumberGroupSeparator": ",",

  "CurrencyPositivePattern": 0,

  "PositiveInfinitySymbol": "Infinity",

  "PositiveSign": "+",

  "PercentDecimalDigits": 2,

  "PercentDecimalSeparator": ".",

  "PercentGroupSeparator": ",",

  "PercentSymbol": "%",

  "PerMilleSymbol": "‰",

  "NativeDigits": [

    "0",

    "1",

    "2",

    "3",

    "4",

    "5",

    "6",

    "7",

    "8",

    "9"

  ],

  "DigitSubstitution": 1

}

Download source

A pretty amazing reshaping of the landscape of Wall Street occurred during the weekend. Major finance bank Merrill Lynch was forced to sell itself for a cool $50 billion and another, Lehman Brothers, filed for bankruptcy. Both have lost huge amounts of money from bad debts. They lent money to people who never had the means to pay it back.

This American Life has a great non-technical and entertaining podcast on how they (and we) got in this situation and why the banks did what they did.

A special program about the housing crisis produced in a special collaboration with NPR News. We explain it all to you. What does the housing crisis have to do with the turmoil on Wall Street? Why did banks make half-million dollar loans to people without jobs or income? And why is everyone talking so much about the 1930s? It all comes back to the Giant Pool of Money.

It is an hour long and well worth listening to if you want to have a better understanding of the "credit crunch".

Rick Strahl has written a great post on serializing ADO.NET objects (DataSet, DataTable, DataRow) to JSON using Json.NET.

Check it out.