core.net

Branding SharePoint

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

SharePoint Branding

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.

Enter Sparkle

2006-02-05T12:58:00.000+05:00

I just can't get enough of the UX enhancements. Cider, the Visual Designer for XAML is brilliant. However, with the release of Microsoft Interactive Designer (aka Sparkle) CTP for January 2006, designers can get excited too. Firstly, don't be fooled by the design environment that looks a lot like Macromedia Flash. Sparkle is totally different. Its not just draw, drag and drop. The ability to zoom not just the scene you are drawing, but also the design/development environment panels is truely remarkable.

Secondly, anyone using the Interactive Designer must take into account the object hierarcy that is formed when you create an object or UI element on the scene/window. This entails that you explicitly activate a drawn element by double clicking it in the timeline panel (NOT on the design surface), and then droping another element onto it, to make the latter the former's child in the hierarchy. This hierarchical element tree allows child elements to be bound to a field in a data context bound to the parent element, instead of having to create and bind individual data contexts for elements.

Lastly, designers and developers can work on the same project using different development environments, i.e. VS 2005 (with WinFX installed), and Sparkle interactive designer. Although, coding support is available in Sparkle, it was never built for development, just for designing.

After playing around with the Fabrikam Catalog Application tutorials, I was ready to create a small Contacts application on my own; not exactly rocket science, but a beauty indeed!

[Click on images to view a larger version]

LAUNCHED!

2006-02-04T23:27:00.000+05:00

The SQL Server 2005/VS2005 Launch event at NED today was a smash hit! What makes user group events really exciting is the enthusiasm of the audience, and at the NED University of Engineering and Technology, excitement is not hard to muster, and my experience as speaker there is always one to blog about. Great work NEDians!

Whats Cookin', Good Lookin'?

2006-02-03T02:40:00.000+05:00

User eXperience, it seems, is everywhere. Even before the release of Windows Vista, apps have already started to look and feel a lot like those Windows Vista. Firstly, MSN Messenger 8.0 Beta gives a feel of the Vista Search capabilities/experience by short-listing entries in a list as the use types in the search-box. Yahoo also seems to have jumped on the UX bandwagon. Yahoo widgets have a glass-style user experience similar to that of Vista. Here's a screenshot of both apps I just mentioned, captured off my desktop.

[Click on images below to view a larger version.]

Technology's New Year Resolutions

2006-01-02T23:31:00.000+05:00

Here is how I think technology will change and the way we live, work, travel, communicate, and think in 2006.

In: Services; Out: Web Services

The new paradigm will be Service-Orientation. We will see a clear distinction between infrastructure providers and service/content providers. Devices such as cellphones, digital camera, laptops, PDAs, televisions, CD/DVD Players would be able to connect to the Internet and consume services.

The cell phone has achieved greater penetration than anyone had previosuly imagined, even more than the Internet. The move will be towards telephony applications accessed through voice, or using mobiles/handheld devices.
The convergence of Internet and Telephones/Cell-phones would usher in a new era of Speech applications, which would become more accurate and mainstream.

Technology will become more accessible to the less priviledged around the world with the release of MIT's $100 laptop, bringing world-class pornography to children even in remote villages, since they wont know what else to do with their new toy.

Star Bucks will open more outlets throughout the world.

HAPPY NEW YEAR!

XAML Respite! Orcas CTP is here!

2005-12-29T20:35:00.000+05:00

Only a month after developers got a breadth of fresh air in form of the WinFX November 2005 CTP becoming part of the Windows Longhorn Platform SDK, the Visual Studio Extensions/Development Tools for WinFX December 2005 CTP with a Visual designer for XAML is indeed the best New Year gift from Microsoft one could have hoped for. The next generation Visual Studio code-named Orcas would allow developers to visually design Windows' GUI in the typical drag and drop fashion, generating XAML in the background. Download and check it out.

READY!

2005-12-22T01:05:00.000+05:00

I agree I've been a bit lazy about User Group events lately. Anyway, Core.NET is Ready to Launch. We would announce the dates for our User Group events at NED, IBA-Karachi, and IBA-Sukkur real soon. Get more information about launch events from the following URL.
http://mea.ineta.org/pakistan/coredotnet/launch/

I intend to demonstrate a hypothetical "State Bank of Pakistan" Web Services Architecture example at this first event on VS 2005 Team Suite for Software Architects and SQL Server 2005. See you there!

Tools of the UX Trade

2005-12-17T23:23:00.000+05:00

A little more than ten years ago, when the Internet was introduced in Pakistan for the first time, a large number of people wanting to jump on the bandwagon immediately turned to learning HTML. I remember going to CD shops in 1996 and seeing piles and piles of tutorial CDs for HTML and web page designing. It was difficult to even find a book on HTML at one point because all had been sold out. Little did anyone realize that pretty soon, web page designing would evolve from knowing more than just plain HTML to something more subtle. All web page designers, pretty soon, started using tools like Microsoft FrontPage, Macromedia Dreamweaver/Fireworks etc. for all web page designing. HTML became less important; WYSIWYG tools could achieve more and in lesser time.

Fast-forward to 2005, the paradigm for the presentation layer is about to change dramatically. Windows Vista would allow designing of GUIs like never before. At the forefront of this change in paradigm is Microsoft's eXtensible Application Markup Language (XAML) and the programming subsystem/framework called Windows Presentation Foundation (WPF), formerly Avalon.

Its natural for anyone wanting to explore WPF to start off with XAML, but keeping in mind what happened to HTML, the focus should turn more towards the designing aspects of the User eXperience and the programming aspects of WPF. I intend to blog about XAML in the coming weeks and months as I delve into this exciting new technology. These days, I have focused a bulk of my attention to the Visual designing tools for XAML, namely Microsoft Expression Acrylic [Download link], Electronic Rain ZAM 3D, and Mobiform Aurora. By the way, Microsoft would come up with 2 more design tools in the not-so-distant future, Microsoft Expression Sparkle and Microsoft Expression Quartz. Stay tuned.

The WinFX Checklist

2005-12-17T11:35:00.000+05:00

Many people install WinFX and later realize that its not functioning properly. The following checklist includes all the items and in the order that you need to install for WinFX to work.

0) Visual Studio 2005
1) WinFX Runtime Components 3, Beta 2
2) WinFX SDK
3) Visual Studio Extensions for WinFX
4) Visual Studio Extensions for Windows Workflow Foundation Beta 1.2

Note: The above checklist is for WinFX November 2005 CTP. (CTPs before September 2005 did not include Windows Workflow Foundation)

The Power of UX

2005-11-20T20:52:00.000+05:00

Things are always changing in the software world; and with every new release or version of every software application in the market, the one thing that always changes or improves is the UI. I always emphasize the need for the UI to always be consistent, attractive, and user friendly in my speaking sessions and blogs. After all, the UI is the application. UI design guidelines have existed before, but they would become less effective, if not completely redundant, when Windows Vista is released next year. Microsoft is attempting to come out with a clear set of guidelines for designing the UI which make the application easy to use, easy to learn, and enjoyable for users. UX (User Experience) as it would be called in Windows Vista, has been codenamed "Aero". The Aero theme file would allows Vista developers to easily bring the UX design into their apps.

While the detailed "UX Guidelines" can be downloaded from the Microsoft website, you need to go through the process of validating yourself as a genuine Windows user, Genuine Windows Advantage as they call it, to be able to download the 14.5 MB self-extracting executable file. The top rules that govern the UX design are:

