Monday to Wednesday:
Visual Studio 2010 and .NET Framework 4

Most of the content of this course came from the kit we at Southworks built for DPE, which is available at Channel 9:

http://channel9.msdn.com/learn/courses/VS2010/

You can check a good part of the course online, including additional videos, or you can download the offline Training Kit which gets you the full content and also includes the Dependency Checker tool for every lab. Running this tool your system is inspected to see if you have all the needed components for this lab, and you get links to download and install any missing part. To make your lab exercise even easier, the tools usually installs a series of Visual Studio snippets also, so you save a lot of typing.

While I was teaching the course, MIX 10 was running in Las Vegas, and had the chance to comment some of the announcements, many related to our latest cool projects, like the launch of Windows Phone 7 Series, and the release of our WP7 training kit, also available at Channel 9: http://channel9.msdn.com/learn/courses/WP7TrainingKit/

One of the topics that get people more excited was the ASP.NET Ajax Library, with all the client template stuff, and it was good that Microsoft just announced that they are investing more heavily in jQuery, as John Resig himself explains in this post.

Also related is the imminent release of the  Web Client Developer Guidance we are building with p&p.

Special thanks in this course for Debora Di Piano, who helped me sharing her incredible expertise in Team Foundation Server with the audience.

Thursday and Friday:
Line of Business Applications with Silverlight 4

I’m finishing this course today, although it is mostly run by two good friends, colleagues and real Silverlight gurus: Julian Dominguez and Ezequiel Jadib.

Julian is one of the masterminds behind the Web Guidance mentioned above, and he was also at the core of the Composite Application Guidance for WPF and Silverlight, also known as Prism (which is way easier to remember).

Ezequiel worked in many awsome projects too, and is the main author of the Silverlight Rough Cut Editor, which may be well one of the more complex Silverlight applications, used to edit video from many sources in complex scenarios like the latest Winter Olympic games. You can see a whole presentation Jason Suess about it from MIX 10.

Here is the content of the course, also in Channel 9: http://channel9.msdn.com/learn/courses/Silverlight4/

Of course, you can find many sessions on Silverlight 4 from MIX 10, as well as tons of other interesting stuff.

Another interesting resource we mentioned during the course, more oriented to designers, but also to the new devigner fellows, is the Design Toolbox.

• Only one view in the accordion region should be active at a time.
• It should be possible to set the header for each AccordionItem.
• It should be easy to extend with other required functionality.

If you are familiar with Prism’s source code, you might probably notice that is quite similar to the way Prism handles Silverlight’s TabControl as a region. Our approach was creating two classes:

• AccordionRegionAdapter: This class would be in charge of creating the region and hooking it up with the control.
• AccordionRegionSyncBehavior: This class would provide the region’s functionality.

Any other functionality that was necessary could be added through other RegionBehaviors. This document from the Prism documentation explains the usual process of creating a custom Region Adapter.

As the code for both those classes is quite long, I decided to simply provide the download at the bottom of this post.

Setting the AccordionItem’s Header Text

As it can be done with the TabControl region, the following syntax can be used to show some text in the header of each AccordionItem (in this case the View’s DataContext is simply a string). The outcome can be seen in the picture placed after the code.

<tk:Accordion Name=“MainRegion” Regions:RegionManager.RegionName=“MainRegion“>
  <shell:AccordionRegionAdapter.ItemContainerStyle>
    <Style TargetType=“tk:AccordionItem“>
      <Setter Property=“HeaderTemplate“>
        <Setter.Value>
          <DataTemplate>
            <TextBlock Text=“{Binding}“/>
          </DataTemplate>
        </Setter.Value>
      </Setter>
    </Style>
  </shell:AccordionRegionAdapter.ItemContainerStyle>
</tk:Accordion>

Sample Application

I created a small sample application which shows this scenario working. You can download it from here. The code is provided “AS IS” with no warranties and confers no rights.

I hope you can make good use of it.

As it was announced by ScottGu a few minutes ago in the MIX 10 keynote , Microsoft has launched the new mobile platform. It’s called Windows Phone 7 Series. One of the principal drivers for this new platform is the user experience .

Developers using Windows Phone 7 Series will take advantage of Silverlight, the XNA Framework and a great set of tools to build rich applications.
This means that all Silverlight and XNA developers are now Windows Phone Developers automatically . Another great news is that developers  will write the code once and then optimize across mobile devices, web, desktop or Xbox, adjusting basically the resolution and the screen size.

If you want to start playing you can download the Windows Phone Developers Tools as a free single download from developer.windowsphone.com .

Windows Phone Developers Tools includes:

• Visual Studio 2010 Express for Windows Phone
• Windows Phone 7 Series Add-in for Visual Studio (For developers already working with Visual Studio 2010)
• Windows Phone 7 Series emulator
• Expression Blend for Windows Phone (NOT YET, COMING IN THE MONTHS AHEAD)

You can also browse the Channel 9 Online Training Course in here.

Stay tuned that I will post a Hello World example application for Windows Phone.

Built upon the Composite Application Guidance for WPF and Silverlight (aka PRISM), the application is modular and extensible, allowing you to easily use it with custom content systems and workflows. Hope to see you there at Jason’s session!

This session will provide an overview and technical details of the Silverlight Rough Cut Editor.  This open source tool provides real time editing for Silverlight Smooth Streaming content, and has been used to create content for high profile events such as the 2010 Vancouver Winter Olympics and Sunday Night Football.  Content publishers can use this tool to create real-time highlights, control dynamic meta-data (ad insertions and content meta-data), and create a modular approval & publishing workflow for live and on demand media content (CMS integration).  This session will review the core architecture (modularity, UI composition, services, and data providers) and detail how this tool is being used to meet the needs of content providers worldwide.

• Manage access to employees that belong to the Active Directory
• Manage access to partners that has their own STS
• Manage access to certain webparts, doc libraries or lists through Sharepoint groups and claims
• Allow/deny access to Windows LiveID users

• Book content online on MSDN.
• Book PDF download
• Final samples download
• Discuss at Codeplex

Looking at my name in the cover of a book together with such a group of experts is really a significant milestone in my career. I want to specially thanks Eugenio for trusting me and inviting me to participate in this project. Hope you find the content useful. If you have any questions or you want to discuss about claims, identity, federation towards your next project feel free to mail me at matias at southworks dot net.

Now heading towards the second book: Cloud Guidance! Stay tuned…

Once presentations are finished we have an “Open Discussion” space. We sit in a circle and any Southie can propose a topic for discussion. After introducing all topics, we vote them and the TOP 2 voted topics are discussed. The open discussions topics are generally related to our daily practice, improvement opportunities, update on different things, etc.

Both, the presentations and discussion are recorded and published in our network to allow any Southie to consume them later if they could not make it.

All these effort is coordinated by the communications team lead by Julian Scopinaro.

Personally, I found these spaces very useful; they help to keep us up to date with things that are happening in the company and also allow us to talk about improvement opportunities.

This is part Southworks’ culture.

Below some pictures from the last Friday.

Since 2010 started, I didn’t blogged that often, but there were a couple of projects that I’ve been working lately. Throughout this post, I’ll describe each one and the futures.

Every piece of feedback will be welcome, as every other contribution too.

Enjoy the ride,
~johnny

