core.net

Apply new Master Page to existing My Sites in MS SharePoint 2010

2012-08-17T23:45:00.002+05:00

Scenario:

The PROD farm in your organization has dozens, possibly hundreds, of user My Sites in existence.
All My Sites use custom branding designed by your graphics department.
The graphics department comes up with a new branding for the My Sites to reflect a change in the organization's strategic focus.
A re-designed master page with the new branding (mysiteRedesigned.master) needs to be applied to ALL existing My Sites without re-provisioning them.

Solution:

Create a folder where you will be copying some files in the subsequent steps. (The script assumes that the folder is C:\temp)
Create a text file in that folder called SitesList.txt
On each separate line inside the SitesList.txt file, enter each of the My Site Urls that you want to apply the master page change to. (These are all the My Sites that already exist. You can get a list by going to Central Administration > View Al Site Collections)
Drop the new/updated Master Page file in the folder you created in Step 1, i.e. C:\temp
Run SharePoint 2010 Management Shell, and paste the following code in the PowerShell window.


$SourceFilePath = "C:\temp\SitesList.txt" 
$SiteList = Get-Content $SourceFilePath 

foreach ($SiteUrl in $SiteList) { 
 write-host "Applying master page to Url", $SiteUrl
  
 $site=Get-SpSite $SiteUrl
 $web=$site.RootWeb
 $masterPageSrc = "C:\temp\mysiteRedesigned.master"
 $masterPageDest = $web.GetFolder("Master Page Gallery")

 Get-ChildItem $masterPageSrc | foreach { 
  $stream = [IO.File]::OpenRead($_.FullName)
  $destUrl = $web.Url + "/_catalogs/masterpage/" + $_.Name.Replace(" ","") 
  $resultingfile = $masterPageDest.files.Add($destUrl, $stream, $true)
  $stream.close()
 } 

 $masterUrl = New-Object System.Uri($destUrl)
 $web.MasterUrl = $masterUrl.AbsolutePath
 $web.CustomMasterUrl = $masterUrl.AbsolutePath
 $web.Update()
 $web.Dispose()
 $site.Dispose() 
  
 write-host "Done"
}

The accompanying SiteList.txt file should list each My Site Url to apply fix to.

SitesList.txt

http://mysites.inetaPakistan.org/personal/saqib_ilyas http://mysites.inetaPakistan.org/personal/hammad_rajjoub http://mysites.inetaPakistan.org/personal/adnan_hashmi

Branding SharePoint

2011-10-21T19:43:00.002+05:00

SharePoint Branding Screencast

Branding MS SharePoint 2010.

Branding MS Office SharePoint 2007.

MOSS 2007 Workflow Forms: Everything you ever wanted to know but were afraid to ask (Part I)

2008-07-27T07:03:00.010+06:00

Background
What differentiates a workflow from a typical process written in code is the ability of multiple actors (human or otherwise) to interact with the long-running workflow process during the course of execution. This allows the executing process to behave in a manner that external actors want it to, as opposed to just performing a sequence of operations along a single pre-defined path. The rule-of-thumb while choosing between Sequential and State-Machine Workflows is based on a simple premise based on the scenario for which the workflow is being created:

Sequential Workflow: Use when a pre-defined sequence of activities need to be executed, involving no external input, and the only repetitive activity executions are through loops.

State-Machine Workflow: Use when external actors are involved, causing the workflow to stop and wait for input from the actor. Also use if the same activity needs to be executed multiple times based on a user-input or external event during the course of workflow execution.

Note: You can choose to use a Sequential workflow even when external actor interaction is involved. However, this will not allow you to jump to another activity, other than the one next in the sequence.

Developing a State-Machine workflow in Visual Studio 2005
Read the following posts to learn how to develop a state-machine workflow in VS 2005.

Creating a MOSS state machine workflow - Part 1 of 4 : Concepts and planning

Creating a MOSS state machine workflow - Part 2 of 4: Creating InfoPath forms

Creating a MOSS state machine workflow - Part 3 of 4 : workflow development

Creating a MOSS State Machine Workflow - Part 4 of 4: Workflow Deployment

Apart from the workflow code file (*.cs and/or *.xoml), the workflow project should include the following files:

feature.xml (Contains information about the SharePoint feature)

workflow.xml (Specifies the workflow properties for the SharePoint feature)

PostBuildActions.bat (A batch file executed as a Post-build event inside Visual Studio that creates a sub-folder in the 'FEATURES' directory under 12 hive [C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\TEMPLATE] and copies feature.xml and workflow.xml files into it; also executes the stsadm command to activate the deployed feature on a SharePoint site)

Note: You can avoid creating the PostBuildActions.bat file if you use WSPBuilder to generate a SharePoint solution file (*.wsp) and deploy it from within the VS2005 environment.

The life-cycle of a workflow involves the following stages:

Development: Visually creating the workflow in VS2005/VS2008 Workflow Designer and writing code for each activity. Also includes creating workflow.xml, feature.xml, and PostBuildActions.bat

Deployment: Deploying the workflow to a SharePoint Server farm and activating it either using the PostBuildActions.bat batch file or using WSPBuilder. In either case, a new folder is created in the FEATURES directory (explained above), the workflow.xml & feature.xml files are copied to it, the workflow assembly (*.dll) is installed into the GAC or copied to the Virtual Directory's bin folder, and the stsadm command is used to activate the feature

Association: Attaching the workflow to a list or content type and specifying when a new workflow instance should kick-off; either manually, OR automatically when a new item is created and/or updated.

Execution:This stage involves the following sub-stages

Initiation: This is the first stage for any workflow instance, happens ONLY once during the course of execution, and is marked by firing of the OnWorkflowActivated event.

Passivation or De-hydration: This is the process of persisting the workflow instance to a datastore so that it can subsequently re-loaded into memory for further execution. Also, passivation or dehydration occurs when the workflow instance wants to wait for an external input or event to execute further.

Re-hydration: This stage involves the workflow instance being loaded back into memory by the workflow engine, after a user input is received OR an external event fires.

Activity Execution: This is characterized by the workflow engine executing the code in each of the workflow activities in the defined sequence, or transitioning states in case of a state-machine workflow.

Modification: This stage is optional, but it allows workflow actors to inject new values into the workflow instance while it is in execution to alter its behavior. This also entails that the workflow has the logic built into it to process the new values.

Completion: The competion stage is marked by the workflow instance completing execution successfully, and the status being written to the data store.

Termination: This stage refers to the workflow instance stopping abruptly due to an internal error, or an actor explicitly ending the workflow instance. Any data written to the list by the workflow instance is NOT rolled-back if the workflow is terminated. Terminated workflows cannot be restarted again.

Having got the above off my chest, lets delve into how users (workflow actors) interact with the workflow.

Workflow Forms
Workflows Forms (as the name implies) are typical forms that allow user input to be communicated to the workflow. In addition, workflow forms also allow data within the workflow to be presented to the actor so that they can take appropriate action. The 4 types of workflow forms that can be created are:

Association Forms: Displayed to the user at the time the workflow is being associated to a list or content type to allow user to enter any additional values that can be used in the workflow association process.

Initiation Forms: When the users initiates a workflow instance, the Initiation Form is displayed to allow entry of additional parameter values that the workflow instance can process during execution.

Modification Forms: Modofication forms are displayed either when the workflow instance encounters the EnableWorkflowModification activity, OR the user clicks the Modification link on the workflow status page.

Task Forms: During execution, a workflow creates tasks in the Tasks List that tell the user what they need to do, and in most cases, move the workflow forward when a task is marked as complete. From the users' perspective, tasks enable them to know where the workflow stands, and what needs to be done to get to the next process in the flow sequence.

In my next post, I will cover how to develop each of the Workflow forms in a state-machine workflow using both ASP.NET and Microsoft InfoPath 2007.

Creating State Machine Workflows using SharePoint Designer 2007: Addendum

2008-04-14T06:45:00.002+05:00

In my previous post, I gave an overview of how to mimic State Machine behavior using sequential workflows developed in SharePoint Designer (SPD) 2007. This post is actually a walk-thru of the development process in SPD 2007.

Create Lists
Create the following 2 lists (See description in previous post cited above):

Core.NET Content (Document Library)

Core.NET Approval Workflows (Custom List with following columns)

Title: Single line of text

File URL: Hyperlink or Picture

Workflow Status: Choice (with following choice values)

Content Analyst: User

Awaiting Approval

Pending Analysis & Review

Awaiting Approval

Approved

Create 'Approval Initiation Workflow' on the 'Core.NET Content' list
Open an instance of SharePoint Designer 2007 on your machine. Go to File > Open Site... and enter the URL for the site you created the lists on.
Go to File > New... > Workflow..., enter Approval Initiation Workflow as the name of the workflow, and select Core.NET Content from the drop down list. Make sure that only the second checkbox (Automatically start this workflow when a new item is created) is checked, and click Next
.

Create workflow action to insert an item into the second list
Enter Initiate Approval process for uploaded content as the Step Name. Click the Actions dropdown button and select Create List Item
from the dropdown. Click the this list link on the action, select the Core.NET Approval Workflows list from the drop down at the top of the 'Create New List Item' dialog, and specify the values for each of the columns as shown below:

Title = Core.NET Content:Name

File URL = Core.NET Content:URL Path

Workflow Status = Awaiting Assignment

Click the Finish button to publish the workflow.

The above step simply takes values from the document library (Core.NET Content) and inserts into the Core.NET Approval Workflows list. We now turn our focus to the other list, and the second workflow.

Create 'Approval Process Workflow' on the 'Core.NET Approval Workflows' list
Create the workflow as below; enter Approval Process Workflow as the name of the workflow, and select 'Core.NET Approval Workflows' list from the drop-down. Make usre that the last 2 checkboxes (Automatically start this workflow when a new item is created + Automatically start this workflow whenever an item is changed) are checked.

Create Variables for the workflow
Click the Variables... button in the Workflow Designer window, and create variables as below:

The 'Approval Process Workflow' will consist of the following 3 steps:

Get Workflow Data

Process Workflow Status

Process Approval/Rejection by Manager

Update Workflow Status

Note: By updating the list in the very last step, the subsequent instance of the workflow (started on item update) can kick off immediately. If the current workflow updates the list while it still has some more activities to perform, the second workflow fails.

An explanation of each of the step follows:

Step 0: Terminate Workflow if already approved
This step is optional, hence I did not include it in the above list of steps. It simply checks to see if the item has already been approved, and if it is, terminates the workflow using the Stop Workflow activity.

Step 1: Get Workflow Data
This step simply intializes the values of the variables and comprises the following 2 steps:

Set the ContentAnalyst variable to the value of the Content Analyst column in the Current item. (This value will be empty when the first instance executes)