Use the Aero Theme and System Font (Segoe UI)

Use common controls and common dialogs

Use the standard window frame, use glass judiciously

Use icons and graphics consistent with the Windows Vista style and quality

Use task dialogs for new or frequently used dialog boxes and error messages

Use Aero Wizards

Use Explorer-hosted, navigation-based user interfaces, provide a Back button

Use the standard Windows Search

Use the Windows Vista tone in all UI text

Clean up the user interface

Use notifications judiciously

Reserve development time for "fit and finish"!

A couple of weeks ago, I heard an instructor, at a Training I was attending, dismiss the need for an attractive GUI for entreprise applications; applications that need to work in a business environment, according to him, need to be sound in their working, and not their GUI. I couldn't disagree more. How would anyone, entreprise user or otherwise, react if she/he could see the Windows on the desktop like this?

SpeechFX?

2005-11-19T00:55:00.000+05:00

While there has never been any formal announcement by Microsoft on referring to the new Speech capabilities in WinFX as SpeechFX, I have read it a couple of times on the blogs of the Microsoft Speech team members. Anyway, read this nice article about Exploring New Speech Recognition And Synthesis APIs In Windows Vista.

Microsoft to "Unveil" the next generation Speech Platform

2005-11-18T23:24:00.000+05:00

Microsoft has been researching "speech" for over a decade, long before the release of Speech Server in 2004. However, this time around, speech would be featured big time in Windows Vista, with a new System.Speech namespace in the WinFX SDK (not be confused with the System.Web.Speech namespace in the Speech Application SDK).

Last month, Microsoft announced that it had acquired certain intellectual property assets from Unveil Technologies Inc. However, now the story is that Microsoft has indeed acquired the whole company, and would also absorb some of its employees into Microsoft. Why? The Unveil Conversation Suite was a brilliant piece of software; a killer-app to be precise; and allowed non-speech developers to rapidly design and develop Enterprise Speech applications graphically. This was more then what Pronexus's VBSALT offered.

So, this adds another company to the growing list of speech companies being acquired and merged in the recent months; Scansoft and Nuance, Unveil and Microsoft, and yet another one, Intervoice and Edify.

By acquiring Unveil, Microsoft has killed two birds with one stone, so to speak. While the Conversation Manager would surely be a vital component in the next release of the Speech Server, Microsoft has also taken a great J2EE-based speech product for the IBM Speech platform, off the market. I call this brilliant strategy. Great thinking Bill!

The Speech Overkill: Possible Solutions

2005-10-22T23:30:00.000+05:00

I had a very interesting discussion with Jahanzeb Sherwani, a PhD student at Carnegie Mellon University who was visiting Pakistan on vacations in July. He pointed out the ineffectiveness of many Telephony Speech applications in the US that simply were too difficult for callers to use, and often irritating because of the way they would prompt users for input, without clearly understanding the spoken input provided to them, signifying a very weak VUI design. Prompting callers without specifically telling them what the system expects and how it expects the spoken input can elicit responses that can't always be defined using Grammar files. A hypothetical example could be

System: Welcome to the Apparel Directory. How many I help you?

Caller: I am just trying to check out the weaknesses in VUI design in your Speech application.

System: What designs are you interested in?

Caller: I am not interested in any Apparel Designs!

System: Good choice. Should I tell you the names of all the vendors or would you like to connect to a particular one?

Caller: Aarghhhh! Whats wrong with you motherfucker??!!!

System: Connecting to Mothercare now. Thank you for calling.

While Microsoft and IBM have come out with their (somewhat ambigiuous) guidelines for designing VUI's, a much better option would be to provide prompt controls, just like the Speech input controls that come with the Speech Application SDK for common answers as Yes/No/Cancel etc. as guidelines are not easy to enforce, and prompt controls may be able to provide boilerplate text for creating effective prompt messages depending on the type of input required. For unknown reasons, the speech developer still has to hand-code GRXML code and databind it to a table's column to create dynamic grammars. Is someone listening ... errr reading?

(Nuance)ScanSoft

2005-10-18T23:14:00.000+05:00

First it was Speechify, whose TTS engine is part of Microsoft Speech Server 2004, which merged with ScanSoft (of the Dragon Naturally Speaking fame) to form a bigger and better Speech company, about a year ago. Now, its ScanSoft, which has been renamed to Nuance Communications, Inc. The new slogan/tagline for the company, "The experience speaks for itself^TM" also speakes a lot for itself, about the extensive suite of speech products and the vast experience brought together. Good news for the Industry indeed.

Microsoft MVP Summit 2005

2005-10-08T06:12:00.000+05:00

Just returned from the Microsoft MVP Summit 2005 in Seattle. The visit was an experience to remember. MVP Summits are always a great way to network with MVPs from around the world in addition to Microsoft product groups and employees. I have maintained a separate blog for my visit. Check it out here.

Welcome Vista!

2005-09-05T23:59:00.000+05:00

I got the Beta-1 of Windows Longhorn (Vista) in my MSDN Subscription mail this month, and I was tempted to install it to see what it is all about. Since this is just the Beta version, it does not allow you to override your current windows installation (what a relief!), but requires 6GB of space on an NTFS partition. For all of you who were expecting Vista to be considerably different from previous Windows', well, apart from the GUI, dont expect a lot of changes from it. The GUI, I agree, is really cool and fast (performance-wise); but for us hardcore developers, it seems a bit...well...how should I put this...over-childish. The vastly multi-colored GUI seems unreasonable and unnecessary. When I say that the GUI is fast, I dont mean that the whole OS is fast; its just that buttons and menus respond more efficiently then Windows XP and/or its predecessors. Some of the features are really slow, like when I double-clicked the volume icon in the system-tray, it literally took a few minutes (NOT seconds) for the volume control dialog to open. An Avalon applicaion with a cool GUI would look far more attractive deployed in Windows XP instead of Vista which would over-shadow it with its own GUI.

A cool thing I found was the Text-to-Speech Voice called Microsoft Anna that comes with Vista. The TTS still has a long way to go before it can compete with the ScanSoft Speechify TTS engine, but compare that to the horrible TTS voices (Mary, Mike, and Sam) that came with the Windows XP, it is absolutely wonderful. All in all, after using Vista myself, I am yet to comprehend the real reason for an operating system that has taken so long to develop and does not have all the changes I was expecting, but has enough to get most Windows users excited.

Click the following links to see the screenshots I captured of Windows Vista.

Start Menu
My Computer
My Pictures
Open Dialog for Images
Control Panel Window

Hop goes the VS Developer [VS.NET IDE for Linux!]

2005-08-07T21:15:00.000+05:00

Many people had been inquiring how they can use their existing .NET skills to develop applications for Linux. Mono was what got people excited but I have seen all the interest and enthusiasm recede as soon as people get a glimpse of how they can go about developing applications using Mono. I believe its primarily because most .NET developers are Windows users and don't have enough Linux skills to get started on Mono.

Enter Grasshoper, the Visual Studio .NET IDE for Linux. You DO NOT actually have to install Linux on your machine to get started; you would still be developing using C# or VB.NET in your VS.NET Development Environment installed on the Windows platform. The download comes bundled with Tomcat and the PostgreSQL 8.0 database. A separate download on the Grasshopper site is LIW or Linux Inside Windows, to allow you to build and test web applications in a Linux virtual environment. Please note that you need to have both, C# and VB.NET installed with your VS.NET 2003 to install Grasshopper. Although J# installation is also required, you can proceed with the installation and install J# support later.

