Web Form Page Processing

In general, the life cycle for a Web Forms page is similar to that of any Web process that runs on the server. Certain characteristics of Web processing — information passed via HTTP protocol, the stateless nature of Web pages, and so on — apply to Web Forms pages just as they do to most Web applications.However, the ASP.NET page framework performs many Web application services for you. For example, the ASP.NET page framework captures information posted with the Web Forms page, extracts the relevant values, and makes the information accessible via object properties.It is important to understand the sequence of events that occurs when a Web Forms page is processed. This knowledge will help you program your Web Forms pages and Web applications more effectively.

The Life Cycle of a Web Forms Page

You might find it helpful to understand some fundamental characteristics of how Web Forms pages work in Web applications before you examine the details of what goes on inside a page when it is processed.

Round Trips

One of the most important things to understand is the division of labor in a Web Forms page. The browser presents the user with a form, and the user interacts with the form, causing the form to post back to the server. However, since all processing that interacts with server components must occur on the server, this means that for each action that requires processing, the form must be posted to the server, processed, and returned to the browser. This sequence of events is referred to as a round trip.

Note   You can create client script in Web Forms, which is useful for user input validation and for some types of UI programming. Client script does not interact with server components.Imagine a business scenario: A user enters an order and you want to confirm sufficient inventory for the order, so your application posts the page to the server at an appropriate point in the user’s order-entry process. A server process examines the order, performs an inventory lookup, perhaps takes some action defined in business logic (such as modifying the page to indicate an error), and then returns the page to the browser for the user to continue.

Round Trip

 

In Web Forms, most user actions — such as clicking a button — result in a round trip. For that reason, the events available in ASP.NET server controls are usually limited to click-type events. Most server controls expose a click event, one that requires an explicit user gesture. By the same token, server controls do not expose high-frequency events such as onmouseover, because each time such an event is raised, another round trip to the server would occur, which would considerably affect response time in the form.

Recreating the Page (View State and State Management)

In any Web scenario, pages are recreated with every round trip. As soon as the server finishes processing and sending the page to the browser, it discards the page information. By freeing server resources after each request, a Web application can scale to support hundreds or thousands of simultaneous users. The next time the page is posted, the server starts over in creating and processing it, and for this reason, Web pages are said to be stateless — the values of a page’s variables and controls are not preserved on the server.Note   The server can be configured to cache page information to optimize the pages, but for purposes of application programming, it is clearest to think of them as being disposed of as soon as the server has finished processing them.In a traditional Web application, the only information that the server has about a form is the information that the user has added to the controls on the form, because that information is sent to the server when the form is posted. Other information, such as variable values and property settings, is discarded.ASP.NET works around these limitations in the following ways:

·                     It saves page and control properties between round trips. This is referred to as saving the view state of the control.

·                     It provides state management facilities so you can save your own variable and application-specific or session-specific information between round trips.

·                     It can detect when a form is requested for the first time versus when the form is posted, which allows you to program accordingly. You may want a different behavior during a page postback versus an initial request.

 Benefits of an Event-Driven Model versus a Linear Processing Model

If you have experience using Active Server Pages (ASP), you recognize that ASP is a linear processing model. An ASP page is processed in a top-to-bottom sequence. Each line of ASP code and static HTML is processed in sequence as it appears in the file. User actions cause the page to be posted to the server in a round trip. Since this action causes a round trip, the server must recreate the page. After the page is recreated, it is processed in the same top-to-bottom sequence as before, and therefore the page is not exhibiting truly event-driven behavior. To create an event-driven experience, you need to explicitly design it. In addition, you have to explicitly maintain page and control state at the most basic level. This model limits the richness of the user interfaces that can be assembled, and it increases the complexity of the code needed to support it.In comparison, an event-driven model, as in a traditional Visual Basic application, contains programmable elements that are initialized and displayed on the form. Users interact with the elements, which cause events to be raised that in turn call event handlers. This model supports true event-driven behavior, which, by design, greatly extends the richness of the user interfaces that can be assembled, and it reduces the complexity of the code needed to support it. ASP.NET replaces the linear processing model of ASP by emulating the behavior of an event-driven model. The ASP.NET page framework is provided to implicitly make the associations of an event to an event handler for you. Using the page framework allows you to easily create a user interface that reacts to user actions.In addition, this same framework eases the implementation of page and control state management. For example, ASP.NET allows you to set up event handlers in server code for events that are passed from the browser. Assume the user is interacting with a Web Forms page that contains one button server control. The user clicks the button control and an event is raised that is transmitted via an HTTP post to the server where the ASP.NET page framework interprets the posted information and associates the raised event with an appropriate event handler. This event handler can be a default handler supplied by ASP.NET or it can be your custom implementation. The framework automatically calls the appropriate event handler for the button as part of the framework’s normal processing. As a result, you no longer need to explicitly design event-like behavior into a linear processing model. 

 Stages in Web Forms Processing

The ASP.NET page framework processes Web Forms pages in distinct stages. During each stage of Web Forms processing, events may be raised, and any event handler that corresponds to the event runs. These methods provide you with entry points — hooks — that allow you to update the contents of the Web Forms page.The table below lists the most common stages of page processing, the events raised when they occur, and typical uses at each stage. These stages are repeated each time the form is requested or posted. The Page.IsPostBack property allows you to test whether the page is being processed for the first time.

Note   There are several more stages of Web Forms page processing than are listed in the following table. However, they are not used for most page processing scenarios. Instead, they are primarily used by server controls on the Web Forms page to initialize and render themselves. If you intend to write your own ASP.NET server controls, you need to understand more about these stages.  

Stage	Meaning	Typical uses
ASP.NET Page Framework Initialization	The page’s Page_Init event is raised, and the page and control view state are restored.	During this event, the ASP.NET page framework restores the control properties and postback data.
User Code Initialization	The page’s Page_Load event is raised.	Read and restore values stored previously: ·                     Using the Page.IsPostBack property, check whether this is the first time the page is being processed. ·                     If this is the first time the page is being processed, perform initial data binding. ·                     Otherwise, restore control values. ·                     Read and update control properties.
Validation	The Validate method of any validator Web server controls is invoked to perform the control’s specified validation.	(There is no user hook at this stage. You can test the outcome of validation in an event handler.)
Event Handling	If the page was called in response to a form event, the corresponding event handler in the page is called during this stage.	Perform your application-specific processing: ·                     Handle the specific event raised. Note   Events are not raised in a particular order, except that cached control events — as specified by the control’s AutoPostBack property — are always processed before the posting event.·                     If the page contains Types of Validation for ASP.NET server Controls, check the IsValid property for the page and for individual validation controls.  ·                     Manually save the state of page variables that you are maintaining yourself. ·                     Check the IsValid property of the page or of individual validation controls.  ·                     Manually save the state of controls dynamically added to the page.
Cleanup	The Page_Unload event is called because the page has finished rendering and is ready to be discarded.	Perform final cleanup work: ·                     Closing files. ·                     Closing database connections.  ·                     Discarding objects. Note   It is important that expensive resources, such as database connections, be explicitly closed. Otherwise, they will remain open until the next garbage collection occurs. On a heavily loaded server, many open resources can adversely affect performance.

State Management

State management is the process by which you maintain state and page information over multiple requests for the same or different pages. As is true for any HTTP-based technology, Web Forms pages are stateless, which means that they do not automatically indicate whether the requests in a sequence are all from the same client or even whether a single browser instance is still actively viewing a page or site. Furthermore, pages are destroyed and recreated with each round trip to the server; therefore page information will not exist beyond the life cycle of a single page.
ASP.NET provides multiple ways to maintain state between server round trips. Choosing among the options for state management available in ASP.NET will depend heavily upon your application, and it should be based on the following criteria:

• How much information do you need to store?

• Does the client accept persistent or in-memory cookies?

• Do you want to store the information on the client or server?

• Is the information sensitive?

• What sorts of performance criteria do you have for your application?

• ASP.NET supports various client-side and server-side options for state management.

Client-side options are:

• The ViewState property

• Hidden fields

• Cookies

• Query strings