Rack::Auth::WRAP, the OAuth WRAP Middleware

Yesterday, with Juan Pablo, we published our first version of Rack::Auth::WRAP the first version of the Rack. If you are familiar with the protocol, you can skip the next section if not, take a look at it. Extracted from the read me at github.com.

What the heck is WRAP?

Web Resource Authorization Protocol (WRAP) is a profile of OAuth, also called OAuth WRAP. While similar in pattern to OAuth 1.0A, the WRAP profile(s) have a number of important capabilities that were not available previously in OAuth. This specification is being contributed to the IETF OAuth WG.

Also this same group owns the specification for the SWT (Simple-Web-Token), for more information read wiki.oauth.net/OAuth-WRAP or visit the groups.google.com/group/oauth-wrap-wg.

The latest specification for the complete protocol can be found at Google Group as HTML (RFC properly formatted) on groups.google.com/group/oauth-wrap-wg/attach/981df73f2839b8ef/draft-hardt-oauth-wrap-01.html?part=5

Creating your first protected resource

As you might be thinking, our first resource will be a Sinatra application.

First of all we need to install the gem, as

[sudo] gem install rack-oauth-wrap

To make the sample easier let’s create our own shared key, we can all share this for demo purpose NjkzNTczOTAtMDA2MC0wMTJkLTQ1M2YtMDAyMzMyYjFmYWY4\n

So let’s start by creating the protected resource

require 'rubygems'
require 'sinatra'
require 'rack/auth/wrap'

use Rack::Auth::WRAP, :shared_secret =>t; "NjkzNTczOTAtMDA2MC0wMTJkLTQ1M2YtMDAyMzMyYjFmYWY4",
                      :audiences =>; "http://localhost:4567",
                      :trusted_issuers =>; "urn:demo-issuer"

get "/" do
    if @env["REMOTE_USER"]
        return “You are authenticated as #{@env["REMOTE_USER"]['Email']}”
    else
        return “You are an unauthenticated user”
    end
end

Now we can start this on a Terminal (cmd, or whatever) and let’s jump to the consumer, but first if you try it without sending a token, and using the client we are going to build, you will get:

?> curl http://localhost:45678
You are unauthenticated

Now lets create a client trying to access a protected resource with a token on the header (requires restclient)

require 'rubygems'
require 'cgi'
require 'base64'
require 'restclient'
require 'hmac/sha2'

SHARED_SECRET = "NjkzNTczOTAtMDA2MC0wMTJkLTQ1M2YtMDAyMzMyYjFmYWY4\n"

simple_web_token = {'Audience' =>; "http://localhost:4567",
                    'Issuer' =>; "urn:demo-issuer",
                    'ExpiresOn' =>; (Time.now.to_i + 60).to_s,
                    'Email' =>; 'johnny.halife@sample.com'}.map{|k, v| "#{k}=#{CGI.escape(v)}"}.join("&")

signature = Base64.encode64(HMAC::SHA256.new(Base64.decode64(SHARED_SECRET)).update(simple_web_token.toutf8).digest).strip
simple_web_token += "&HMACSHA256=#{CGI.escape(signature)}"

puts RestClient.get("http://localhost:4567/", "Authorization" =>; "WRAP access_token=#{CGI.escape(simple_web_token)}")

Now let’s try our client, and see if there’s any difference with the curl request:

?> ruby client.rb
You are authenticated as johnny.halife@sample.com

As you can see, we have our first end to end, Rack::Auth::WRAP Sample.

DISCLAIMER: On a real world application you won’t generate your own token as we are doing on the client code. We are doing it for demo purposed, but probably on you app you will get a token from an authorization server.

Both snippets are available as gits on github: Protected Resource / Client. We are assuming that this is running on localhost:4567

TODO’s and futures

On the upcoming days/weeks/months we are going to get on the middleware support for the other ways of getting the token, like Query String and/or method body. Also we would like to implement the Web Profile of WRAP, so stay tuned.

You can read the freshly published documentation at http://rack-oauth-wrap.heroku.com

Source Code available at: http://github.com/johnnyhalife/rack-oauth-wrap

OAuth WRAP 0.9 for Tcl

First of all, if you aren’t familiar with Tcl it’s “originally from “Tool Command Language”, but conventionally
rendered as Tcl is a scripting language created by John Ousterhout”. I encourage you to test it and also if you are interested read Where’s Tcl hiding?.

This project was born after half an hour spiking on how hard it will be to parse a token on a bare linux distro that only has Tcl. After we noticed that Tcl is really straightforward language for design, prototype and is fun to write, we packed this lib and make it available for anyone interested.

Here’s an snippet of the intended usage of the lib

package require ::oauth::wrap

set rawToken "access_token=something&other_parameters_to_ignore" #=> the token from the IP

# => creates a configuration dictionary for the values
dict set configuration signingKey {valid_key} # => signing key used by the Identity Provider
dict set configuration issuer {valid_issuer} # => the identity provider URI
dict set configuration audience {valid_audience}  # => my application audience URI

# this will return the token when it's valid else it will return false
set token [oauth::wrap::authenticate $configuration $rawToken]

# at this point if the token valid you can mess around with its claims
# that are returned on a dictionary form
set name [dict get $token name]

It’s fun to give it a shot, check out the source code at http://github.com/johnnyhalife/tcl-oauth-wrap

Windows Azure Storage for Ruby v1.0

On the 4th February, 2010 I’ve published the version 1.0 of ruby gem I wrote for Windows Azure Storage. This time it has the great contribution of my friend Juan Pablo Garcia Dalolla who has implemented the Windows Azure Tables support.

This version of the gem also includes support for the version 2009-09-19.

Here’re are some code snippets from the Windows Azure Tables support

require 'waz-storage'
require 'waz-tables'

# The same connection of Windows Azure Storage Core (Queues, Blobs) can be reused
WAZ::Storage::Base.establish_connection!(:account_name =>; account_name,
                                         :access_key =>; access_key)

# Grab the service instance
service = WAZ::Tables::Table.service_instance

# Query the customer table
service.query('customer_table', {:expression =>; "(PartitionKey eq 'customer') and (Age eq 23)", :top =>; 15} )

# Insert something into the customer table
serivce.query('customer_table', {:row_key =>; 'my_custom_id', :name =>; 'johnny'})

There’s also a DataMapper adapter effort going on for Windows Azure Storage Tables, I recommend you to check out Juan Pablo’s post about Windows Azure Tables Adapter for Datamapper

Source Code available at: http://github.com/johnnyhalife/waz-storage

RDoc available at: http://github.com/johnnyhalife/waz-storage

Logins vs. User accounts

To connect to a SQL Server instance you first need a login so the instance can authenticate you (know who you are). But to perform operations on a specific database you will need a user account in that database. The user account is used for database access and permission validation. So you could have a login, but if you don’t have a user account associated to that login, you  won’t be able to access that database.

Logins

To create a login you can use the following code snippet.

– To create a login that uses Windows Authentication:
CREATE LOGIN <name of Windows User> FROM WINDOWS; GO

– To create a login that uses SQL Server Authentication:
CREATE LOGIN <login name> WITH PASSWORD = ‘<the password>’ ; GO