Once installed, Grasshopper would add a VS.NET add-in to the Microsoft Development Environment (MDE), called Visual MainWin. Remember, to create a new project, the Tomcat server would need to be started. All other things remain the same. When you run the project, it would run on the localhost:8080 address as opposed localhost for normal .NET web apps. Additionally, if you right-click a project in the Solution Explorer, the popup menu would have an item 'Generate J2EE Project'.

Now I come to the really cool part; MainSoft Corp, the company that created Grasshopper aims to release a version for Whidbey when VS 2005 is released. Apart from supporting ASP.NET 2.0, the Whidbey version would include Web Parts mapping to Java Specification Request (JSR) 168, Generics, Java Development Kit (JDK) 1.5 Support, and Web Service-Security (WS-Security) + additional WS standards; means all the cool things that were available only to ASP.NET implementations would now be available to J2EE implementations as well. And maybe, just maybe, this could be a good start for J# as non-.NET developers (Java Developers in particular) would be inclined to use Visual MainWin and J# using the VS.NET IDE.

I would recommend .NET developers to try it out NOW! Core.NET and INETA Pakistan would certainly be conducting a UG event on this technology in the coming weeks.

Comparing the Un-Comparable

2005-08-01T16:30:00.000+05:00

A project I was working on required variables of type struct to be stored in an ArrayList. The storing-in-ArrayList part was very easy because any variable that derives from class 'Object' can be stored in a Collection/ArrayList. However, a problem surfaced when I wanted to call the 'Sort' method on the ArrayList to sort all the stored values. Remember, variables of a user-defined type cannot be sorted since there is no pre-defined mechanism to compare 2 variables of that user-defined type. So, if you are ever faced with a similar situation, rest-assured, .NET would never leave you out in the cold.

You would need to implement the IComparable interface in your definition, and define the mechanism for comparison of 2 instances of that type. Visual Studio .NET makes it more easy; as soon as you type the declarator statement for the struct type (preceding the opening de-limiter operator), a tool-tip text would appear saying 'Press TAB to implement stubs for interface System.iComparable'. Press the TAB key and behold; VS.NET would automatically add a 'CompareTo' method that accepts an object as argument and returns an integer. The 'CompareTo' method is where you would define your comparison mechanism, which would subsequently be called when a comparison between variables of that type is to be made. In most cases, the result of a comparison operation is boolean (0 or 1); however, in case you need to know if instance of one variable is greater than-, less than-, or equal to- the another instance, you need three flags or values (-1, 0, and 1); hence the int return type in the 'CompareTo' method. To elaborate, I am including a simple example below:


public struct Length : IComparable
{
 public int Feet;
 public int Inches;

 #region IComparable Members

 public int CompareTo(object obj)
 {
  if (!(obj is Length)) 
   throw new Exception("Cannot compare.");

  Length l = new Length();
  l = (Length)obj;

  if (Feet == l.Feet && Inches == l.Inches)
   return 0;
  else if (Feet > l.Feet)
   return 1;
  else
   return -1;
 }

 #endregion
}

Welcome HP Pavilion!

2005-07-28T14:57:00.000+05:00

Notice any changes ? No ? Well, you can't. Thats because it is I who is blogging today from my brand new HP Pavilion ze2160ea notebook; 1.8 GHz Intel Centrino Processor, 1 GB RAM, 80 GB HDD, a DVD writer alongside a number of other things are making me love every bit of it. Although I had previously been using a Toshiba with a 2.4 GHz Intel P4 Processor with 512 MB RAM and a 40 GB HDD, the new HP takes the cake.

Courtesy, For God's sake !

2005-06-27T17:33:00.000+05:00

Been trying to blog this for quite a while. Today, I finally found the courage to post it.

I love what I do; not just software development, but helping people, listening to their problems patiently, suggesting solutions, and if possible giving them a complete walk thru of how to go about solving a complex problem. All this I do not for the sake of any material rewards, or appreciation, or gratitude, but for the simple reason of inspiring and motivating my fellow countrymen to help others. The satisfaction and inspiration one gets from sharing with others, is something that cannot be described in words. This is what keeps me going. This is what I want to keep doing as long as I physically can.

But lately, people have started to take all this for granted. They feel that assisting anyone and everyone is somehow an obligation for us MVPs (Microsoft Most-Valuable Professionals) and INETA office-bearers. People have completely forgotten that we too have personal lives of our own, that we also have work to do to earn a living (Microsoft does not pay MVPs), we have other engagements too with our families and friends, and we need time for ourselves too, so we expect a little privacy. While sharing and helping is too noble a cause to set aside, and although it does take precedence over what other things we do most of the time, there is absolutely nothing to suggest that we are thinking of becoming MotherTeresa.NET! So, it really angers me when someone calls me at odd timings, or e-mails me asking for something that they take would take credit for from their bosses, or even asks me to visit them because they are facing a problem. I mean, C'mon. Since when does the well go to thirsty instead of the other way around. So, anyone and everyone reading this, I request you to understand our situation, understand that we expect a little privacy, and that we love to share knowledge and ideas, but certainly NOT at a very high cost to us. Hope you understand.

INETA Pakistan @ PDC 2005

2005-06-22T16:05:00.000+05:00

I had to fly to Islamabad the very next day PDC 2005 ended so I couldn't blog about this earlier. I am back in Karachi now, so here goes.

The Pakistan Developer Conference this year, as in 2003 and 2004, was a roaring success. In addition to the great speakers including Rafal Lukawiecki, Stephen Forte, Clemens Vesters, Arvindra Sehmi, and Goksin Bakir (who also happens to be the Regional Head for INETA MEA region), the major difference at PDC 2005 was the Community Lounge, providing delegates with an opportunity to network with professionals, MVPs, and ofcourse the Speakers. For me personally, the experience was unforgettable. I was always accompanied by my 2 trusted comarades, Saqib Ilyas and Hammad Rajjoub. Since Hammad sahab was visiting Karachi from Dubai after almost 3 months, it was great to have him with us. I think INETA Pakistan was really able to reach out to the Pakistani .NET community during the 3 days of the conference. We have been invited to a number of cities in Pakistan, specifically Sukkur, Hyderabad, and Nawabshah. Also, many people in Karachi who did not take INETA Pakistan seriously are now bombarding us with e-mails, inviting us to speak at their venues. And while Saqib sahab, Hammad sahab, and I were running about doing our stuff during the conference, a handful of volunteers from NED University of Engineering and Technology worked tirelessly to talk to people about INETA, the Microsoft MVP Program, and Imagine Cup. I thank you volunteers; Miss Sabrina, Miss Shehzina, Miss Sundaleen, Miss ZumZum, and Miss Preeyaa; all of you did a great job.

The Business Value of Speech

2005-05-10T23:35:00.000+05:00

(My Article for INETA Pakistan Newsletter - Debut Edition)

Imagine being able to speak to your TV set about which channel to tune on what number; or setting the timer on your microwave or the thermostat of your refrigerator using nothing but simple voice commands. As far back as I can remember, all science fiction movies had at least one talking computer that was able to converse intelligently with humans. Many people (myself included) still remember their fascination with ‘Kit’, the talking car in the 80’s hit TV series ‘Knight Rider’.