Server-side options are:

• Application state

• Session state

• Database Client-Side State Management Options

Storing page information using client-side options doesn’t use server resources. These options tend to have minimal security but fast server performance because the demand on server resources is modest. However, because you must send information to the client for it to be stored, there is a practical limit on how much information you can store this way.

View State

Web Forms pages provide the ViewState property as a built-in structure for automatically retaining values between multiple requests for the same page. View state is maintained as a hidden field in the page.

You can use view state to store your own page-specific values across round trips when the page posts back to itself. For example, if your application is maintaining user-specific information — that is, information used in the page but not necessarily part of any control — you can store it in view state.

The advantages of using view state are:

• No server resources required. The view state is contained in a structure within the page code.

• Simple implementation.

• Automatic retention of page and control state.

• Enhanced security features. The values in view state are hashed, compressed, and encoded for Unicode implementations, thus representing a higher state of security than hidden fields have.The disadvantages of using the view state are:

• Performance. Because the view state is stored in the page itself, storing large values can cause the page to slow down when users display it and when they post it.

• Security. The view state is stored in a hidden field on the page. Although view state stores data in a hashed format, it can be tampered with. The information in the hidden field can be seen if the page output source is viewed directly, creating a potential security issue

Hidden Fields

You can store page-specific information in a hidden field on your page as a way of maintaining the state of your page.

If you use hidden fields, it is best to store only small amounts of frequently changed data on the client. ASP.NET provides the HtmlInputHidden control, which offers hidden field functionality. For more information on HtmlInputHidden see ASP.NET server Controls by Function.

Note If you use hidden fields you must submit your pages to the server using the HTTP POST method rather than requesting the page via the page URL (the HTTP GET method).

The advantages of using hidden fields are:

• No server resources are required. The hidden field is stored and read from the page.

• Broad support. Almost all browsers and client devices support forms with hidden fields.

• Simple implementation. :

The disadvantages of using hidden fields are

• Security. The hidden field can be tampered with. The information in the hidden field can be seen if the page output source is viewed directly, creating a potential security issue.

• Limited storage structure. The hidden field does not support rich structures. Hidden fields offer a single value field in which to place information. To store multiple values, you must implement delimited strings and the code to parse those strings.

• Performance. Because hidden fields are stored in the page itself, storing large values can cause the page to slow down when users display it and when they post it.

Cookies

Cookies are useful for storing small amounts of frequently changed information on the client. The information is sent with the request to the server.

The advantages of using cookies are:

• No server resources are required. The cookie is stored on the client and read by the server after a post.

• Simplicity. The cookie is a lightweight, text-based structure with simple key-value pairs.

• Configurable expiration. The cookie can expire when the browser session ends, or it can exist indefinitely on the client computer, subject to the expiration rules on the client.

The disadvantages of using cookies are:

• Limited size. Most browsers place a 4096-byte limit on the size of a cookie, although the support for 8192-byte cookie size is becoming common in the new browser and client-device versions available today.

• User-configured refusal. Some users disable their browser or client device’s ability to receive cookies, thereby limiting this functionality.

• Security. Cookies are subject to tampering. Users can manipulate cookies on their computer, which can potentially represent a security compromise or cause the application dependent on the cookie to fail. For more information see Introduction to Web Application Security.

• Durability. The durability of the cookie on a client computer is subject to cookie expiration processes on the client and user intervention.

Note Cookies are often used for personalization, where content is customized for a known user. In most of these cases, identification is the issue rather than authentication, so it is enough to merely store the user name, account name, or a unique user ID (such as a GUID) in a cookie and use it to access the user personalization infrastructure of a site.
For details about creating and reading cookies, see HttpResponse.Cookies Property and HttpRequest.Cookies Property.

Query Strings

A query string is information appended to the end of a page’s URL. For more information, see Introduction to Web Forms State Management.

You can use a query string to submit data back to your page or to another page through the URL. Query strings provide a simple but limited way of maintaining some state information. For example, they are an easy way to pass information from one page to another, such as passing a product number to another page where it will be processed.
<b> Note : </b>  Query strings are a viable option only when a page is requested via its URL.

You cannot read a query string from a page that has been submitted to the server.

The advantages of using query strings are:

• No server resources required. The query string is contained in the HTTP request for a specific URL.

• Broad support. Almost all browsers and client devices support passing values in a query string.

• Simple implementation. ASP.NET provides full support for the query string method, including methods of reading query strings using the HttpRequest.Params property.

The disadvantages of using query strings are:

• Security. The information in the query string is directly visible to the user via the browser user interface. The query values are exposed to the Internet via the URL so in some cases security may be an issue.

• Limited capacity. Most browsers and client devices impose a 255-character limit on URL length.

Client-Side Method State Management Summary

The following table summarizes client-side state management options and when you should consider using them.
Method Use when View state You need to store small amounts of information for a page that will post back to itself. Use of the ViewState property provides functionality with basic security.

Hidden fields You need to store small amounts of information for a page that will post back to itself or another page, and security is not an issue.

Note You can use a hidden field only on pages that are submitted to the server.
Cookies

You need to store small amounts of information on the client and security is not an issue.
Query string You are transferring small amounts of information from one page to another and security is not an issue. Note You can use query strings only if you are requesting the same page, or another page via a link.

Server-Side State Management Options

Server-side options for storing page information tend to have higher security than client-side options, but they can use more Web server resources, which may lead to scalability issues when the size of the information store is large. ASP.NET provides several options to implement server-side state management.

Management.
Session State

ASP.NET provides a session state, available as the HttpSessionState class, as a method of storing session-specific information that is visible within the session only. For more information, see Introduction to Web Forms State Management and Session State.
You can store your session-specific values and objects in session state, which is then managed by the server and available to the browser or client device. The ideal data to store in session-state variables is short-lived, sensitive data that is specific to an individual session.

Note If you store a dataset in application state, you have to cast it from Object back to a dataset

The advantages of using session state are:

• Ease of implementation. The session state facility is easy to use, familiar to ASP developers, and consistent with other .NET Framework classes.

• Session-specific events. Session management events can be raised and used by your application.

• Durability. Data placed in session-state variables can survive Internet Information Services (IIS) restarts and worker-process restarts without losing session data because the data is stored in another process space.

• Platform scalability. Session state can be used in both multi-computer and multi-process configurations, therefore optimizing scalability scenarios.

• Session state works with browsers that do not support HTTP cookies, although session state is most commonly used with cookies to provide user identification facilities to a Web application. For more information on using session state without cookies, see ASP.NET Configuration Sections.

The disadvantage of using session state is:

• Performance. Session state variables stay in memory until they are either removed or replaced, and therefore can degrade server performance. Session state variables containing blocks of information like large datasets can adversely affect Web server performance as server load increases.

Database Support
In some cases, you may wish to use database support to maintain state on your Web site. Typically, database support is used in conjunction with cookies or session state. For example, it is quite common for an e-commerce Web site to maintain state information using a relational database for the following reasons:

• Security

• Personalization

• Consistency

• Data miningThe following are typical features of a cookie-supported database Web site:

• Security. The visitor types an account name and password into a site logon page. The site infrastructure queries the database with the logon values to determine if the user has rights to utilize your site. If the database validates the user information, the Web site will distribute a valid cookie containing a unique ID for that user on that client computer. The site grants access to the user.

• Personalization. With security information in place, your site is able to distinguish each user on your site by reading the cookie on the client computer. Typically, sites have information in the database that describes the preferences of a user (identified by a unique ID). This relationship is known as personalization. The site can research the user’s preferences using the unique ID contained in the cookie, and then place content and information in front of the user that pertains to the user’s specific wishes and reacts to the user’s preferences over time.

• Consistency. If you have created a commerce Web site, you may wish to keep transactional records of purchases made for goods and services on your site. This information can be reliably saved in your database and referenced by the user’s unique ID. It can be used to determine if a purchase transaction has been completed, and also to determine the course of action should a purchase transaction fail. The information may also be used to inform the user of the status of an order placed using your site.