The actions you can perform with a SQL Server instance (like create, backup and restore databases) depend on the server roles associated with your login. Once the login is created you can assign it server roles by using the [sp_addsrvrolemember] stored procedure. Possible server roles are: dbcreator, sysadmin and serveradmin among others.

User Accounts

User accounts are defined at database instance level, and every user account must be associated to a login, so to create a user account you must provide login.

– To create a user for the myLogin login for the myDatabase database
use myDatabase
create user myUser for login mylogin with default_schema=dbo

As you can see, when creating a user you don’t need to provide a password, because there is already a password associated with the login.What a user can do with the  database is defined by the user’s permissions. Permissions are grouped into Roles and there are three different kind of roles:

• Database Fixed roles: are pre-defined roles by the system
• User-defined roles: are roles created by the user
• Application roles:  are created to support the security needs of an application. (often database applications
  enforce their own security based on the application logic)

When a user is created it is automatically added to the public (fixed) role. To add a user to a role you can use the [sp_addrolemember] stored procedure.

Hope you find this useful.

1. Missing referenced assemblies: set CopyLocal = True for referenced assemblies not in .NET Framework 3.5 or Microsoft.WindowsAzure.ServiceRuntime (these assemblies are the only ones present in Windows Azure).
   
2. Project built for 32bits only: Use Platform target = Any CPU (or x64). Windows Azure runs on 64 bits. 
   
3. Path too long: Use project names with less than 28 characters. Sometimes no exception is shown, to know if this is the issue, exclude all the roles but one from the Cloud Service project and run once each time to be able to view the error details in the output window when running on the Development Fabric. You should see the following error message “ERR: Failed to complete setup of assembly (hr = 0×8007006f)”.
4. Missing files: Include all the used files in the project. Files that are not included are not published (for instance, images)

If you will perform a service upgrade, first suspend it. If you do not suspend the service and you perform an upgrade, it will never end. Apparently, it tries to return to the previous version state as part of the upgrade process, if our new version has the same issue (fails to initialize by iterating between the stopping to initializing states), it will get stuck in the middle of the process and you won’t be able to perform any action from the Azure portal, you cannot even delete the service. If this happened to you, you can try using the Azures Cmdlets to set the deployment status.

If you continue having issues, the following blog post includes more possible causes and suggestions:

• Windows Azure Deployment Stuck in Initializing, Busy, Stopping – Why?

The progressive enhancement and its counterpart, Graceful Degradation, are approaches that can help rich Web Applications support more browsers and have a wider reach.

Disclaimer: We are writing this documentation as part of the new Web Client Guidance that is being done in patterns & practices. We are close to finishing this project, so I would like to get more feedback or validation from everyone that gets the chance to read this before we release. Have in mind that the content of this topic can change both in content and in form (it can change because of YOUR feedback).

Progressive Enhancement vs. Graceful Degradation

Graceful degradation is the practice of building an application for modern browsers while ensuring it remains functional in older browsers and other user agents (for example, accessibility tooling and mobile devices).

Progressive enhancement is usually preferable to graceful degradation: it starts with the simple basics and improves usability and aesthetics on top of that. When developing using Progressive enhancement you should define a development base, for example when using MVC the base could be a user that does not have JavaScript enabled. Therefore, the expectation is that you should have the basic functionality available without JavaScript; but with JavaScript, the experience is richer, including functionality, such as client-side form validation, predictive fetching, and preview.

It is strongly recommended to use progressive enhancement, when designing something from scratch. Graceful degradation can be tedious, difficult and requires more work to implement.

However, if you are maintaining an existing site, the easiest choice is to provide graceful degradation, unless you want to rewrite the whole site.

It is also possible to combine both approaches in the application. Even some features may end up being the same, independent of the approach used.

Note: For more information about both concepts, see Progressive Enhancements and Graceful Degradation: Making a Choice.

Core Principles

• Progressive Enhancement consists of the following core principles:
• The basic content should be accessible to all browsers
• The basic functionality should be accessible to all browsers
• Semantic markup contains all content
• Enhanced layout is provided by externally linked CSS
• Enhanced behavior is provided by unobtrusive, externally linked JavaScript
• End user browser preferences are respected

There are several scenarios to consider for using these patterns:

1. Browsers that have JavaScript turned off
2. Different browsers that:
   1. implement JavaScript and DOM features differently
   2. implement CSS differently
3. The need for SEO (Search Engine Optimization)

Browsers that Have JavaScript Turned Off

Browsers may have JavaScript disabled due to company policies, screen readers, or other accessibility issues. This is usually the biggest challenge of all, as it requires the most development effort. If it is not done correctly, it could prevent the user from interacting with the site at all.

To address this scenario, you should start developing the site using HTML for the basic content. You should use semantic markup and CSS to enhance the layout. Then you should start adding functionality for browsers that do support JavaScript and other client technologies.

The following are some advantages and disadvantages of creating applications without JavaScript.

Advantages:

• Can support browsers without JavaScript
• It is SEO friendly (as search engine spiders do not use JavaScript)
• Easier to create an accessible site as a side effect without too much effort
• Possibility to open links in new tabs and bookmark it (for example if you use the middle mouse, it will open the link in href instead of executing the JavaScript defined for the click event).

Disadvantages:

• There is usually a need to create a server-side version of a view, and a separate client version of the same view or portions of it.

The developer has to be aware of the scripted and non-scripted features of the application, instead of just assuming that JavaScript will always be present.

Different Browsers that Implement JavaScript and DOM Features Differently

This challenge is typically known as cross-browser incompatibility. Compared to the previous scenario, when not implemented successfully, might prevent the user from interacting with the site in some cases, which causes frustration for the user, or even breaking JavaScript functionality completely, and cause a situation similar to the previous scenario.

This challenge has been a major pain point for web developers in past years, which led to using mostly server-side controls made by expert web developers that emit islands of JavaScript automatically, in order to prevent the application developer to have to learn all the browser differences, which in turn led to application developers from getting away from learning any JavaScript at all, even for simple tasks.

In recent years several JavaScript libraries have emerged that provide a cross browser experience for all of the most common tasks. By writing your code on top of these base libraries, in most cases you can avoid dealing with branching logic for the different browsers, which leads to a better appealing to the JavaScript language as a renewed development tool.

Different Browsers that Implement CSS Differently

CSS differences between browsers, though it is generally good to account for, it is usually not a big problem if bypassed. The reason is that having CSS that do not work in all browsers might cause some browsers to render the page with some inconsistencies in sizes, placement, overlapping of sections, but this will generally not prevent the user from interacting with the site entirely.

The following are some tips for dealing with these CSS inconsistencies:

• Use a CSS reset, which improve a lot of the cross-browser inconsistencies in size, placement, and overlapping issues.
• Develop the site with standards in mind (consider targeting XHTML 1.0 Transitional here), which almost always works in IE8, Firefox, Safari, Chrome, and usually Opera.
• If the standards targeted HTML/CSS has IE6/7 issues, fix those issues by including CSS “hacks” in separate stylesheets referenced through conditional comments.

It is up to the business to decide the ROI for creating a site that looks identical across all the browsers. Because not supporting all versions of CSS implementations will not prevent users from interacting with your site, you could typically decide to support the CSS features in the browsers with the largest market shares, while ignoring older browsers.

How to Achieve Progressive Enhancement

To implement PE you should begin with the basic version, and then add enhancements for those browsers that can handle them.