Although only fiction a decade ago, interaction with computers using Speech has become a reality today that would increasingly affect how we communicate with machines in the years to come. Already, the Microsoft Automotive Initiative, of which speech technology is an intrinsic part, is putting PC’s into cars to allow drivers to give spoken instructions to the onboard computer and look up the nearest gas station or coffee shop and dial phone calls using speech. Fact of the matter is: speech is going to be part of all software applications and devices in some form or the other within a decade. This statement may sound a bit farfetched at the moment, but businesses around the world, even today, are realizing the benefits of Speech applications in their processes and customer relationship management.

To begin with, use of Speech technology is on the rise in contact center deployments to facilitate operators by transferring only those calls to them which require human interaction; the rest of the calls are handled by speech applications, thus increasing operator productivity. In addition, survey results put the cost of handling calls by automated speech applications at only 20 cents per call as opposed to $5 to $10 per call handled by a human operator. From the customer or caller’s view point, with telephony speech applications, callers get an ever-courteous voice ready to be of service; one that would never hang-up on the caller until and unless the call has been serviced. Anybody who has ever had to call any of our utility companies with a complaint or query can very well understand the importance of this.

Industry standards such as SALT (Speech Application Language Tags), SRGS (Speech Recognition Grammar Specification), and SSML (Speech Synthesis Markup Language) are helping to drive speedy adoption of speech in business. The release of Microsoft Speech Server 2004 last year would further pave the way for companies to use existing code-base and infrastructure to deploy speech applications in-house for managing customer relationships, without having to outsource this vital link between them and the outside world to a third party. The death of the call center BPO (business process outsourcing) model, although still far away, is imminent.

So, as developer, decision-maker, or customer, the next time you pick up the phone to talk to your bank, travel agent, stock broker, or even the doctor for an appointment, imagine the possibilities, experience, and swiftness of having a speech application on the other side of the line. My advice at this point is “Speech NOW or forever hold your peace”.

Related Links:
Microsoft Speech Website
Microsoft Automotive Initiative
SALT Forum

Introducing Zindagi XP Professional Edition

2005-05-02T15:02:00.000+05:00

Started a new blog today. Check it out.

Zindagi XP

What's Next: Voice-SQL (pronounced V-Sequel)

2005-04-30T22:50:00.001+05:00

Although nothing of this sort exists at the moment, today I stumbled on the idea of using voice commands to retrieve information from the database. How is this supposed to work? Well, its not about speaking SQL statements and getting the result on display. Its a bit more complex. The idea is to allow people who do not have any idea of SQL to get the information they want by speaking to a V-SQL Query Analyzer, similar to the SQL Query Analyzer in SQL Server. The reason I thought of bringning Speech into this was because of the inherent capabilities of Speech Recognition Grammar Specification (SRGS) and the Microsoft Speech Application SDK (SASDK) to process utterances like 'List all Customers who live in Islamabad' or 'List Customers from Islamabad' in a similar fashion. If the user is simply provided with a textbox to enter commands like the ones I mentioned above, I would be re-inventing the wheel by having to process the text input, when the same can be done by the SASDK Speech Recognition Engine for spoken input. Once the information (or tokens) have been extracted from the voice command, the resulting tokens can be used to generate a simple SQL SELECT statement. The rest is pretty easy. However, all this would require creating a dictionary of commonly used terms/words for database objects, like Customer, Product etc. and then matching the word spoken by the user (from the dictionary) to the Synonym for a database object. I hope I am making sense.

SQL Server is not exactly my core competency. I look forward to asking quite a few questions from Stephen Forte, the SQL Server MVP, who would be visiting to speak at Microsoft PDC 2005. Wish me luck.

Consuming a Web Service with Flash (finally, Thank God)

2005-04-28T03:09:00.000+05:00

(I had promised the attendees at the INETA Pakistan event on "Flash Remoting with .NET" at SSUET that I would blog about this within 2 days, something that I m doing today after 2 weeks; so, my apologies to all of you.)

Can't believe this is so simple. Its even easier than consuming a web service any other way. This is because Flash provides a way to bind values returned by a web service to Flash Components. No coding is required; only a couple of clicks and drags, thats it! This is a great way to develop Flash tickers to display data (possibly Stock Quotes, Currency Exchange Rates, etc.) on a web page without ever needing to refresh it for updated data. So, how to go about doing this? Very simple.

1) Create a Web Service
Create a simple "Hello World" Web Service; one that simply returns the string "Hello World" when invoked. If you develop the Service using Visual Studio .NET, the code for "Hello World" is generated automatically. Run and test the Web Service in your web browser. Copy the URL for your Web Service Description or WSDL document i.e. if the URL for your web service is "http://localhost/FlashRemoting/HelloWorld.asmx", then you can access its service description at "http://localhost/FlashRemoting/HelloWorld.asmx?WSDL".

Run Macromedia Flash MX 2004 Professional, and create a new Flash document.

2) Link the Flash Movie to the Web Service
Open the "Web Services" panel by going to Window > Development Panels > Web Services. Click the globe icon on the panel; a small window will appear. Click the "+" Add button on the window, and enter the URL you copied for the WSDL document in step 1. (This will not work if you simply enter the URL for your web service; it MUST be the URL for the WSDL document). When you click the OK button, you will see that the Web Service has been added to the list in the Web Services panel. Expand the "[Your Web Service Name]" Node in the panel and right-click the method you want to call. From the pop-up menu, click "Add Method Call". (An instance of the Web Service Connector component would be added to the stage).

3) Place Flash UI Components on the stage
Go to Window > Development Panels > Components, and drag a "Label" and "Button" control on to the main Flash movie stage.

4) Name all the Component Instances on the stage
Name all 3 component instances on the stage, the Label, the Button, and the WebServiceConnector component from the "Properties" panel.

5) Bind Web Service Result to the UI Component
In order to display the string returned from the web service, you need to bind the result to the Label component you placed on the stage. Go to Window > Development Panels > Component Inspector. Select the Label component on the stage and go to the "Bindings" tab on the "Component Inspector" window. Click the "+" Add Binding button. Select "text : String" from the list and click the OK button. Now that you have specified the UI component property to bind to, you now need to specify the Data Source that would provide the value to display in the Label component. Select the "bound to" item in the Key-Value list on the "Bindings" tab, and then click the Magnifying Glass icon (The "Bound To" window will appear). From the "Component Path" list on the left, select the "WebServiceConnector <[Your Web Service Name]>" node, select "result : String" from the "Schema Location" list on the right, and click the OK button.

6) Add Behavior to Invoke/Trigger the Web Service
To invoke the web service, you need to add a behavior to the button. Go to Window > Development Panels > Behaviors. Select the Button component on the stage and on the "Behaviors" panel, click the "+" Add Behavior button. On the context menu, go to Data > Trigger Data Source (The "Trigger Data Source" window will appear). Select the "[Your Web Service Name]" node and click the OK button.

7) Run the Flash Movie
Press Ctrl+Enter to compile and run the Flash movie. When you click the button, the web service will be invoked and the returned text will appear in the Label component.

Thats It! I told you it was very easy.
Look Mom ! No Code. :)

Dhoop Kinaray and .NET Flash Remoting

2005-04-14T00:58:00.000+05:00

Raat yoon dil mein teree
Khowee howee yaad aaey,
Jaisay weraanay mein chupkay say bahaar aa jaaey,
Jaisay sehraaoon mein holay say chalay baad-e-naseem,
Jaisay beemaar ko bay-wajah qaraar aa jaaeey.