• Data mining. Information about your site usage, your visitors, or your product transactions can be reliably stored in your database. For example, your business development department may wish to use this data collected from your site to determine next year’s product line or distribution policy. Your marketing department may wish to examine demographic information about users on your site. Your engineering and support department may wish to look at transactions and note areas where your purchasing process could be improved. Most enterprise-level relational databases such as Microsoft SQL Server contain an expansive toolset for most data mining projects.

By designing the Web site to repeatedly query the database by using the unique ID during each general stage in the above scenario, the site maintains state. In this way, the user perceives that the site is remembering and reacting to him or her personally.

The advantages of using a database to maintain state are:

• Security. Access to databases is typically very secure, requiring rigorous authentication and authorization.

• Capacity. You can store as much information as you like in a database.

• Persistence. Database information can be stored as long as you like, and it is not subject to the availability of the Web server.

• Robustness and data integrity. Databases include various facilities for maintaining good data, including triggers and referential integrity, transactions, and so on. By keeping information about transactions in a database (rather than in session state, for example), you can recover from errors more readily.

• Accessibility. The data stored in your database is accessible to a wide variety of information-processing tools.

• Wide support. There is a large range of database tools available, and many custom configurations are available.

The disadvantages of using a database to maintain state are:

• Complexity. Using a database to support state management implies more complex hardware and software configurations.

• Performance. Poor construction of the relational data model can lead to scaling issues. Also, leveraging too many queries to the database can adversely affect server performance.

Server-Side Method State Management Summary

The following table summarizes server-side state management options and when you should consider using them.
Method Use whenApplication state You are storing infrequently changed, global information that is used by many users, and security is not an issue. Do not store large quantities of information in application state.
Session state You are storing short-lived information that is specific to an individual session, and security is an issue. Do not store large quantities of information in session state. Be aware that a session state object will be created and maintained for the lifetime of every session in your application. In applications hosting many users, this can occupy significant server resources and affect scalability.

Database support You are storing large amounts of information, managing transactions, or the information must survive application and session restarts. Data mining is a concern, and security is an issue.

Writing a proposal for Web Project

If you are working as Project Manager or Consultant or Senior Experienced Developer, It is quite common that you will be asked to write a proposal for new project. It is always challenging to bring a proposal to develop a new project for a client‘s Web Site. When competing for web design and development or marketing contracts, a professionally presented development proposal most often decides whether you lose or win the business. In the past, I have written many proposals that were reviewed and approved by the client. We also delivered the product on the basis of Proposal Approved successfully. I just wanted to share my proposal writing experience with you by writing this post. When putting together a basic web site proposal, you should include the following elements:

Executive Summary:
Describe the Business Problem statement and Vision/Scope statement here.
This element can have sub elements as follows:

• Objective:
  Describe Business Problem statement and Project. Vision/Scope statement.

• Timeframes & Price
  Describe the tentative start and end date of the project. Also, a list out the factors on which schedule
  and cost of the project will depends. For example, if team does not get feedback or approval from client within specific time,
  schedule and cost of the project may be affected.
  Also, describe why do you think your project team will be execute this project and deliver it on schedule and within budget successfully.
  Write some positive points of the company over its competitors.

Company Profile:
Describe company background or company history, business qualifications, technical skills, past achievements and contact details.

Scope of the Project:

The business you are submitting the proposal for, your understanding of their products and services, the target market, the goals of the web site and a rough outline of how you will achieve them.

This should also includes requirements which are excluded from the project and assumptions for the project.

Proposed Solution:

A description of style of site you are proposing. Elements from the client’s current branding you will utilize or new elements you will develop.

• Special Considerations:

such as globalization, security, performance or other issues pertaining to the business, site or target market that will need to be addressed.

Current Architecture:
A details description of the architecture of the current system and its shortcoming.

Proposed Architecture:

A details description of the architecture that will be used for the project. Also, describe how it will solve current business problem. It should be explained clearly with the help of Flow Chart or Visio Diagrams.

• Web site flow chart:

A diagram showing the different pages of the site and navigational structure.

• Flowchart Description:

A detailed description of each web page, how it fits in with the overall web site theme and the project element it addresses.

Proposed technology:

A details description of the technologies that will be used for the project like .Net framework, Web Services etc.
Also, Describe how the proposed technology will be most suitable for the project.

Development Timeline:

This should be a description of each stage of the web projects’ development, the estimated completion date of deliverables/milestones and notes regarding client consultation and supply of information/feedback from the client. Point should be clear made that schedule and cost of the project will be affected if there would be change in the requirements or delay in feedback or approval from Client side.

• Delivery Schedule

This should show the delivery date and mode of the delivery for all the deliverables/milestones for the project.

• Gantt Chart

The Gantt Chart for the project is shown below:
This should show the Gantt chart prepared for the project.

Project Management:

• Project Management

This should be summary of project management activities that will performed by
Project team. Project Key members like Business Deliver Owner and Project manager will be appointed. Project team will develop the project. It should be mentioned here that once proposal is approved then team can process with detail design of the project.
Also, it should indicate that client should give feedback/approve on time, failing to do so may delay the schedule and cost of the project.

• Project Plan Management

Here you can give details of the Project Management tools will be used for Project Management like MS Project, MS Excel, Project Monitoring System etc.
PMS provides the following features:

Project Management tool if available should provide :

• Project Setup

• Capturing Actual Effort

• Bug Tracking

• Quality Data Analysis

• Project Metrics Reports

• Employee Training Plans

• Weekly Status Report

Describe how Weekly Status report will be prepared and sent to the client..

• Monthly Project Status Review

This should explain how Monthly Project Status Review will help to monitor the progress of the project. It should also explain how the strategic issues like customer satisfaction, staff training, change control, risk management and deviations from company procedures will be reviewed.

• Project Quality Management

This gives detail description of Quality Processes and control to be followed in all phases of the project.

• Quality Objective

The detail description of Quality object explained here. like

• Deliver a product that meets and exceeds expectations.

• No schedule slippage.

• No P0 bugs are found during the Acceptance testing phase

• Formal technical review

Describe the details description of technical reviews plan for the project, like Code Review, checking for adherence to standards and naming convention.

• Software Testing

Describe the detail description of Software Unit Testing planning and Test Cases creation.

• Standards

Explain the standards and processes teal will follow throughout the life cycle of the project.

• Enforcement of Standard

Explain how team will follow standards in the Project Life Cycle.

• Bug Classification

Explain how bug will be classified for the project like P0 for Critical, P1 for Non Critical etc.

• Project Communication Management

Here you can give detail description of the communication that will be used for interacting with the client for his feedback and approval.

• Email

Here can you write details like email will be primary mode of communication and will be used for sending project documents to clients for his approval.

• Telephonic Conference

Here you can explain how telecon will be used to keep the project on track and in good health.

• Project Risk Management

This will have detail description of Project Risk Identification, and assessment and their mitigation plan.

• Project Related Risk

This should explain risks associated with the project like increasing or changing requirement from users, delay in client ‘s feedback/approval.

• Project Life Cycle

This should give detail description of the project life cycle model that will be used for the project with diagram. eg. Waterfall, agile, spiral, incremental etc

• Project Organizational Roles and Responsibilities

This should explain the roles and responsibilities of project team of clients and your organization.

• Team Structure

This should show the team structure of the project team in hierarchical fashion and also shows it will interact with client ‘s project team. Also, it should depict who reports whom.

• Project Configuration Management

This should explain the scope of the configuration activities for the project. This should explain how controlled items will stored and versioned.

• Configuration Items

You can give the list of all the items which have been identified as configuration items for the project like Functional specification, Detail Design, Source Code etc.

• Change Control Procedure

This will explain how team will handle change request for the project.
Template is given in the appendix.

• Reporting Procedures

This will explain the reporting procedure for the project. Like who will report whom and how the matter to be escalated in case of some conflict and problem.

Documentation :
Here you can give a list of documents will be prepared and delivered to the client for the project. Like function specification, detail design, user manual etc.

Project Costing:

A descriptive breakdown of costing phase wise or deliverable wise and total of quote including an end date before the price will need to be re-calculated.
No clients prefer to pay for project in advance or in full. So, describe that how much payment will be due after each phase or deliverable.