First, you should start developing your application in plain HTML. Plain HTML is understood by all browsers. Furthermore, search spiders will be able to access and index your site content.

This also means that all anchors and forms must have a working target URL for navigating or posting data without the need for JavaScript.

Then, add styles using CSS in an external file to improve the look and feel of the site. Almost all browsers support CSS, and those which do not support it, will simply ignore the styling.

Finally, add JavaScript support, using unobtrusive JavaScript. Unobtrusive scripts are silently ignored by browsers that do not support JavaScript, but it is applied by those that do it.

Unobtrusive JavaScript separates content from behavior. This means you should avoid having inline JavaScript as in the following example.

HTML
<form id=”profile” action=”http://mySite.com/SaveProfile”>
  <input type=”text” name=”age” />
  <input type=”submit” value=”Save” onclick=”SaveProfileWithAjax();” />
</form>

This is because the purpose of markup is to describe a document’s structure, not its programmatic behavior.

The unobtrusive solution is to register the necessary event handlers programmatically, rather than inline. This is commonly achieved by assigning a particular CSS selector to all elements which are affected by the script, to reduce the amount of script code. The JavaScript code should reside in a separate file. In the following code the id attribute is used for identifying a form:

HTML
<form id=”profile” action=”http://mySite.com/SaveProfile”>
  <input type=”text” name=”age” />
  <input type=”submit” value=”Save” />
</form>

It is recommended that you use libraries that provide an abstraction of the DOM. The jQuery and ASP.NET Ajax libraries do a good job at this.

The following jQuery script binds the submit event of the form with id=”profile”, to the SaveProfileWithAjax function:

Note: jQuery simplifies this, by providing a CSS-like selector, instead of just getting the elements by ID.

