SEMANTIC WEB SOLUTIONS USING NATURAL LANGUAGE

TECHNOLOGY

By

P. Raj Kumar
REGISTER NUMBER: 67107100205

A thesis submitted to the

FACULTY OF INFORMATION AND COMMUNICATION ENGINEERING

In partial fulfillment of the requirements

For the award of the degree of

MASTER OF COMPUTER APPLICATIONS

ANNA UNIVERSITY
CHENNAI – 600 025
MARCH 2010
 BONAFIDE CERTIFICATE

Certified that this thesis titled SEMANTIC WEB SOLUTIONS USING

NATURAL LANGUAGE TECHNOLOGY is the bonafide work of Mr.P. Raj Kumar,

who carried out the research under our supervision. Certified further, that to the

best of our knowledge the work reported herein does not form part of thesis or

dissertation on the basis of which a degree or award has conferred on an earlier

occasion on this or any other candidate.

Internal Guide

Dr. R.MuthuRaj
Senior Lecturer,
Department of Computer Science
Anna University
Chennai

Head of the Department

XXXXXX
Department of Computer Science and Engineering
Anna University
Chennai
 ACKNOWLEDGEMENT

The satisfaction that accompanies the successful completion of any task would be

incomplete without mentioning the names of people who made it possible, whose constant

guidance and encouragement crowns all efforts with success.

I would like to express my sincere thanks to XXXX, Director, School of computer

Science and Engineering, Anna University for having permitted me to undertake this project.

I convey my earnest thanks to Dr.R.Muthuraj, Senior Lecturer, Department of

Computer Science and Engineering, Anna University for his invaluable guidance, support and

suggestions throughout the course of this project work.

I express my sincere thanks to the review committee members Dr.G.V Uma Assistant

Professor, Department of Computer Science and Engineering, Anna University and Dr.

S.Swamynathan Assistant Professor, Department of Computer Science and Engineering, Anna

University for their suggestions and constructive criticisms during the course of my project.

Last but not the least, I am grateful to my parents and friends for their constant support

and encouragement.
 ABSTRACT
Many modern natural language-processing applications utilize search engines to locate
large numbers of Web documents or to compute statistics over the Web corpus. Yet Web search
engines are designed and optimized for simple human queries-they are not well suited to support
such applications. As a result, these applications are forced to issue millions of successive
queries resulting in unnecessary search engine load and in slow applications with limited
scalability.
In response, this paper introduces the Bindings Engine (BE), which supports queries
containing typed variables and string-processing functions. For example, in response to the query
“powerful (noun)” BE will return all the nouns in its index that immediately follow the word
“powerful", sorted by frequency. In response to the query “Cities such as
ProperNoun(Head((NounPhrase)))", BE will return a list of proper nouns likely to be city names.
BE's novel neighborhood index enables it to do so with O(k) random disk seeks and O(k)
serial disk reads, where k is the number of non-variable terms in its query. As a result, BE can
yield several orders of magnitude speedup for large-scale language-processing applications. The
main cost is a modest increase in space to store the index. We report on experiments validating
these claims, and analyze how BE's space-time tradeoff scales with the size of its index and the
number of variable types. Finally, we describe how a BE-based application extracts thousands of
facts from the Web at interactive speeds in response to simple user queries.
 TABLE OF CONTENTS

Chapter 1 - Introduction

Overview of the project

Proposed System

Objectives & Scope

Organization of the report

Chapter 2 – Requirements specification

Introduction

Overall Description

Product Perspective

Product Functions

User Characteristics

Operating Environment

Constraints

Specific Requirements

External Interface Requirements

System Features

Data Flow Diagrams, UML

Performance Requirements

Software Quality Attributes

Chapter 3 – System Design and Test Plan

Decomposition Description

Dependency Description

Detailed Design

Proposed Sampling Methods

Test plan

Chapter 4 – Implementation and Results

Implementation

Results

Chapter 5 – Conclusion and Future work

Summary

Future Work

References

Appendixes
 LIST OF TABLES

Table No Description Page No.

1 Content

2 Module

3 User
 LIST OF FIGURES

Figure No Description Page No.

1 Architectural Diagram

2 0th Level Data Flow Diagram

3 1st Level Data Flow Diagram for User Interface

4 Sequence Diagram

5 Collaboration Diagram

6 Use Case Diagram

 LIST OF ABBREVIATIONS

Term Definition
CI Configuration Item

HTML Hyper text markup language

IEEE Institute of Electrical and Electronic

Engineers

PCS Patient care system

PIS Patient Information System

QA Quality assurance

Report Overall patient detail record

SCMP Software Configuration Management Plan

SDD Software Design Document

SEI Software Engineering Institute, Pittsburgh,

Pa

SQAP Software Quality Assurance Plan

SRS Software Requirements Specification

Web Site A place on the world wide web

N/A Not Applicable

NLP Natural Language Processing

CHAPTER 1 - INTRODUCTION

OVERVIEW OF THE PROJECT

Modern Natural Language Processing (NLP) applications perform computations over
large corpora. With increasing frequency, NLP applications use the Web as their corpus and rely
on queries to commercial search engines to support these computations [21, 10, 11, 8]. But
search engines are designed and optimized to answer people's queries, not as building blocks for
NLP applications. As a result, the applications are forced to issue literally millions of queries to
search engines, which can overload search engines, and limit both the speed and scalability of
the applications.
 EXISTING SYSTEM

The application generates this list by using the Content term. Application is doing a kind
of query expansion to enable naive users to extract information. In an effort to find low-quality
extractions, we sort the list by the hit count for each binding, summed over all the queries.

PROPOSED SYSTEM

We have configured application to support interactive information extraction in response

to simple user queries. The application generates this list by using the query term to instantiate a
set of generic extraction phrase queries. In effect, the application is doing a kind of query
expansion to enable naive users to extract information. In an effort to find high-quality
extractions, we sort the list by the hit count for each binding, summed over all the queries.
 OBJECTIVES & SCOPE

AIM

Search used to search a particular document in a particular domain or within some

premises. These premises generate the security of the files and documents. Any user can query,
and need not to login to accomplish a search task. Search is based on the keywords entered in the
document. Search begins by searching it with the content of the file description.

SCOPE

NLP has significant overlap with the field of computational linguistics, and is often
considered a sub-field of artificial intelligence. Some of the features of the NLP are Automatic
Summarization, Foreign Language Reading and Writing, Information Extraction and Retrieval,
Machine Translation, Natural Language Generation and Recognition, Optical Character
Recognition, Query expansion and answering.
 ORGANIZATION OF THE REPORT

OVERVIEW OF THE CHAPTER TO FOLLOW

Chapter List Description