Ensure you take into account business related items including travel time, electricity, telephone and consumables.

Bear in mind that things rarely go strictly to plan in web design and delays can be expected.
Also, cost of the project dependent upon the complexity of the task and the competency of the designer.
In your eagerness to gain the contract, you may lose money if you quote too close to the bone. Time is money.

Acceptance:
This should give detailed description of the Acceptance guidelines and rules for the project.

• Acceptance Criteria

Describe the Acceptance criteria for the product to be delivered.

• Performance Guarantee

This should explain how the project team ensure that product have no performance issue.
Also, it will handle post production product related performance related issues.

• Acceptance Performance

Describe who will develop Acceptance test plan, also describe that it would be client ‘s responsibility to acknowledge, review and approve the delivery as complete and acceptable within 2 weeks of final delivery being made.
If rejected, team will rework the software to requirement.

Warranty Support:

Describe how long team will support the product after final release. Usually it is 30 after acceptance or deemed acceptance of the product. General Terms and conditions:

• Expectations and commitments

It is not unusual for web projects to be delayed due to clients not supplying feedback or content necessary to complete sections. It is just as important to be clear in what you expect from your clients as well as explaining your commitment to them. Conflict resolution issues and feedback mechanisms should be described.

Your clients will need to know what will occur if they do not supply information when requested, or request changes mid-stream and the action that you will take if you are running behind in the project yourself. You need to be clear on payment details and consequences of failure to pay for the services that you provide.

• Mock-ups (samples).

Be careful not to give too much away, just enough to give the client a good idea of what the site will look like. Ensure copyright notices and intellectual property statements are in place.

• Ongoing web site maintenance.

Summarize an offer of ongoing site maintenance or the implications of the client deciding to update or maintain the site themselves after it has been established.

Proposal Validity:

This should explain until when this proposal will be valid.

Disclosure:
You should make it clear that entire project will be performed by your company, if external resource is expected to become part of the team then it may be necessary to revisit costing based on effort redistribution.

Above points are usually sufficient to put together a professional web design proposal for a small to medium web based project. It had worked for us for many projects.
Be prepared to give presentation on the proposal to the client. Most of the clients prefer to have presentation on the proposal to ensure that they are reading from the same page. Also, first you need to release draft version of Proposal document and send it to Sponsor/Stakeholder so that if they want any changes, you can easily negotiate with them before releasing final version of the proposal. You should also ensure that Proposal should address all the concerns/issues client had laid down.
Also, many client like to negotiate with cost and schedule, so be prepared to do some heavy revisions to satisfy your client and find the middle ground where all parties feel comfortable.
Some clients wants Proposal documentation in certain format, respect that as well.

Also remember that some companies will ask you for proposals purely to use as a comparison against another designer that they are interested in utilizing; so try and limit the amount of time you spend on the draft until the client gives indication of serious interest.

Appendix A : Change Request Form
Customer Name :
Contact Name :
Project Id :
Project Manager/Leader(offshore) :
Project Name :
TO BE FILLED IN BY CLIENT :
Priority :
(Urgent, High, Medium, Low)
Initiated By :
Change Required :
Reasons :
Effort and Impact :.
Affected Modules & Documents :
Costing :
Decision : Approved / Not Approved : By : Date :

TO BE FILLED IN BY OWNER:
Request No :
Date Received By Offshore :
Effort and Impact :
Affected Modules & Documents :
Costing :

.Net Framework 3.0

When I started learning and working on MS Visual Basic 3.0 ,  I had never thought that MS programming language/model  would come a long way and would give its competitor a run for their money.  .Net is the most successful development platform now. MS always put their best efforts in improve .Net development platform. .Net 2.0 has a lot of features to make coding and testing easy and help you to design and develop robust, flexible, extensible, configurable and secured application with ease.  

Now we have Microsoft .Net Framework 3.0  that is the new managed code programming model. It combines the power of .Net Framework version 2.0 with new technologies for building applications that have visually compelling user experiences, seamless communication across technology boundaries,  and the ability to support wide range of business processes. In this new version of .Net 3.0 framework, Microsoft has not changed the CLR (Common Language Runtime) but it introduces four new technologies on the top of .net 2.0. Good news is that MS have not modified .net 2.0 base model. No, .Net Framework 2.0 I is not going anywhere. We don’t have to do modify or make changed in .net 2.0 based existing applications. Also, since .net 3.0 framework run on top of .net framework 2.0. While installing .Net framework first it look for .net 2.0, if it could not find it then it install on target machine. 

The four technologies which have been added to .Net Framework are as follows: 

• Window Presentation Foundation ( WPF)
• Windows Communication Foundation ( WCF)
• Windows Workflows Foundation ( WWF)
• Windows Cardspace Foundation (WCF)

 

Windows Presentation Foundation or WPF is a new method for controlling the visual representation of information on the screen. WPF is  the answer of Microsoft to Adobe Flash.  It is the framework that presents 3D advanced graphics to provide a consistent platform for user interfaces. It help you develop rich media solution which will incorporate video, audio, 2D ,3D, rich data visualization among others to enhance your experience with solution. Furthermore, it uses the Extensible Application Markup Language (XAML), an XML-based platform-independent language that enables you to define your user interface declaratively. 

Windows Communication Foundation is a service-oriented messaging system that offers you reliable, transacted services. It is a unified method of enabling solutions to accurately communicate with each other. The Windows Communication Foundation supports interoperable communications using the SOAP protocol and offers reliability, security, and transactional support for such communications. 

Windows Workflow Foundation is used  for automating tasks using workflows; in essence, defining your business processes. It can also be  used to track movement of data.It is a framework you can use for managing the way in which work/data flows between applications and people. WFMC states that workflow is the “automation of a business process, in whole or part, during which documents, information, or tasks are passed from one participant to another for action, according to a set of procedural rules.

Windows Card Space is a software component that securely stores a person’s digital identities and provides a unified interface for choosing the identity for a particular transaction, such as logging in to a Web site.  It is a new standard defined for approach to security. WCS is an ambitious plan by Microsoft, supported by many leading security advisory boards to solve the inherent insecure problem of user ID and passwords. Internet Explorer 7 comes with WCS installed to help you control access to WCS enabled applications and web sites. 

The Microsoft .NET Framework Community says, “Use the .NET Framework 3.0 today to build applications that have visually compelling user experiences, seamless communication across technology boundaries, the ability to support a wide range of business processes, and an easier way to manage your personal information online.”  

What is new in .Net 2.0

The Microsoft .NET Framework version 2.0 includes significant enhancements to ASP.NET in virtually all areas. ASP.NET has been improved to provide out-of-the-box support for the most common Web application situations. You will find that you can get Web sites and pages up and running more easily and with less code than ever before. At the same time, you can add custom features to ASP.NET to accommodate your own requirements.
Specific areas in which ASP.NET has been improved are:

• Productivity: You can easily and quickly create ASP.NET Web pages and applications using new ASP.NET server controls and existing controls with new features. New areas such as membership, personalization, and themes provide system-level functionality that would normally require extensive developer coding. Core development scenarios, particularly data, have been addressed by new data controls, no-code binding, and smart data-display controls.
• Flexibility and extensibility: The enhanced ASP.NET architecture supports a broader range of Web applications. For example, all controls now feature integrated support for browsers and devices so that they support the type of functionality previously available in the MMIT. Many ASP.NET features are also extensible so that you can easily incorporate custom features into applications. The ASP.NET provider model, for example, provides pluggable support for different data sources.
• Performance: Features such as precompilation, configurable caching and SQL cache invalidation allow you to optimize the performance of your Web applications.
• Security: It is now easier than ever to add authentication and authorization to your Web applications.
• Hosting: ASP.NET includes new features that make it easier to manage a hosting environment and create more opportunities for hosters to add value.
• Completeness: New and existing features work in concert to allow you to create end-to-end scenarios that address real-world Web development challenges.