JavaScript using jQuery
$(document).ready(function(){ //Wait for the page to load.
    $(’form#profile’).bind(’submit’, SaveProfileWithAjax);
});

function SaveProfileWithAjax(event){
    event.preventDefault(); // this will prevent the browser for submitting the form in the default way, as we will handle the post programmatically using AJAX
    // Post the data using an AJAX call
}

Note: The event.preventDefault JavaScript method cancels the event if it is cancelable, meaning any default action normally taken by the implementation as a result of the event will not occur.

The following code shows the implementation in ASP.NET Ajax Library.

JavaScript using ASP.NET Ajax Library
Sys.Application.add_init(function() {
    $addHandler($get(’#profile’), ’submit’, SaveProfileWithAjax);
});

function SaveProfileWithAjax(event){
    event.preventDefault();
    // Post the data using an AJAX call
}

Note: To attach events, modern browsers use the addEventListener function specified in the DOM Level 2 (Events) specification, while Internet Explorer will use its proprietary attachEvent function. For this reason, if you want to achieve cross-browser compatibility in a simple manner, you should always attach events using a library like jQuery or ASP.NET Ajax Library, which automatically deals with these compatibility issues.

Tips for Achieving Progressive Enhancement in ASP.NET MVC

Consider the following tips when implementing the progressive enhancement pattern in ASP.NET MVC.

First, build an HTML feature that works without JavaScript. For example, the song rating functionally of the Reference Implementation, which was created using radio buttons.

The following rules are applied to every web application (not just ASP.NET MVC ones) to achieve PE.

1. Use semantic markup to render the basic content.
2. Use CSS to enhance the layout.
3. Anchors should always have the href attribute set to return a working view from a controller.
4. Forms should always have the action attribute set to post the data to a working action in a controller, based on the input elements in the form. Consider rendering hidden inputs for preset values that the users don’t need to update or see.

Once the basic functionality works without JavaScript, consider the following:

1. Enhance the experience using Unobtrusive JavaScript. This typically includes:
   • Adding client-side validation to acquire immediate feedback without requiring a full post.
   • Converting full page POST/GET requests into AJAX calls that update portions of the page.
   • Adding animations / eye candy features.
2. When converting a full page request into an AJAX call, hijack and prevent the default action of the anchor link or form submit, and replace it with the AJAX call. You typically do this by calling the preventDefault method of the arguments object received when handling the click/submit event using JavaScript.
3. Avoid having different URLs for accomplishing the same business result for these cases. You can add branching code in your controller that checks the Request’s headers to see if it is an AJAX call as opposed to a typical GET or POST call, and return a different result in this case.
   • Typical approaches include returning partial HTML markup to be inserted without processing into the DOM, or data represented in JSON that requires some processing in the browser to display it.
   • ASP.NET MVC provides a standard way of checking if the request was initiated using XmlHttpRequest by calling the Request.IsAjaxRequest() extension method
     Note: If you use ASP.NET WebForms instead of ASP.NET MVC, you might need to create different endpoints, such as Web Services, ASP.NET Page Methods, or even expose MVC controllers for these actions, as there is no easy way of reusing the same endpoint, because a URL maps to a physical ASPX file.
4. In the cases where you return JSON, you might need to use JavaScript to directly manipulate the DOM, or when possible, have a template view that renders data that was retrieved in JSON format. Having templates can help you better separate UI logic from the model in the JavaScript code. The ASP.NET Ajax Library has a very good templating engine that allows you to bind to a ViewModel in a somewhat similar way as WPF & Silverlight. For more information, see Isolating the Domain Model from the Presentation Layer (this is in the Web Client Guidance documentation).
5. In some cases, you may have DOM elements that only make sense in a non-JavaScript version of the page. This is common, and you might want to remove these elements by using JavaScript if it is available in the browser.
   For example, you may have a link that redirects to a different page, but when you enhance it with JavaScript, you might hide those links entirely, and replace it with a much richer experience that does not require a redirect for example.
   Note: You can also use the noscript HTML element to render content when JavaScript is not enabled or not supported by your browser.
6. Cascading drop-downs is another canonical example: If you have a State drop down, that once selected will set available cities in another drop-down, the non-JavaScript version will have a visible submit button, and so after setting the State, the user can POST back to the server and get the same page with the available cities already populated. When JavaScript is enabled, after the page is loaded, you might want to hide this button, and on selection change of the State dropdown, request the available cities with an AJAX call that returns JSON, and update the dependant Cities dropdown. There is no need for the user to explicitly click the button to get the cities.

Finally, move on to the next feature. Remember, to always build a non-JavaScript version of a feature, and enhance it afterwards. There might be secondary features in the application where you can decide to implement in browsers that only have JavaScript enabled, but you should make this decision consciously, identifying the risks for not supporting that scenario.

Sources

• Progressive Enhancement and Graceful Degradation: Making a Choice
• Progressive enhancement
• Unobtrusive JavaScript

More Web Client Guidance

You can find this and many other topics and key decisions for creating web client applications (both in ASP.NET Web Forms and ASP.NET MVC) in our latest Web Client Guidance drops. We are close to finishing this guidance, so your prompt feedback is invaluable to us. Make sure you check it out and comment in this topic or in the codeplex forums (there is a special tag to mark conversations for this new guidance)

Typically, the user interface in Web Applications is composed of multiple pages. Now with the increasing popularity of AJAX, it is common that people want to develop Web applications that are similar and provide the same user experience as desktop applications. One common problem in Web applications is the constant page reloads and flickering when navigating the application.

Disclaimer: We are writing this documentation as part of the new Web Client Guidance that is being done in patterns & practices. We are close to finishing this project, so I would like to get more feedback or validation from everyone that gets the chance to read this before we release. Have in mind that the content of this topic can change both in content and in form (it can change because of YOUR feedback).

Forces

Any of the following conditions suggest using the solution described in this pattern:

• You want to minimize the page reloads and flickering when navigating through the application.
• You want to change only the content of the page and maintain the general layout; that is the header, footer, and menus, when updating the page.
• You want the user to keep the context of most of the page, while only manipulating the data on part of the page.
• You want to have long running processes and/or avoid losing/refreshing dynamic content state while navigating (for example, uploading files or a chat window).
• You want to improve the user experience of Web applications, by simulating the look and feel, and usability of desktop applications.

Solution

Have all of your page features, or at least most of them, in a single page. This is known as the Single-Page Interface (SPI) model. In the SPI model, all browser interactions with a Web application occur inside the boundaries of one page.

The SPI pattern improves the UI navigability of Web applications because it decreases the number of page reloads and eliminates flickering.

The SPI model requires a number of highly interactive features, which include in-place editing, context-sensitive user interface, immediate user feedback prompts, and asynchronous operations.

The Single-page Interface pattern elements

SPI is an AJAX pattern that suggests you have only a main page in your Web Application. This page interface is rearranged as a result of user interaction with the application.

Having a single-page interface, may result in your application using less-distinct URLs. Therefore, this pattern may not provide good support for search engines, unless explicit mechanisms for also allowing the navigation of the site by using full redirects are implemented.

Liabilities

The Single-page Interface pattern has the following liabilities:

• As all interactions occur within a page, there are less distinct URLs. Therefore, this pattern does not inherently provide good support for search engines
• You need to implement a mechanism to identify the different states of the application; this is for providing history browsing support and bookmarking. It might be used also for supporting permanent link. Unique URLs and deep linking can be supported in an SPI app but with additional development cost. Web applications built using more traditional full page refreshes support unique URLs and deep linking more easily.
• You have to be careful with memory leaks, because as the page is not refreshed as often, the memory is not cleaned automatically by the browser. Therefore you have to manually dispose objects, handlers, and so on, when navigating through the page.
• The SPI pattern requires a lot of JavaScript. If JavaScript is turned off, the user will not be able to use the application. This then requires down-level support in addition to the SPI pattern. It makes more sense to implement the SPI pattern if you have more control of your browsers, for example, if you have an intranet application and you know the corporate image does not restrict JavaScript, then SPI might work here. For the Internet case, it is more mixed because some users will enable JavaScript and some will not.
• Consider using the Progressive Enhancement or Graceful Degradation pattern, for addressing accessibility, browsers where JavaScript is disabled, and search engine optimization. Otherwise older browsers or readers will not be able to use your application. If you choose to support accessing the website without the use of JavaScript, the complexity of the application increases exponentially, as you would typically need to create server and client side version of most of the views. This approach can also help to add better support for search engines.

Identifying the State of an Application with Distinct URLs

When using AJAX and the SPI pattern, an application may perform different operations, and therefore pass through different states while the URL in the browser stays constant. This creates the need of a mechanism to identify different states of the application, for example, for moving back to a previous state.

Browsers implement the Back and Forward buttons functionality by caching the list of visited URLs.

In AJAX, the server communication is done through XMLHttpRequests, and these requests do not change the page URL. Therefore, the list of visited URLs is not modified.

The Unique URLs pattern helps addressing this problem, by assigning a unique and expressive URL to each significant application state.

Scripting does not provide a mechanism to modify the list of visited URLs, but it provides mechanisms to modify the URLs.

You can manipulate the URL with JavaScript using the window.location.href property, but this will trigger a page reload; fortunately you can use the window.location.hash property. The hash property is used for fragment identifiers, which are optional components of URLs that came after the hash character (#). The string that comes after the hash character is not sent to the server; therefore, the browser is responsible for restoring the state through client scripts, and retrieving the appropriate views. Because they are like normal links, but within a single page, no page reload occurs, and the browser behaves as if you have clicked a standard link, adding the URLs to the list of visited URLs. This also enables history navigation, bookmarking and sharing URLs with other people.

Note: Setting the hash property does not work reliably on all browsers, and you do not get change notifications on all browsers either. For this reason, it is recommended using some library that handles these differences in a cross-browser way, such as the Microsoft Ajax Library History control.

Therefore, when there is an important state change in your application, modify the URL hash property. In this way the changes will be tracked by the browser.

JavaScript
window.location.hash = stateData;

The resulting URL will look like the following.

URL
http://www.mycompany.com/mypage.aspx#someState

Once you have identified each relevant state of the application, you need to implement code to parse the URL. You can choose the format based on your specific needs to represent a state, you can even add parameters in the URL, as seen in the following example.

URL
http://www.mycompany.com/mypage.aspx#viewProduct=5529

Finally, after parsing the URL, you should restore the application to the corresponding state based on the hash data, keep in mind that the hash data is not sent to the server as part of the URL. In the previous example, when loading that URL, the application should go to the product details form, showing the details of the product with ID 5529.

More Information

For more information about the Single-Page Interface pattern, see the following:

• Single-Page Interface and AJAX patterns on MSDN Magazine

For more information about software design patterns applied in the Web Client Guidance, see Patterns in the Web Client Guidance.

You can find this and many other topics and key decisions for creating web client applications (both in ASP.NET Web Forms and ASP.NET MVC) in our latest Web Client Guidance drops. We are close to finishing this guidance, so your prompt feedback is invaluable to us. Make sure you check it out and comment in this topic or in the codeplex forums (there is a special tag to mark conversations for this new guidance).

NBC is also tapping the capabilities of Silverlight to allow for the creation of more highlights packages more quickly. Whereas traditional highlights require an editor to cut the video clip, Silverlight allows for highlights to be created just by creating an XML file of the various time that one wants to start and stop.

That’s important, because the demand for highlights is actually higher than for full streams of events, said Perkins Miller, Senior Vice President of Digital Media for NBC Universal.

"It’s about that water cooler moment," Miller said in a telephone interview.

To generate the highlights, editors at NBC and CTV will be using a Silverlight application, the Rough Cut Editor, to consume smooth streamed content, assemble clips, insert ads, and publish highlights for immediate viewing online. Southworks developed the Rough Cut Editor (previously used for creating highlights of Sunday Night Football) and has been working closely with Microsoft, DeltaTre, NBC, CTV and other partners over the last several months to prepare the application for the Olympics. When the opening flame has been lit and the games have begun, be sure to visit the NBC Olympics and Universal Sports sites to enjoy the live events and some amazing highlights.

Disclaimer: We are writing this documentation as part of the new Web Client Guidance that is being done in patterns & practices. We are close to finishing this project, so I would like to get more feedback or validation from everyone that gets the chance to read this before we release. Have in mind that the content of this topic can change both in content and in form (it can change because of YOUR feedback).
Also, this topic was created using ASP.NET Ajax Library 0911 beta and jQuery 1.3.2.

Guidelines for using ASP.NET Ajax Library and jQuery

There are different JavaScript libraries that can assist you in authoring JavaScript code that runs on the browser, and using at least one of them is an absolute must in today’s environment. Though ASP.NET WebForms is better suited -but not limited to- for using the ASP.NET Ajax Library, ASP.NET MVC has no preference over either ASP.NET Ajax Library, jQuery or other 3rd party libraries. Furthermore, ASP.NET Ajax Library and jQuery can work especially well together and complement each other, whether you render markup using WebForms or MVC.

ASP.NET Ajax Library and jQuery can be used together in the same Web application, and they both have support from Microsoft. These libraries do not conflict with each other, but they complement each other greatly. The overlap between functionality is not big, and since jQuery’s official support by Microsoft, this overlap is getting reduced in every release.

ASP.NET Ajax Library has made important changes to its core to leverage jQuery functionality when it detects that jQuery is also loaded. For example, ASP.NET Ajax Library provides some basic jQuery-like selector support for selecting DOM elements for its Sys.get(selector) method, which is used internally by many other components. Nevertheless, when jQuery is available, the selector passed into this method can be very complex, because it will delegate the DOM selection to jQuery under the hoods.  Furthermore, all ASP.NET Ajax Library controls and plugins, are also exposed automatically as jQuery plugins.

We found that in most cases, although there is an additional cost for downloading the 2 libraries instead of just one, the productivity and features covered by both libraries working together far outweighs that cost. Also, keep in mind, that if your application is hosted in the internet, as opposed to an Intranet, it is strongly recommended that you use the Microsoft CDN, so the download time gets reduced, and sometimes skipped, as the files may be cached by the browser.

The following sections define some pros that we found when using a particular library over the other. This list should not be taken as completely objective or closed, as depending on what plugins you decide to use, there might be advantages or disadvantages for each. These guidelines are based on the experience developed by using both ASP.NET Ajax Library and jQuery when building web applications in the last few months, as Microsoft has recently added support for jQuery from within Visual Studio, and the ASP.NET Ajax Library has taken huge steps towards supporting both libraries side by side.

Why should you use jQuery

One of the more important reasons for using jQuery is for DOM (Document Object Model) manipulation.

• The jQuery library is extremely easy to use for finding elements using selectors, for moving elements to different locations inside the DOM, changing element classes, basic animations, and so on.
• jQuery has a simple API for handling DOM events. However, this functionality is comparable to what can be accomplished with ASP.NET Ajax Library. Due to this, in the Reference Implementations both approaches are used interchangeably; depending on what was the handling logic being used for (that is, DOM manipulation, controlling logic, and so on).

Another strong point of jQuery is the Developer community behind it.

• Because jQuery supports only client-side functionality, it is server-side technology agnostic, and has a powerful extension mechanism.
• For the previous reasons, it has been more widely used to develop plugins for a lot of different situations. These plugins are available through the official jQuery site, although each of them has its own license. Nevertheless, a big percentage of these plugins use very permissive open source licenses, an most of them use the same license as the jQuery core, to ease adoption for users who are already using jQuery.

Why should you use the ASP.NET Ajax Library

We found the ASP.NET Ajax Library to be especially useful for writing JavaScript logic whose objective was not just manipulating or animating the DOM. Also, the script loading capabilities was of great help in both the perceived performance of the application and in the development and organization of the JavaScript code.

Some other strong points of the ASP.NET Ajax Library are the following:

• API and syntax similar to the .NET framework. The library imitates the .NET framework API, type system and namespaces hierarchies, therefore the developers familiar with the .NET framework can learn this framework with ease.
• The Ajax Script Loader that comes with the library is useful for loading scripts in parallel and for managing dependencies. Using the Script Loader gives you the following advantages.
  • Minimize an Ajax application’s render time
  • Handle loading script dependencies
  • Leverage script combining techniques
  • Perform lazy loading of scripts behind the scene

Note: For more information about the ASP.NET Ajax Library Script Loader, there is a specialized Script Loading document in the Web Client Guidance, make sure to check it out.

• It is especially useful for writing logic that does not only manipulate the DOM. It provides infrastructure for creating JavaScript controls and behaviors (extending the Sys.Component type), and also provides memory management, easy control creation/instantiation.
• You can use Client Templates to bind the UI to an observable view model. This allows separating the concerns of UI specific code (or DOM manipulation) from the presentation logic. This also simplifies unit testing the JavaScript code by avoiding the need to test the DOM state and user interaction directly.
• Browser history:  When the state of a web page changes by using Ajax calls to the server, the URL in the browser does not change automatically. The ASP.NET Ajax Library simplifies working with the browser history, with a cross-browser approach.
• The Ajax Control Toolkit is a set of reusable controls that can be used from both ASP.NET Ajax Library and jQuery using JavaScript code, and is also very friendly for using it from server-side generated JavaScript, especially when using ASP.NET WebForms server controls.
• It provides auto-generated proxy classes that simplify calling Web service methods from client scripts.
• When using ASP.NET WebForms, the ASP.NET Ajax Library is the easiest to use in several scenarios, as many of the controls and functionality can be used from their server-side controls counterparts.
• Working with ADO.NET Data Services is very easy with the ASP.NET Ajax Library. This, in combination with Client Templates can help creating client side views that consume data from the server very easy.

More Web Client Guidance

You can find this and many other topics and key decisions for creating web client applications (both in ASP.NET WebForms and ASP.NET MVC) in our latest Web Client Guidance drops. We are close to finishing this guidance, so your prompt feedback is invaluable to us. Make sure you check it out and comment in this topic or in the codeplex forums (there is a special tag to mark conversations for this new guidance)

Last Friday, we shipped the first Major version (v1.0.0) of the Windows Azure Storage API gem for ruby, started a few months ago by my friend Johnny Halife. As it is an open-source project, I had the opportunity to contribute with:

• Support for table service to query, get_one, insert, update, merge and delete entities.
• Support for running against the Storage Developement Fabriq shipped with Microsoft SDK.
• Signature support for Tables service according to msdn.microsoft.com/en-us/library/dd179428.aspx
• Support to enumerate, create, and delete tables on give storage account.
• Give feedback to Improve the support for stacked connection management.

This release of waz-storage for ruby includes numerous features collected thru 0.5.6 to 1.0.0, for more information you can visit the http://waz-storage.heroku.com/ where you will find all the gem documentation, or if you like to read the source code, contribute or giving us feedback you can get it from on http://github.com/johnnyhalife/waz-storage.

The Present

One of the objectives of having Tables support on the gem was to have an interface to interact with Tables and Entities that we can consume from an adapter as we usually do with our favorite ORM written in ruby which is DataMapper.

This is why this weekend was pretty much to make the dream come true, creating a new project on github called dm-waztables-adapter (http://github.com/jpgarcia/dm-waztables-adapter) and spitting some lines of code.

Writing the adapter

As everything in Ruby wonderful world, it was really easy to have a first version running with the features provided by Datamapper.

It took me a few hours to write down 85 lines of code to cover the whole adapter (Create, Read, Update and Delete methods)

Sorry, I’m forgetting the aditional 30 minutes I spent on writing 32 more lines to cover the Migrations stuff. So you won’t worry about creating the tables when you design your models (As Windows Azure doesn’t have support for schemas inside tables, migrations exists just to make sure that you have the tables. It won’t modify attributes of existing data).

Below you will find some code samples. I hope you like it.

Getting started

sudo gem install dm-waztables-adapter --source http://gemcutter.org

Usage

require 'dm-waztables-adapter'

# set up a DataMapper with your Windwows Azure account
DataMapper.setup(:default, { :adapter => 'WAZTables',
                                         :account_name => 'name',
                                         :access_key => 'your_access_key' })

# define a new model
class Guitarist
    include DataMapper::Resource

    property :id, String, :key => true
    property :name, String
    property :age, Integer
end

# set up database table on Windows Azure for a specific model
Guitarist.auto_migrate! # (destructive)
Guitarist.auto_upgrade! # (safe)

# set up database table on Windows Azure for all defined models
Datamapper.auto_migrate! # (destructive)
Datamapper.auto_upgrade! # (safe)

# play with DataMapper as usual
Guitarist.create(:id => '1', :name => 'Ritchie Blackmore', :age => 65)

yngwie = Guitarist.new(:id => '2', :name => 'Yngwio Malmsteen', :age => 46)
yngwie.name = "Yngwie Malmsteen"
yngwie.save

# retrieving a unique record by its id
ritchie = Guitarist.get('1')
ritchie.age # => 65

# updating records
ritchie.age = 66
ritchie.save

# retrieving all guitarists
    Guitarist.all.length # => 2

# performing queries
    older_guitar_players = Guitarist.all( { :age.gte => 50 } )

# deleting records
older_guitar_players.destroy!

TODO

• Allow users to define the model partition key by using :partition_key => true option on the property.
• Allow users to set the partition key as an additional attribute of the model with a lambda as default value.
• Allow users to set the partition key as a method on the model.
• Implement “in” operator in queries
• Implement “order” query option
• Retrieve more than 1000 fields using Windows Azure :continuation_token

Known Issues

• Like statements are not working since Microsoft service API is throwing a NotImplemented exception when
  using startswith and endswith filters (more information here)
• There’s no way to tell thru the entity which is the partition key of our entity, so there’s no out-of-the-box load balancing support (for mor info on the tables model that a look at http://msdn.microsoft.com/en-us/library/dd179338.aspx)

As Roger announced in his blog, the first release of the SQL Server 2008 R2 Update for Developers Training Kit is available for free download from the Microsoft Download center at:

• http://go.microsoft.com/?linkid=9710868

The SQL Server 2008 R2 Update for Developers Training Kit is ideal for developers who want to understand how to take advantage of the key improvements introduced in Microsoft SQL Server 2008 and Microsoft SQL Server 2008 R2 in their applications, as well as for developers who are new to SQL Server.

Stay tuned because new releases of this training kit are going to be published every two weeks approximately containing new labs, demos, presentations and videos related to SQL Server 2008 R2 features.

Training Kit Content

This release contains all the original content from the SQL Server 2008 Developer Training Kit (but targeting Microsoft SQL Server 2008 R2) and also the following new one:

• How to build your first web application with SQL Server and ASP.NET: This hands-on lab shows how to connect to SQL Server and perform Create, Read, Update and Delete (CRUD) operations on SQL Server 2008 from an ASP.NET Web application. It also shows you how to work with images stored in SQL Server in a web application. This lab is ideal for developers who are new to building web applications with SQL Server and ASP.NET.
• Data-tier Applications in SQL Server 2008 R2 and Visual Studio 2010: This hands-on lab shows how to perform the basic steps in creating, developing, deploying, managing and upgrading a Data-tier Application (DAC) using the new features in Microsoft SQL Server 2008 R2 and Microsoft Visual Studio 2010. It also shows some of the new IDE tools and enhancements included in Microsoft Visual Studio 2010 to work with Database projects.
• Introduction To StreamInsight and Complex Event Processing: Microsoft SQL Server StreamInsight is Microsoft’s new Complex Event Processing technology to help businesses derive better insights by correlating event streams from multiple sources with near-zero latency. This hands-on lab shows how to leverage the new StreamInsight framework released as part of Microsoft SQL Server 2008 R2 while developing a StreamInsight sample application. It also explains the basics about Complex Event Processing.
• Using the New Features of Reporting Services 2008 R2: This hands-on lab introduces the new features included in Microsoft SQL Server 2008 R2 Reporting Services like the Map Wizard to display geospatial data, the lookup functions in report expressions so that data from multiple datasets can be shown in a single data region and the capability to export report data to an Atom data feed. It also shows the new features in Report Builder 3.0.
• PowerPivot in SQL Server 2008 R2: This hands-on lab introduces to the Microsoft SQL Server PowerPivot for Excel 2010 add-in and shows how to load data into it and how to create PowerPivot pivot tables. It also introduces DAX expressions for multidimensional calculations against PowerPivot data and explains how to publish PowerPivot workbooks to Microsoft SQL Server PowerPivot for SharePoint 2010.
• 7 Introductory Videos: these videos introduce and review the new features and enhancements in Microsoft SQL Server 2008 and Microsoft SQL Server 2008 R2.
  • SQL Server 2008 R2 Update for Developers Overview Part I - SQL Server 2008 Review
  • SQL Server 2008 R2 Update for Developers Overview Part II - Introducing SQL Server 2008 R2
  • Introducing SQL Server 2008 R2 StreamInsight
  • Demo: Real Time Analytics with SQL Server 2008 R2 StreamInsight
  • Introducing SQL Server 2008 R2 Application and Multi-Server Management
  • Introducing SQL Server 2008 R2 Reporting Services
  • Introducing PowerPivot for Excel 2010 and SharePoint 2010

Resources

• Microsoft SQL Server 2008 R2 November CTP
• AdventureWorks 2008 R2 Sample Databases
• Microsoft Visual Studio 2010 Ultimate 2010 Beta 2
• Microsoft SQL Server PowerPivot for Excel
• Microsoft Office 2010 Excel Beta
• Microsoft SharePoint Server 2010 Beta

Enjoy

Mariano

• Composite Manifest Support for Rough Cut Editing scenarios in SSME by Vishal Sood
• New Composite Manifest support for building Rough Cut Editing (RCE) scenarios with Smooth Streaming by John Deutscher

I’ve been working with CSMs for three months now, so in this post I would like to share with you the lessons I’ve learnt during the process of creation and usage of the CSMs.

There are a few common mistakes and issues you might face during that process, so I hope this post will be helpful for the community. 

Configure IIS to serve .CSM files

In order to do that, you have to add a mime type entry on IIS for the .CSM extension on every IIS server that is serving up the .csm files. The mime type for the .csm must be “text/xml”. You can do this on the IIS Manager. Also you can achieve the same by editing the applicationHost.config and adding the following line:

 <mimeMap fileExtension=”.csm” mimeType=”text/xml” />

“Error encountered on HEAD request to manifest uri <your manifest> for <position> clip in RCE manifest”

This will likely be the first issue you will encounter after trying to use a CSM. When using a CSM the Smooth Streaming Media Element (SSME) attempts to do a HEAD request on the manifest for each clip to make sure that the content hasn’t been moved (and if it has, it will used the new URL on the response).

There are two changes you have to make in order to fix this issue.

The first one is related to an existing known-issue on the applicationHost.config file of IIS. This server bug prevents the On-Demand smooth streaming handler from responding to HEAD request. To fix this go to the Smooth Streaming Readme page and check the Known Issues section, specifically the “Configuring the SmoothHandler handler mapping to process HTTP Head requests” item.

The second change must be done on the clientaccesspolicy.xml file, essentially to indicate that HEAD requests are allowed. To fix this make sure that your clientaccesspolicy.xml file includes http-methods=”*”or http-methods=”GET,HEAD,POST”:

<?xml version=”1.0″ encoding=”utf-8″?>
<access-policy>
  <cross-domain-access>
    <policy>
      <allow-from http-methods=”*” http-request-headers=”*”>     
        <domain uri=”*”/>
      </allow-from>     
      <grant-to>     
        <resource path=”/” include-subpaths=”true”/>
      </grant-to>     
    </policy>
  </cross-domain-access>
</access-policy>

“Caught exception trying to parse main manifest: V2 Manifest: Audio stream requires CodecPrivateData attribute”

This is because the CSM contains a clip that is referring a V1 Manifest, which is not a valid source for a CSM.

“Caught exception trying to parse main manifest: First video (audio) chunk in clip <position> [start time = <start time>, duration = <duration>] does not contain clip start position <clipStartPosition>”

This message indicates that the first chunk time + the first chunk duration of the reported stream is smaller or larger that the clip’s begin position. Therefore the first chunk time + the first chunk duration of the stream must contain the clip’s begin position.

“Caught exception trying to parse main manifest: Last video (audio) chunk in clip <position> [start time = <start time>, duration = <duration>] does not contain clip end position <clipEndPosition>”

This message indicates that the last chunk time + the last chunk duration of the reported stream is smaller or larger that the clip’s end position. Therefore the last chunk time + the last chunk duration of the stream must contain the clip’s end position.

Different Audio encoding settings in the CSM clips

If you have clips with different audio encoding settings, then the playback will suddenly stop. Due to a limitation on Silverlight, the audio settings have to be the same. The Silverlight pipeline is not able to handle audio property changes on the fly. So make sure that the audio of the clips are being encoded at same bit rate.

Sparse stream data within the clip

This will likely not cause any issue, but as today having sparse stream data within a clip is not supported I decided to include it on this list.

As you see, there are a couple of things to have in mind when creating and using composite stream manifests. I hope this post encourages you to use this amazing feature.

Happy streaming!

• http://blogs.msdn.com/bethmassi/archive/2010/01/28/creating-a-sharepoint-visual-web-part-using-visual-studio-2010.aspx
• http://www.helloitsliam.com/archive/2009/10/20/sharepoint-2010-–-create-a-visual-web-part.aspx
• http://blogs.pointbridge.com/Blogs/nielsen_travis/Pages/Post.aspx?_ID=32

The problem is that there is not much talking about how to deploy the packaged Webpart on a different server. I run into this issue following the last post mentioned above because I am trying to deploy a custom Webpart to analyze the Claims inside a Token in a Claims based Authentication Sharepoint Web Application.

I finally came across this post (http://dotnet.sys-con.com/node/1208275) which details the deployment process as follows and is a recommended reading BWT. I am considering that you have a .WSP Webpart packaged by Visual Studio 2010 Beta.

1. Add-SPSolution c:\code\SharePointProject2\bin\debug\SharePointProject2.wsp
2. Install-SPSolution –Identity SharePointProject2.wsp –WebApplication http://sp2010 -GACDeployment

I will complement that post adding the final steps you should run to actually be able to see that webpart on your web application!

When adding a web part while editing a sharepoint page you might find that not all available webparts are show. This might happen if your Site Collection has not enabled all features and is also necessary for activating custom webparts. You should do the following as a Site Collection administrator,

1. Site Actions
2. Site Settings
3. Manage Site Features
4. Site Collection Features

Hope this helps!

We expect to see this monitored on the SCOM Management Pack when the product hits RTM.

Lessons Learned

1. Watch out the Log files on File System: By default on “C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\14\LOGS” On Sharepoint generated 147Gb of log files in two weeks! Yes, 147Gb, this is kindly we fixed by the RTM release. But you should configure Central Administration > Diagnostic Logging to limit the space available for log files. I configured 1Gb for our Cloud deployment.
2. Watch out the WSS_Logging Database: When you do a Single Server installation using SQL Express 2008 to host Sharepoint DBs, you must watch out for the growth of the DB named “WSS_Logging” which usually resides on “C:\Program Files\Microsoft Office Servers\14.0\Data\MSSQL10.SHAREPOINT\MSSQL\DATA”. I had one instance which reached 4Gb and put my SQLExpress instance to the limit (Here is someone who run into the same issue). That DB cannot be truncated as it is not supported right now and it takes care of analytics of the web traffic. You can disable the Health and Data Collection gathering from Monitoring > Reporting > Configure usage and health data collection, however web analytics is very neat to be left apart.
   I was not able to find a procedure to migrate that DB to another server, so I had to disable the feature.

Key Takeaways

1. Limit your log files usage.
2. Deploy on server-farm mode to move the WSS_Logging db to another db server.

Example: Visual Studio Unit Testing Framework

In order to exemplify a kind of unit tests used in TDD in a graphical way, I chose to develop a quite simple Tic-Tac-Toe solution in C#, using Visual Studio. The following image shows three tests for the Square class, which can hold only circles, crosses or empty spaces (simulating a Tic-Tac-Toe square).

The use of this unit testing framework (Visual Studio Unit Testing Framework) is quite self-explaining. There is a test class that holds tests methods, which can be executed individually or all together. Each test method shown here has an Assert method in the end, which is one way of defining if the method passes or fails.

Note that these tests were written before actually coding anything to the actual class; so, when going to code the required functions, the API has already been defined by the tests, and it’s quite easy to know what to do.

Another important thing to mention is that tests shouldn’t have any kind of correlativeness between each other, since they should act as individual testing units. Here this is exemplified by the fact that the instance of the Square class can have different names among the tests, and they’ll still work perfectly.

TDD, ATDD and Scrum

Since a key matter in TDD based projects is to know how to divide and prioritize development tasks, TDD is more effective in agile environments such as Scrum. Practicing TDD is a good way to deliver constantly (see Frequent Delivery in our company mindsets), so TDD and Scrum do benefit from each other.

Furthermore, mainly because of the last point in the benefits section of the first part of this post, it’s extremely important for the customer to have an active and appropriate role in constantly defining the direction of the project (he is the one that will consume the product, hence it is wise for him/her to participate in the decision making). So that’s where Acceptance Test Driven Development (ATDD) comes into consideration. ATDD is in fact a really interesting subject which deserves a post on its own and more, but just to mention the concept, it’s a methodology that implies writing Acceptance Tests, that become the criteria that the customer defines for his business requisites.

It’s important, though, that the role of the customer and the developer doesn’t overlap each other: in other words, the customer shouldn’t define specific implementation details (the how) as requirements, because the developer usually knows more about it; and the developer, on the other hand, shouldn’t decide on strategic external features (the what), since the customer knows more about his business.

(Ideas for this section have been taken from ‘Diseño Agil con TDD‘, a must-read free online book for Spanish-speaking developers interested on the subject)

Conclusion

Test Driven Development is a powerful methodology, that can bring outstanding results, especially in large, complex projects. Its benefits are best shown not when using it on isolation, but when combining it with the appropriate resources and organization.

Again, if you have any thoughts about what I’ve said, don’t hesitate to comment here.