The one-minute long title song for "Dhoop Kinaray", a hit TV serial in the 80's by Haseena Moin on Pakistan Television and sung by Nayyara Noor. After searching for it for 17 years, I finally managed to get my hands on it. Have already listened to it countless times today (listening to it still); copied it to the Nomad MP3 Player (sent by Microsoft as a gift for becoming an MVP), to listen to it even while on the road; I am happy. (This song should have been an hour long).

There would be an INETA Pakistan event at SSUET on Saturday, and I have to deliver a lecture on "Flash Remoting using .NET". So, after procrastinating for 2 months, I am finally blogging it.

Flash Remoting is a way for creating Macromedia Flash UI's that communicate with business logic developed using .NET, Java, or ColdFusion. I have mentioned this in a previous blog too; the great thing about developing Web Applications with a Flash GUI is the page does not have to reload after a postback, thus limiting the data transferred to and from the server. Once a Flash movie has loaded into the web browser, the UI does not re-load when some new data is retrieved from the server/database. Apart for the speed, a Flash UI also provides a rich user experience. Even images can be dynamically loaded into the Flash movie at runtime, and masks can be applied to them without re-creating those images as would typically be required if the GUI comprised of HTML pages. In addition, Flash GUI's can be used in 4 ways; by communicating with an ASP.NET web form page, by consuming an XML Web Service, by communicating with a .NET assembly, and by retrieveing data from an ADO.NET DataSet.

There are many code samples available on the internet to demonstrate how to connect a Flash GUI to back-end server logic, so there really is no point in getting into all that now. However, I have been bombarded by the same questions about Flash Remoting again and again, from people who were unable to run those code samples. Ok then, lets start.

Download and Install Flash Remoting Components
When first starting out with Flash Remoting, download the Flash Remoting components from the Macromedia Flash Remoting site. Be sure to check which Flash version you are using; Flash MX or Flash MX 2004, and download components accordingly. Run and install the downloaded file. You will be able to see the Flash Remoting classes in the ActionScript panel once the components have been installed.

Add a reference to flashgateway.dll
First of all, add a reference to the flashgateway.dll file (If you can't find the flashgateway assembly, download a sample application from the macromedia site; that would hopefully contain the flashgateway.dll file).

Add the flashgateway.dll registration to the web.config file
The main reason most people are unable to run remoting samples is they dont perform this task. DO NOT FORGET TO COPY THE FOLLOWING INTO YOUR WEB.CONFIG FILE, OTHERWISE DON'T E-MAIL ME.


  <httpModules>
  <add name="GatewayController"
       type="FlashGateway.Controller.GatewayController,flashgateway" />
  </httpModules>

Create a Web Form page for the Flash UI to communicate with
Create a web form page in Visual Studio.NET; lets call it MyWebPage.aspx and place the page class in the MyApp.FlashRemoting Namespace (You can use your own names for the web page and class but I have used the names for reasons of clarity). The code for the web page and page-class in the code-behind file would look like this:

MyWebPage.aspx


<%@ Register TagPrefix="Macromedia" Namespace="FlashGateway" 
   Assembly="flashgateway" %>
<%@ Page language="c#" Codebehind="MyWebPage.aspx.cs" 
  AutoEventWireup="false" Inherits="MyApp.FlashRemoting.myWebPage" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
 <HEAD>
  <title>FlashUI_Page</title>
 </HEAD>
 <body>
  <form method="post" runat="server">
   <Macromedia:Flash ID="Flash" runat="server" />
  </form>
 </body>
</HTML>

MyWebPage.aspx.cs


namespace MyApp.FlashRemoting
{
 public class MyWebPage : System.Web.UI.Page
 {
  protected FlashGateway.Flash Flash;
 
  private void Page_Load(object sender, System.EventArgs e)
  {
   if (Flash.Params.Count == 0) 
   { 
     throw new Exception("No arguments received."); 
   }

   string myString;
   myString = "Hello ";
   myString += Flash.Params[0].ToString(); 
   myString += " !!!";
   Flash.Result = myString;
  }

  /% ----------------------------------
  //  Web Form Designer generated code
  %/ ----------------------------------
 }
}

Create the gateway.aspx file
Create an empty *.aspx file in your ASP.NET project, remove the markup, and even the Page directive from the page, and name it gateway.aspx. REMEMBER, the gateway.aspx file should be in the directory in which you created MyWebPage.aspx above.

Specify the Classpath in Macromedia Flash Environment
Forgetting to perform this is the second most common mistake people make. Firstly, if you are using Macromedia Flash MX 2004, you have to use the import statement as opposed to the #include statement, as you can see from the ActionScript code in the next step. Keep one thing in mind. Namespaces in ActionScript are not logical hierarchical names as in .NET languages. Instead, ActionScript namespaces reflect the hierarchical directory structure. So, the following import statement represents the NetServices.as file in the remoting sub-directory in the mx directory. But where is the mx directory located? Well, its in the directory you specified in the class-path panel. On the top menu, go to Edit > Preferences, and click the ActionScipt 2.0 Settings button in the ActionScript tab. Locate directory where you unzipped the Flash remoting component files you downloaded from the Macromedia website, click the '+' button on the Class-Path Panel and enter that path for that directory. There you go; now every time you enter the following import statement, Flash would look it up in classpath you specified.

import mx.remoting.NetServices

Write ActionScript code in Flash
Type the following ActionScript code on Frame 1 of the main timeline of your Flash movie. (Code lines have been numbered)


 1: import mx.remoting.NetServices
 2: 
 3: if (inited == null)
 4: {
 5:  inited = true;
 6:  
 7:  NetServices.setDefaultGatewayUrl("http://localhost/MyApp/gateway.aspx");
 8:  var gatewayConnection = NetServices.createGatewayConnection();
 9:  var aspxService = gatewayConnection.getService("MyApp.FlashRemoting", this);
10: }
11: 
12: function MyWebPage( name )
13: {
14:  if( (name != null) && (name != "") )
15:  {
16:   aspxService.MyWebPage ( name );
17:  }
18: }
19: 
20: function MyWebPage_Result( result ) 
21: {
22:  if( txtResult == undefined )
23:  {
24:      _root.createTextField( "txtResult", 100, 5.7, 87, 160, 18 );
25:  }
26:  txtResult.text = result;
27:  txtResult.autoSize = true;
28: }
29: 
30: function MyWebPage_Status( error )
31: {
32:  trace( error.code );
33:  trace( error.description );
34:  trace( error.details );
35: }

NOTE:Be sure to correctly specify the URL of your gateway.aspx on Line 7. Also, On Line 9, specify the Namespace of the page-class in your web page's code-behind file. ALL the methods must be named after your Web Form page i.e. MyWebPage. That is how Flash knows which ASP.NET web form to communicate with.

Create a button to call the Method
Lastly, create a button on the stage. The on event handler for the button shoulw look like this.


on (release) 
{
 // call the method named after your web page
 MyWebPage("Dhoop Kinaray");
}

This has been a very long post. I just CAN'T seem to get enough of this song. Looks like I will be listening to it throughout the night.

Effective VUI Design + SRGS

2005-04-11T00:41:00.000+05:00

System: Welcome to FoodTalks.NET Food Ordering service. Please say your Customer Account Number?

Caller: The account number is FT1234.

System: Please say or key-in your 5 digit code number.

Caller: 78699

System: Thank you; Would you like to place a new order or would you prefer a repeat of your previous order.

Caller: I think I will go for a new order.

System: Very well. Please say the meal ID on the FoodTalks.NET menu card that you would like to order.

Caller: Ummmm...Meal ID 786.

System: I understood Meal ID 786. Is that correct?

Caller: Yes, that is correct.

System: Would you like any thing else?

Caller: No thanks, that will do for now.

System: Your meal cost has been deducted from your account. Your meal will be delivered to your address in 15 minutes. Thank you for calling FoodTalks.NET; We look forward to serving you again. Good bye.

The above is a typical interaction between a caller and a Speech-enabled Voice-only (telephony) FoodTalks.NET (fictitious restaurant) application. For clarity, the utterances have been numbered. Little does one realize that they are talking to a machine and not a real-life human operator. Although the above example also goes to show a good VUI (Voice User Interface) design practice, what I wanted to demonstrate here is the use of the Speech Recognition Grammar Specification (SRGS). Lets look at the above call closely by understanding the utterances by both, the System and Caller, and looking at the underlined words in the utterances by the caller.

When the call is connected, the music allows the caller to know that he is hearing a recorded message so there really is no need for the message to explicitly say that the caller is talking to an automated system. Also, instead of saying "What is your Customer Account Number?" which would confuse the caller whether she has to dial the Account Number or say it, the system clearly asked the caller to SAY the Customer Account Number (Utterance 1).

The underlined words in the Caller utterances above represent 'tokens'. A Token is that part of an utterance which is of use to the system; the rest of the uttered words are ignored. For example, in Utterance 2, the caller could have said 'My account number is FT1234', 'My customer account number is FT1234', 'The Customer account number is FT1234', 'Customer account number is FT1234' or simple 'FT1234' instead of 'The account number is FT1234'. In each case, only the Customer Account Number i.e. FT1234 is to be used by the application to validate the caller. However, in order for the system to process any of the utterances by a caller, a Grammar has to be pre-defined to allow the system to extract the token from an utterance and generate a value from the processed voice input. The Grammar is defined using the Speech Recognition Grammar Specification or SRGS (which I would blog about in detail later). In short, SRGS is an XML specification that allows Speech Application Developers to create Grammars rules in a Grammar (*.grxml) file. One grammar file can contain multiple validation rules. The Grammar file is then processed in the browser by SALT's prompt tag to process a spoken utterance by a user. For example, the grammer to process Utterance 2 would be something like this:


<rule id="AccountNumber" scope="public">
  <item repeat="0-1">
    <?MS_Grammar_Editor GroupWrap?>
      <one-of>
        <item>The Customer Account Number is</item>
        <item>The Account Number is</item>
        <item>My Customer Account Number is</item>
        <item>My Account Number is</item>
        <item>Customer Account Number is</item>
        <item>Account Number is</item>
     </one-of>
  </item>
  <item>F. T.</item>
  <ruleref uri="Library.grxml#Digit4" type="application/srgs+xml"/>
</rule>

The repeat="0-1" attribute represents that the item is optional and may or may not occur. The ruleref tag specifies that another rule for a 4-digit number in a seperate grammar file (Library.grxml) is being accessed.

OK, thats it for me. My meal (Meal ID 786) would be here soon. :)