Web Site Management
Web site configuration is improved to include many more settings. You can easily manage application settings using the Web Administration Tool, which provides a wizard-like interface for setting up and maintaining your applications. The Web Administration Tool is particularly useful for managing remote sites (for examples, sites hosted by an ASP.NET-compatible ISP).
If you host sites for others, you can use a new ASP.NET Microsoft Management Console (MMC) plug-in or an administrative API to manage sites and monitor their health. You can add value to your hosting site by offering controls or services that you can selectively enable or disable.
New Administration Features and Tools:
ASP.NET includes features to make Web site management easier for both Web site developers and for administrators. Configuration files include a richer set of elements that give site developers control over new features and finer control over existing ones. A new configuration API makes it possible to control configuration programmatically. New tools provide a GUI interface for configuring applications — the new Web Site Administration Tool makes it easy for Web site developers to manage their own sites using a Web-based interface (both locally and remotely), and an ASP.NET-specific MMC snap-in allows site administrators to manage complex configuration scenarios using a standard Windows server-based tool.Reserved Folders for Special Functionality:
Web sites can include a Code folder into which site developers can put source code that is then compiled automatically as part of the Web site, making it unnecessary to compile components or controls before using them in a site. A Data folder is reserved for databases (for example, Microsoft Access .mdb files) and is preconfigured with appropriate permissions for the run-time user account. A Resources folder contains XML-based files containing strings and other resources for localization, which are dynamically compiled into .resx files at runtime. For details, see Shared Code Folders in Web Sites.
Precompiling Web Sites for Error Checking and Deployment:
You can now precompile your Web site, which allows you to enhance performance by avoiding the overhead of dynamic compilation and allows you to catch compile-time errors. You can also precompile a site for deployment, producing a version of the site that you can easily copy to or install on a production server. Precompiling for deployment strips source code, which helps you protect your intellectual property. For details, see Understanding Site Precompilation.
Navigation:
You can add site navigation to your Web sites by defining a site map (typically an XML file). You can then use new navigation controls such as the TreeView and SiteMapPath controls that can automatically create a menu or tree view of pages, or that can display a navigation path (also known as a breadcrumb) showing the current page hierarchy. For details, see Understanding ASP.NET Site Navigation.
Site Statistics:
A new site statistics feature allows you to automatically track page visits and control clicks. ASP.NET automatically tracks and stores site counter information, which you access programmatically or by using a reporting feature in the Web Site Administration Tool.

Page Design
New features of ASP.NET help you easily create pages that are more consistent and can offer a richer experience to users.
Consistent Layout using Master Pages:
You can use master pages to create a consistent page layout for your Web site or for a group of related pages. On the master page, you define a common look; you can then create individual content pages that provide the dynamic content that is displayed using the master page as a template. For details, see Understanding ASP.NET Master Pages.
Themes for Consistent Appearance:
Themes allow you to create a consistent look for your site. A theme contains a collection of control skins that define property settings (such as background color and font), CSS style settings, and images to specify the appearance of a control. You can apply themes that ship with ASP.NET or create and use our own custom themes. For details, see Understanding ASP.NET Themes.
Adaptive Rendering for Browser-Specific Output:
To support a wide variety of browsers, including those on mobile devices, pages and controls can use adaptive rendering, or device-specific rendering classes, to automatically render the appropriate markup to the requesting browser. This eliminates the need to have special versions of controls for different devices. Because the adaptive rendering model is extensible, new rendering classes can be added as new browsers become available.
New Code-Behind Model for Pages:
ASP.NET continues to support the single-file model from the previous version of ASP.NET and now includes a new code-behind model. The new model allows you to use a new .NET Framework feature, partial classes, to create a code file with just the code in it that you need, such as event handlers. The end result is a clean separation of the markup from the code in a page, and a robust model for managing a page’s code.
User-Customizable Web Pages:
With Web parts, you can create modularized Web pages that users can customize extensively. A Web part incorporates a discrete piece of functionality, such as a weather report, a stock ticker, or a window for reading news. ASP.NET allows you to create your own Web parts. You can then create Web pages that include a selection of Web parts. Using the Web parts architecture, you can allow users to customize individual Web parts (for example, by typing in a ZIP code to display local information) and change the layout of Web parts. You can also allow users to add and remove Web parts, thereby giving users the ultimate flexibility in using your site. For details, see Customizing Web Pages with Web Parts.
User-Specific Values:
You can provide users with a custom experience in your Web site by defining and using profile properties, which you can use to track user information (address, city), preferences (color scheme, list of stocks to follow), or any custom information required by your application (shopping cart). Once you have defined profile properties, ASP.NET automatically associates individual instances of the profile properties with each user, and you can use code to set or get the values. ASP.NET persists property values in a data store (which you can configure), and the next time a user visits your site, ASP.NET automatically retrieves the profile property value for that user. For details, see Understanding ASP.NET Profile Properties.
New Caching Features:
Enhancements to caching help you increase the performance of your site and manage the cache more precisely. You can manage caching at the Web site level using Web.config settings, rather than managing it at the page level. You can now invalidate cache contents programmatically. If you are using SQL Server 7.0 or later, you can set up a cache dependency based on a SQL Server database table so that when the table changes, the cache entry dependent on it is made invalid.
Enhanced Client-Side Functionality:
ASP.NET pages make it easier to add client-side functionality to pages to enhance the run-time experience for users. You can more easily bind client-side event handlers to controls and add better support for accelerator keys. For multipage forms, you can use the new Wizard control, or you can take advantage of the new cross-page-posting facility in Web pages.
Controls
ASP.NET features many improvements to Web server controls, including both enhancements to existing controls and a selection of new controls.
General Control Improvements:
A major area of enhancement in ASP.NET 2.0 is in the controls you use to create ASP.NET Web pages. General improvements to controls include:

• By default, controls now generate markup that is compatible with the XHMTL 1.1. standard.
• All controls support adaptive rendering, and can emit markup that is appropriate for the requesting browser.
• All data controls can use either the new data-binding model with data source controls, or can continue to use the model used in previous versions of ASP.NET 1.1.
• All controls support themes and skins so that you can customize their appearance using an ASP.NET theme.
• Many controls such as the Button control support site counters; ASP.NET can track how often the control is clicked.
• You can use device filtering with many control properties, specifying different property values for different devices. When the control is rendered, the appropriate property value is set based on the requesting browser.
• Validator controls can now be grouped, which allows you to selectively enable validation for some controls.
• Improvements to individual controls such as the Label control, ListBox control, and others to add functionality often requested by developers.

New Controls:
ASP.NET offers a greater selection of controls to help you create fully featured Web pages much more quickly. You can now take advantage of the following controls:

• Data. The GridView control is a highly capable data grid that can display and edit data, page, and sort, all without code. The TreeView control displays XML data and includes many options to customize both its appearance and behavior. To simplify data binding, you can use the new data source controls, described in more detail below under Data.
• Navigation. You can add navigation paths (also known as breadcrumbs) to pages with the SiteMapPath control and display a site map using the TreeView control.
• Security. You can authenticate users with a suite of login controls that allow you to get and validate user credentials, display custom output for logged-in users, and more. For more information, see Security.
• Graphics. The DynamicImage control can display graphics from a file, a database, or that you create programmatically. A new image generation service allows you to programmatically manipulate graphics for Web pages.
• Statistics. The new site counter service allows you to track page visits and click-throughs in your Web applications and helps you track the resulting information. New and existing controls, including the AdRotator and Hyperlink controls, now take advantage of a new site counter service that allows you to track visits and click-throughs.
• Devices. A number of controls, such as the PhoneLink control, are specifically designed to help you create pages for devices. In addition, all controls can render device-specific output (adaptive rendering), as described in Device Support.
• Web Parts. A new set of Web Part controls allow you to create portal pages that users can personalize at run time. For example, you can create a Web Part that allows a user to enter a custom value such as a postal code and get localized weather reports.
• Client behavior. New controls provide ASP.NET server control functionality for tasks that previously was handled only by HTML elements. These include the FileUpload control, ImageMap control, and the Hidden control. The new Wizard control allows you to create a page with multiple panels that step the user through multi-part forms.