Initialize the UpdateStatus variable to 'No'.

Step 2: Process Workflow Status
This step relies on IF condition activities to process the workflow according to the Workflow Status for that particular instance of the workflow.

Refer to the diagram above; starting from the top

The first time the workflow executes, the status is set to Awaiting Assignment, causing ONLY the Actions for the first Condition to execute. The action themselves are pretty straight-forward and self-explanatory.

The second condition (where status equals 'Pending Analysis & Review') may be true a number of times, depending on the number of times the manager rejects the document.

Just like the second condition, this may be true multiple times depending on the number of times the workflow was submitted to the manager for approval.

Alternatively, you can also add a condition here to check if the workflow status is set if 'Approved', and terminate the workflow (as shown below).

Note: You can get the user input for a 'Collect Data from a User' action by simply referencing the column of the Tasks list named after that specific input you specified in the 'Custom Task Wizard' dialog.

Step 3: Process Approval/Rejection by Manager
This step was included since its not possible to have a nested IF statement in the Actions sections of a step.

Either one of the conditions can only be true if and only if the workflow status is Awaiting Approval. If the Manager APPROVED the document, the NewStatus variable is set to Approved, if the Manager REJECTED the content document, the NewStatus variable is set to Pending Analysis & Review, sending the workflow back to the Analyst specified by the Repository Manager.

Step 4: Update Workflow Status
This step MUST execute at the very end, to allow the successful termination of the current workflow instance and initiation of the subsequent workflow instance. Also, the UpdateStatus variable was explicitly set to 'No' at the very start of the workflow instance, and unless a step hasn't set it to 'Yes', the update action in this step will not execute.

This step updates the 'Workflow Status' column
to the value in the NewStatus variable, and the 'Content Analyst' column to the value in the ContentAnalyst variable (shown below).

Creating State Machine Workflows using SharePoint Designer 2007

2008-03-31T06:57:00.005+05:00

NOTE: This is a workaround to mimic state-machine behavior from a sequential workflow developed using SharePoint Designer 2007.

To get up to speed with developing SharePoint workflows using Visual Studio 2005, watch the HOWTO: Series of SharePoint Workflow HOW-TO Videos by Robert Shelton.

Sequential workflows are fairly straight forward to create whether you are developing in Visual Studio (VS) or SharePoint Designer (SPD) 2007 and can be used to model most single or multi-step approval workflows. The only downside to Sequential workflows is that you cannot make the workflow jump back to a previous step/activity that may or may not have already executed or, in other words, cannot move from being in one state to the other like a state machine workflow. For most workflow developers/creators, this is reason enough to go for workflow development in VS. While VS worksflows work just the same as those develped using SPD 2007, keep in mind that SPD 2007 is more suited for managers and/or business analysts (non-developers) who may be reluctant to assign workflow development task because of time, resource, and budgetary constraints. This is where the following intuitive solution may come in handy. Lets look at a hypothetical scenario in detail.

Scenario:
A technical document needs to be analyzed, revised (if need be), and approved to exist in the repository.

Actors:

Repository Managers

Content Analysts

Managers

Workflow (see state-machine diagram above):

Document Uploaded to MOSS 2007 Document Library. [Document Status updated to Awaiting Assignment]

Repository Manager assigns document to Content Analyst. [Document Status updated to Pending Analysis & Review]

Analyst views documents, makes required changes, and submits document to Manager for approval. [Document Status updated to Awaiting Approval]

If Manager rejects document, document routed to Content Analyst. [Document Status updated to Pending Analysis & Review]

If Manager approves document, it is kept in the document library. [Document Status updated to Approved]

The above workflow is pretty straight-forward, and could easily have been created using SharePoint Designer if it were not for step 4, which can happen any number of times until the document gets approved by the Manager. To create a State Machine behavior in a SPD 2007 workflow, create a separate list (say "Content Approval Workflows") to maintain the state of the workflow at any given point in time. A separate list also ensures that the user cannot go and manually change the status. Also, 2 workflows would need to be created; one on the actual document library (called "Core.NET Content") that houses the uploaded documents, and the other on the Content Approval Workflows list. The 2 lists we are working with are summarized below:

Core.NET Content
List Type: Document Library
Workflow Name: Approval Initiation Workflow
Workflow Executed: On Item creation

Core.NET Approval Workflows
List Type: Custom List
Workflow Name: Approval Processing Workflow
Workflow Executed: On Item creation
; On Item update

Columns: Title, Document Status (Choice Column with each of the workflow states), WorkflowInstance Id (Lookup column that references ID column in the Core.NET Content document library)

To get an even better idea, take a look at the following diagram.

The steps modeled in the diagram above are:

Document uploaded to Core.NET Content Document Library.

Item creation in Core.NET Content Document Library kicks off Approval Initiation Workflow which creates an item in the Content Approval Workflows list (with the Document Status value set to "Awaiting Assignment") and completes.

Creation of item in Content Approval Workflows list kicks off the Approval Processing Workflow that performs the following operations recursively i.e. completion of every step below updates the Document Status column value and in-turn starts another Approval Processing Workflow instance on the same item.

Start on item creation - If Document Status is "Awaiting Assignment", create a task in the Tasks list for Repository Managers, using the "Collect Feedback from user" activity, assign the task to the username entered in the task, and set the Document Status value to "Pending Analysis & Review".

Start on item update - If Document Status is "Pending Analysis & Review", create a task in the Tasks list for the user in the Content Analysts group who was assigned the Analysis & Review task in the preceding step, using the "Collect Feedback from user" activity, and set the Document Status value to "Awaiting Approval" when the user clicks the "Complete Task" button.

Start on item update - If Document Status is "Awaiting Approval", create an approval task in the Tasks list for Managers using the "Collect Feedback from user" activity, to either approve or reject the document. If Manager approves the document, set the Document Status value to "Approved", else set the Document Status value to "Pending Review & Analysis" which re-starts the workflow from step 3-2.

Note: The IF condition on every step ensures that the workflow takes only one path depending on the value for Document Status. Also, using the "Collect Feedback" activity in SPD 2007 ensures that the workflow stay in the wait state until the actor specifies the required input, and clicks the "Complete Task" button.

[UPDATE: Read the process of creating the State-machine workflow using SharePoint Designer 2007 in the following post here]

Pakistan Developer Conference 2007

2007-05-13T09:34:00.000+05:00

With physical presence at Lahore and Islamabad in addition to Karachi, the Pakistan Developer Conference 2007 would be the biggest annual developer event in the country.

Register now! I hope to see you there in Lahore and Karachi.

A Pal for Web 2.0

2007-04-01T23:35:00.000+05:00

I blogged about SitePal a long time ago. I am blogging about it again, since I now have a demo account. This post is more of a strategy guide than a technology roadmap. If you have a Flash player installed (or you are reading this post while the demo account is still valid and active), you will be able to see (and hear) it on the right sidebar of my blog.

The technology news coming out of the World Economic Forum that concluded in Davos, Switzerland not very long ago, was abuzz with talk of Web 2.0. The essence of Web 2.0 are Rich Internet Applications that give users not only a rich user experience, but which may in fact comprise of data and services from many other 3rd party websites and online resouces.

In the Web 2.0 world, businesses increasingly have to rely on setting themselves apart through a mixture of content and design to ensure a continued audience and user-base. While the SitePal you see on the right is just a small demonstration of what websites can achieve using this technology, a SitePal can achieve a lot more for your online service than just playing a welcome message. Apart from its obvious usage on Social Networking sites, a SitePal can be leveraged in teaching students online, and for assisting users on insurance, healthcare, or recruitment wesbites. Imagine a website where students learn chemistry from Harry Potter, physics from Dexter, and computer programming from Jimmy Neutron; OR in a completely different scenario, allowing senior citizens to hear about diabetes, cancer, and health insurance benefits from a doctor SitePal, without having to read long text from a website or printed brochure.

The process of creating a SitePal character is pretty straight forward too. The tutorial movie on the SitePal website provides an easy-to-follow walk-thru of setting up and hosting a SitePal character. An existing SitePal character can be modified literally within seconds. I modified the current SitePal character on this blog within minutes, and amazingly, she looked completely different (see picture below). [Since I am very fond of blondes with glasses, I ended up using the previous version].

SitePal is not just limited to webpages. You can also embed a SitePal character into your PowerPoint presentation, taking interactivity to a whole new level.

Try it out for yourself. Certainly reminds one of S1m0ne (Simone), doesn't it?

DAL goes SubSonic

2007-03-19T01:10:00.001+05:00

Oh boy! I have a lot of things to blog about, mainly posts on "Atlas [now ASP.NET AJAX Extensions] at last" and "MS Speech Application SDK". My reason for staying away from blogging was that I was buried in a project in Pakistan till December 2006, after I came back from the MVP Open Days in Turkey in September. Anyway, I have just shifted to USA, and will try to blog regularly from now on.

As developers (and architects) come to terms with the changes that would come with LINQ and the ADO.NET Entity Framework, and the impact it would have on business applications, many existing applications developed or ported to C# 2.0 or VB 8.0 from previous version would never be able to exploit its benefits. Architects and developers working on new software applications or application functionality, however, can make the wise choice of using the Web Service Software Factory to generate business entities, and expose them through web services. (more on that coming up in future posts, HOPEFULLY).

Hardly any developer would want to be bogged down with writing business object classes to represent the entity tables in an enterprise application. The alterative for O/R Mapping, in most cases, is to turn to techniques for code generation, that allow generation of business object code for data access; NHibernate being one of the most popular ones.

SubSonic is yet another O/R Mapper or DAL code generator on the horizon, and does not involve using a separate application for code generation. All the developer needs to do to use SubSonic is add a reference to the actionpack.dll file and add some tags to the web.config file, and thats it. Even more amazing is the fact that SubSonic allows developers to swiftly generate web pages for inserting, updating, and deleting records in the table, kind of like the ones used in administration sections of most websites. Check out the SubSonic site to learn more.

Without a doubt, code generation can give development teams a head-start, when it comes to rapidly generating business entities as soon as they have a database design in place. However, a fact that is often overlooked in enterprise applications, when there are literally hundreds of tables the code needs to be generated for, is that business entities seem to loose their original meaning, and instead exist only as code stubs for data access logic pertaining to the tables they were created for. The same thing happens if you use strongly typed datasets to represent business entities.