Microsoft's Most Valuable Professional (MVP)

2005-04-03T03:34:00.000+05:00

Its been 2 weeks since I first got word that I am one of the 3 receipients (from Pakistan) of Microsoft's Most Valuable Professional (MVP) award for 2005 along with my 2 comarades, Mr. Saqib Ilyas and Mr. Hammad Rajjoub. Today, it was made official when I received an e-mail from Microsoft. It took 2 years; I am finally there.

Check out my MVP Profile.

FoodTalks.NET + A simple Business Tip

2005-03-31T02:33:00.000+05:00

Had a meeting with a famous restaurant chain owner who wanted to get an application developed from scratch and replace his existing touch-system Point-of-Sale (POS) system with a (Multi-modal) POS Speech Application. He needed a demo to see first-hand how Speech works in a business environment. So I've started working on a new demo which I have chosen to call "FoodTalks.NET". This application would, for the first time ever, also include the logo for Voicability, my latest business venture.

Business Tip: Demos have been instrumental in securing software projects. So a good demo is not sufficient; you need to come up with a GREAT demo; one that does not satisfy the customers, but delights them. So take your time when you are developing a sample or demo application and pay special attention to the GUI, since it would largely impact and influence the customer's decision-making within the first 5 minutes of your demonstration meeting. An attractive GUI is of paramount importance.

FlightEnquiry.NET

2005-03-29T02:32:00.000+05:00

FlightEnquiry.NET is a small ASP.NET project that demonstrates best practices for accessing data stored in SQL Server 2000 by means of the Microsoft Data Access Application Block. The project was actually developed to showcase the Mcrosoft Speech Application SDK (SASDK) by showing ease-of-use of the SASDK (at the Microsoft ISV Community Days at Karachi and Lahore on March 18 and March 19, 2005 respectively), by speech-enabling the FlightEnquiry.NET application.

My laptop started functioning again (thanks to my brother) I have uploaded the FlightEnquiry.NET source code to the core.net User Group site on Yahoo.

Stay tuned !

2005-03-28T15:24:00.000+05:00

My laptop suddenly decided to stop working when I returned from Islamabad. So I haven't been able to upload the code for the FlightEnquiry.NET application I demonstrated at the Microsoft ISV Community Days event and at the AIOU seminar. Will do so as soon my notebook becomes functional.

To my Enemy...

2005-03-28T02:24:00.000+05:00

(The following is a poem I wrote back in 2000; I am yet to have my vengence.)

There will be another time.
There will be another battle.
You'll meet your doom
and suffer the pain,
you'll bear the scars
when I'm through with you.
There will be triumph,
and there will be glory,
but all for me
and none for you,
for I will strike
and you will perish.
There will be a funeral.
There will be a grave,
Beneath it you would rot.
Above, I would rejoice.
Not one soul would mourn,
beside your decaying corpse.
There will be a consequence.
There will be a fatality.
Suffer you will, suffer you must.
Hail my words friend my foe,
'There will be another time,
and there will be another battle.'

Karachi, Lahore, Islamabad :: INETA Rules !

2005-03-24T23:42:00.000+05:00

Had a fun-filled week that took me from Karachi, passing through Lahore, all the way to Islamabad. The reason, Microsoft ISV Community Days. After conducting a session on "Microsoft Speech Application SDK" at Sheraton Karachi on March 18, proceeded to Lahore alongside Mr. Saqib Ilyas, and conducted the same session at the Lahore University of Management Sciences (LUMS) on March 19. Went on to Islamabad from there. An INETA seminar was arranged in a hurry on March 24 at Allama Iqbal Open University (AIOU) comprising 2 sessions; "Introduction to INETA and the Microsoft .NET Framework" and "Developing Speech Applications in .NET". INETA Pakistan has already had a strong presence at Karachi. Now, Islamabad is on fire !

Speech RAD with a pinch of SALT

2005-02-20T15:06:00.000+05:00

VBSALT, a Rapid Application Development (RAD) environment from Pronexus (Microsoft Speech Partner), is a Visual Studio .NET Add-in that allows rapid development of Speech applications for the Microsoft Speech Server (MSS), making full use of components provided by the Speech Application SDK (SASDK). The name "VBSALT" may be a bit misleading at times because application code can be generated for both, VB.NET and C# applications. The company probably used "VB" in the name since VBSALT is the .NET version of "VBVoice", a Speech RAD tool for Visual Basic (classic).

