ASP.NET Simplicity and Performance with Scott Hunter

On this episode of Pixel8 Scott Hunter (@coolsch) joins us to discuss his team’s focus on simplicity and performance in ASP.NET. Scott was kind enough to surprise me with some talking points about what his team is thinking about for releases coming after ASP.NET 4! Please note, what’s discussed herein are un-implemented features of ASP.NET so your feedback is not only welcome, but encouraged!

  1. Velocity Provider for Caching: This will allow developers to plug in caching scenarios based on their needs.
  2. Automatic Generation of CSS Sprites: Adding images to the Content folder will trigger the ASP.NET framework to stitch together a single image which is later sliced up by inline styles. A helper method is responsible for generating markup of the appropriate CSS coordinates to wire-up the sprite. This feature will allow for groups so related images may be combined together.
  3. Complex Helpers: There are scores of common features and functionality that many developers want to include in their applications, but unfortunately right now these features require a lot of code to implement. In the future you may have helpers available that provide a simple API to do the following:
    • Resize images
    • Watermark images
    • Flip images
    • Send Email - helpers for single method calls to send and mail or verify an address [ex: Email.Send() or Email.VerifyAddress()]
    • Schedule Tasks - submit tasks to a background worker process (wouldn’t take down app domain if exception occurred)
    • Posting status updates to Facebook, Twitter, etc.
    • Polls
    • Ratings
    • Comments
    • OpenID integration
    * Many of these features will likely be released outside the formal ASP.NET framework
  4. Data Simplicity: Active record implementation that features a code-first approach. Consider a blank database with no tables. The active record pattern would allow you to instantiate the Foo class and then add values to Foo.Bar1 and Foo.Bar2, then call Foo.Save(). If the Foo table does not exist in the database, then the table is created and the data is persisted. Also Foo.All() would return all the records of Foo, but the return type is an IQueryable so you could further filter on the server. The code-first won’t be the only direction the integration will work. Changes in the database can be reflected in the model by use of T4 templates.

    Note: I ask the requisite question about the virtues of the repository pattern as opposed to active record. Scott demonstrates how the implementation they are considering would not hinder you from exposing your own DTOs and wrapping a repository around the active record objects.

Also make sure you check out my post 12 Ways to Simplify ASP.NET and Visual Studio I wrote after being inspired by this interview!