A good data-access pattern within a good system architecture, would be to have a separate layer between the DAL (mainly stored procs and logic residing on the database), and the business logic layer (which includes business objects). This new layer would comprise the code generated using an O/R Mapper. While developers building a project from scratch, and trying to get it completed in the scheduled time, would very much want to overlook this important aspect, since it would need to done manually without any code generation. I will try to illustrate using an example. A typical "Employee" business entity generated using an O/R Mapper might have methods like Insert() and Update() for saving and updating a record in the Employee. For most development teams trying to meet the dealine, this is good enough. However, a great design would create the same Employee class (in a different namespace) that would have methods like Hire(), Create(), ChangeAddress(), IncrementSalary() etc. calling the same Insert() and Update() methods under the covers. Not only does this make the code far more readable and self-explanatory, but also highly maintainable. The advantage of using this approach becomes even more profound when you are dealing with tables that do not necessarily represent real-life entities, and require methods like Debit(), Credit, TakeBack(), Adjust(), Reconcile() etc.

For now, I would recommend a Webcast that should get you up and running with DAL generation at SubSonic speeds.

I dream about Turkey!

2006-09-07T10:48:00.000+05:00

That's the slogan of the Turkish tourism advertisement I saw on my flight from Istanbul to Antalya, on my way there for the Microsoft MVP Open Days event for MEA (Middleast and Africa) region this week, and let me tell you, I dream about Turkey from now on too.

Is this COOL or what?

2006-08-17T13:25:00.000+05:00

This is a test post to check Windows Live Writer. You can get more information here.

Atlas at last! - Part III

2006-08-08T10:36:00.000+05:00

Previously:
Atlas at last Part II: Looking to the road ahead
Atlas at last Part I: Getting down and dirty with JavaScript

Matt Gibbs has written an excellent "Atlas at last" article in the July 2006 issue of MSDN Magazine. Check it out: Atlas At Last: ASP.NET Atlas Powers the AJAX-Style Sites You’ve Been Waiting For.

So much can change between 2 posts is hard to imagine. For one, WinFX was renamed; now its called .NET 3.0 (combining WPF, WCF, WF, WCS). I touched upon the idea of WPF in the web browser in the previous Atlas at last post. An article on MSDN titled "Deploying Microsoft .NET Framework Version 3.0" explains how to detect if .NET 3.0 is installed on a PC from within JavaScript/JScript code running inside a browser. Get ready; we would be seeing sites developed using .NET 3.0, with WPF on the presentation tier, very soon. The keyword to remember is "Smart Client"; browser-based applications lending a rich presentation to a SOA (Service-Oriented Architecture) strategy.

There's more than one way to skin a cat, or so I heard, and that really depends on what you want to do after you've done it. In the same way, you have a choice to develop with Microsoft "Atlas" using 2 different approaches, depending on the type of project you are building, the development time you have, and/or the amount of responsiveness and richness you want in your web app. The 2 approaches are: Server-Centric and Client-Centric Development. The diagram below provides a glimpse of what these 2 approaches encompass.

Very briefly, the Server-Centric approach primarily involves using Atlas Server Controls to achieve the desired result. This essentially means adding the "UpdatePanel" control, and enclosing all other server controls within it. Control Extenders, as the name implies, allow developes to add DHTML behaviors to existing server or client controls. Although the current online literature on Atlas does not classify the use of Control Extenders as a server-centric approach, it is easy to explain Control Extenders to developers in context of the server-centric approach, mainly because they encapsulate DHTML behaviors, shielding the user from the complexity of the JavaScript code, and are used pretty much like pre-developed ASP.NET server controls.

The Client-Centric approach relies on client-side script (no surprises there) running inside the web browser to not only achieve most of the things possible with the server-centric approach, but to also create and add rich client-side interactivity within the webpage. Remember, these 2 approaches are not alternatives to each other. A single website, or even a single webpage, can have implementations of both approaches. The next 2 "Atlas at last" posts would look into more detail of both these approaches separately.

It is incorrect to assume that only the client-centric approach involves scripting. There are no clear guidelines in existence that would mandate the use of one approach instead of the other. Many web/ASP.NET developers who are just getting started with Microsoft "Atlas" would want to go with the UpdatePanel control since it requires the least effort and development time. However, the UpdatePanel might not hold the answer to what you wanted to achieve in the first place. I received a couple of queries from people who wanted to know which approach they should follow for their projects, and my answer was always the same: it depends. Its better to choose the approach for each webpage accordingly instead of making a choice of the approach to follow at the beginning of the project and adhereing to it throughout. Let me elaborate through some scenarios.

The webpage comprises of static information.
Recommended approach: None; Since the data contained in the page does not change, it is pointless to use Atlas in it.

The webpage is used to present dynamic information stored on the server in a database/XML file, and loads inside a particular region of the page depending on the query string value.
Recommended approach: Server-Centric; The UpdatePanel would only change a portion of the page after a response is received from the server, while static portions of the page like header images, logos, menus etc. would not reload.

The webpage lists information from a database table, and the user should not have to navigate to a different webform page to enter new, or modify existing data from that table.
Recommended approach: Control Extenders; The 'Modal Popup Control Extender' provides an easy-to-implement mechanism to dislay a webform in a modal popup window, graying-out the rest of the portion of the screen outside the popup window, allowing the user to enter new, or change existing, information; When the modal popup closes, the portion of the page that lists the data from the table refreshes to show the updated information from the server (without a full postback).

The webpage consists of multiple dropdown lists (combo-boxes), and each one after the first dropdown list populates with values based on the value selected in a previous dropdown, like a City dropdown populating everytime for the Country seleted from another dropdown list.
Recommended approach: Control Extenders; The 'Cascading DropDown Control Extender' allows a dropdown list to call and web service in response to a selection made into it and populate the next dropdown list in the sequence.

You want to give the user the ability to either enter a new value into a textbox or else select from a list of values already stored in the database.
Recommended approach: Both Client-Centric and Server-Centric approaches support the Auto-Complete behavior (Also see next point).

You want to give the user the ability to either enter a new value into a textbox or else select from a list of values already stored in the database, based on a selection or preference specified ealier.
Recommended approach: Client-Centric; Only JavaScript would allow the Auto-complete list to be populated based on a condition, since XML-Script and the AutoComplete Control Extender only attach a web service (hard-code) to an autocomplete list, whereas JavaScript code provides the flexibility to select from a list of web services depending on a condition.

The above does not (and cannot possibly) cover all the scenarios that Microsoft "Atlas" is designed for. Stick around for more "Atlas at last" posts.

EID Presentation Upload

2006-07-17T10:23:00.000+05:00

I apologize for not uploading the "Building Next Generation GUIs using Microsoft Expression Interactive Designer" presentation earlier. I just uploaded it to the Core.NET Yahoo Group in the "Files > PDC 2006 Slides and Demos > EID" Folder.

For samples and application demos, check out these URLs.

Microsoft Expression Blog

WPF SDK Blog

Tim Sneath's Blog

WPF Samples from the .NET 3.0 community website

The WPF Blog

"Atlas" Presentation Slides and Demo Code

2006-07-01T23:00:00.000+05:00

I got an overwhelming response from both of my presentations during the 3-day Pakistan Developer Conference 2006, or PDC 2006 as we like to call it. I have uploaded my presentation slides and demo code for all applications I demonstrated at Core.NET's Yahoo! Group account. Download away!

The three files pertaining to the presentation uploaded in the "Files > PDC 2006 Slides and Demos > AJAX & Atlas" folder are

Atlas_AdnanHashmi.PDF

PDC06.Demos.NaukriAtlas.ZIP

PDC06.Session.Demos.ZIP

* The term 'Naukri' in Urdu means 'Job'. NaukriAtlas.NET is an AJAX-enabled job portal.

More on .NET 3.0

2006-06-14T02:13:00.000+05:00

Good to see things getting clearer as Tech Ed 2006 approaches. These two articles provide a good understanding about what .NET 3.0 is all about.

Realize New Functionality in .NET 3.0
New Technology Offers Dev Challenges, UI Improvements