VBSALT lets IT Managers, programmers, and Call Center developers define call-flow and swiftly generate SALT-side portion of their Speech apps, thus enabling them to concentrate on the business logic. The steps involved in developing an app using VBSALT are:

Planning the System
Creating the Call Flow Diagram and Setting Properties
Creating Grammars
Creating and Configuring Greetings
Testing the System

VBSALT also comes with a couple of pre-recorded greeting prompts. Call-flows can easily be defined using drag-and-drop components, which are subsequently linked together to build a visual flow-chart of call-flow logic. Grammars can be developed either using the Grammar builder provided by the SASDK or using the VBSALT VoiceForm wizard, although I think the former one is much better. Come to think of it, people had been developing Grammars by simply typing in notepad before the SASDK arrived. For now, Life is Good !

Enter KOMaL v1.0

2005-02-10T21:22:00.000+05:00

I was trying to develop an Adaptive Learning System back in 2000 and came up with an idea of Developing a GUIML (Graphic User Interface Markup Language), but the only issue was the development of a Runtime to parse and generate the GUI in real time. Luckily, Microsoft solved that problem (even though much later) by launching XAML (eXtensible Application Markup Language). I stumbled on SCORM (Sharable Content Object Reference Model) during that time too. There are a number of underlying problems with SCORM, something I would blog later.

KOMaL (Knowledge Object Modeling Language) is something I have been trying to develop for the past 2 years (but my schedule wouldn't let me). Anyway, I finally came with the following small description for KOMaL which I would refine further as I discover new tools and technologies.

The Internet is an almost-limitless resource of Information which exists in the form of web pages, followed by images, pdf files etc. However, web pages provide the only means for hosting information, each one having a URL, and acessible only through a web browser which renders the HTML in the page to display the content. Looking up or searching for information on a particular topic involves knowing the exact URL or by using a search engine where searches can only be made for a keyword.

Currently, the global directory of domain names maintained by InterNIC has no means of indentifying the type of content hosted at a particular domain name. In most cases, a user does not necessarily get to the exact information she requires since a search usually turns up thousands of results and it is impossible to look each one up. Since web pages are composed of textual information contained within markup, the only way the content of that page can be characterized is by making a search on the terms and keywords in it. Usually, the meta tag is used to explicitly add keywords to a web page so they may be picked up by a spider or web-crawler.

With the advent of computers decades ago, the word "data" was adopted and used in connection with the textual and numerical facts and figues used in electronic data processing. With the proliferation of Internet a little more than a decade ago, the word "Information Technology" with emphasis on "Information" became widely used. The focus now has shifted to the word "knowledge" which primarily refers to the Information that is of particular use to an individual or organization. True, vast information is available on the internet; however, the internet failed to become a source of knowledge i.e. the most relevant and meaningful information for an individual or enterprise. In order to allow information to be represented as knowledge, changes in the existing internet architecture or infrastructure is not a possible option. The need is to come up with a new architecture that can run parallel to the existing system, is sharable, and can enable a more thorough representation of knowledge and its search mechanisms.

Finally, I have also found a couple of energetic students at SSUET to undertake this project. Wish 'em all the best.

Taking TTS to a new level

2005-02-05T15:50:00.000+05:00

I have been helping a couple of students from Jinnah University for Women develop a natural sounding Urdu TTS (Text-to-Speech) Engine. An Urdu TTS is absolutely essential if Urdu Speech Applications are to be proliferated in Pakistan. The possibilites for Urdu Speech applications here are endless for all Banks, Brokerage Houses, Call Centres, Restaurants etc., which can only be achieved with development of Urdu Speech Recognition and TTS apps.

I mentioned the real-sounding SpeechWorks/ScanSoft TTS in one of my previous blogs. But one TTS I came across with actually took my breath away. It not only gives voice output (as most TTS engines do) but also provides a human character developed in Flash to speak the voice output. Brilliant work, and can prove very effective in teaching applications. Check it out at http://www.sitepal.com

A Decade of Change

2005-02-02T22:29:00.000+05:00

It would be 10 years since the release of Windows 1995 this year, an event that triggered the wide-spread use of computers, specially by home users, thus realizing Bill Gates' dream of "a PC in every American household". This got me thinking about so many things that happened a decade ago. For the people of my generation, or rather my age-group, this would be the first time in our lives that we would clearly be able to recall things that happened a decade ago, because before now, it was difficult (or impossible) to recall decade-old things since it would take us to a time we weren't old enough to remember or process as much information. My moving to Pakistan from abroad, my first experience with software programming, an aunt's wedding, my first crush :), all happened a decade ago, in a world that has undergone tremendous transformation and yet so much still remains. Pretty soon, it would be a decade since the release of .NET, or even Visual Studio .NET Whidbey. So, here's to a decade of across the World progress, if not prosperity.

INETA Pakistan Event at NED

2005-01-15T23:20:00.000+05:00

Had a joint speaking session with Mr. Hammad Rajjoub at NED Audio-Visual Lab; the topic: "Data Access Patterns". The session was great, although the lesser than expected turnout was a turn-off. Anyway, at the end of the event, Mr. Hammad was presented with 2 DVDs: "Windows 2003 Server (Trial)" and "We Rock 24/7.NET" (both of which I ended up snatching after we got out of the hall), while I was presented with the book "Writing Secure Code" by Michael Howard & David LeBlanc. Great Book ! Read the first 2 chapters and am hooked to it.

Debugging a Windows Service (at KFC)

2005-01-14T23:55:00.000+05:00

Had a nice Zinger Dinner at KFC, Gulshan-e-Iqbal with Mr. Saqib Ilyas (INETA Pakistan Country Leader) and Mr. Hammad Rajjoub. Discussion Points: INETA Activities, INETA Event at NED the next day, and MSMQ + Windows Services.

I had spent the past 3 days trying to figure out why a Windows Service I had developed wasn't performing the task I expected it to, and since I couldn't figure out a way to debug a Windows Service, Mr Hammad (who also happens to be my Guru) was the one person I knew I could count on. :)

Windows Services are primarily background processes that keep running while you are free to do something else. If you want to perform a task that takes a lot of time in ASP.NET, a Windows Service is the best choice, since the ASP.NET page that initiated the (long running) process would probably timeout before the process ends. The ASP.NET page does not initiate or communicate directly with the Windows Service. It sends/places one or more Messages in a Queue (Microsoft Message Queueing) which is/are subsequently read by the Windows Service and the task is initiated.

Anyway, if you try to run or debug a Windows Service in Visual Studio.NET, the "Cannot start service from the command line or a debugger. A Windows Service must first be installed (using installutil.exe) and then started with the ServerExplorer, Windows Services Administrative tool or the NET START command." message would appear (and for good reason too). As I mentioned before, Windows Services are applications that run in the background and cannot be run like other applications. Also, you cannot catch and display Exceptions in a Windows Service as you would in a typical Windows or Web App. In order to run a Windows Service, do the following:

1) Build your Windows Service Project in VS.NET to generate its exe.

2) Run the Visual Studio.NET 2003 Command Prompt; OR On the DOS prompt, go to C:\WINDOWS\Microsoft.NET\Framework\v1.1.4322 (Directory path may vary).

3) Use the following command to run your Windows Service. (Subsitute the items in [...] according to your local app.)

installutil C:\[YourAppPath]\[AppName]\[Debug Release]\[AppName].exe