In addition, existing ASP.NET controls have been enhanced with new features. All controls now support the new data-binding model, themes, and personalization. You can also use all controls to create pages for devices; controls now automatically support adaptive rendering and device filtering. For more information, see Device Support.
Data
ASP.NET includes substantially improved support for working with data in your Web applications.
Data Source Controls:
For binding data to controls on Web pages, you can now use data source controls, which encapsulate connections, query commands, and parameters into a single control. ASP.NET includes data source controls that work with a variety of back-end data sources, including Microsoft SQL Server, Microsoft Access, XML files, Web services, FrontPage site maps, and business objects that return data sets. All data source controls support the same basic object model, giving you a consistent way to work with data regardless of its source.
Data source controls can automatically fetch data and manage it when the page runs. You no longer need to write code to execute commands and manage datasets for common data scenarios. However, if your application requires it, you still have access to the lower-level data functions exposed by ADO.NET.
To pass parameters to data source controls, you can configure the controls to draw parameters values from other controls, Session state, query strings, or cookies; in addition, you can set parameter values programmatically.
Middle-Tier Data Access:
By using the new ObjectDataSource control, you can easily add data access to a page that is based on a middle-tier business object. The ObjectDataSource exposes the same binding interface to controls on the page, but instead of performing direct database access, it invokes methods on a component that you specify.
Data Display Controls:
ASP.NET also includes enhanced support for displaying and updating data with controls on Web pages. All controls can now use data source controls as data source instead of working directly against a dataset or other store. You can also take advantage of the following new controls that are specifically built to make data access easier:

• The GridView, DetailsView, FormView controls to display and edit data. (The GridView control supersedes the DataGrid control from previous versions of ASP.NET.)
• The TreeView control to display hierarchical information from XML files, sitemap files, and relational data sources.
• The SiteMapPath and Menu controls to provide data-bound support for navigation.

XML Support:
You can use XML data in a variety of ways in ASP.NET. An XML data source control exposes XML data to be used either as hierarchical or tabular data. You can bind a TreeView control to XML data to provide a hierarchical view for users, or you can bind a list control such as the GridView control to display XML in a traditional way.
Connection String Storage:
To enhance Web site security, you can store connection strings in a dedicated section of the configuration file.
Security
New ASP.NET features provide built-in support for authenticating and authorizing users. ASP.NET membership manages authentication, providing facilities for validating user credentials and helping users manage their passwords.
The membership service provides APIs that you can call programmatically to create new users, validate credentials, and get user information. To simplify authentication even more, you can use the new login controls, which work with the ASP.NET membership to perform a variety of tasks, often with no extra code required. The Login control prompts users for credentials and validates them. The PasswordRecovery control provides various options for helping users either change or remember their password. You can display user information with the LoginName control, and present a Login or Logout button using the LoginStatus control. The LoginView control allows you to mark content in a page that is visible only to authenticated users.
ASP.NET role management helps you manage authorization, providing high-level ways for you to define and check roles for users. For details, see Understanding ASP.NET Role Management.
Both the membership and role management systems use the new ASP.NET provider model, which separates the functionality of the systems from the data store that supports them. For example, membership allows you to store user information in Microsoft SQL Server or Microsoft Access. If these default options are not suitable for your requirements, you can create your own provider that accepts calls from membership and then fulfills them using your custom data logic.
Device SupportPages and controls in ASP.NET feature integrated support for a variety of browsers and devices. ASP.NET supports adaptive rendering, so that pages and controls can automatically create the appropriate output for the browser or device that originated a page request, whether HTML, XHTML, or a protocol for a mobile device such as WML and cHTML.
Note: ASP.NET is backward compatible with Web applications created using the Microsoft Mobile Internet Toolkit (MMIT).
Controls support device filtering, which allows you to override a control’s properties based on requesting browser or browser class. For example, you can specify that the Text property of a control display a short string for a mobile phone but a longer string for a device that supports a larger viewing area.
To help you create applications that are optimized for various devices, ASP.NET includes controls that are specifically designed for smaller viewing areas. Examples include the MultiView control, which allows you create multipaned forms, and the Pager control, which automatically handles pagination when output is too large for the current device’s display area.

Estimating the Software Project

It is very essential activity of any project and success of any project depend on realistic estimation of the project. Most of the project suffer due to bad estimation. Estimation varies project to project and it depends on many factors. When it comes to estimating the project, team select experience person who has worked on similar project or technologies on which project based. There is no such thing as 100% correct estimation of the project exists, at least for me. My experience says that it is almost impossible to get accurate estimation of the project because there are many factors which we can not see or control  while estimating the project like requirement gathering,  technology issues, client feedbacks and approval, resource attrition, risk assessment.  

 Competition is another factor which lead to project team to estimate the project incorrectly because management put the pressure on team to give low estimate to  reduce the cost of the project in order to get the project from client. It put put huge pressure on the project team to complete the project within unrealistic and callous deadline. I have experienced working for such projects working day and night  like chicken with its headcut off. I am sure many people are still working offshore  for such projects minimum 12 hours a day. No, I am not saying that there is no rule or guidelines are available to get good estimation of the project. As I  said earlier, some rules and guidelines can be applicable to one project but same may not applicable to another project. For example, you can not apply same rules for estimating two different project like Asp based project and .Net Project/J2EE Project.So here are some rules and guidelines which I have experienced working for some projects. If the requirement gathering is done for the project or you have a fair idea what you need to develop for the client, then your next task is to estimate the project and send the proposal to the client, get his approval, if  project proposal is approved, then you can start working on next phases of project like planning, designing, coding and testing and deploying of the project.

 I am taking example of ASP based project for estimation. In the scenerio, you need to do first Screen based estimation. You need to identify all the screen. Classify the screen(GUI) in simple,  medium and complex. Depending on the functionality of the screen, for example you can estimate that simple screen will take like 2 pd (Person Day) and medium take 4 pd and complex take 6. So suppose if you have 15 medium screen, 8 medium and 5 complex. So total screens will be 28 and estimate for all the screens will 15 * 2 + 8 * 4 + 5 * 6 = 91 pd. So effort for completing 28 screens will be 91 pd. Same way you can do estimation for all the reports. Now next task is  to get FP (Function Points) based estimation. For example, in the Library Management System, Registering new memeber in LMS may be one function point. Now you have to estimate how many effort it will take to complete 1 FP. you have to divide the effort into all the phases of SDLC. for example, if you think Registering new member will take 20 PD, then you have to estimate that how much efforts you will be needing for Designing, Writing, Test Cases,Coding, Testing, Project Management. Ideally,  you should take 30% of efforts for Analysis + 10% of efforts for writing test case + 25% efforts for coding + 25% for testing + 10% for project management for all the FPs. Then you can calculate efforts required for all the Function Points. This is the guidelines had worked for us when we applied for one of our asp project. It may not work for all the projects. It give you some idea how the project should be estimated. If you have some better ideas, please share it with me in comments sections. I will appreciate it.

Use Cases and Usage Scenerios

As I have already explained the importance of Use Cases and Usage Scenario in my earlier post of Analyzing information. This post would throw more light on Use case and Usage scenario.  

Use cases consists of some elements  that  are responsible for functionality and behavior of the system. Users always interact with the system to do some activity and get some result. Ideally, Use cases should represent all the processes, including all the events  that can occur in all possible situations. Creating Use cases is one of the main step of requirement gathering and analyzing and it should not be ignored. It helps non-technical people to understand the system well because it does not require any technical language. It enables easy communication between End User and Stakeholders and Project team and it bring them to agree on common perception about the system. Use Case diagram is basically developed in Feasibility phase. Use case is based on what to develop concept rather than how to develop the system

A use case diagram documents the following design activities:
·       Identifying the system
·       Identifying actors
·       Defining the interactions between the actor and the system
·       Determining the system boundary