At a glance, .NET 3.0 [http://www.netfx3.com/] includes

.NET Framework 2.0

The 2.0 Common Language Runtime (CLR)

The 2.0 Base Class Library

ADO.NET 2.0, ASP.NET 2.0, Windows Forms 2.0

VB 8.0 and C# 2.0

WinFX

Windows Communication Foundation (WCF) [http://wcf.netfx3.com/]

Windows Presentation Foundation (WPF) [http://wpf.netfx3.com/]

Windows Workflow Foundation (WF) [http://wf.netfx3.com/]

InfoCard

Renamed to Windows CardSpace (WCS) [http://wcs.netfx3.com/]

Interestingly, the announcement made about .NET 3.0 on June 9 by Somasegar on his blog was exactly what I had forecasted and blogged about in my post just 3 days prior, and I had absolutely no idea at that time that it would come so soon.

.NET: 2 Fast, 3 Furious

2006-06-11T01:48:00.000+05:00

I am not sure how the decision to rename WinFX (which encompasses WPF, WCF, and WF) to .NET 3.0 will go down with developers who are still in the process of trying to explore, and gradually coming to terms with the changes that new technologies like Atlas and WinFX brought to .NET 2.0. Developers, however, were content, knowing that WinFX was built on top of .NET 2.0 and will be supported for the next decade. This new change, in addition to creating a lot of confusion, will also raise a number of questions; Will existing investments in .NET 2.0 go down the drain soon? Should we wait for the new 3.0 platform to mature before we implement it? Is .NET 2.0 gone?

Hopefully, Microsoft would move swiftly to allay a lot of fears in the coming days. My best guess is that .NET 2.0 (along with its underlying technologies) would be a subset of .NET 3.0 along with Orcas/C# 3.0, WinFX, and LINQ. For now, I am keeping my fingers crossed.

Atlas at last! - Part II

2006-06-06T01:31:00.000+05:00

Previously:
Atlas at last-Part I: Getting down and dirty with JavaScript

The following text is my own take on the AJAX/Atlas future, and DOES NOT reflect any future Microsoft strategy.

Lets face it; web sites today, regardless of the technology they've been built on, do not come even close to providing the utility envisaged and hyped about in the Dot Com era. Though the future outlook initially looked very promising for e-learning, e-business, and e-everything, the reality has been very different. And so, as it happens, once in a while a technology comes along that holds the promise of changing something that we have become so accustomed to that we don't realize needs fixing. Question is, does AJAX fall under that category? Certainly not. AJAX, as time will tell, is not an end, but a means to an end. AJAX (and all its implementation frameworks) will do nothing more then allow the idea of asynchronous call-backs to the server without mandating a page refresh to gain acceptance. This would enable a much richer class of web applications then ever before. The trade-off to this, however, is a much longer inital loading time for the page.

Imagine having to tune your television to the channel you want to watch everytime you want to watch it. Isn't that what has been going on for so many years the internet has been in existence; the whole page refreshing just to display a message on a small portion of the webpage.

Going with the analogy of television, imagine turning on your television and seeing a "Loading...Please wait" message on the screen. Isn't that what AJAX would put web surfers through when the page loads for the first time? If you happen to have a slow internet connection as I do, it would take a couple of "manual" page refreshes just to see the whole UI on the screen, hopefully without a JavaScript error appearing in the web browser's status bar. Thankfully, such considerations will not slow the buzz that has been generated in web developer circles since the advent of the AJAX approach.

Getting back to the point I made about asynchronous call-backs and initial loading time above, developers and users/surfers alike would attune to the idea of longer initial loading times just so they get fast responses and a richer experience once the UI has loaded; communicating with web services asynchronously without whole round-trips to the server and complete page refreshes.

For the time being, that looks like the change we will be seeing in websites. However, if you think that the story ends there, think again. For the Web 2.0 idea to become a reality, and not fade into oblivion after a while, the web has to be a platform. That would put more pressure on the web browsers, since no one would want to see one website work on IE and FireFox but break down in Opera. These unresolved issues are still in abundance as companies move to invest in web applications that would make use of the AJAX approach.

How do we move forward then? What does the future hold for AJAX and Atlas? Well, to answer these questions, architects and developers would need to focus on the Smart Client paradigm. The biggest benefit Smart Clients have is that they only need to be installed once on the client PC after being downloaded from the Internet (Click Once deployment). This would allow the application to be used without visiting any website again and wait for the UI to load. The reason the Smart Client model was sidelined (by AJAX) was because it killed the web browsing experience; it did not function inside the web browser, but instead appeared as a stand-alone application. To cut a long story short, for the next generation of web applications, 3 things are of utmost importance:

Responsiveness (brought about using communication with web services)

Rich User Experience and UI

Least or No download time

Uptill now, only the first of the 3 above has been addresed by the AJAX approach. The only way I see 2 and 3 (along with 1) becoming a reality is with XAML and Windows Presentation Foundation (WPF). XAML or eXtensible Application Markup Language in its current form still has a long way to go, but it does hold a promise, simply because it has the capacity to encompass a lot of UI logic declaratively (using tags) without any scripting language. Hence, the next generation web applications UI's would be developed in tools such as Microsoft Expression Interactive Designer, and exist as WPF Express applications. The third point of least or no download time can be made possible by caching the XAML UI after it has loaded into the web-browser so that it does not need to download the next time the user visits the site. Webpages are kept in the browser's cache even now, but that serves no purpose in making the next visit to that page more responsive. Some might argue the need for keeping large amount of UI data in the web-browser's cache even if the surfer may be visiting the site for the first and last time; to which my answer would be: You keep the phone number of the people you call frequently stored in your cellphone so that you dont have to memorize them, or even dial them everytime. However, even if you make a call to someone for the first (and possibly last) time, even then, that number remains in your cellphone's memory for some time. So, web-browsers may prompt the users if they want to keep the UI cached so they dont have to download it again in the next visit. Ideally (and for good reason), web surfers would keep the websites they visit frequently cached in their browsers. What a surfing experience that would be?!

For now, the idea of declarative programming will gain wider acceptance in the web developer community as they use tags in Atlas to bind UI elements to data or extend existing web controls with control extenders. If nothing else, one thing is certain; JavaScript is back from her death-bed (if not her grave), and has become something for companies to explore and take seriously for the next couple of years.

See you at the Pakistan Developers Conference 2006

Pakistan Developers Conference (PDC) 2006

2006-05-27T23:32:00.000+05:00

Awright! Its that time of the year again which developers in Pakistan look forward to; the annual Microsoft Pakistan Developers Conference 2006 (June 28 ~ June 30). This year, the conference would be bigger and better then previous years, since it would take place in Karachi and Lahore simultaneously. The event in Karachi would be 3 day long, whereas in Lahore, it would only be a single day event. Check out the agendas for both cities here. I will be speaking in 2 sessions this time around; "Developing Rich Internet Applications using AJAX and Atlas" and "Building Next Generation GUI's using Microsoft Expression Interactive Designer". I will be posting more about my demos in the coming weeks.

Register online NOW! I hope to see you there.

WPF Data Binding Tutorial

2006-05-13T11:33:00.002+05:00

WPF Databinding Tutorial

Watch the screencast for this tutorial/post here.

As promised, I am posting the code and explanation of the WPF Data Binding example I showed at the "Introduction to Windows Presentation Foundation" NED.NET user group event this Saturday.

A developer typically creates a class to represent an entity (table) in the database, whereby CRUD operations are performed by calling methods on the objects, e.g; for class Employee, objEmployee.Save(), objEmployee.Load(), objEmployee.Update(), objEmployee.Delete() etc. Also, everytime the values in the object change, the developer has to manually write code to update each of the UI elements that display the values stored in the object's members. The same holds true when the values on the UI change. With WPF, you can lessen your code greatly by binding the object directly with the UI (each of object's members data-bound to individual UI elements) using XAML syntax. I will be covering 3 different approaches for displaying data in the object onto the UI.

Typical

Using only C# [INotifyPropertyChanged]

Using C# and XAML [INotifyPropertyChanged and XAML]

I am going to use the same "Examinee" table I used at several demos earlier this year for the HEC (Higher Education Commission) Web Service example. The columns for the table are

RollNo (PK, nvarchar(5), not null)

FirstName (nvarchar(10), not null)

LastName (nvarchar(10), not null)

University (nvarchar(50), not null)

MarksObtained (int, not null)

Exam (nvarchar(15), not null)

Typical Approach
The following provides a glimpse of what goes on in code with the typical approach. The developer creates the Examinee class for the table as follows: [For clarity, code has been colored and lines numbered. Also, ignore the SqlDataReader use for fetching a single row; it was done to lessen code ;)]


     // =========================
     //   Code Listing 1
     // =========================
  1: using System;
  2: using System.Collections.Generic;
  3: using System.Text;
  4: using System.Data;
  5: using System.Data.SqlClient;
  6: 
  7: namespace Demos.WPF.Binding.PropertyChangeNotNotified
  8: {
  9:     class Examinee
 10:     {
 11:         private string _RollNo;
 12:         public string RollNo
 13:         {
 14:             get { return _RollNo; }
 15:             set { _RollNo = value; }
 16:         }
 17:         
 18:         private string _FirstName;
 19:         public string FirstName
 20:         {
 21:             get { return _FirstName; }
 22:             set { _FirstName = value; }
 23:         }
 24:         
 25:         private string _LastName;
 26:         public string LastName
 27:         {
 28:             get { return _LastName; }
 29:             set { _LastName = value; }
 30:         }
 31: 
 32:         private string _University;
 33:         public string University
 34:         {
 35:             get { return _University; }
 36:             set { _University = value; }
 37:         }
 38: 
 39:         private int _MarksObtained;
 40:         public int MarksObtained
 41:         {
 42:             get { return _MarksObtained; }
 43:             set { _MarksObtained = value; }
 44:         }
 45: 
 46:         private string _Exam;
 47:         public string Exam
 48:         {
 49:             get { return _Exam; }
 50:             set { _Exam = value; }
 51:         }
 52: 
 53:         public Examinee()
 54:         {
 55:         }
 56: 
 57:         public void Load()
 58:         {
 59:             if (_RollNo.Trim().Length == 0)
 60:                throw new Exception("Roll Number not specified.");
 61: 
 62:             SqlConnection oConnection = new SqlConnection([...]);
 63:             oConnection.Open();
 64: 
 65:             string str = "";
 66:             str += "SELECT * ";
 67:             str += "FROM Examinee ";
 68:             str += "WHERE RollNo = @RollNo";
 69:             SqlCommand oCommand = new SqlCommand(str, oConnection);
 70:             oCommand.CommandType = CommandType.Text;
 71:             oCommand.Parameters.Add(new SqlParameter("@RollNo", _RollNo));
 72:             SqlDataReader oDR = oCommand.ExecuteReader();
 73: 
 74:             if (oDR.Read())
 75:             {
 76:                 _FirstName = oDR["FirstName"].ToString();
 77:                 _LastName = oDR["LastName"].ToString();
 78:                 _University = oDR["University"].ToString();
 79:                 _MarksObtained = Convert.ToInt32(oDR["MarksObtained"]);
 80:                 _Exam = oDR["Exam"].ToString();
 81:             }
 82: 
 83:             oCommand.Dispose();
 84:             oConnection.Close();
 85:             oConnection.Dispose();
 86:         }
 87: 
 88:         public void Update()
 89:         {
 90:             if (_RollNo.Trim().Length == 0)
 91:                throw new Exception("Roll Number not specified.");
 92: 
 93:             SqlConnection oConnection = new SqlConnection("[...]");
 94:             oConnection.Open();
 95: 
 96:             string str = "";
 97:             str += "UPDATE Examinee ";
 98:             str += "SET FirstName = @FirstName, ";
 99:             str += "LastName = @LastName, ";
100:             str += "University = @University, ";
101:             str += "MarksObtained = @Marks ";
102:             SqlCommand oCommand = new SqlCommand(str, oConnection);
103:             oCommand.CommandType = CommandType.Text;
104:             oCommand.Parameters.Add(new SqlParameter("@FirstName", _FirstName));
105:             oCommand.Parameters.Add(new SqlParameter("@LastName", _LastName));
106:             oCommand.Parameters.Add(new SqlParameter("@University", _University));
107:             oCommand.Parameters.Add(new SqlParameter("@Marks", _MarksObtained));
108:             oCommand.Parameters.Add(new SqlParameter("@RollNo", _RollNo));
109:             oCommand.ExecuteNonQuery();
110: 
111:             oCommand.Dispose();
112:             oConnection.Close();
113:             oConnection.Dispose();
114:         }
115:     }
116: }

I figured that since it is XAML that we are demonstrating, might as well develop the UI in Microsoft Cider, the Visual Studio 2005 add-in visual designer for XAML. So, to use the above class, the UI would be something like this.

The resulting XAML for the window shown above is



 <!-- 
 =========================
    Code Listing 2
    Simple.xaml
 =========================
 -->
<Window 
 x:Class="Demos.WPF.Binding.Simple"
 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 Title="Demos.WPF.Binding" Height="209" Width="371"
 Background="WhiteSmoke" WindowStartupLocation="CenterScreen">
    <Grid>
    <Label
     VerticalAlignment="Top" 
     HorizontalAlignment="Left" 
     Grid.Column="0" 
     Grid.ColumnSpan="1" 
     Grid.Row="0" 
     Grid.RowSpan="1" 
     Margin="21.37,23,0,0" 
     Width="76.63" 
     Height="23.2766666666667" 
     Name="label1">Roll Number:</Label>
    <Label 
     VerticalAlignment="Top" 
     HorizontalAlignment="Left" 
     Grid.Column="0" 
     Grid.ColumnSpan="1" 
     Grid.Row="0" 
     Grid.RowSpan="1" 
     Margin="20.37,42.7233333333333,0,0" 
     Width="76.63" 
     Height="23.2766666666667" 
     Name="label2">First Name:</Label>
    <Label 
     VerticalAlignment="Top" 
     HorizontalAlignment="Left" 
     Grid.Column="0" 
     Grid.ColumnSpan="1" 
     Grid.Row="0" 
     Grid.RowSpan="1" 
     Margin="20.37,66,0,0" 
     Width="75.63" 
     Height="23.2766666666667" 
     Name="label3">Last Name:</Label>
    <Label 
     VerticalAlignment="Top" 
     HorizontalAlignment="Left" 
     Grid.Column="0" 
     Grid.ColumnSpan="1" 
     Grid.Row="0" 
     Grid.RowSpan="1" 
     Margin="21.37,89,0,0" 
     Width="62.63" 
     Height="23.2766666666667" 
     Name="label4">University:</Label>
    <Label 
     VerticalAlignment="Top" 
     HorizontalAlignment="Left" 
     Grid.Column="0" 
     Grid.ColumnSpan="1" 
     Grid.Row="0" 
     Grid.RowSpan="1" 
     Margin="21.37,112.723333333333,0,0" 
     Width="62.63" 
     Height="23.276666666666671" 
     Name="label5">Marks:</Label>
    <TextBox 
     VerticalAlignment="Top" 
     HorizontalAlignment="Stretch" 
     Grid.Column="0" 
     Grid.ColumnSpan="1" 
     Grid.Row="0" 
     Grid.RowSpan="1" 
     Margin="134,23,56,0" 
     Width="NaN" 
     Height="20" 
     Name="txtRollNo" 
     BorderBrush="#FF000000" 
     Foreground="#FF336699"></TextBox>
    <TextBox 
     VerticalAlignment="Top" 
     HorizontalAlignment="Stretch" 
     Grid.Column="0" 
     Grid.ColumnSpan="1" 
     Grid.Row="0" 
     Grid.RowSpan="1" 
     Margin="134,46,56,0" 
     Width="NaN" 
     Height="20" 
     Name="txtFirstName" 
     Foreground="#FF336699" 
     BorderBrush="#FF000000"></TextBox>
    <TextBox 
     VerticalAlignment="Top" 
     HorizontalAlignment="Stretch" 
     Grid.Column="0" 
     Grid.ColumnSpan="1" 
     Grid.Row="0" 
     Grid.RowSpan="1" 
     Margin="134,69.2766666666667,56,0" 
     Width="NaN" 
     Height="20" 
     Name="txtLastName" 
     Foreground="#FF336699" 
     BorderBrush="#FF000000"></TextBox>
    <TextBox 
     VerticalAlignment="Top" 
     HorizontalAlignment="Stretch" 
     Grid.Column="0" 
     Grid.ColumnSpan="1" 
     Grid.Row="0" 
     Grid.RowSpan="1" 
     Margin="134,92.2766666666667,56,0" 
     Width="NaN" 
     Height="20" 
     Name="txtUniversity" 
     Foreground="#FF336699" 
     BorderBrush="#FF000000"></TextBox>
    <TextBox 
     VerticalAlignment="Top" 
     HorizontalAlignment="Stretch" 
     Grid.Column="0" 
     Grid.ColumnSpan="1" 
     Grid.Row="0" 
     Grid.RowSpan="1" 
     Margin="134,114,56,0" 
     Width="NaN" 
     Height="20" 
     Name="txtMarks" 
     Foreground="#FF336699" 
     BorderBrush="#FF000000"></TextBox>
    <Button 
     VerticalAlignment="Bottom" 
     HorizontalAlignment="Left" 
     Grid.Column="0" 
     Grid.ColumnSpan="1" 
     Grid.Row="0" 
     Grid.RowSpan="1" 
     Margin="134,0,0,11" 
     Width="51" 
     Height="23" 
     Name="btnLoad" 
     Click="btnLoad_Click">Load</Button>
    <Button 
     VerticalAlignment="Bottom" 
     HorizontalAlignment="Right" 
     Grid.Column="0" 
     Grid.ColumnSpan="1" 
     Grid.Row="0" 
     Grid.RowSpan="1" 
     Margin="0,0,128.5625,11" 
     Width="48.4375" 
     Height="23" 
     Name="btnUpdate" 
     Click="btnUpdate_Click">Update</Button>
    <Button 
     VerticalAlignment="Bottom" 
     HorizontalAlignment="Right" 
     Grid.Column="0" 
     Grid.ColumnSpan="1" 
     Grid.Row="0" 
     Grid.RowSpan="1" 
     Margin="0,0,56,11" 
     Width="55" 
     Height="23" 
     Name="btnCheck" 
     Click="btnCheck_Click">Check</Button>
    <Button 
     VerticalAlignment="Top" 
     HorizontalAlignment="Right" 
     Grid.Column="0" 
     Grid.ColumnSpan="1" 
     Grid.Row="0" 
     Grid.RowSpan="1" 
     Margin="0,115,12,0" 
     Width="39" 
     Height="19" 
     Name="btnAddTen" 
     Click="btnAddTen_Click">+10</Button>
  </Grid>
</Window>

The app lets the user enter the Roll Number for a student, and dislays the Examinee's stats when the "Load" button is clicked. The user can then make any changes in values if required (except for the Roll Number), and click "Update" to make the changes in the database. Nothing fancy here. The code-behind file is pretty straight-forward as well. I have placed a "Check" button on the form to let the user view and compare the values in both, the Examinee object and on the UI.


     // =========================
     //   Code Listing 3
     //   Simple.xaml.cs
     // =========================
  1: using System;
  2: using System.Windows;
  3: using System.Windows.Controls;
  4: using System.Windows.Data;
  5: using System.Windows.Documents;
  6: using System.Windows.Media;
  7: using System.Windows.Media.Imaging;
  8: using System.Windows.Shapes;
  9: using Demos.WPF.Binding.PropertyChangeNotNotified;
 10: 
 11: namespace Demos.WPF.Binding
 12: {
 13:     public partial class Simple : Window
 14:     {
 15:         Examinee oExaminee = new Examinee();
 16: 
 17:         public  Simple()
 18:         {
 19:             InitializeComponent();
 20:         }
 21: 
 22:         private void btnLoad_Click(object sender, EventArgs e)
 23:         {
 24:             try
 25:             {
 26:                 oExaminee.RollNo = txtRollNo.Text;
 27:                 oExaminee.Load();
 28: 
 29:                 // tedious code to update UI with object's properties
 30:                 txtFirstName.Text = oExaminee.FirstName;
 31:                 txtLastName.Text = oExaminee.LastName;
 32:                 txtUniversity.Text = oExaminee.University;
 33:                 txtMarks.Text = oExaminee.MarksObtained.ToString();
 34:             }
 35:             catch (Exception oEx)
 36:             {
 37:                 MessageBox.Show(oEx.Message);
 38:             }
 39:         }
 40: 
 41:         private void btnUpdate_Click(object sender, EventArgs e)
 42:         {
 43:             try
 44:             {
 45:                 // tedious code to set object's properties from UI elements
 46:                 oExaminee.FirstName = txtFirstName.Text;
 47:                 oExaminee.LastName = txtLastName.Text;
 48:                 oExaminee.University = txtUniversity.Text;
 49:                 oExaminee.MarksObtained = Convert.ToInt32(txtMarks.Text);
 50: 
 51:                 oExaminee.Update();
 52:                 MessageBox.Show("Information Updated.", "Update");
 53:             }
 54:             catch (Exception oEx)
 55:             {
 56:                 MessageBox.Show(oEx.Message);
 57:             }
 58:         }
 59: 
 60:         private void btnCheck_Click(object sender, EventArgs e)
 61:         {
 62:             string str = string.Format("OBJECT:\nFirstName: {0}" 
 63:                 + "\nLastName: {1}"
 64:                 + "\nUniversity: {2}"
 65:                 + "\nMarksObtained: {3}"
 66:                 + "\n\nUI:"
 67:                 + "\nFirst Name: {4}"
 68:                 + "\nLast Name: {5}"
 69:                 + "\nUniversity: {6}"
 70:                 + "\nMarksObtained: {7}", 
 71:                 oExaminee.FirstName, 
 72:                 oExaminee.LastName, 
 73:                 oExaminee.University, 
 74:                 oExaminee.MarksObtained.ToString(), 
 75:                 txtFirstName.Text, 
 76:                 txtLastName.Text, 
 77:                 txtUniversity.Text, 
 78:                 txtMarks.Text);
 79:             MessageBox.Show(str);
 80:         }
 81: 
 82:         private void btnAddTen_Click(object sender, EventArgs e)
 83:         {
 84:             if ((oExaminee.MarksObtained + 10) > 100)
 85:                 oExaminee.MarksObtained = 100;
 86:             else 
 87:                 oExaminee.MarksObtained += 10;
 88:         }
 89: 
 90:     }
 91: }

Notice that in the event handlers for both, the "Load" (lines 29 to 33) and "Update" (lines 45 to 49) buttons, the values need to be shuttled between the object and the UI elements to keep them synchronized. If the form had, lets say, 30+ UI elements, the developer would have to write atleast 60 additional lines of code to achieve this synchronization. Ironically, this is what usually happens.

Using only C# [INotifyPropertyChanged]
The typical approach is pretty cumbersome. The same result can be achieved by implementing the INotifyPropertyChanged interface in the Examinee class to generate an event everytime the value in the object's property changes. I have highlighted portions in code listing 4 that need to be added to implement INotifyPropertyChanged.


     // =========================
     //   Code Listing 4
     // =========================
  1: using System;
  2: using System.Collections.Generic;
  3: using System.Text;
  4: using System.Data;
  5: using System.Data.SqlClient;
  6: using System.ComponentModel;
  7:  
  8: namespace Demos.WPF.Binding.PropertyChangeNotified
  9: {
 10:     class Examinee : INotifyPropertyChanged
 11:     {
 12:         private string _RollNo;
 13:         public string RollNo
 14:         {
 15:             get { return _RollNo; }
 16:             set
 17:             { 
 18:                _RollNo = value;
 19:                // Notify Property Change
 20:                OnPropertyChanged("RollNo");
 21:             }
 22:         }
 23:        
 24:         private string _FirstName;
 25:         public string FirstName
 26:         {
 27:             get { return _FirstName; }
 28:             set 
 29:             { 
 30:                _FirstName = value; 
 31:                // Notify Property Change
 32:                OnPropertyChanged("FirstName"); 
 33:             }
 34:         }
 35:         
 36:         private string _LastName;
 37:         public string LastName
 38:         {
 39:             get { return _LastName; }
 40:             set 
 41:             { 
 42:                _LastName = value; 
 43:                // Notify Property Change
 44:                OnPropertyChanged("LastName");
 45:             }
 46:         }
 47: 
 48:         private string _University;
 49:         public string University
 50:         {
 51:             get { return _University; }
 52:             set 
 53:             { 
 54:                _University = value; 
 55:                // Notify Property Change
 56:                OnPropertyChanged("University"); 
 57:             }
 58:         }
 59: 
 60:         private int _MarksObtained;
 61:         public int MarksObtained
 62:         {
 63:             get { return _MarksObtained; }
 64:             set 
 65:             { 
 66:                _MarksObtained = value;
 67:                // Notify Property Change
 68:                OnPropertyChanged("MarksObtained"); 
 69:             }
 70:         }
 71: 
 72:         private string _Exam;
 73:         public string Exam
 74:         {
 75:             get { return _Exam; }
 76:             set 
 77:             { 
 78:                _Exam = value; 
 79:                // Notify Property Change
 80:                OnPropertyChanged("Exam"); 
 81:             }
 82:         }
 83: 
 84:         public Examinee()
 85:         {
 86:         }
 87: 
 88:         public void Load()
 89:         {
 90:             if (_RollNo.Trim().Length == 0)
 91:                throw new Exception("Roll Number not specified.");
 92: 
 93:             SqlConnection oConnection = new SqlConnection([...]);
 94:             oConnection.Open();
 95: 
 96:             string str = "";
 97:             str += "SELECT * ";
 98:             str += "FROM Examinee ";
 99:             str += "WHERE RollNo = @RollNo";
100:             SqlCommand oCommand = new SqlCommand(str, oConnection);
101:             oCommand.CommandType = CommandType.Text;
102:             oCommand.Parameters.Add(new SqlParameter("@RollNo", _RollNo));
103:             SqlDataReader oDR = oCommand.ExecuteReader();
104: 
105:             if (oDR.Read())
106:             {
107:                 _FirstName = oDR["FirstName"].ToString();
108:                 _LastName = oDR["LastName"].ToString();
109:                 _University = oDR["University"].ToString();
110:                 _MarksObtained = Convert.ToInt32(oDR["MarksObtained"]);
111:                 _Exam = oDR["Exam"].ToString();
112:                 
113:                 // following code raises onPropertyChanged event because 
114:                 // properties are being set from within the class itself.
115:                 OnPropertyChanged("FirstName");    
116:                 OnPropertyChanged("LastName");     
117:                 OnPropertyChanged("University");   
118:                 OnPropertyChanged("MarksObtained");
119:                 OnPropertyChanged("Exam");         
120:             }
121: 
122:             oCommand.Dispose();
123:             oConnection.Close();
124:             oConnection.Dispose();
125:         }
126: 
127:         public void Update()
128:         {
129:             if (_RollNo.Trim().Length == 0)
130:                throw new Exception("Roll Number not specified.");
131: 
132:             SqlConnection oConnection = new SqlConnection("[...]");
133:             oConnection.Open();
134: 
135:             string str = "";
136:             str += "UPDATE Examinee ";
137:             str += "SET FirstName = @FirstName, ";
138:             str += "LastName = @LastName, ";
139:             str += "University = @University, ";
140:             str += "MarksObtained = @Marks ";
141:             SqlCommand oCommand = new SqlCommand(str, oConnection);
142:             oCommand.CommandType = CommandType.Text;
143:             oCommand.Parameters.Add(new SqlParameter("@FirstName", _FirstName));
144:             oCommand.Parameters.Add(new SqlParameter("@LastName", _LastName));
145:             oCommand.Parameters.Add(new SqlParameter("@University", _University));
146:             oCommand.Parameters.Add(new SqlParameter("@Marks", _MarksObtained));
147:             oCommand.Parameters.Add(new SqlParameter("@RollNo", _RollNo));
148:             oCommand.ExecuteNonQuery();
149: 
150:             oCommand.Dispose();
151:             oConnection.Close();
152:             oConnection.Dispose();
153:         }
154:         
155:          public event PropertyChangedEventHandler PropertyChanged;                
156:          protected void OnPropertyChanged(string propertyName)                    
157:          {                                                                        
158:              if (this.PropertyChanged != null)                                    
159:                 PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
160:          }                                                                        
161:     }
162: }

Changes made to class Examinee of listing 1 are given in code listing 4 above. The INotifyPropertyChanged interface implementation allows the class to raise the PropertyChanged event everytime a property value changes. The above class can now be instanitated in the code-behind file (see code listing 5 below) of another XAML file (WithoutXAML.xaml) which is similar to that of code listing 2.


     // =========================
     //   Code Listing 5
     //   WithoutXAML.xaml.cs
     // =========================
  1: using System;
  2: using System.Windows;
  3: using System.Windows.Controls;
  4: using System.Windows.Data;
  5: using System.Windows.Documents;
  6: using System.Windows.Media;
  7: using System.Windows.Media.Imaging;
  8: using System.Windows.Shapes;
  9: using Demos.WPF.Binding.PropertyChangeNotified;
 10: 
 11: namespace Demos.WPF.Binding
 12: {
 13:     public partial class WithoutXAML : Window
 14:     {
 15:         Examinee oExaminee = new Examinee();
 16: 
 17:         public  Simple()
 18:         {
 19:             InitializeComponent();
 20:         }
 21:         
 22:         private void WithoutXAML_Load(object sender, EventArgs e) 
 23:         {                                                         
 24:            oExaminee.PropertyChanged += oExaminee_PropertyChanged;
 25:         }                                                         
 26:
 27:         // Property Changed Event Handler [Pathetic Code!]
 28:         private void oExaminee_PropertyChanged(object sender,          
 29:                             PropertyChangedEventArgs e)                
 30:         {                                                              
 31:             switch(e.PropertyName)                                     
 32:             {                                                          
 33:                 case "FirstName":                                      
 34:                     txtFirstName.Text = oExaminee.FirstName;           
 35:                     break;                                             
 36:                 case "LastName":                                       
 37:                     txtLastName.Text = oExaminee.LastName;             
 38:                     break;                                             
 39:                 case "University":                                     
 40:                     txtUniversity.Text = oExaminee.University;         
 41:                     break;                                             
 42:                 case "MarksObtained":                                  
 43:                     txtMarks.Text = oExaminee.MarksObtained.ToString();
 44:                     break;                                             
 45:             }                                                          
 46:         }                                                              
 47: 
 48:         private void btnLoad_Click(object sender, EventArgs e)
 49:         {
 50:             try
 51:             {
 52:                 oExaminee.RollNo = txtRollNo.Text;
 53:                 oExaminee.Load();
 54:             }
 55:             catch (Exception oEx)
 56:             {
 57:                 MessageBox.Show(oEx.Message);
 58:             }
 59:         }
 60: 
 61:         private void btnUpdate_Click(object sender, EventArgs e)
 62:         {
 63:             try
 64:             {
 65:                 oExaminee.Update();
 66:                 MessageBox.Show("Information Updated.", "Update");
 67:             }
 68:             catch (Exception oEx)
 69:             {
 70:                 MessageBox.Show(oEx.Message);
 71:             }
 72:         }
 73: 
 74:         private void btnCheck_Click(object sender, EventArgs e)
 75:         {
 76:             string str = string.Format("OBJECT:\nFirstName: {0}" 
 77:                 + "\nLastName: {1}"
 78:                 + "\nUniversity: {2}"
 79:                 + "\nMarksObtained: {3}"
 80:                 + "\n\nUI:"
 81:                 + "\nFirst Name: {4}"
 82:                 + "\nLast Name: {5}"
 83:                 + "\nUniversity: {6}"
 84:                 + "\nMarksObtained: {7}", 
 85:                 oExaminee.FirstName, 
 86:                 oExaminee.LastName, 
 87:                 oExaminee.University, 
 88:                 oExaminee.MarksObtained.ToString(), 
 89:                 txtFirstName.Text, 
 90:                 txtLastName.Text, 
 91:                 txtUniversity.Text, 
 92:                 txtMarks.Text);
 93:             MessageBox.Show(str);
 94:         }
 95: 
 96:         private void btnAddTen_Click(object sender, EventArgs e)
 97:         {
 98:             if ((oExaminee.MarksObtained + 10) > 100)
 99:                 oExaminee.MarksObtained = 100;
100:             else 
101:                 oExaminee.MarksObtained += 10;
102:         }
103:         
104:         ///////////////////////////////////
105:         // WARNING: Pathetic Code below! //
106:         // Event-handlers for text-boxes //
107:         ///////////////////////////////////
108: 
109:         private void txtRollNo_TextChanged(object sender,   
110:           EventArgs e)   
111:         {      
112:             oExaminee.RollNo = txtRollNo.Text;   
113:         }      
114: 
115:         private void txtFirstName_TextChanged(object sender,  
116:           EventArgs e)   
117:         {      
118:             oExaminee.FirstName = txtFirstName.Text;  
119:         }      
120: 
121:         private void txtLastName_TextChanged(object sender,  
122:           EventArgs e)   
123:         {      
124:             oExaminee.LastName = txtLastName.Text;  
125:         }      
126: 
127:         private void txtUniversity_TextChanged(object sender,  
128:           EventArgs e)   
129:         {      
130:             oExaminee.University = txtUniversity.Text;  
131:         }      
132: 
133:         private void txtMarks_TextChanged(object sender,   
134:           EventArgs e)   
135:         {      
136:             int marks = 0;     
137:             if (int.TryParse(txtMarks.Text, out marks))  
138:                 oExaminee.MarksObtained = marks;   
139:         }      
140:     }
141: }

Notice that the oExaminee_PropertyChanged event handler (lines 27 to 46) updates the UI with object values everytime a PropertyChanged event occurs on the Examinee object. To update the object with UI values, TextChanged event handlers were added for all the textboxes (see lines 104 to 139).

Notice also that the "Load" and "Update" button event handlers do not contain the Object-to-UI and UI-to-Object update code as that is now being handles by the event handlers.

However, just because we implemented the INotifyPropertyChanged interface in our Examinee class, we were not absolved of the responsibility to write custom event handlers for the object and UI update logic. The whole point of all the above code is to show the tedious coding required to keep the object and UI in sync.

Using C# and XAML [INotifyPropertyChanged and XAML]
Both the approaches described above were used with typical Windows applications, although I created the form using XAML. The final approach (and the right one at that) uses the Data Binding syntax in XAML, and would show you how easy it is to bind UI elements directly to an object that implements INotifyPropertyChanged.

To see WPF Data Binding in action, the Binding sytax in the textboxes' "Text" property values. The XAML file would not look something like code listing 6. [Changes from previous XAML file have been highlighted.]



 <!-- 
 =========================
    Code Listing 6
    WithXAML.xaml
 =========================
 -->
<Window 
 x:Class="Demos.WPF.Binding.WithXAML"
 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 Title="Binding - Using XAML Binding Syntax" 
 Height="209" Width="371" Background="WhiteSmoke"
 WindowStartupLocation="CenterScreen" Loaded="WithXAML_Load" >
    <Grid x:Name="myGrid" >
    <Label ...>Roll Number:</Label>
    <Label ...>First Name:</Label>
    <Label ...>Last Name:</Label>
    <Label ...>University:</Label>
    <Label ...>Marks:</Label>
    <TextBox
     ...
     Name="txtRollNo" 
     Text="{Binding Path=RollNo}"></TextBox>
    <TextBox 
     ...
     Name="txtFirstName" 
     Text="{Binding Path=FirstName}"></TextBox>
    <TextBox
     ...
     Name="txtLastName" 
     Text="{Binding Path=LastName}"></TextBox>
    <TextBox
     ...
     Name="txtUniversity" 
     Text="{Binding Path=University}"></TextBox>
    <TextBox
     ... 
     Name="txtMarks" 
     Text="{Binding Path=MarksObtained}"></TextBox>
    <Button ...>Load</Button>
    <Button ...>Update</Button>
    <Button ...>Check</Button>
    <Button ...>+10</Button>
  </Grid>
</Window>

The Binding statement added to the XAML above allows you to discard all the event-handlers in the code-behind that were needed before. The function that we wanted from our app is now achievable with a lot less code.


     // =========================
     //   Code Listing 7
     //   WithXAML.xaml.cs
     // =========================
  1: using System;
  2: using System.Windows;
  3: using System.Windows.Controls;
  4: using System.Windows.Data;
  5: using System.Windows.Documents;
  6: using System.Windows.Media;
  7: using System.Windows.Media.Imaging;
  8: using System.Windows.Shapes;
  9: using Demos.WPF.Binding.PropertyChangeNotified;
  10: 
 11: namespace Demos.WPF.Binding
 12: {
 13:     public partial class WithXAML : Window
 14:     {
 15:         Examinee oExaminee = new Examinee();
 16: 
 17:         public WithXAML()
 18:         {
 19:             InitializeComponent();
 20:         }
 21: 
 22:         private void WithXAML_Load(object sender, EventArgs e)
 23:         {
 24:             myGrid.DataContext = oExaminee;
 25:         }
 26: 
 27:         private void btnAddTen_Click(object sender, EventArgs e)
 28:         {
 29:             if ((oExaminee.MarksObtained + 10) > 100)
 30:                 oExaminee.MarksObtained = 100;
 31:             else
 32:                 oExaminee.MarksObtained += 10;
 33:         }
 34: 
 35:         private void btnLoad_Click(object sender, EventArgs e)
 36:         {
 37:             try
 38:             {
 39:                 oExaminee.Load();
 40:             }
 41:             catch (Exception oEx)
 42:             {
 43:                 MessageBox.Show(oEx.Message);
 44:             }
 45:         }
 46: 
 47:         private void btnUpdate_Click(object sender, EventArgs e)
 48:         {
 49:             try
 50:             {
 51:                 oExaminee.Update();
 52:                 MessageBox.Show("Information Updated.", "Update");
 53:             }
 54:             catch (Exception oEx)
 55:             {
 56:                 MessageBox.Show(oEx.Message);
 57:             }
 58:         }
 59: 
 60:         private void btnCheck_Click(object sender, EventArgs e)
 61:         {
 62:             string str = string.Format("OBJECT:\nFirstName: {0}"
 63:                 + "\nLastName: {1}"
 64:                 + "\nUniversity: {2}"
 65:                 + "\nMarksObtained: {3}"
 66:                 + "\n\nUI:"
 67:                 + "\nFirst Name: {4}"
 68:                 + "\nLast Name: {5}"
 69:                 + "\nUniversity: {6}"
 70:                 + "\nMarksObtained: {7}",
 71:                 oExaminee.FirstName,
 72:                 oExaminee.LastName,
 73:                 oExaminee.University,
 74:                 oExaminee.MarksObtained.ToString(),
 75:                 txtFirstName.Text,
 76:                 txtLastName.Text,
 77:                 txtUniversity.Text,
 78:                 txtMarks.Text);
 79:             MessageBox.Show(str);
 80:         }
 81:     }
 82: }

The only change occured in line 24 in the WithXAML_Load event handler; the Examinee object was assigned to the main Grid's DataContext property. The highlighted statement in code listing 7 above defines a data context for the Grid, the UI element that encloses all the other UI controls. WPF introduces the concept of "Dependency Properties" that enables a XAML UI element to inherit a value from its parent UI control (in this case the grid). Once the data context is set in the form load event, the {Binding Path=...} statements in XAML simply retrieve the values from the bound object or resource and place them in the target textbox. If you run the application now, everytime you change the value in a textbox, the corresponding value in the object changes (You can test this by clicking the "Check" button after you update the value in a textbox). Same holds true for the object. If you click the "+10" (btnAddTen) button, the value in the object is incremented by 10. However, you will also see that the value is automatically updated in the textbox as well.

Try the above, and feel free to ask any questions that you may have. I have really outdone myself with this post. I guess I am all set to write a book now.

Download source code from here.

Developing Speech Applications - Part II

2006-05-02T16:41:00.000+05:00

ASP.NET Speech applications developed using the Microsoft Speech Application SDK (SASDK) resemble typical ASP.NET applications in terms of their programming and exection model. Hence, it is extremely easy for web developers to use their existing skill set to develop speech applications from scratch, or use their existing ASP.NET code to speech enable a previously developed project.

In Part I, I slightly touched upon the type of speech applications i.e. Voice-Only and Multi-modal, that you can develop using the SASDK. The diagram below would give you some idea about how ASP.NET Speech apps differ from the traditional ASP.NET web apps.

The only difference between a typical web app, a voice-only speech app, and a multi-modal speech app is the top layer that the user interacts with. In the typical ASP.NET web application (left-most in the figure), the GUI simply comprises one or more web forms containing text-boxes, combo-boxes, images, plain-text etc. In a multi-modal speech applicaion (right-most), the user, although interacts with the application through the GUI (web forms displayed in a browser), can also use voice commands to make selections in combo-boxes, speak text into a text-box, etc. In both of these scenarios (typical web application and multi-modal speech application), the web form loads into the user's browser in response to a request sent by the client to the web server. A voice-only speech app (middle of diagram), is different from the previous two in that it does not have a GUI that a user can interact with; nor does it load into a web browser on the client user's PC. The voice-only application user interacts with the app through a telephone using her voice or touch-tone (DTMF), with the speech application running on a remote server. The output is also in the form of voice, which the user hears on her phone. It is important to note that in the voice-only application scenario, the speech app is infact running in a web browser (like all ASP.NET applications) on the server, but the loaded web pages are composed of SALT instead of HTML tags. Also, while the ASP.NET portion of the application is hosted in IIS, the task of receiving the call and transferring voice commands and responses between the telephone line and the app rests with Microsoft Speech Server (MSS).

To start off, lets look at a typical ASP.NET application first. The figure below provides an overview of how your everyday ASP.NET web app works.

The series of steps/events shown in the above diagram are:

Request sent from a web form loaded into the client's web browser.

Request processed.

Query sent to database.

Query results returned to the application.

Response generated and sent to the requesting web browser.

Keeping the above in mind, lets take a look at our FlightEnquiry.NET voice-only ASP.NET speech application.

On an abstract level, the application works like this.

The user calls the FlightEnquiry.NET application from her phone. The app picks up the phone, plays a welcome prompt, and asks the user for the Flight she wants to enquire about.

The caller speaks the flight number.

[...]

[...]

[...]

[...]

[...]

[...]

[...]

[...]

[...]

The application tells the caller the status of the flight and the call is disconnected.

The reason I left out points 3 to 11 was because they are hidden from the caller and mainly involve processing done by the application. Lets now look at the technical details of the FlightEnquiry.NET speech demo.

Step 1:
When the phone call is received, Microsoft Speech Server answers the phone by playing a pre-recorded prompt. This prompt could be a recorded voice or that coming from a Text-to-Speech (TTS) Engine.
The FightEnquiry.NET application played the prompt, "Welcome to FlightEnquiry Dot Net. Please say the Airline Name and Flight Number."

Step 2:
The caller speaks the flight name and number she wants to enquire about.
Depending on how flexible your have built your app, the caller can say the Flight Name and Number in a number of ways; Pakistan International Airlines PK 347, Pakistan International Airlines 347, PIA 347, PK 347, PIA Flight 347, PIA Flight PK 347, etc.

Step 3:
The spoken input is validated against a grammar rule. All grammar rules exist inside a separate *.srgs file that contains the XML for the grammar. In order to allow the caller to answer in a number of possible ways, the grammar should take into consideration the maximum number of possibilities that the caller can say in response to a played prompt. The result of the grammar validation is plain XML within a SML (Semantic Markup Language) tag.
The resultant SML for the FlightEnquiry.NET app looks like this:


<SML>
  <FlightNumber>PK347</FlightNumber>
</SML>

Step 4:
Values can be extracted from the generated SML using an XPath query that you specified during application development. The extracted value is then stored in an object variable called a semantic item. Each semantic item can hold only one value. A semantic item is simply a server control that can be shared between the browser and ASP.NET application.
The value "PK347" we got from the generated SML is stored in a semantic item called "siFlightNumber".

Step 5:
Once the value is stored in the semantic item, it is submitted to the server. The value of the semantic item can be accessed inside the browser using JavaScript through its value property, i.e. siFlightNumber.value. However, on the server, the semantic item's value is accessed using the Text property, i.e. siFlightNumber.Text.

Step 6:
As with any typical ASP.NET web application, the request is processed.

Step 7:
The database is queried for the flight's status.

Step 8:
Query results are returned back to the application.

Step 9:
The Flight status is now returned, again as a semantic item back to the client.

Step 10:
In order to play the Flight's status back to the caller, a client-side JavaScript code written at the time of development formats the status it receives in the form of a semantic item from the server. This JavaScript code resides inside a prompt function (*.pf) file that contains both XML and JavaScript, and converts the status into a form that can be spoken back to the caller.

Step 11:
The prompt function returns a string that would be spoken either by the TTS or would be generated from pre-recorded prompts and played to the caller i.e. Pakistan International Airlines Flight P K three four seven from Karachi to Lahore departing six thirty and arriving wight fourty is on schedule. Thank you for calling Flight Enquiry Dot Net.

Step 12:
The callers hears the TTS/prompt voice and the call ends.

Whew! Hopefully, I have been able to explain how my FlightEnquiry.NET demo works in this post. I would be covering the steps for speech-enabling the FlightEnquiry.NET application in my next post, the last of this series on developing speech application using Microsoft SASDK. Comments and feedback are always welcome.

In all its Glory!

2006-04-24T00:52:00.000+05:00

Pakistan's capital Islamabad is ranked as the most beautiful capital city in the region. The picture above show the Prime Minister's Secretariat decorated with lights (as were many buildings in Islamabad) because of a religious holiday; Eid Milad-un-Nabi, Prophet Muhammad's birthday.

Last week was monumental. Firstly, fellow MVP, Country Leader INETA Pakistan, and good friend Saqib Ilyas got married. I couldn't attend because I was in Islamabad. Anyway, best wishes for him and his wife. My reason for visiting Islamabad was to conduct events at 4 universities; Mohammad Ali Jinnah University (MAJU), FAST, Allama Iqbal Open University (AIOU), and COMSATS Institute of Information Technology (CIIT); all in a span of 1 week. This time around, I was fortunate to be presenting with some very talented and young individuals from Islamabad. Tenoon Raza and Salma Nasir from Microsoft Islamabad office presented at the first 2 presentations each, and the latest edition to the Pakistani MVP Community, Ahmed Salam, presented at the remaining two.

Islamabad always charges me up. I look forward to going back soon.

UX Article

2006-04-05T00:49:00.000+05:00

My article on User eXperience published in The Beta Experience Newsletter 2.

Check it out here.

Developing Speech Applications - Part I

2006-03-27T01:20:00.001+05:00

Haven't blogged, or conducted a session, about Speech Technologies (my second love) and the Microsoft Speech Application SDK (SASDK) for quite sometime. However, I have received a lot of requests for the SASDK tutorial on FlightEnquiry.NET Speech Demo that I showed at the Microsoft ISV Community Days in March 2005, Pakistan Developer Conference 2005 in June 2005, and at various INETA Pakistan user group events last year. I have figured that it is better to blog about something in a series of posts, as opposed to trying to type one HUGE post and be absent from the blogging world for days and weeks. So, if time and old age permit, I will hopefully try to blog about the SASDK tutorial in 3 posts. (I will try to keep the "Atlas at last" posts coming during this time too.)

NOTE: Most of the following text had been written about 8 months ago.

BACKGROUND
When ASP.NET first appeared on the horizon, most of us heaved a sigh a relief; No more having to work with ASP's two separate languages, VBScript on the server and JavaScript on the client; no spaghetti code; and most importantly, no need to worry about posting data back on to the form when it reloaded. With a number of cool ASP.NET server controls, life had been made simpler for the Web Developer. In a sense, for a brief moment in time, ASP Developers (who had shifted to ASP.NET) forgot all about JavaScript, since all ASP.NET controls had client-side logic built into it. The burden of writing JavaScript (or JScript) code had shifted from the Web Application Developer to the ASP.NET Server Control developer.

INTRODUCTION
Enter Microsoft Speech Application SDK (SASDK). Suddenly, client-side scripting became relevant again. Speech Applications built with the SASDK were browser-based ASP.NET applications with much of the handling done at the client i.e. web-browser. In making their Speech platform compatible with ASP.NET, Microsoft had 2 objectives: (1) to allow companies to use their existing ASP.NET code infrastructure in developing Speech apps; and (2) to make use of SALT (Speech Application Language Tags), a standard for providing speech input and output in the web-browser using tags. In various talks and speaker session, I have repeatedly been asked if the Microsoft SASDK would speech-enable websites or allow voice-activated web browsing. My answer: yes and no, depending on the type of platform you are developing the speech application for.

A Speech Application developed using the Microsoft SASDK can be in either one of two categories; (1) Voice-only (2) Multi-Modal. Both application types leverage existing ASP.NET code but differ in implementation. Voice-only applications have a VUI (Voice User Interface) and no GUI i.e. all communication between the app and the user is by means of voice or DTMF (Dual-Tone Multi-Frequency) that may be transferred over a telephone line or any other voice carrier medium. Multi-Modal applications, on the other hand, have a VUI as well as a GUI. This allows the user to interact with the application using voice as well as with the mouse and keyboard. The use of Voice-only telephony applications is understandable, but why use Multi-Modal? Fact of the matter is that the bulk of Multi-Modal applications that would be developed within the next few years won't be for the desktop PC, but would instead be for Mobile and Smart Clients. PC users typically have all the hardware they need, namely the keyboard and mouse, to interact with their applications. However, it is difficult to use Mobile/Smart Client application because of the small keypad or even stylus while on the road. Microsoft's release of the Mobile Internet Toolkit did not really bring about increased development of Mobile applications as many would have expected because mobile or smart client applications are extremely difficult to use because of the small size of the device they are running on. Speech-enabled Mobile or Smart Client applications require minimal use of the keypad or stylus and rely more on speech for input (and even output), thus providing increased ease-of-use. [NOTE: Multi-modal applications failed to take-off in a way that Microsoft had exepected. The Speech API (SAPI) 5.3 that comes built into Windows Vista would allow development of desktop speech applications and DOES NOT make use of SALT. You can download a video of the Multi-modal Speech Application (Sublime Demo) running on a hand-held device from Jahanzeb Sherwani's web page.]

The execution model followed by an application developed using the SASDK is somewhat the same as any ASP.NET application, consisting mainly of a certain number of requests and responses. However, the client-side processing done for a speech application is different. In a typical web form (non-speech app) scenario, information is submitted to the server through form controls (textboxes, checkboxes, radio buttons etc.) which form the GUI. In speech applications, input is received by the a speech control that is not visually rendered but is in fact hosted inside a web page using the tag from SALT specification. When a voice input is received, it is processed on the client by JScript, meaningful information is extracted and sent to the server by means of a variable known in the SASDK domain as a "semantic item". The importance of JScript that I highlighted at the start of this article stems from this client side processing of the speech input. This scenario is valid for both, Voice-only and Multi-modal Speech applications. For more information on SALT, check out the SALT Forum web site.

Please note that in order for Internet Explorer to interpret SALT tags, you need to have Microsoft Enterprise Instrumentation Framework (EIF) installed on your PC. EIF is a pre-requisite and comes with the SASDK. Also, SASDK v1.0 and v1.1 work only with .NET Framework 1.1 and Visual Studio.NET 2003.

In the second part of this 3 part series of posts, I will briefly discuss the series of functions performed during the execution of a typical Voice-only application.

Atlas at last! - Part I

2006-03-23T01:23:00.000+05:00

The great thing about being a Microsoft MVP is that you are always out to learn new tools, technologies, tips, and tricks, in anticipation of being asked a technical question on any forum regardless of what your competencies actually are. Not only does gaining knowledge benefit MVPs themselves; it also lets them share that knowledge, expertise, and experience to the developer community at large. I simply love doing it, and I am glad that I too am finally blogging about AJAX and Atlas after so many of my fellow -MVPs and -bloggers around the world have already done so. I hope to blog about Atlas, as I have understood it, in a series of posts.

You might have been hearing and reading a lot about Web 2.0 lately. If you haven't heard about it, and you apparently live in a cave (as the saying goes) check out an indepth article on it here.

AJAX is all about JavaScript as it involves using the XmlHTTP object built into your web browser, and has been a part of the browser since 1998. I dont think a lot web developers would want to get down to writing AJAX apps using directly the XmlHttp object, and would instead rely on pre-built libraries that leverage XmlHTTP. If you happen to be an ASP.NET developer (and you probably are), you need to get hold of Atlas, the client and server-side libraries and controls for building AJAX applications from Microsoft. Since Atlas has not been finally released, you might have to do a lot of JavaScript coding yourself. The thing with working with JavaScript is that when you are getting down and dirty writing code in a language that you usually do not program in, and reluctantly learning many of the details of client-side scripting that you are not accustomed to or atleast did not care about previously, you are bound to get an error once in a while. Many times, the line of code that is marked as being the culprit for the error is not actually the one that has something wrong with it. Since you might not get a lot of Intellisense and debugging support in the VS IDE for client-side scripts (although Microsoft is working to change that in future), there are a couple of things that I recommend you do when you encounter a JavaScript error.

Pray that you are able to solve the problem within the next hour. [Optional]

Go and have a glass of water. [Mandatory]

Take a deep breath and relax. [Mandatory]

Empty your web-browser's cache. [Optional]

Go over your script's code, one statement at a time, to ensure that you did not mis-spell anything. Check variable and function names. Do not assume that your typing skills are excellent. You could be great, but that changes when you are typing JavaScript code. DO IT! [Mandatory]

REMEMBER, JavaScript is case-sensitive, so textbox is not the same as textBox. [Mandatory]

Use the JavaScript 'alert' function judiciously to display values in a browser dialog box, to ensure variable values are what you think they are at a particular point in your code. [Mandatory]

There is NOTHING wrong with the Atlas client libraries (*.js files inserted into the project when an Atlas website is created); so if you get an error at, lets say, line no. 1554, check to see if you have closed all Atlas tags correctly. [Mandatory]

IE would do just so much to let you know the line of code that has the error. It is highly likely that the line marked with having the error is perfectly alright. Check to see if that line in followed by a function-call statement. If it is, go to point no. 5 and start debugging that function. [Mandatory]

REMEMBER, AJAX/Atlas involves calling web services asynchronously. Every web service call must also specify a call-back function, which is executed when the service finishes executing and returns data back to the browser.

When you get an error on the JavaScript statement calling a web service, be sure to debug the call-back function (the function that executes once the web service returns the results of its execution). [Mandatory]

There are more indepth tutorials and technical stuff that I would cover in my future "Atlas at last" posts.

Book on MS Speech Server

2006-02-12T15:06:00.000+05:00

I can hardly wait.
http://msmvps.com/blogs/williamryan/archive/2006/01/25/81837.aspx

Google on IE7 NOW!

2006-02-07T21:53:00.000+05:00

It literally took ages for the good people at Microsoft to realize the importance of search, and they only came out with their search engine once Google's domination of the search market was complete; their time to respond to this reality being horribly slow.

I had (finally) started using MSN Search for the past few days, ever since I downloaded and installed Internet Explorer 7 Beta 2, as it provided the MSN Search textbox on the top-right side of the window without having to visit a particular webpage to enter the search query. Not any more. Today, as I typed www.google.com.pk in my IE7 web browser, the Google search page had a new addition on the top-right hand corner of the page, prompting me to make Google the search engine in IE. I clicked the "Make Google my search" button and the 13.6 KB download instantly added the Google search option to a web browser that is still in its Beta. Talk about quick response. What's in-store for Web 2.0, I wonder? The good people of Google are swift.