You can view your Service running by Navigating to Start > Control Panel > Administrative Tools > Services.

To start your Service, right-click it and select Start from the context menu. Thats it !
So, How do you Debug a Windows Service? Very Simple.

a) Insert a breakpoint in your Windows Service app in VS.NET.

b) Build and run your service using Steps 1 to 3 above.

c) Select "Processes..." from the "Debug" Menu at the top. (The Processes Window would appear)

d) Locate your service in the list. (It would appear with the name you gave to the Service Project, NOT the one you specified in its property sheet.)

e) Click you Service in the list and click the "Attach" button.

To uninstall/unload the Windows Service, use the following command at the DOS prompt.

installutil /u C:\[YourAppPath]\[AppName]\[Debug Release]\[AppName].exe

As it turned out, my Windows Service wasn't running becoz I had used a "\" (backslash) in a value (without the escape character) that had been read from a config file. The 3 of us sat there glued to my laptop's screen, although I was distracted by the young ladies on the other table. :) Fortunatly for me, Hammad my man was there to save the day.

ActionScript 2.0

2005-01-12T01:46:00.000+05:00

Had a chance to go through a lot of Flash Remoting applications. None of them seemed to work. After searching for a while, I realized that all the sample applications that exist on the web were developed in Flash MX using ActionScript 1.0 which was completely based on JavaScript; while I was trying to run them on Flash MX 2004 which uses ActionScript 2.0. You can immediately tell whether the code is in ActionScript 1.0 or 2.0 simply by looking at the very first line on the code.

ActionScript 1.0 uses a C/C++ resembling syntax for the include directive for including .as files to the code, like
#include "NetServices.as";

Whereas ActionScript 2.0 uses C#-resembling syntax as

import mx.remoting.NetServices // Use without the semi-colon

Also, you could not define variable type in a declaration statement in ActionScript 1.0 just like JavaScript and objects had to be explicitly instantiated in a variable to give it a type which could be changed at a later time in the program. For example

var s; // Declaration
s = new String(); // Object Instantiation
/*
... some code ...
*/
s = new Number(); // Yes, this was possible !

Now, with ActionScript 2.0, you can specify type in the declaration statement.

var s:String;
Or
var n:Number;

NOTE: Don't waste time trying to run ActionScript 1.0 code on Flash MX 2004. For more information on Flash Remoting with ActionScript 2.0, go to

http://www.person13.com/flashremoting/

Flash Remoting :: A New GUI Design Paradigm

2005-01-09T22:14:00.000+05:00

ASP.NET, I believe, is the best Web Application technology to-date. Not only does it drastically cut down the development time, but it also enables developers to create re-usable ASP.NET Server components.

However, as with every other Web Application development technology, the emphasis is on the generation of HTML that would be sent to the web browser. Each and every ASP.NET Server control needs to generate some HMTL code that would allow it to be visible when the page is rendered. This holds true even for web apps communicating with XML web services. The bottomline is, HTML is needed to format and display any information that needs to be displayed, and for every postback that occurs on a typical web page, a lot of unchanged HTML is again loaded into the browser.

Enter Flash Remoting Component for .NET. This component would completely change how GUIs are developed for Web Applications in future by allowing Flash movies loaded into the browser only once to communicate with .NET Assemblies and web services without having to load again when information needs to be sent back to the page (postback). Also, in contrast with ASP.NET Server components where the developer has to think about style (GUI) as well as behavior (functionaliy), Flash Components require less attention in terms of the GUI and developers can focus more on the behavior. Recent examples include the GUI of www.myWallop.com where the whole application is Flash-based as opposed to the typical HTML web pages we are accustomed to seeing.

Speech Works TTS

2005-01-06T16:49:00.000+05:00

Speech Works (http://www.SpeechWorks.com) has been Microsoft 's development partner for MS Speech Server 2004, mainly providing their Text-to-Speech (TTS) engine to the SDK, and have recently merged with ScanSoft.

Their TTS, known as RealSpeak, is excellent. In addition to supporting multiple languages, it provides very natural sounding Speech in American, British, Australian, and Indian accents. They also have a web-based demo app. Check it out !

http://www.scansoft.com/realspeak/solo/

SCONEST 2004 :: JUW

2004-12-29T13:39:00.000+05:00

Just came back from the Inaugural session of IEEE SCONEST 2004 at Jinnah University for Women. Can't seem to understand something...Why is it that the most foolish of people ends up being the IT Minister of Sindh?

Microsoft Data Access Application Block

2004-12-28T21:28:00.000+05:00

The Data Access Application Block v2 is good and provides reusable and efficient code to retrieve and update info into the SQL Server Database, and comprises of 2 classes; SQLHelper, and SQLHelperParameterCache. However, I noticed that the code was a bit hard to understand and the code comments weren't very helpful either, so I m re-writing the whole class and hope to present it in my speech on "Data Access Patterns" at PAF KIET on December 30.

Back to Work...

INETA Seminar at NED :: Project Ideas

2004-12-24T15:02:00.000+05:00

Had a chance to give a speech to NED final year students today about the Projects they should be working on. The Seminar went GREAT; the students were very ambitious (reminded me of myself when I as at that stage) but had a few apprehensions whether they would be able to get through with the limited hands-on experience they have of .NET etc.

All in all, the seminar gave a good idea of where to start from and they left the lecture hall knowing that INETA Pakistan was there for them.

Islamabad, Here I come !

2004-12-23T22:01:00.000+05:00

Rapping things up aroung here. Shifted some stuff out of my office. Took the Company's large sign off from the building. No stopping me now. Final Destination: Islamabad (Hopefully for ever).

Pakistan's Public Sector catching up

2004-11-24T21:22:00.000+05:00

Had a chance to go and observe first-hand the working of Sui Southern Gas Company, a large Public sector utility company of Pakistan, and I must say, it was comparable to any Public sector organization around the world. Much had been done to make the organization's working more efficient. Since I was there as a consultant, I was supposed to observe their bidding procedures and suggest how improvements could be made. They wanted to have a "Bid Ticker" (a name I suggested) developed to display the bids' information to the Vendors/Bidders as and when they were opened (Bids were submitted in writing and/or through the Internet). Naturally, I immediately suggested that in addition to only displaying the information, it would be great to have the bids announced by the computer, and a couple of demos later, they agreed. Got the Project !

Back in Karachi

2004-11-21T13:47:00.000+05:00

Good to be back in Karachi after 2 weeks in Islamabad and Lahore. Spent the last days of Ramadan in Islamabad, and spent Eid in Lahore. Loved every bit of it !

Walking, Talking Microsoft Agents

2004-11-07T01:15:00.000+05:00

Just downloaded the Microsoft Agent Linguistic Information Sound Editing Tool (6.2 MB exe) from http://www.microsoft.com/products/msagent/downloads/developer.asp which, simply stated, allows developers to generate the lip movement for the voice that you record into it. This is mainly to make Miscrosoft Agents talk (using speech) and make them sound more natural. Currently, the ones that pop-out in MS Office application don't talk. On the same page, is also a link to download the Microsoft Agent Character Editor, so you can develop (or edit) you own cute, and not so cute, Agents.

This blends well with my own project for developing technologies to enable children learn better and smarter. More on that later.

Not a Speech-specific blog

2004-11-04T19:19:00.000+05:00

Welcome,

Although we would be discussing Speech Technologies for the most part, this is not a Speech-specific blog. Hope you can make the most of it.