Identifying the system  When we develop the Use case, we need to identify the single system or  subsystems. A system can be a collection of many subsystems. For example,  Online Shopping System might have a subsystem that  validate and authenticate the credit card for the shopper. A collection of Use cases indicates the relationships among the subsystems that make up the system, in addition to the relationships between systems that interact with each other.Identifying actors
The actor is external entity which  interact with the system to be built for the completing an event. In sample language, Actor represents Users who interact with the system for their day to day activities. Also,  Actor can be another system or database that might  interact with subsystem. The actor is an integral part of the use case. The use case represents the interactions between an actor and the system.  An actor can be: For example, In library Management System, some of the actors are Member, Book Entry Clerk, Manager, Cashier etc.
The roles played by actors explain the need and outcome of a use case. By focusing on the actors, the design team can concentrate on how the system will be used instead of how it will be developed or implemented. Focusing on the actors helps the team to refine and further define the boundaries of the system. Defining the actors also helps to identify potential business users that need to be involved in the use case modeling effort.

What is Usage Scenarios?
Usage scenarios describe in detail a particular instance of a use case. It takes many usage scenarios to document a use case completely. Whereas use cases are diagrams, usage scenarios are narratives. Usage scenarios provide additional information about the activities and task sequences that constitute a process. Usage scenarios document the sequence of tasks. Usage scenarios depict objects in a workflow process. Objects are something that are affected by the system, something that affects the system, or something that a system needs to be aware of to function properly. For example, objects in a training center include the customer, the training course, and the sales representative. Objects provide a view of the characteristics and behavior of elements in the problem domain that is addressed by the business challenge. In the conceptual design phase, you create usage scenarios that depict the objects in the problem domain.When you develop usage scenarios, you might identify a task that must be treated as a use case. For example, in the “Register customer for course” use case, you might determine that the task sequence “Process customer payment” is a high-level use case that is part of the workflow process and has several usage  scenarios. Consequently, each usage scenario for “Register customer for course” ends with “Entering course number.” Then you create all relevant usage scenarios for the new “Process customer payment” use case. You identify the use cases that correspond to the workflow process and then develop usage scenarios that describe the task sequences for each use case. From the usage scenarios, you can determine the current state requirements.

Need of creating Current State Usage Scenarios?After you identify a use case, you can determine the different usage scenarios that can occur for the use case. You then use the information that you gathered from users to describe the different usage scenarios possible for the use case. Creating a usage scenario helps you determine if you gathered the appropriate level of information. Gathering the required amount of information for describing the current state is part  of the iterative aspect of gathering and analyzing information.

You can create scenarios for both the current and the future states of the business environment. The current state scenario depicts how business activities are currently conducted; the future state scenario presents the activities as the business wants them to be. For both states, the scenario emphasizes business processes, information, users, and tasks. In some situations, full scenarios need be developed only for use cases that are known to have many exceptions or dependencies. This allows the project
team to balance costs against the potential benefits. Use cases and scenarios should be developed iteratively, and can be discovered or continued during development work on the initial set of use cases. Although there are various ways to analyze the current business processes,  use cases and usage scenario specially effective in modeling the process. 

Use case title: Customer requests product literature
Abbreviated title: Customer requests product literature
Use case ID: UC05.1
Requirements ID: 14.1
Description: Customer wants to obtain information for a product. The customer is able to view a copy online, print a copy, or request a hard copy to be delivered by mail.
Actors: Customer
Preconditions: ·         Customer has Internet access.·         Customer has browsed to the Adventure Works Cycles Web site.·         Customer has clicked Browse Product Descriptions.·         Product information exists in the database, and the site is working properly.
Task sequence
Customer scrolls to desired product.
Customer selects product by clicking on product graphic or details.
Customer views basic product information (name, description, image, in-stock status, price, item number).
Customer clicks Need Complete Specification?
Customer views full product specification online (UC05.1.3).
Customer clicks Mail Me Full Brochure (UC05.1.1).
Customer clicks Submit.
Customer browses away from product specification.
Postconditions: The request to receive the full specification by mail is complete and saved in the database.
Unresolved issues: How should saved requests best be queued for fulfillment?If submit process fails three times, what process should be invoked?
Authority: Mike Danseglio
Modification history: Date: November 6, 2002Author: Heidi SteenDescription: Initial version

Reference : Analyzing Requirements and Defining  MS .Net Solution Architecture exam 70-300 eBook.

Modeling in Software Development

Modeling help you depict business processes and their relationship with other processes. It also help you to describe complex problems in a simpler structure and enable easy communication. As the business processes are modeled and adapted to reflect the requirements, you can build a model of the architecture that describe the final business solution. Most commonly used modeling notations are:Unified Modeling Language (UML)  UML: UML is a standard modeling language that you use to model software systems of varying complexities. It was developed to provide users with a standard visual modeling language so that they can develop and exchange meaningful models. UML is independent of particular programming languages and development processes. You use UML to: 

• Visualize a software system with well defined symbols.
• A developer or application can unambiguously interpret a model written in UML by another developer.
• Specify the software system and help build precise, unambiguous, and complete models. Construct models of the software system that can correspond directly with a variety of programming languages. Document the model of the software system by expressing the requirements of the system during it development and deployment stages.
• It is a simple, extensible, and expressive visual modeling language.
• It provide the ability to create simple, well documented, and easy to understand software models.

 UML enables system engineers to create standard blueprint of any system.  UML provides a number of graphical tools that you can use to visualize and understand the system from different viewpoint. You can use diagrams to present multiple view of the system. You use models or views to depict the complexity of a software system. The various UML view depict several aspect of the system. For example End User/Stakeholder may not understand the technical diagram.. So UML has User view which represents the goal and objective of the system from the viewpoint of the end user and their requirement of the system.  This view shows how User interact with the system for day to day activities. User view help project team to understand the system and it requirements. Major task of the project team is to use requirement to design and develop the system.  Use case diagrams. A use case diagram represents the functionality that is provided to external entities by the system.  

UML has following Views. 

• User View contains Use Case diagram represents the functionality that is provided to external entities by the system. 
• Structural view which is also called design view and it represents static or  idle state of the System. Structural View includes Class and Object Diagrams: A class diagram depict various classes and their associations. Associations are depicted as bi-directional connections between classes. A object diagram depict various object in a system and their relationship with each other. 
• Behavioral view which represents the dynamic or changing state of the system. This is also call Process view.  Behavioral View contains following diagrams: 

• Collaboration diagrams. A collaboration diagram represents a set of classes and the messages sent and received by those classes.

• Sequence diagrams. A sequence diagram describes the interaction between classes. The interaction represents the order of messages that are exchanged between classes.
• State diagrams. A state diagram describes the behavior of a class when the external processes or entities access the class. It depicts the states and responses of a class while performing an action.

•  Implementation View:  The view represents the structure of the logical elements of the system.   This View contains A component diagram represents the implementation view of a system. It represents various components of the system and their relationships, such as source code, object code, and execution code. 
• Environment View which represents the distribution of the physical elements of the system. This is also called Deployment View. This View contains a deployment diagram represents the mapping of software components to the nodes of the physical implementation of a system.   

Analyzing Information

Analyzing requirements is one of the most critical activities of the requirement management process. The objective of this activity is to make sure you have very well formed written business requirements that everyone has agreed to. It helps to make developer ’s life easier. Once  Requirement gathering is done, next step is analyzing the requirements. Before analyzing the requirements, you should ensure and verify that you have enough information to indicate the current state of the business and product requirement. If any critical information is missing, you have to pay heavy price in the form getting rework in the later stage of the project. It will be real pain in the butt.

Sometimes, Requirement gathering and analyzing go hand in hand. As you review the requirements and analyze it, you will undoubtedly discover that you have more questions.

You then frame the queries or doubts regarding the requirements and take them back to the appropriate source for the clarification. This form of collaboration will continue throughout the life cycle of the project, although most of the information gathering and analysis will occur at the beginning of the life cycle.

When you think you have gathered enough information from the customer, you will have to determine what information is most relevant to the business challenge. You need to synthesize the information to create a detailed description of the current state of the business.

As you synthesize and analyze the information, you can identify any gaps that exist in the information you collected, and, if necessary, gather additional information.

 Use Cases and Usage Scenarios: 

After you have synthesized the information, you can develop use cases and usage scenarios to document the business processes and business requirement in more details.

 Use Cases: 