Outlines requirements gathering process, requirements

analysis and the requirements specification
Chapter 2: Requirement Specification

Provides the overall, component, database and interface

design specification with the necessary explanations also
Chapter 3: System Design & Test Plan
Provides test plan, test cases, test results as well the
implementation plans for the system

Looks deeply in to the main components of the system

and how they have been implemented
Chapter 4: System Implementation &
Result

Provides generalizations based on the application, reflects

on what learned and considers future work
Chapter 5: Conclusions & Future Work

References Provides the list of documents, web references and other

credentials referred

Includes the system setup guide, user manual, project

specification, requirement collection documents etc.
Appendices
CHAPTER 2 – REQUIREMENTS SPECIFICATION

INTRODUCTION
Search used to search a particular document in a particular domain or within some premises.
These premises generate the security of the files and documents. Any user can query, and need
not to login to accomplish a search task. Search is based on the keywords entered in the
document. Search begins by searching it with the content of the file description.

INFORMATION SYSTEM

Definition
Combination of hardware, software, infrastructure and trained personnel organized to
facilitate planning, control, coordination, and decision making.

BusinessDictionary.com
OVERALL DESCRIPTION
 PRODUCT PERSPECTIVEPRODUCT FUNCTIONS

Presentation Web
The system functions can be Components(ASP.NET,
described as follows: C#)

 Search for Sentence.


Application Login to the systemComponent
with username and password.
Controller
 Upload Documents
 Change Password. Domain
Objects(Semanti
c Web Solution
Service Service Interfaces and Implementation Using NLP
Techniques)

Data Access Repository Interfaces and Implementation

Persistence SqlServer Driver Specification

Database
USER CHARACTERISTICS
The system functions can be described as follows:

Login Users:
This module describes the login part of the semantic web solution project. The admin logged
into the account and capable of Adding a new employee user and can add the custom security settings.
After completing the necessary operations user can finish their sessions.
Upload the search Document and edit the document, add new users and change password.

Search:
Search used to search a particular document in a particular domain or within some premises.
These premises generate the security of the files and documents. Any user can query and need not to
login to accomplish a search task. Search is based on the keywords entered in the document. Keywords
used to search and get a document easily. Search begins by searching it with the content of the file
description.
SYSTEM REQUIREMENTS
Hardware Requirements

 Processor PENTIUM III

 RAM 128 MB
 Hard Disk 4 GB
 Display Card Super Video Graphics Adapter (SVGA)
 Mouse Logitech Serial Mouse
 Keyboard Standard 104 Enhanced Keyboard

Software requirements

 Operating System - Windows XP

 DOTNET Technologies - ASP.NET 2.0, C#
 Back End - SQL Server 2005
 CONSTRAINTS

1. Internet Explorer browser is only targeted for the client. The users should have IE 6.0 or
higher version is recommended.

2. The Web Server must be scalable and must have necessary power backup.

3. Legal, ethical, social and professional issues.

Legal

Legal issues might happen here, such as, access critical or secret information
without the company’s permission and using illegal software to the project. Those
are the big legal issues. Company and software agent can sue us for this kind of
situation. So develop the system to minimize such legal issues. Here any
information, photographs materials used must take by Intellectual Property Law,
Contact Law, Data Protection Law, and Computer misuse Law. Any bridge of
such provisions will be a serious and critical issue.

Ethical

Ethical Issues means final project cannot be produced on delivery date. In this
situation we gave promises before, to finish the system on certain date, but
unfortunately cannot finish the system in particular scheduling time. The system
should be avoided and it should be made without such unethical means.Bring in
all stakeholders towards common goal of developing system is an issue.
Organized information to incorporate the relevant areas of information in an
appropriately with the due satisfaction will also be an issue. No real employee’s
data will be provided.

Social

Social issues will be happen, sometimes if we miss to develop the project without
social standards. The problems are employees have lack of knowledge to
accessing this new projects or training is not enough them.The social awareness
must be one of the critical success factors of the company’s system. Any outdated
or uncertainties may have social impact by misleading public. So it’s an issue that
must be addressed with better awareness

Professional issues

Sometimes the project follow may not be professionally effective and efficient.
 SPECIFIC REQUIREMENTS

System Interfaces

Interfaces

The user should have necessary work experience with computers. If needed, the user should
be trained up to use this software.

The user of the system may be an administrative, front-desk staff, doctors or other hospital
personnel.

Hardware Interfaces

Operating System: Windows XP, Windows Vista/7

Processor: Pentium 3.0 GHz or higher

RAM: 512 Mb or more

Hard Drive: 20 GB or more

Software Interfaces

 OS should be windows.
 Microsoft Visual Studio 2005 and Microsoft SQL Server 2005 platform is being used to
develop the application.
 All functions are compatible with IE 6.0 and above. Most functions will be compatible
with Mozilla and Firefox
Communications Interfaces

The following are the communication interfaces used by the system:-

 LAN protocols(Any one from the following)

Ethernet/IEEE 802.3,

Token Ring/IEEE 802.5

and Fiber Distributed Data Interface (FDDI).

 Communication Protocols
HTTP

Memory Constraints

The following are the primary memory and secondary memory requirements of the system

 RAM: 512 Mb or more(Primary Memory)

 Hard Drive: 20 GB or more(Secondary Memory)
 SYSTEM FEATURES

Functional Requirements

3.2.1. Search
Use Case Name: Search Page
Priority Essential
Precondition Search a particular document is connected to
the Internet and is on the Search Page
Basic Path The Web Server provides with the PCS home
page to the user

Alternate Path N/A

Postcondition The Alum is on the Alumni Home Page
Exception Path If there is a connection failure the Web Server
returns to the wait state
Other
Reference

3.2.2 Login
Use Case Name: Login
Priority Essential
Trigger Menu selection
Precondition 1. Search a particular document is connected to
the Internet and is on the Search Page
2. The user must have registered with the
system and must have an unique username and
password.
Basic Path The Web Server provides with the PCS home
page to the user

Alternate Path If the user is not registered with the system,fill in

the registration form and get an username and
 password.
Postcondition The user is logged on to the system.
Exception Path If there is a connection failure the Web Server
returns to the wait state
Other
Reference

3.2.3. Upload
Use Case Name: Add Upload Details
Priority Essential
Trigger Menu Selection
Precondition Search a particular document is connected to
the Internet and is on the Add Upload Details.
Basic Path 1. The Main Server presents the User with a
form.
2. The User fills in the form and click submit
3. The Main Server checks to see if all required
fields are not empty.
4. If the required fields are not empty, the
Main Server creates a new record in the Add
Upload Details of the Content Database.
5. If any of the required fields are empty, the
Main Server returns an error message and
prompts to add detail.

Alternate Path N/A

Postcondition The Patient details are added in the Add Patient
table of the patient database.
Exception Path If the connection is terminated before the form
is submitted, the fields are all cleared and the
Main Server is returned to the wait state.
LOGICAL DATABASE REQUIREMENTS
SQLSERVER2005 is used as Back End environment.

Although SQL Server 2000 and 2005 can exist side by side on the same machine, they have to be
installed as separate named instances. This document does not attempt to address the details of
SQL Server named instances – if in doubt, consult the DBA for the project for which the
installation is being performed.

Should a user require SQL Server 2000 AFTER SQL Server 2005 has been installed, it can be
installed as a separate named instance, however a check should be made to ensure that any
critical applications that require SQL Server 2000 are capable of supporting named instances –
not all are.

1. Insert the DVD into the DVD drive and double-click on the icon:

2. The installation screen should appear:

Click on Server components, tools, Books online and samples

6. Read the terms and conditions of the license agreement and click the check box to accept
them.

7. Click Next, and then Install.

 DATA FLOW DIAGRAMS, UML DIAGRAMS

DATA FLOW DIAGRAM

User

Request User interfaces

Search Page Process request

Process request

Login

Upload Document Edit Document Create User Change Password

SEQUENCE DIAGRAM

:User :System :Admin

Search Document Login

Provide user interface

System User
Confirm Login

Login
Upload Document

Validate login Change Password

Display Search Document
Create User
User validated

Search Document
Change Password
Add/update Document
 COLLABORATION DIAGRAM

1: Search Document
:User :System

2: Login
4: Upload Document
5: Create User
6: Change Password

3: Confirm Login

:Admin

Fig 5. Collaboration Diagram

 PERFORMANCE REQUIREMENTS

PERFORMANCE REQUIREMENTS
As a Performance Requirement, it will be useful to find how many years of past data does the
system require maintaining in its database. It is extremely important before designing a system
that you find out all the possible extremes, so that you can be prepared to handle the situation.

Thus getting the idea about the data volume, this will not only uncover the sheer data volume,
but also will prompt us in to finding ways to improve performances in data retrieval times and
ease of maintenance of data.

TECHNICAL REQUIREMENTS

Although there is no such direct requirement, yet it will be useful to find out the structure of the
geographical database schemas that the authorities are using to store data.

Obtaining such information will increase the portability of the system. However there is no
assurance that such information exists and even if it does, whether it is obtainable as such
information
 SOFTWARE QUALITY ATTRIBUTES

Consistent Programming Model

Different programming languages have different approaches for doing a task. For example,
accessing data with a VB 6.0 application and a VC++ application is totally different. When using
different programming languages to do a task, a disparity exists among the approach developers
use to perform the task. The difference in techniques comes from how different languages
interact with the underlying system that applications rely on.

Direct Support for Security

Developing an application that resides on a local machine and uses local resources is easy. In this
scenario, security isn't an issue as all the resources are available and accessed locally. Consider
an application that accesses data on a remote machine or has to perform a privileged task on
behalf of a no privileged user. In this scenario security is much more important as the application
is accessing data from a remote machine.

Simplified Development Efforts

Let's take a look at this with Web applications. With classic ASP,when a developer needs to
present data from a database in a Web page, he is required to write the application logic (code)
and presentation logic (design) in the same file. He was required to mix the ASP code with the
HTML code to get the desired result.
CHAPTER 3 – SYSTEM DESIGN AND TEST PLAN

DECOMPOSITION DESCRIPTION

The system functions can be described as follows:

Login:
This module describes the login part of the semantic web solution project. The admin logged
into the account and capable of Adding a new employee user and can add the custom security settings.
After completing the necessary operations user can finish their sessions.

Add User:
A user can be added by the administrator and every user can post new topics by entering the
title and keywords for the particular topic. A user must have a unique user name to identify a particular
user. A password used to separate a user from the accessing it other users. Any number of users can be
added in a domain.

Upload:
Upload content used to upload a new document into a local drive. This recess includes the
following. Title of the topic being uploaded and the keywords to search the specific document and
description of the keywords used and the entire content of the document. After entering these details a
File has to be uploaded in order to include the appropriate content. After successful upload of a file
content any user can search the content by searching it from the desktop. And it is also possible to
search without logging into the user account.

Displaying the content:

Used to render (show) the content of the uploaded files and documents. The collection of files
included here includes the documents from every user of the application and the administrator. It
should display a specific document after the search completes.
 It also allows a user to edit or delete a particular topic. The arrangement of this is as follows.
S.No, tile of the doc, description, Content of the file, file name, file size and the operations Edit and
Delete.

Changing the Password:

Password can be changed after entering into a articular account by logging in. change of
password used to enhance and possess security in the domain. A user can change only his/he individual
password not the other users of the system. To change a existing password a user must logged into
his/her account and change the password by entering the old password and new password. New
password has to be entered twice to check the strings from the user.

Search:
Search used to search a particular document in a particular domain or within some premises.
These premises generate the security of the files and documents. Any user can query and need not to
login to accomplish a search task. Search is based on the keywords entered in the document. Keywords
used to search and get a document easily. Search begins by searching it with the content of the file
description.
 DEPENDENCY DESCRIPTION

The following is the use case diagram for the system. It describes the dependency among various
modules.

USE CASE DIAGRAM

Login

Confirm Login

:admin Upload Document system

Create User

Change Password
 DETAILED DESIGN
DATABASE TABLES

Table Name: Module

Table Name: Search Content

Table Name: Users

 PROPOSED SAMPLING METHODS

PROCESS AND METHODOLOGY

The strategy deployed here is the Software Development Life Cycle (SDLC). The five phases of
the software development life cycle is important and is crucial in any software development life
cycle. The five phases involved are:

 Analyzing the Customers Problem / Analysis

 Design
 Coding
 Testing
 Implementation and Maintenance.
Analysis

This is the most important phase in any software development. First of all the basic need
to develop any software is to analyze the problems of the customer, what the customer requires,
the expectations with the software and many more. The customer’s requirement is tracked down
and based on the needs of the customer; the design is generated for the software. Once the
customer’s requirements are tracked down, various factors such as the team length for the
particular product is set, with the goals assigned to each and every key player who is involved in
this project.

The cost estimation of the particular project is also done. The deadlines are assigned to each and
every key player and they ought to complete the task well within the date assigned to them.
Design

After the analysis is done, the programmers sit down and work towards the design of the
particular software. The design includes the front end and the back end design.

Back End Design

The Back End Design is much more crucial, since it is the one that is going to hold the
data base. The data base is vital for any concern and it is the backend that holds the database, so
the preference is first laid to the Backend. The structure of the database should be clear, once the
structure of the database is clear, one can start working on the front end. The backend includes
the table structure that holds the records in the specific data type.

Front End Design

The front-end design is based on the structure of the backend design. The programmer
designs the front-end with the help of the tools deployed to them. The front end is only to view
the data and hence factors such as the height, width, color, Background of the form is given more
preference as to attract the attention of the customers.

Coding

Coding is again based on the design phase; the coding is generated based on the
textboxes, the command buttons, the label buttons, and the checkboxes and so on.

The coding must match the design else the data will not be generated. After the design
phase the coding is taken over and the test case generations ought to be carried and the errors that
occurs in the particular coding is debugged.

Testing

Each and every phase is tested individually, the analysis phase, the design phase, the
coding phase. All these phases are tested and if error free, it moves to report generation and
documentation. The output of one phase acts as the input to another phase.
 SYSTEM TESTING

The purpose of testing is to discover errors. Testing is the process of trying to discover every
conceivable fault or weakness in a work product. It provides a way to check the functionality of
components, sub assemblies, assemblies and/or a finished product It is the process of exercising
software with the intent of ensuring that the Software system meets its requirements and user
expectations and does not fail in an unacceptable manner. There are various types of test. Each
test type addresses a specific testing requirement.

TYPES OF TESTS
Unit testing
Unit testing involves the design of test cases that validate that the internal program logic is
functioning properly, and that program input produce valid outputs. All decision branches and
internal code flow should be validated. It is the testing of individual software units of the
application .it is done after the completion of an individual unit before integration. This is a
structural testing, that relies on knowledge of its construction and is invasive. Unit tests perform
basic tests at component level and test a specific business process, application, and/or system
configuration. Unit tests ensure that each unique path of a business process performs accurately
to the documented specifications and contains clearly defined inputs and expected results.

Integration testing

Integration tests are designed to test integrated software components to determine if they
actually run as one program. Testing is event driven and is more concerned with the basic
outcome of screens or fields. Integration tests demonstrate that although the components were
individually satisfaction, as shown by successfully unit testing, the combination of components is
correct and consistent. Integration testing is specifically aimed at exposing the problems that
arise from the combination of components.
Functional test

Functional tests provide a systematic demonstrations that functions tested are available as
specified by the business and technical requirements, system documentation, and user manuals.

Functional testing is centered on the following items:

Valid Input : identified classes of valid input must be accepted.

Invalid Input : identified classes of invalid input must be rejected.

Functions : identified functions must be exercised.

Output : identified classes of application outputs must be exercised.

Systems/Procedures: interfacing systems or procedures must be invoked.

Organization and preparation of functional tests is focused on requirements, key functions, or

special test cases. In addition, systematic coverage pertaining to identify

Business process flows; data fields, predefined processes, and successive processes must be
considered for testing. Before functional testing is complete, additional tests are identified and
the effective value of current tests is determined.

System Test
System testing ensures that the entire integrated software system meets requirements. It tests a
configuration to ensure known and predictable results. An example of system testing is the
configuration oriented system integration test. System testing is based on process descriptions
and flows, emphasizing pre-driven process links and integration points.
White Box Testing
White Box Testing is a testing in which in which the software tester has knowledge
of the inner workings, structure and language of the software, or at least its
purpose. It is purpose. It is used to test areas that cannot be reached from a black
box level.

Black Box Testing

Black Box Testing is testing the software without any knowledge of the inner
workings, structure or language of the module being tested . Black box tests, as
most other kinds of tests, must be written from a definitive source document, such
as specification or requirements document, such as specification or requirements
document. It is a testing in which the software under test is treated, as a black
box .you cannot “see” into it. The test provides inputs and responds to outputs
without considering how the software works.
 Document Change History

Version Number Date Contributor Description

V1.0 No changes were made

1. Introduction

This test approach document describes the appropriate strategies, process, workflows and
methodologies used to plan, organize, execute and manage testing for Semantic Web Solution
with information sharing in Natural Language process.

Scope

In Scope

Semantic Web Solution with information sharing in Natural Language process Test Plan defines
the unit, integration, system, regression, and Client Acceptance testing approach. The test
scope includes the following:

 Testing of all functional, application performance, security and use

cases requirements listed in the Use Case document.
 Quality requirements and fit metrics of Semantic Web Solution with
information sharing in Natural Language process.
 End-to-end testing and testing of interfaces of all systems that interact
with the Semantic Web Solution with information sharing in Natural
Language process.


Out of Scope
The following are considered out of scope for Semantic Web Solution with information sharing
in Natural Language process.

Test Plan and testing scope:

 Functional requirements testing for systems for Semantic Web

Solution with information sharing in Natural Language process.
 Testing of Business SOPs, disaster recovery and Business Continuity
Plan.

Quality Objective

Primary Objective

A primary objective of testing application systems is to assure that the system meets the full
requirements, including quality requirements (AKA: Non-functional requirements) and fit
metrics for each quality requirement and satisfies the use case scenarios and maintain the
quality of the product. At the end of the project development cycle, the user should find that the
project has met or exceeded all of their expectations as detailed in the requirements.

Any changes, additions, or deletions to the requirements document, Functional Specification, or

Design Specification will be documented and tested at the highest level of quality allowed within
the remaining time of the project and within the ability of the test team.

Secondary Objective
The secondary objective of testing application systems will be to: identify and expose all issues
and associated risks, communicate all known issues to the project team, and ensure that all
issues are addressed in an appropriate matter before release. As an objective, this requires
careful and methodical testing of the application to first ensure all areas of the system are
scrutinized and, consequently, all issues (bugs) found are dealt with appropriately.

The traditional development and testing processes have been customized to allow for faster and
more frequent delivery cycles. Specifically, testing will now consist of the following phases
(listed chronologically):

Unit and integration level – adherence to coding standards and successful communication
between units
Code Quality Assurance - acceptance into system level testing by successfully repeating a
small subset of the tests performed in the code and integration level
System level – compatibility, performance, usability, functionality etc.
System Quality Assurance & Acceptance (acceptance into Production)
Post Implementation

Each testing phase will be described within its own test plan. While the MTP (this document)
may outline the overall strategy and document the aspects of the testing that is common to all of
the phases.

2. High Level Functional Requirements

Testing will consist of several phase (see introduction), each phase may or may not include
testing of anyone or more of the following aspects of the Semantic Web Solution with
information sharing in Natural Language process Software (listed alphabetically):

Accessibility
Audit
Availability
Coding standards
Compatibility
Content
Functional
Legal
Marketing
Navigation
Performance
Reliability
Scalability
Security
Site recognition
Usability

3. Exit Criteria

It is the intent that all of the individual test cases contained in each test plan will be performed.
However, if time does not permit, some of the low priority test cases may be dropped.

4. Test Deliverables

The following documents will be generated as a result of these testing activities:

Master test plan (MTP - this document)
Combination incident/test summary reports for each phase
Test log for each phase
Automated test scripts and supporting test data

Note: Under normal testing conditions, a daily incident report would be produced rather than a
combined incident/test summary report. A daily incident report would normally be used by the
development team to get a “heads up” on any potential defects However, due to the short test
execution time period a single incident/test summary report will be produced for each of the
testing phases. With the exception of the automated test scripts, all documents will be delivered
as Microsoft Office 2000 documents.

5. Test Environment

The system test environment will be used for the server-side configuration and Windows XP
desktop P.C running Internet Explorer 6.0 will be used (unless otherwise stated) for the client-
side configuration. Windows XP was chosen because this is the O/S that is currently installed on
the majority of the testing team’s desktop P.C’s, while Internet Explorer was chosen because of
it’s strict adherence to HTML/JavaScript standards, making it easier to spot such errors.

Available Testing Tools

The following 3rd party “free” tools were available to scan the Web site and provide feedback:

· Bobby (accessibility, performance & html syntax) – cast.org

· Freeappraisal (performance from 35 different cities) – keynote.com
· Scrubby (meta tag analyzer) – scrubtheweb.com
· Site analysis (search engine ratings) – site-see.com
· Stylet (style sheet validation) – microsoft.com
· Tune up (performance & style checker) & gif lube (gif analyzer) – websitegarage.com
· Websat (usability) – nist.gov
· Web metasearch (search engine ratings) – dogpile.com
· Webstone (performance benchmarking tool) - mindcraft.com
· Windiff (file comparison) – microsoft.com
· W3C validation service (html and css syntax) – w3c.org

In addition the following “commercial” tools were available:

· Aetgweb (pair-wise combinations) from Telcordia/Argreenhouse

· Astra Site Manager (linkage) from Mercury Interactive
· eTester suite (capture/reply, linkage & performance) from RSW – 100 virtual user license
· FrontPage (spell checking) from Microsoft
· Ghost (software configuration) from Symatec
· KeyReadiness (large scale performance testing) from Keynote systems
· LinkBot Enterprise (link checking, HTML compliance and performance estimates) from
Watchfire
· Prophecy (large scale performance testing) from Envive
· WebLoad (performance) from Radview – 1000 virtual user license
· Word (readability estimates) from Microsoft

A manual digital stopwatch was also available.

6. Test Team

The following people will be responsible for:

CEO – Project sponsor

IS Director– Decisions requiring senior management approval
Test Manager – System and post implementation testing
Development Manager – Unit and integration testing
QA Manager – Quality Assurance
Office Manager for Asia-Pacific branch - International testing
Librarian – Configuration management
VP of Marketing – Final acceptance of the Software
Business Analyst – Business operational matters
Legal Counsel –Legal matters
VP of HR – Staffing issues
7. Test Schedule

The following tentative schedule will hopefully be meet:

· Test design (this document) is expected to be completed by the end of this month

· Test execution is expected to last no more than two weeks and to start immediately after the test
plans have been approved and the Web application has been hosted

· Producing the Test Incident/Summary report is expected to be completed within 2 business

days of completing the test execution phase.

8. Issue Resolution

An Excel sheet is used to track the issues and risk that evolves during the testing process and the
corrective method is also provided.

9. Approval

The IS Director must approve this plan.

CHAPTER 4 – IMPLEMENTATION AND RESULTS

IMPLEMENTATION

Implementation is the stage in the project where the theoretical design is turned Into a working
system and is giving confidence on the new system for the users , which it will work efficiently
and effectively. It involves careful planning, investigation of the current System and its
constraints on implementation, design of methods to achieve the change over, an evaluation, of
change over methods. Apart from planning major task of preparing the implementation are
Search of users. The more complex system being implemented, the more involved will be the
system analysis and the design effort required just for implementation.

An implementation co-ordination committee based on policies of individual organization has

been appointed. The implementation process begins with preparing a plan for the implementation
of the system. According to this plan, the activities are to be carried out, discussions made
regarding the equipment and resources and the additional equipment has to be acquired to
implement the new system.

Implementation is the final and important phase, the most critical stage in achieving a successful
new system and in giving the users confidence. That the new system will work effective .The
system can be implemented only after through testing is done and if it found to working
according to the specification . This method also offers the greatest security since the old system
can take over if the errors are found or inability to handle certain type of transactions while using
the new system.
 RESULTS

Screen Shots

Search
Loginform
Login Home
Add User
Change Password
Upload Document
Edit/Delete Document
Edit Document
 SAMPLE CODING

Search Page

Imports System.IO
Imports System.Diagnostics
Imports System.Text
Imports System.Text.RegularExpressions

Namespace SearchDotnetXML

Partial Class SiteSearch

Inherits System.Web.UI.Page

#Region " Web Form Designer Generated Code "

'This call is required by the Web Form Designer.

<System.Diagnostics.DebuggerStepThrough()> Private Sub
InitializeComponent()

End Sub

Private Sub Page_Init(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles MyBase.Init
'CODEGEN: This method call is required by the Web Form Designer
'Do not modify it using the code editor.
InitializeComponent()
End Sub

#End Region
Protected WithEvents AllWords As System.Web.UI.WebControls.RadioButton
Protected WithEvents AnyWords As System.Web.UI.WebControls.RadioButton
Protected WithEvents Phrase As System.Web.UI.WebControls.RadioButton

Private sSite As Searchs.UserSearch

Private Sub Page_Load(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles MyBase.Load

If IsNothing(sSite) Then
sSite = Session("Site")
End If

End Sub

Private Sub SearchButton_Click(ByVal sender As System.Object, ByVal e

As System.EventArgs) Handles SearchButton.Click
Dim SearchString As String
SearchResultsPanel.Visible = False
SearchString = Trim(Request.Params("search"))

If Not SearchString.Equals("") Then

 sSite = SearchSite(SearchString)
Session("Site") = sSite

If Not IsNothing(Searchs.Site.PageDataset) Then

PagesDatagrid.CurrentPageIndex = 0
DisplayContent()
End If
End If
End Sub

Private Sub DisplayContent()

If Not IsNothing(sSite.PageDataset) Then
SearchResultsPanel.Visible = True
SearchWords.Text = sSite.SearchWords

If ViewState("SortExpression") Is Nothing Then

ViewState("SortExpression") = "PageId Desc"
End If

BindDataGrid(ViewState("SortExpression"))
TotalFiles.Text = Searchs.Site.TotalFilesSearched
FilesFound.Text = sSite.TotalFilesFound
End If
End Sub

Private Function SearchSite(ByVal strSearch As String) As

Searchs.UserSearch
Dim UserSearch As Searchs.UserSearch
UserSearch = New Searchs.UserSearch()
'Read in all the search words into one variable
UserSearch.SearchWords = strSearch

UserSearch.Search()

Return UserSearch
End Function

Private Sub BindDataGrid(ByVal strSortField As String)

Dim PagesDataView As DataView
PagesDataView =
sSite.PageDataset.Tables("SearchPages").DefaultView
PagesDataView.Sort = strSortField
PagesDatagrid.DataSource = PagesDataView
PagesDatagrid.DataBind()

End Sub

Protected Sub PagesDatagrid_SortCommand(ByVal s As System.Object,

ByVal e As System.Web.UI.WebControls.DataGridSortCommandEventArgs) Handles
PagesDatagrid.SortCommand
ViewState("SortExpression") = e.SortExpression
DisplayContent()
End Sub
 Protected Sub PagesDatagrid_PageIndexChanged(ByVal s As System.Object,
ByVal e As System.Web.UI.WebControls.DataGridPageChangedEventArgs) Handles
PagesDatagrid.PageIndexChanged
PagesDatagrid.CurrentPageIndex = e.NewPageIndex
DisplayContent()
End Sub

Protected Function DisplayTitle(ByVal Title As String, ByVal Path As

String) As String
Return String.Format("<A href='{1}'>{0}</a>", Title, Path)
End Function

Protected Function DisplayPath(ByVal Path As String) As String

Return String.Format("{0}{1}/{2}",
Request.ServerVariables("HTTP_HOST"), Request.ApplicationPath, Path)
End Function
End Class

End Namespace

QueryBuilder

Imports System.Text.RegularExpressions

Namespace SearchDotnetXML.Searchs

Public Class QueryBuilder

Public Shared Function Build(ByRef asFieldAry As String(), ByVal

asKeyWords As String) As String
'Senthil
Dim asKeyWords1 As String = asKeyWords
'End
Dim RegExp As Regex
Dim Pattern As String
Dim RequiredWords As MatchCollection
Dim UnwantedWords As MatchCollection
Dim OptionalWords
Dim SqlString As String
Dim ArrayIndex As Integer
Dim Keyword As String

Pattern = "((AND|[+&])\s*[\(\[\{""].*[\)\]\}""])|((AND\s|[+&])\s*\
b[-\w']+\b)"

RegExp = New Regex(Pattern, RegexOptions.IgnoreCase)

RequiredWords = RegExp.Matches(asKeyWords)

asKeyWords = RegExp.Replace(asKeyWords, Pattern, "",

RegexOptions.IgnoreCase)
 Pattern = "(((NOT|[-])\s*)?[\(\[\{""].*[\)\]\}""])|(((NOT\s+|[-])\
s*)\b[-\w']+\b)"
UnwantedWords = RegExp.Matches(asKeyWords, Pattern)

asKeyWords = RegExp.Replace(asKeyWords, Pattern, "",

RegexOptions.IgnoreCase)

Pattern = "(((OR|[|])\s*)?[\(\[\{""].*[\)\]\}""])|(((OR\s+|[|])\
s*)?\b[-\w']+\b)"
OptionalWords = RegExp.Matches(asKeyWords, Pattern,
RegexOptions.IgnoreCase)
asKeyWords = RegExp.Replace(asKeyWords, Pattern, "",
RegexOptions.IgnoreCase)

If Not RequiredWords.Count = 0 Then

SqlString = SqlString & "("

Keyword = RequiredWords.Item(ArrayIndex).Value
Keyword = asKeyWords1

Keyword = RegExp.Replace(Keyword, "^(AND|[+&])\s*", "",

RegexOptions.IgnoreCase)
Keyword = RegExp.Replace(Keyword, "[()""\[\]{}]", "",
RegexOptions.IgnoreCase)

Keyword = Replace(Keyword, "'", "''")

If Not ArrayIndex = 0 Then

SqlString = SqlString & " AND "

End If

SqlString = SqlString & "(" & Join(asFieldAry, " LIKE '%" &
Keyword & "%' OR ") & " LIKE '%" & Keyword & "%')"

SqlString = SqlString & ")"

End If

If Not OptionalWords.Count = 0 Then

If SqlString = "" Then
SqlString = "("
Else
SqlString = SqlString & " AND ("
End If
Keyword = OptionalWords.Item(ArrayIndex).Value
Keyword = asKeyWords1
Keyword = RegExp.Replace(Keyword, "^(OR|[|])\s*", "",
RegexOptions.IgnoreCase)
Keyword = RegExp.Replace(Keyword, "[()""\[\]{}]", "",
RegexOptions.IgnoreCase)

Keyword = Replace(Keyword, "'", "''")

If Not ArrayIndex = 0 Then

SqlString = SqlString & " OR "

 End If

SqlString = SqlString & "(" & Join(asFieldAry, " LIKE '%" &
Keyword & "%' OR ") & " LIKE '%" & Keyword & "%')"

SqlString = SqlString & ")"

End If

If Not UnwantedWords.Count = 0 Then

If SqlString = "" Then

SqlString = "("

Else

SqlString = SqlString & " AND NOT ("

End If

For ArrayIndex = 0 To UnwantedWords.Count - 1

Keyword = UnwantedWords.Item(ArrayIndex).Value

Keyword = RegExp.Replace(Keyword, "^(NOT|[-])\s*", "",

RegexOptions.IgnoreCase)
Keyword = RegExp.Replace(Keyword, "[()""\[\]{}]", "",
RegexOptions.IgnoreCase)

Keyword = Replace(Keyword, "'", "''")

If Not ArrayIndex = 0 Then

SqlString = SqlString & " OR "
End If

SqlString = SqlString & "(" & Join(asFieldAry, " LIKE '%"

& Keyword & "%' OR ") & " LIKE '%" & Keyword & "%')"
Next
SqlString = SqlString & ")"
End If
If Not SqlString = "" Then
SqlString = "(" & SqlString & ")"
End If
Return SqlString
End Function

End Class
End Namespace
Namespace SearchDotnetXML.Searchs
Public Class UserSearch
Private m_TotalFilesFound As Integer = 0
Private m_SearchWords As String = ""
Private Shared m_PageDataset As DataSet
Private m_Page As New System.Web.UI.Page()

Public Property SearchWords() As String

Get
Return m_SearchWords
End Get
Set(ByVal Value As String)
m_SearchWords = Value
End Set
End Property

Public ReadOnly Property PageDataset() As DataSet

Get
Return m_PageDataset
End Get
End Property

Public ReadOnly Property TotalFilesFound() As Integer

Get
Return m_TotalFilesFound
End Get
End Property

Public Function Search() As DataSet

If Searchs.Site.EnglishLanguage = True Then
m_SearchWords = m_Page.Server.HtmlEncode(m_SearchWords)
Else
m_SearchWords = Replace(m_SearchWords, "<", "&lt;", 1, -1, 1)
m_SearchWords = Replace(m_SearchWords, ">", "&gt;", 1, -1, 1)
End If

m_PageDataset = Searchs.SearchPagesDataset.Create()

FiterPagesDatset()
Return m_PageDataset
End Function

Private Sub FiterPagesDatset()

Dim StrExpr As String
Dim FoundRows As DataRow()
Dim Field() As String = {"Title", "Description", "Keywords",
"Contents"}

StrExpr = Searchs.QueryBuilder.Build(Field, m_SearchWords)

m_Page.Trace.Warn("Error", StrExpr)
FoundRows =
Searchs.Site.PageDataset.Tables("Pages").Select(StrExpr)

FillDataset(FoundRows)
End Sub
 Private Sub FillDataset(ByVal rows() As DataRow)

If rows.Length <= 0 Then

m_Page.Trace.Warn("Error", "no rows found")
Exit Sub
Else
m_TotalFilesFound = rows.Length
End If

Dim PageRow As DataRow

For Each PageRow In rows

Dim SearchPage As New Searchs.Page()

SearchPage.Title = PageRow("Title")
SearchPage.Description = PageRow("Description")
SearchPage.Keywords = PageRow("Keywords")
SearchPage.Contents = PageRow("Contents")
SearchPage.Path = PageRow("Path")
SearchPage.CheckFileInfo()
Searchs.SearchPagesDataset.StoreFile(m_PageDataset,
SearchPage)
Next PageRow

End Sub

End Class
End Namespace

Style Sheet
body {
scrollbar-face-color: #ECDFBC;
scrollbar-shadow-color: #666666;
scrollbar-highlight-color: #FFFFFF;
scrollbar-track-color: #ECDBBC;
scrollbar-arrow-color: #FFFFFF;
scrollbar-3dlight-color: #000000;
scrollbar-darkshadow-color: #000000;
font-family: Verdana, Arial, Helvetica, sans-serif;
color : #000000;
font-size: 12px;
font-weight: normal;
}
td {
font-family: Verdana, Arial, Helvetica, sans-serif;
color : #000000;
font-size: 12px;
font-weight: normal;
}
.GridFooter {
color:#333333;
background-color:#CCCC99;
}
.GridHeader
{
font-weight: bold;
color: activecaption;
background-color: #ffffff;
}
.GridPager
{
color: black;
background-color: #ffffff;
text-align: center;
}
.GridSelectedItem{
font-weight:bold;
color:activecaption;
background-color:#ffffff;
}
.GridItem
{
color: #ECDFBC;
background-color: #ffffff;
}
.path
{
color: #A6925A;
}

.button {
border: 1px outset;
background-color: #ECDFBC;
font-family: Arial, Helvetica, sans-serif;
font-size: 12px;
color: #000000;
cursor: hand;
border-color: #ECDFBC #ECDFBC #ECDFBC #ECDFBC;
}

.TextBox {
border: #ECDFBC 1px solid;
border-color: #ECDFBC #ECDFBC #ECDFBC #ECDFBC;
background-color: #FFFFFF;
background-attachment: fixed;
font-family: Verdana, Arial, Helvetica, sans-serif;
font-size: 12px;
color: #000000;
}
.SearchStatus{
background-color: #ECDFBC;
}
APPENDIXES
ASP.NET OVERVIEW

ASP.NET, the next version of ASP, is a programming framework used to create enterprise-class
Web Applications. These applications are accessible on a global basis leading to effecient
information management. The advantage of ASP.NET offers is more than just the next version of
ASP.

Why ASP.NET?

The .NET Framework was introduced with a vision to create globally distributed software with
Internet functionality and interoperability. The .NET Framework consists of many class libraries,
includes multiple language support and a common execution platform. It's a very flexible
foundation on which many different types of top class applications can be developed that do
different things. Developing Internet applications with the .NET Framework is very easy.
ASP.NET is built into this framework; we can create ASP.NET applications using any of the
built-in languages.

Unlike ASP, ASP.NET uses the Common Language Runtime (CLR) provided by the .NET
Framework. This CLR manages execution of the code we write. ASP.NET code is a compiled
CLR code instead of interpreted code (ASP). CLR also allows objects written in different
languages to interact with each other. The CLR makes development of Web applications simple.

Advantages Using ASP.NET

 ASP.NET drastically reduces the amount of code required to build large applications
 ASP.NET makes development simpler and easier to maintain with an event-driven,
server-side programming model
 ASP.NET pages are easy to write and maintain because the source code and HTML are
together
 The source code is executed on the server. The pages have lots of power and flexibility
by this approach
ASP.NET Features

ASP.NET is not just a simple upgrade or the latest version of ASP. ASP.NET combines
unprecedented developer productivity with performance, reliability, and deployment. ASP.NET
redesigns the whole process. It's still easy to grasp for new comers but it provides many new
ways of managing projects. Below are the features of ASP.NET.

Easy Programming Model

ASP.NET makes building real world Web applications dramatically easier. ASP.NET server
controls enable an HTML-like style of declarative programming that let you build great pages
with far less code than with classic ASP. Displaying data, validating user input, and uploading
files are all amazingly easy. Best of all, ASP.NET pages work in all browsers including
Netscape, Opera, AOL, and Internet Explorer.

Flexible Language Options

ASP.NET lets you leverage your current programming language skills. Unlike classic ASP,
which supports only interpreted VBScript and JScript, ASP.NET now supports more than
25 .NET languages (built-in support for VB.NET, C#, and JScript.NET), giving you
unprecedented flexibility in your choice of language.

Great Tool Support

You can harness the full power of ASP.NET using any text editor, even Notepad. But Visual
Studio .NET adds the productivity of Visual Basic-style development to the Web. Now you can
visually design ASP.NET Web Forms using familiar drag-drop-double-click techniques, and
enjoy full-fledged code support including statement completion and color-coding. VS.NET also
provides integrated support for debugging and deploying ASP.NET Web applications. The
Enterprise versions of Visual Studio .NET deliver life-cycle features to help organizations plan,
analyze, design, build, test, and coordinate teams that develop ASP.NET Web applications.
These include UML class modeling, database modeling (conceptual, logical, and physical
models), testing tools (functional, performance and scalability), and enterprise frameworks and
templates, all available within the integrated Visual Studio .NET environment.

Rich Class Framework

Application features that used to be hard to implement, or required a 3rd-party component, can
now be added in just a few lines of code using the .NET Framework. The .NET Framework
offers over 4500 classes that encapsulate rich functionality like XML, data access, file upload,
regular expressions, image generation, performance monitoring and logging, transactions,
message queuing, SMTP mail, and much more. With Improved Performance and Scalability
ASP.NET lets you use serve more users with the same hardware.

Compiled execution

ASP.NET is much faster than classic ASP, while preserving the "just hit save" update model of
ASP. However, no explicit compile step is required. ASP.NET will automatically detect any
changes, dynamically compile the files if needed, and store the compiled results to reuse for
subsequent requests. Dynamic compilation ensures that your application is always up to date,
and compiled execution makes it fast. Most applications migrated from classic
ASP see a 3x to 5x increase in pages served.

Rich output caching

ASP.NET output caching can dramatically improve the performance and scalability of your
application. When output caching is enabled on a page, ASP.NET executes the page just once,
and saves the result in memory in addition to sending it to the user. When another user requests
the same page, ASP.NET serves the cached result from memory without re-executing the
page. Output caching is configurable, and can be used to cache individual regions or an entire
page. Output caching can dramatically improve the performance of data-driven pages by
eliminating the need to query the database on every request.
Web-Farm Session State

ASP.NET session state lets you share session data user-specific state values across all machines
in your Web farm. Now a user can hit different servers in the Web farm over multiple requests
and still have full access to her session. And since business components created with the .NET
Framework are free-threaded, you no longer need to worry about thread affinity.

Enhanced Reliability

ASP.NET ensures that your application is always available to your users.

Memory Leak, Deadlock and Crash Protection

ASP.NET automatically detects and recovers from errors like deadlocks and memory leaks to
ensure your application is always available to your users. For example, say that your application
has a small memory leak, and that after a week the leak has tied up a significant percentage of
your server's virtual memory. ASP.NET will detect this condition, automatically start up another
copy of the ASP.NET worker process, and direct all new requests to the new process. Once the
old process has finished processing its pending requests, it is gracefully disposed and the leaked
memory is released. Automatically, without administrator intervention or any interruption of
service, ASP.NET has recovered from the error.

Easy Deployment

ASP.NET takes the pain out of deploying server applications. "No touch" application
deployment. ASP.NET dramatically simplifies installation of your application. With ASP.NET,
you can deploy an entire application as easily as an HTML page, just copy it to the server. No
need to run regsvr32 to register any components, and configuration settings are stored in an
XML file within the application.
Dynamic update of running application

ASP.NET now lets you update compiled components without restarting the web server. In the
past with classic COM components, the developer would have to restart the web server each time
he deployed an update. With ASP.NET, you simply copy the component over the existing
DLL, ASP.NET will automatically detect the change and start using the new code.

Easy Migration Path

You don't have to migrate your existing applications to start using ASP.NET. ASP.NET runs on
IIS side-by-side with classic ASP on Windows 2000 and Windows XP platforms. Your existing
ASP applications continue to be processed by ASP.DLL, while new ASP.NET pages are
processed by the new ASP.NET engine. You can migrate application by application, or single
pages. And ASP.NET even lets you continue to use your existing classic COM business
components.

XML Web Services

XML Web services allow applications to communicate and share data over the Internet,
regardless of operating system or programming language. ASP.NET makes exposing and calling
XML Web Services simple. Any class can be converted into an XML Web Service with just a
few lines of code, and can be called by any SOAP client. Likewise, ASP.NET makes it
incredibly easy to call XML Web Services from your application. No knowledge of networking,
XML, or SOAP is required.

Mobile Web Device Support

ASP.NET Mobile Controls let you easily target cell phones, PDAs and over 80 mobile Web
devices. You write your application just once, and the mobile controls automatically generate
WAP/WML, HTML, or iMode as required by the requesting device.
 SQL SERVER 2005

Microsoft SQL Server 2005 is a full-featured relational database management system (RDBMS)
that offers a variety of administrative tools to ease the burdens of database development,
maintenance and administration. In this article, we'll cover six of the more frequently used tools:
Enterprise Manager, Query Analyzer, SQL Profiler, Service Manager, Data Transformation
Services and Books Online. Let's take a brief look at each.
Enterprise Manager is the main administrative console for SQL Server installations. It provides
you with a graphical "birds-eye" view of all of the SQL Server installations on your network.
You can perform high-level administrative functions that affect one or more servers, schedule
common maintenance tasks or create and modify the structure of individual databases.
Query Analyzer offers a quick and dirty method for performing queries against any of your SQL
Server databases. It's a great way to quickly pull information out of a database in response to a
user request, test queries before implementing them in other applications, create/modify stored
procedures and execute administrative tasks.

SQL Profiler provides a window into the inner workings of your database. You can monitor
many different event types and observe database performance in real time. SQL Profiler allows
you to capture and replay system "traces" that log various activities. It's a great tool for
optimizing databases with performance issues or trouble shooting particular problems.

Service Manager is used to control the MSSQLServer (the main SQL Server process), MSDTC
(Microsoft Distributed Transaction Coordinator) and SQLServerAgent processes. An icon for
this service normally resides in the system tray of machines running SQL Server. You can use
Service Manager to start, stop or pause any one of these services.

Data Transformation Services (DTS) provide an extremely flexible method for importing and
exporting data between a Microsoft SQL Server installation and a large variety of other formats.
The most commonly used DTS application is the "Import and Export Data" wizard found in the
SQL Server program group.
 ADO.NET

Data Access in ADO.NET relies on two components: DataSet and Data Provider.

DataSet

The dataset is a disconnected, in-memory representation of data. It can be considered as a local

copy of the relevant portions of the database. The DataSet is persisted in memory and the data in
it can be manipulated and updated independent of the database. When the use of this DataSet is
finished, changes can be made back to the central database for updating. The data in DataSet can
be loaded from any valid data source like Microsoft SQL server database, an oracle database
from a Microsoft Access database.

Data Provider

The Data Provider is responsible for providing and maintaining the connection to the database. A
Data Provider is a set of related components that work together to provide data in an efficient
and performance driven manner. The .NET Framework currently comes with two Data
Providers: the SQL Data Provider which is designed only to work with Microsoft's SQL Server
7.0 or later and the OleDb Data Provider which allows us to connect to other types of databases
like Access and Oracle. Each Data Provider consists of the following component classes:

The Connection object which provides a connection to the database

The Command object which is used to execute a command

The Data Reader object which provides a forward-only, read only, connected recordset.