Use case shows the functionality of a system and how an individual interacts with the systems to obtain value.

The purpose of use cases are to:

n      Identify the business process and all activities from start to finish.

n      Document the context and environmental issues.

n      Establish the connections between business needs and requirements.

n      Focus users and development team

 

The Use cases provide the following benefits:

n      Provide context for the requirements

n      Facilitate common understanding

n      Provide the basis for usage scenario

n      Facilitate objectivity and consistency in evaluating user suggestions.

 Usage Scenarios: 

Use cases describe the high-level interactions between an individual and a system. Usage scenarios provide additional information about the activities and task sequences that constitute a process. Together, use cases and usage scenarios provide a description of a workflow process.

Example of an interview
Following is an example of an interview from the Adventure Works Cycles scenario that was introduced in Chapter 1, “Introduction to Designing Business Solutions.”
Summary of an interview with the territory sales manager We had a great year in sales this year. Our jobs have been a lot easier since the company equipped us with laptop computers and PDAs. We have been doing some forecasting for the next year, and we are starting to see a slow decline in sales, particularly if we continue to operate like we have in the past. The sales department has established a number of goals for the new fiscal year. The top three goals are (a) focus on our best customers, (b) use sales staff time more effectively, and (c) manage sales opportunities better.
We don’t have an easy way to analyze our customer base. Currently, customer data is stored in our systems, but there’s no easy way to retrieve the data and allow us to view the data in different ways. To better identify our best customers and why they are our best customers, we need a way to access our data and to be able to analyze it in a meaningful way.
Another problem we’ve experienced in recent months is in presenting our products and achieving sales in our foreign markets. Currently, all the information on our computers is written in English only. We need to store multilingual and multiregional information in the database rather than depending on the sales force to translate the information.
Our team needs to obtain the latest pricing information on a daily basis, and we should be doing this every day. Currently, the sales representative connects to the corporate network and downloads the new pricing list each day in the morning. However, the download process does not identify which prices have been modified for that individual sales representative. So the sales representative must download the entire list every morning. You can imagine how customers feel when they have negotiated a deal with us only to find out that the price was incorrect.
Another area that needs definite improvement is in our sales opportunities management. Employees are supposed to use our customer management system to plan, execute, and track sales and marketing strategy. In addition to that, sales representatives need to install a large application on their laptop computers and connect to the corporate network to use it. We want to be more mobile than that; we want to be able to access this information from a Web site. The information must be easy to access and meaningful for the sales representatives and the company; otherwise it doesn’t help anyone. We want to achieve the following goals with the new system: Minimize the amount of technical knowledge that sales and marketing needs to access the data, and allow the staff to obtain standard reports, generate custom queries, track promotions, and view customer segmentation information. In addition, we want this system to be flexible enough so that we can add third-party data sources and financial evaluation tools. No matter who views a particular customer’s information, that individual must get a clear, unified view of the customer and the customer’s relationship with us.

Example of a use case diagram: 

 Draft Requirements Document:

Draft Requirements Documents with additional informations:

Actor Catalogue:

Actor is a entity which interact with the system. eg Sales Manager, Accountant, Vice Preseident etc. Actor Catalogue contain information about all the actors used in Use Cases. Actor catalogue contains

information like Actor name, responsibilities, source of this information etc.

For example, in the given exampleActor Catalogue, a sales representative is an actor whose responsibilities include establishing contacts with customers within a geographic region, and acquiring knowledge about products and their specifications and information about all the customers. The source of this information is tracked in case you need to go back to the source for additional information or clarification.

 Business Catalogue:

The business rules catalog is a living document that lists the business rules for a solution. The business rules catalog is a predecessor for the requirements document. This document is created early in the design process, when the team gathers information. This document, like the actors catalog, is meant only for the team and is typically not provided to the customer.

 

 

Requirement Gathering

Requirement Gathering and Analysing  is most important and difficult part of any project. Success of any project, does not matter whether it is small, madium or large, depend on the efficient requirement gathering. You may develop something which customer may reject if  your final product does not match the client requirements and clients needs are not addressed in final product. Sometimes, frequent change in the requirement also leads to failure of the project, if requirement changes are not managed properly. Also, there is a saying, “Walking on water and developing software from a specification are easy if both are frozen”.

It is always difficult to collect correct requirement to develop the system. Fortunately for us, we have many tools and technique which help us to do requirement gatheting efficiently.

There are 6 main  techniques that you can use for gathering information:

Shadowing:

Shadowing is the technique in which End User show you how he performs certain activity or task. You are allowed to ask a questions related to the tasks performed by the end user. By doing so, you understand the purpose of performing the specific tasks.

Although, Shadowing will not help you to understand the tasks which user perform only occasionly and not frequently eg monthly report printing, adhoc report printing etc, but Shadowing is a good way to get an idea what and how does a person perform day to day activities.In addition to the information that you would collect from the individual, you might collect relevant work artifacts, such as documents and screen shots of the current solution.

Interviewing:

There are certaing batch process which require no human intervention. An example of a process that requires no human intervention is the automatic bill-paying service provided by financial institutions. For gathering information about such activities and processes, you need to conduct interviews.

An interview is a one-on-one meeting between a member of the project team and a user or a stakeholder. The quality of the information a team gathers depends on the skills of both the interviewer and the interviewee. An interviewer who becomes an ally can learn a great deal about the difficulties and limitations of the current solution. Interviews provide the opportunity to ask a wide range of questions about topics that you cannot observe by means of shadowing.

Focus groups:

A focus group is a session in which individuals discuss a topic and provide feedback to a facilitator.  Focus groups allow you to gather detailed information about how an activity fits into the business as a whole. Individuals in a focus group can fill knowledge gaps for one another and provide a complete description of a business process.

Focus groups concentrate on group interviewing techniques. Use this method in cases in which there are more users than you can involve directly in the information gathering process.

Surveys:

Surveys consist of sets of questions that are created to gather information. Examples of surveys include user registration forms and customer feedback or satisfaction forms.

You can use surveys to gather information and to identify further information gathering activities that you need.One of the benefits of using surveys is that they enable users to respond anonymously. You can collect information that might be impossible to collect with any other technique.

User instruction:

When you use the user instruction technique, users actually train you on the tasks that they perform. This allows you to participate in the activity and view each step of the process from the user’s perspective. You might also gain knowledge that an individual has learned over time and that is unavailable from artifacts or systems.

User instruction can be time consuming if the process you are investigating is long. This method could also be frustrating for the researcher if the user is not accustomed to teaching others. In addition, different users might perform the same task differently. Consequently, you should collect information from multiple users.

Prototyping:

Prototyping allows you to gather information by simulating the production environment. You can use several tools to collect information, such as a camera to monitor visual activity or a computer program to monitor keystrokes and mouse clicks. The tool that you select for prototyping depends on the type of information you want to collect.

Use prototypes when it is impossible to shadow a person in the normal work environment. The data that you collect by prototyping is typically empirical rather than responses from users. Therefore, you can easily validate this data. However, the cost of prototyping might be high.

Sources of Information:

As we  know requirement gathering is very important and it is equally important to know the source of the information. Some of the information sources are:

• Artifacts

• Systems

• People

Artifact: 

An artifact in information gathering is an item that is physically available in the business environment and that describes an element or core business process. As in archeology, artifacts help us understand the current environment. They provide information about tasks, processes, business needs, and constraints. Examples of artifacts include training manuals, video recordings, regulatory requirements, earlier program files or tapes, help desk documentation, and financial reports.

Systems:

Systems describe an element of the business that is performing an action. A specific system is a set of discrete processes that accomplish an action. A system might be composed of subsystems. A system can be a tangible process, such as an inventory tracking system, or an intangible process, such as the methods that a manager uses to identify and resolve problems within a department.

People:

The people who are stakeholders in the business can be the source of valuable insights into the business, often providing information that is not documented anywhere. These stakeholders include executives, developers, managers, customers, and users. In cases where documentation is incomplete (or non-existent), people might be the only source for the information you need to learn about the business.