Sei sulla pagina 1di 77

1.

INTRODUCTION

1. INTRODUCTION
1.1 Background
The project abstract has been done. The requirements are identified. The functional
requirements (use cases) and the actors involved with use cases are identified. User
requirement document is done.

1.2 Overview
Footrace tracking system is designed to display a course map showing runners
progress.The continuous updating of the race course display can be monitored and can be
updated on the central server.Global positioning system technology and mobile phones can be
used to track selected runners on a course map.
The following are the modules in this project

GPS Communication Subsystem


Race Course Drawing Subsystem
Real-Time Updates
Advertisement Subsystem

1.3 Scope of the project


GPS Communication subsystem includes a web service and XML based GPS location
service which runs on a central server. It uses queries and updates the device coordinates for
use by the mobile GPS client and TV graphical display.
For Race Course Drawing subsystem the application is installed on high-end PC running
windows XP and Microsoft Framework 2.0 for creating the course map display using
windows GDI+.

The real time updates give information about the longitude and latitude values from the
GPS devices and are forwarded over an Evolution-Data optimized network to a central server
where position data was maintained for a continuous updating of the race course display.
Advertisement subsystem is used to display the advertisement content of various
companies and sponsors for the events.

1.4 Requirements Specification


The Proposed System is developed on the below stated specifications.
Hardware/Software Specifications
1. Hardware

Pentium 4 Processor
1 GB of Memory
80GB of hard drive space
GPS device
Mobile device

MS.NET 2005 with C#


Windows XP

2. Software

1.5 Existing System


Initially progress of the winner and runners were traced manually by a person going on a
bike or some other vehicle. The camera men who follow the race on a bike could give the
information about the area on which the marathon is passing on. The information regarding
the marathon would be available of the participants on whom the camera is focused.

1.6 Disadvantages of Existing System


Its only possible to view the position of the runner on whom the camera is
focused.

Position of the required runner cannot be viewed over Television sets.


The race summary is displayed much generalized. The personal interest of
the spectators is not given proper importance.
Information of each and every participant is not available.
The tracking system delays the relay of the race.
The spectator stream will be confined to Television sets

1.7 Proposed System


The development of the proposed system mainly focuses to overcome the limitations prior
to the system. Here we try to gain information about each and every runner participating in
the race. This system enables the mobile users also to get real-time updates of the race,
which was not possible in the existing system.The GPS technology will not lay any stress or
to be skeptical about the accuracy. The Time delay in relay is reduced as a result of satellite
usage. It allows spectators to know the position of each runner till the end of the race.
1. The present model uses GPS-device Emulators to track selected runners speed on a
course map.
2. The progress of the individual Athlete will be traced by attaching a GPS device to
their hand.
3. This progress can be checked using GPS device emulators in our application.
4. We are going to calculate the speed & distance and display them on device
emulator along with device coordinates, time, direction and satellite location.
5. Along with the course map the Advertisement content of various companies,
organizations and sponsors for the event are also displayed.

About GPS
The Global Positioning System (GPS) is the only fully-functional satellite navigation
system. More than two dozen GPS satellites are in medium Earth orbit, transmitting signals
allowing GPS receivers to determine location, speed and direction.
Since the first experimental satellite was launched in 1978, GPS has become indispensable
for navigation around the world and an important tool for map-making and land surveying.
GPS also provides a precise time reference used in many applications including scientific
study of earthquakes, and synchronization of telecommunications networks.
Technologically and scientifically, GPS is perhaps the most important practical application
so far of Einstein's theory of general relativity.
A GPS receiver calculates its position by measuring the distance between itself and three
or more GPS satellites. Measuring the time delay between transmission and reception of each
GPS radio signal gives the distance to each satellite, since the signal travels at a known speed.
The signals also carry information about the satellites' location.
By determining the position of, and distance to, at least three satellites, the receiver can
compute its location using trilateration. Receivers do not have perfectly accurate clocks, and
must track one extra satellite to correct their clock error.

GPS Device Emulator


The GPS device simulator exactly replicates the usage of original physical GPS Device. As
the GPS Device has some constraints when dealing with system connectivity at the tracking
time, this task can be simplified using simulator.
The device emulator exhibits same properties such as displaying the quantized information
as such location, latitude, longitude, elevation and direction of the gps device holder. It also
gives abundant information of the satellite which is in contact with the device emulator.

Pocket PC
According to Microsoft, the Pocket PC is "a handheld device that enables users to store
and retrieve e-mail, contacts, appointments, tasks, play multimedia files, games, exchange text
messages with Windows Live Messenger (MSN Messenger), browse the Web, and more."
For instance, any device which is to be classified as a Pocket PC must

Run Microsoft's Windows Mobile, Pocket PC edition

Come bundled with a specific suite of applications in ROM

Include a touch screen

Include a directional pad or touchpad

Include a set of hardware application buttons

Some Pocket PCs feature integrated GPS often combined with mobile phone functionality.
Pocket PCs with built-in telephony differ from Windows Mobile Smart phone Edition devices
in several respects - including the lack of a touch screen on the latter.

2. THEORETICAL ANALYSIS

2. THEORETICAL ANALYSIS
2.1 Microsoft.NET Framework
The .NET Framework is a new computing platform that simplifies application
development in the highly distributed environment of the Internet. The .NET Framework is
designed to fulfill the following objectives

To provide a consistent object-oriented programming environment whether object


code is stored and executed locally, executed locally but Internet-distributed, or
executed remotely.

To provide a code-execution environment that minimizes software deployment and


versioning conflicts

To provide a code-execution environment that guarantees safe execution of code,


including code created by an unknown or semi-trusted third party.

To provide a code-execution environment that eliminates the performance Problems of


scripted or interpreted environments.

To make the developer experience consistent across widely varying types of


Applications, such as Windows-based applications and Web-based applications.

To build all communication on industry standards to ensure that code based on the
.NET Framework can integrate with any other code.

The .NET Compact Framework is used to develop applications for smart devices. By smart
devices we mean devices that run the Pocket PC 2000, Pocket PC 2002 and Windows
CE.NET operating systems. These operating systems are targeted for mobile devices (like
PDA, Pocket PC) that have small display areas, small storage areas and run on batteries.
Developing applications for devices has never been easier! It essentially consists of an
operating system and development tools (like embedded Visual Basic and embedded Visual
C++). With the advent of the .NET Compact Framework, Microsoft has unified the
programming models between developing applications for PC's and applications for devices.
The .NET Compact Framework provides a managed execution environment for applications
on devices and makes writing applications extremely easy.

The .NET Framework has two main components

The common language runtime and

The .NET Framework class library.

2.1.1 Common Language Runtime


The CLR is the most important part of the .NET Compact Framework. It is responsible for
taking a .NET assembly and then setting up an application domain for it to run. A
native just-in-time (JIT) compiler is used to compile the MSIL code to the actual
machine bits. The CLR provides the services of memory management, garbage
collection and class loading. The CLR also manages the security structure in which the
application executes.
The CLR consists of two parts

Execution engine which is responsible for execution of the code and

Case class libraries which are a set of reusable classes that contain a basic set of
building blocks that applications can use. The following figure shows a typical
construction of the .NET Compact Framework.

The diagram is pretty straight forward.


Applications, device libraries and base class libraries occupy the managed space. The CLR
provides the execution environment for these applications along with a set of base services.

The execution engine itself is a native executable, as is the Platform


Adaptation Layer which is an abstraction between the execution engine and the
underlying operating systems.

These two layers are packaged as a single executable called MSCOREE.

2.1.2 .NET Framework Class Library


The .NET Framework class library is a collection of reusable types that tightly integrate
with the common language runtime. The class library is object oriented, providing types from
which your own managed code can derive functionality. This not only makes the .NET
Framework types easy to use, but also reduces the time associated with learning new features
of the .NET Framework. In addition, third-party components can integrate seamlessly with
classes in the .NET Framework.
You can use the .NET Framework to develop the following types of applications and services

Console applications.

Scripted or hosted applications.

Windows GUI applications (Windows Forms).

ASP.NET applications.

XML Web services.

Windows services.

Features of the Common Language Runtime


The common language runtime manages memory, thread execution, code execution, code
safety verification, compilation, and other system services. These features are intrinsic to the
managed code that runs on the common language runtime.
With regards to security, managed components are awarded varying degrees of trust,
depending on a number of factors that include their origin (such as the Internet, enterprise

10

network, or local computer). This means that a managed component might or might not be
able to perform file-access operations, registry-access operations, or other sensitive functions,
even if it is being used in the same active application.
The runtime enforces code access security. For example, users can trust that an executable
embedded in a Web page can play an animation on screen or sing a song, but cannot access
their personal data, file system, or network. The security features of the runtime thus enable
legitimate Internet-deployed software to be exceptionally feature rich.
The runtime also enforces code robustness by implementing a strict type-and-codeverification infrastructure called the common type system (CTS). The CTS ensures that all
managed code is self-describing. The various Microsoft and third-party language compilers
generate managed code that conforms to the CTS.
This means that managed code can consume other managed types and instances, while
strictly enforcing type fidelity and type safety.
A feature called just-in-time (JIT) compiling enables all managed code to run in the native
machine language of the system on which it is executing. Meanwhile, the memory manager
removes the possibilities of fragmented memory and increases memory locality-of-reference
to further increase performance.
Finally, the runtime can be hosted by high-performance, server-side applications, such as
Microsoft SQL Server and Internet Information Services (IIS). This infrastructure enables
you to use managed code to write your business logic, while still enjoying the superior
performance of the industry's best enterprise servers that support runtime hosting.

Client Application Development


Client applications are the closest to a traditional style of application in Windows-based
programming. These are the types of applications that display windows or forms on the
desktop, enabling a user to perform a task. Client applications include applications such as
word processors and spreadsheets, as well as custom business applications such as data-entry

11

tools, reporting tools, and so on. Client applications usually employ windows, menus, buttons,
and other GUI elements, and they likely access local resources such as the file system and
peripherals such as printers.
Another kind of client application is the traditional ActiveX control (now replaced by the
managed Windows Forms control) deployed over the Internet as a Web page. This application
is much like other client applications: it is executed natively, has access to
For example, the .NET Framework provides simple properties to adjust visual attributes
associated with forms. In some cases the underlying operating system does not support
changing these attributes directly, and in these cases the .NET Framework automatically
recreates the forms. This is one of many ways in which the .NET Framework integrates the
developer interface, making coding simpler and more consistent.

Server Application Development


Server-side applications in the managed world are implemented through runtime hosts.
Unmanaged applications host the common language runtime, which allows your custom
managed code to control the behavior of the server. This model provides you with all the
features of the common language runtime and class library while gaining the performance and
scalability of the host server.
The following illustration shows a basic network schema with managed code running in
different server environments. Servers such as IIS and SQL Server can perform standard
operations while your application logic executes through the managed code.

2.2 Introduction to windows forms


Windows Forms is a framework for building Windows client applications that utilize the
common language runtime. Windows Forms applications can be written in any language that
the common language runtime supports. Some of the advantages of using Windows Forms
include the following:

12

Simplicity and power: Windows Forms is a programming model for

developing Windows applications that combines the simplicity of the Visual Basic 6.0
programming model with the power and flexibility of the common language runtime.
Lower total cost of ownership: Windows Forms takes advantage of the

versioning and deployment features of the common language runtime to offer reduced
deployment costs and higher application robustness over time. This significantly
lowers the maintenance costs (TCO) for applications written in Windows Forms.
Architecture for controls: Windows Forms offers an architecture for controls

and control containers that is based on concrete implementation of the control and
container classes. This significantly reduces control-container interoperability issues.
Security: Windows Forms takes full advantage of the security features of the

common language runtime. This means that Windows Forms can be used implement
everything from an untrusted control running in the browser to a fully trusted
application installed on a user's hard disk.
XML Web services support: Windows Forms offers full support for quickly

and easily connecting to XML Web services.


Rich graphics: Windows Forms is one of the first ship vehicles for GDI+, a

new version of the Windows Graphical Device Interface (GDI) that supports alpha
blending, texture brushes, advanced transforms, rich text support, and more.
Flexible controls: These controls also offer new features, such as "flat look"

styles for buttons, radio buttons, and check boxes.

2.3 C# .NET 2005


C# (pronounced C-Sharp, just like in musical notation) is a new language for Windows
applications, intended as an alternative to the main previous languages, C++ and VB. Its
purpose is twofold

It gives access to many of the facilities previously available only in C++, while

retaining some of the simplicity to learn of VB.

13

It has been designed specifically with the .NET framework in mind, and hence

is very well structured for writing code that will be compiled for .NET.
C# is a simple, modern, object oriented language which aims to combine the high
productivity of VB and raw power of C++. C# is a new programming language developed by
Microsoft.
Using C# we can develop console applications, web applications and windows applications.
In C#, Microsoft has taken care of C++ problems, such as memory management , pointers etc.

2.4 ADO.NET Overview


ADO.NET is an evolution of the ADO data access model that directly addresses user
requirements for developing scalable applications. It was designed specifically for the web
with scalability, statelessness, and XML in mind. ADO.NET uses some ADO objects, such as
the Connection and Command objects, and also introduces new objects. Key new ADO.NET
objects include the DataSet, DataReader, and DataAdapter. The important distinction
between this evolved stage of ADO.NET and previous data architectures is that there exists an
object -- the DataSet -- that is separate and distinct from any data stores. Because of that, the
DataSet functions as a standalone entity.
You can think of the DataSet as an always disconnected recordset that knows nothing
about the source or destination of the data it contains. Inside a DataSet, much like in a
database, there are tables, columns, relationships, constraints, views, and so forth.
DataAdapter is the an object that connects to the database to fill the DataSet. Then, it
connects back to the database to update the data there, based on operations performed while
the DataSet held the data. In the past, data processing has been primarily connection-based.
Now, in an effort to make multi-tiered apps more efficient, data processing is turning to a
message-based approach that revolves around chunks of information.
At the center of this approach is the DataAdapter, which provides a bridge to retrieve and
save data between a DataSet and its source data store. It accomplishes this by means of
requests to the appropriate SQL commands made against the data store.

14

The XML-based DataSet object provides a consistent programming model that works with
all models of data storage: flat, relational, and hierarchical. It does this by having no
'knowledge' of the source of its data, and by representing the data that it holds as collections
and data types. No matter what the source of the data within the DataSet is, it is manipulated
through the same set of standard APIs exposed through the DataSet and its subordinate
objects.
While the DataSet has no knowledge of the source of its data, the managed provider has
detailed and specific information. The role of the managed provider is to connect, fill, and
persist the DataSet to and from data stores. The OLE DB and SQL Server .NET Data
Providers (System.Data.OleDb and System.Data.SqlClient) that are part of the .Net
Framework provide four basic objects: the Command, Connection, DataReader and
DataAdapter. In the remaining sections of this document, we'll walk through each part of the
DataSet and the OLE DB/SQL Server .NET Data Providers explaining what they are, and
how to program against them.
The following sections will introduce you to some objects that have evolved, and some that
are new.
These objects are

Connections. For connection to and managing transactions against a database.

Commands. For issuing SQL commands against a database.

DataReaders. For reading a forward-only stream of data records from a SQL

Server data source.

DataSets. For storing, remoting and programming against flat data, XML data

and relational data.

DataAdapters. For pushing data into a DataSet, and reconciling data against a

database.

15

2.5 XML
XML is a markup language for documents containing structured information. Structured
information contains both content (words, pictures, etc.) and some indication of what role that
content plays (for example, content in a section heading has a different meaning from content
in a footnote, which means something different than content in a figure caption or content in a
database table, etc.). Almost all documents have some structure.A markup language is a
mechanism to identify structures in a document. The XML specification defines a standard
way to add markup to documents.

2.6 WEB SERVICES


Web services are a new breed of Web application. They are self-contained, self- describing,
modular applications that can be published, located, and invoked across the Web. Web
services perform functions, which can be anything from simple requests to complicated
business processes...Once a Web service is deployed, other applications (and other Web
services) can discover and invoke the deployed service.Viewed from an n-tier application
architecture perspective, the web service is a veneer for programmatic access to a service
which is then implemented by other kinds of middleware. Access consists of service-agnostic
request handling (a listener) and a facade that exposes the operations supported by the
business logic.
The logic itself is implemented by a traditional middleware platform. A web service can
be described as a function that can be deployed over the web and can be called by any other
application or other service. The name web services applies to services deployed over the
types of web i.e. internet, intranet and extranet. Web services can offer any kind of service
which focuses on business to consumer, business to business, peer to peer or department to
department communication. Web services reduces the communication gap among the web
applications, enhancing interactivity.

16

Some of the activities related to the web services are


1. Web services need to be created.
2. The service interface and invocation methods for the web service should be defined.
3. The web service should be published on the internet or intranet to facilitate the web
users in using the service.
4. The web users should find the web service in order to use it.
5. The web service should be invoked to allow the web users to use it.
6. A web service needs to be unpublished when it is not needed or no longer available.
The following characteristics can be used to identify a web service:

A web service can be accessed over the web.

A web service has a service interface. This service interface helps the web service to
be called by another application programmed or another web service. Service interface
is an XML document this is because XML has emerged as a global data exchange
technology that has been widely accepted by the technology world.

A web service should be registered in a service registry to be accessed by other


programs. Web services use standard web protocols to communicate for example
SOAP.

An important characteristic of web services is that they support loose coupling.

An application can be broken down into any number of logical service

components.

Each of these service components can be built using any architectural frame work and
can be physically distributed among a number of computers.

These machines should be on the web and the services need to be registered with the
service registry.

17

Consuming a web service


A web service can be consumed in various ways which include either consuming the
service using a web browser or a web/desktop application. The different methods using
which a web service can be consumed are:

HTTP-GET

HTTP-POST

SOAP

Using web services proxy

2.7 WEB SERVICES DESCRIPTION LANGUAGE(WSDL) Web Services


Description Language is an XML format for describing network services as a set of endpoints
operating on messages containing either document-oriented or procedure-oriented
information.
The operations and messages are described abstractly, and then bound to a concrete
network protocol and message format to define an endpoint. Related concrete endpoints are
combined into abstract endpoints (services). WSDL is extensible to allow description of
endpoints and their messages regardless of what message formats or network protocols are
used to communicate. Visual Studio.NET has the ability to auto-generate proxies of Web
services based on WSDL. This feature automatically allows developers to have an SDK to
work with at the object level without having to do string manipulation to build SOAP
Requests.
It is a grammar for a web service or moreover to be thought of as a language that describes
a web service. It is developed through a joint research by Microsoft ,Ariba and IBM. WSDL
provides a common frame work to describe web services. It is XML based service description
language. It helps you define a web service and allows you to specify the way in which a

18

service can be accessed. Information about the web service such as the method contains,the
parameters that need to be passed to these methods are described through WSDL.

2.8 UDDI
UDDI - Universal Description, Discovery and Integration creates a platform-independent, open
framework for describing services, discovering businesses, and integrating business services. It is a
directory service which business can be registered and web services can be searched. It can be used
for locating Information about web services offered by the business partners.

List of providers for a particular web service.

The technical details of how a particular web service has been exposed .

The companies under specific business category offering a particular web

service and so

on.Thus the services registered once with UDDI are accessible from

anywhere on the net. UDDI is helpful both to the web consumer as well as the
programmer this is because UDDI features programmatic discovery of web services.
UDDI can be used for locating technical details about business registrations to be
combined with online market places and search engines to provide advanced search features.
UDDI provides market places and search engines with standardized formats for programmatic
service and business discovery.

Definitions and acronyms

ADO.NET - ActiveX Data Objects, Microsoft's high-level interface for data objects.

XML - Extensible Markup Language, a specification developed by the W3C. XML is

a pared-down version of SGML, designed especially for Web documents.

HTTP - HyperText Transfer Protocol, the underlying protocol used by the World

Wide Web.

SMTP - Simple Mail Transfer Protocol, a protocol for sending e-mail messages

between servers.

19

TCP/IP - Transmission Control Protocol over Internet Protocol. TCP is one of the

main protocols in TCP/IP networks. Whereas the IP protocol deals only with packets, TCP
enables two hosts to establish a connection and exchange streams of data.

SOAP Simple Object Access Protocol (SOAP) is a lightweight protocol for

exchange of information in a decentralized, distributed environment. SOAP relies on the


use of a transport protocol, and while it is not tied to a particular transport protocol,
currently HTTP is the only one that has been defined by the W3C.

2.9 INTRODUCTION TO ASP.NET


ASP.NET is Microsofts upgrade to ASP(Active Server Pages) . ASP.NET architecture
is very well woven into the .NET Framework to provide a powerful event-driven
programming model. The new feature of code-behind allows true separation of code and
design.
Also, you can write ASP.NET pages in any of the managed languages, and the code is
compiled to give high performance. One of the ASP.NET. feature is the capability to have
custom validation embedded into the pages from JavaScript (.js) files, which originate from
the root on the server;ASP.NET has a whole host of validation controls to use. Also the
backbone of the .NET architecture is built on XML. The use of XSL/Transforms on XML data
from DataSets provide the developer with the ability to create custom content for various
clients with minimal program logic overhead.ASP.NET is a more robust way to bring
applications to the Web. Gone are the endless lines of spaghetti code and with it the
ambiguous debugging. With ASP.NET, you will be able to create cross-browser, crossplatform applications that you can port across the Web.

2.9.1 ASP.NET Architecture


In the ASP.NET architecture, the .NET Framework works with the OS. A Webclient
requests a Web Form (ASPX) resource, which is delivered through theInternet Information
Server (IIS) combining all additional resources, which mayinclude a database, Web Service,

20

COM component, or a component class. All ofthese are delivered through a compiled
assembly (DLL) from the Web application,which sits in the bin directory within IISs Web
root. ASP.NET includes some new file
extensions for the different types of pages you can create in your solutions. Thenew
extensions allow ASP.NET to sit alongside ASP 3.0 on the same server withno filename
conflicts.Here is a list of the four most commonly used extensions

.aspx Used for Web Forms and is the replacement for the standard .asp

extension used in ASP 3.0.

.ascx Used to denote a reusable page components or control.

.asmx Used to denote a Web Service.

.asax Used for the Global file and is the replacement for the .asa extension.

2.9.2 Features of ASP .NET

Better language support

Programmable controls

Event-driven programming

XML-based components

User authentication, with accounts and roles

Higher scalability

Increased performance - Compiled code

Easier configuration and deployment

Not fully ASP compatible

Language Support
ASP .NET uses the new ADO .NET.
ASP .NET supports full Visual Basic, not VBScript.
ASP .NET supports C# (C sharp) and C++.
ASP .NET supports JScript as before.

21

ASP .NET Controls


ASP .NET contains a large set of HTML controls. Almost all HTML elements on a page
can be defined as ASP .NET control objects that can be controlled by scripts.
ASP .NET also contains a new set of object oriented input controls, like programmable list
boxes and validation controls.A new data grid control supports sorting, data paging, and
everything you expect from a dataset control.

Event Aware Controls


All ASP .NET objects on a Web page can expose events that can be processed by ASP
.NET code. Load, Click and Change events handled by code makes coding much simpler and
much better organized.

ASP .NET Components


ASP .NET components are heavily based on XML. Like the new AD Rotator, that uses
XML to store advertisement information and configuration.

User Authentication
ASP .NET supports forms-based user authentication, including cookie management and
automatic redirecting of unauthorized logins.

User Accounts and Roles


ASP .NET allows for user accounts and roles, to give each user (with a given role) access
to different server code and executables.

High Scalability
Much has been done with ASP .NET to provide greater scalability.

22

Server to server communication has been greatly enhanced, making it possible to scale an
application over several servers. One example of this is the ability to run XML parsers, XSL
transformations and even resource hungry session objects on other servers.

Compiled Code
The first request for an ASP .NET page on the server will compile the ASP .NET code and
keep a cached copy in memory. The result of this is greatly increased performance.

Easy Configuration
Configuration of ASP .NET is done with plain text files.
Configuration files can be uploaded or changed while the application is running. No need
to restart the server. No more metabase or registry puzzle.

Compatibility
ASP .NET is not fully compatible with earlier versions of ASP, so most of the old
ASP code will need some changes to run under ASP .NET. To overcome this problem,
ASP .NET uses a new file extension ".aspx". This will make ASP .NET applications able to
run side by side with standard ASP applications on the same server.

What is a Web Service?


A Web service is a piece of business functionality exposed via Internet protocols. Web
services are Internet-based modular applications that perform a specific business task and
conform to a specific technical format. The modular technical format allows for these selfcontained business services (from the same or different companies) to mix and match easily to
create a complete business process.

23

3. SYSTEM DESIGN

24

3. SYSTEM DESIGN
3.1 Systems design
Systems design is the process or art of defining the architecture, components, modules,
interfaces, and data for a system to satisfy specified requirements. One could see it as the
application of systems theory to product development. There is some overlap and synergy
with the disciplines of systems analysis, systems architecture and systems engineering.
Requirements Analysis
In systems engineering and software engineering, requirements analysis encompasses
those tasks that go into determining the needs or conditions to meet for a new or altered
product, taking account of the possibly conflicting requirements of the various stakeholders,
such as beneficiaries or users. Systematic requirements analysis is also known as requirements
engineering. It is sometimes referred to loosely by names such as requirements gathering,
requirements capture, or requirements specification. The term requirements analysis can also
be applied specifically to the analysis proper (as opposed to elicitation or documentation of
the requirements, for instance).
Requirements analysis is critical to the success of a development project.
Requirements must be actionable, measurable, testable, related to identified business needs
or opportunities, and defined to a level of detail sufficient for system design.
Benchmarking
Benchmarking (also "best practice benchmarking" or "process benchmarking") is a process
used in management and particularly strategic management, in which organizations evaluate
various aspects of their processes in relation to best practice, usually within their own sector.
This then allows organizations to develop plans on how to adopt such best practice, usually
with the aim of increasing some aspect of performance. Benchmarking may be a one-off

25

event, but is often treated as a continuous process in which organizations continually seek to
challenge their practices.
Architectural design - creates a blueprint for the design with the necessary specifications for
the hardware, software, people and data resources. In many cases, multiple architectures are
evaluated before one is selected.
Design designers will produce one or more 'models' of what they see a system eventually
looking like, with ideas from the analysis section either used or discarded. A document will be
produced with a description of the system, but nothing is specific they might say
'touchscreen' or 'GUI operating system', but not mention any specific brands.
Computer programming and debugging in the software world, or detailed design in the
consumer, enterprise or commercial world - specifies the final system components.
System Testing - evaluates the system's actual functionality in relation to expected or
intended functionality, including all integration aspects.

3.2 Unified Modeling Language


In the field of software engineering, the Unified Modeling Language (UML) is a
standardized specification language for object modeling. UML is a general-purpose modeling
language that includes a graphical notation used to create an abstract model of a system,
referred to as a UML model.
UML is officially defined at the Object Management Group (OMG) by the UML
metamodel, a Meta-Object Facility metamodel (MOF). Like other MOF-based specifications,
the UML metamodel and UML models may be serialized in XMI. UML was designed to
specify, visualize, construct, and document software-intensive systems.
UML is not restricted to modeling software. UML is also used for business process
modeling, systems engineering modeling, and representing organizational structures. The

26

Systems Modeling Language (SysML) is a Domain-Specific Modeling language for systems


engineering that is defined as a UML 2.0 profile.
UML has been a catalyst for the evolution of model-driven technologies, which include
model-driven development (MDD), model-driven engineering (MDE), and model-driven
architecture (MDA). By establishing an industry consensus on a graphic notation to represent
common concepts like classes, components, generalization, aggregation, and behaviors, UML
has allowed software developers to concentrate more on design and architecture.

Why UML?
Modeling is an activity that has been carried out over the years in software
development. When writing applications by using the simplest languages to the most
powerful and complex languages, you still need to model. Modeling can be as
straightforward as drawing a flowchart listing the steps carried out by an application. Why
do we use modeling? Defining a model makes it easier to break up a complex application
or a huge system into simple, discrete pieces that can be individually studied. We can
focus more easily on the smaller parts of a system and then understand the big picture.
Hence, the reasons behind a modeling can be summed up in two words:

Readability

Reusability

Readability brings clarityease of understanding. Understanding the system is the first


step in either building or enhancing the system. This involves knowing what a system is
made up of, how it behaves, and so forth. Modeling a system ensures that it becomes
readable and most importantly, easy to document. Depicting a system to make it readable
involves capturing the structure of a system and the behavior of the system.
Reusability is the byproduct of making a system readable. After a system has been
modeled to make it easy to understand, we tend to identify similarities or redundancy, be
they in terms of functionality, features or structure.

27

Even though there are many techniques and tools for modeling, in this article series ,
we will be concerning our selves with modeling object oriented systems and applications
using the Unified Modeling Language. The UML as it is popularly known by its
TLA(Three letter acronym!),is the language that can be used to model systems and make
them readable. This essentially means that UML provides the ability to capture the
characteristics of a system by using notations. UML provides a wide array of simple, easy
to understand notations for documenting systems based on the object oriented design
principles. This notations are called the nine diagrams of UML.
So the question arises, why is UML the preferred option that should be used for
modeling? Well , the answer lies in one word: standardization!
Different languages have been used for depicting systems using object oriented
methodology. The prominent among these were the Rumbaugh methodology, the Booch
methodology, and the Jacobson methodology.
The problem was that, although each methodology has its advantages, they were
essentially disparate. Hence, if you had to work on different projects that used any of these
methodologies, you had to well verse with each of these methodologies. A very tall order
indeed! The UML is just that. It unifies the design principles of each of these
methodologies into a single, standard, language that can be easily applied across the board
for all object oriented systems. But, unlike the different methodologies that tended more to
the design and detailed design of systems, UML spans the realm of requirements, analysis
and design and, uniquely, implementation as well. The beauty of UML lies in the fact that
any of the nine diagrams of UML can be used on an incremental basis as the need arises.
For example, if you need to model requirements for a given system, you can use the use
case diagrams only without using the other diagrams in UML. Considering all these
reasons, it is no wonder that UML is considered the language of choice.

28

UML does not have any dependencies with respect to any technologies or languages.
This implies that you can use UML to model applications and systems based of the current
hot technologies.

3.3 UML Diagrams


A use case diagram is a type of behavioral diagram defined by the Unified Modeling
Language (UML). Its purpose is to present a graphical overview of the functionality provided
by a system in terms of actors, their goalsrepresented as use casesand any dependencies
between those use cases.
In the Unified Modeling Language (UML), a class diagram is a type of static structure
diagram that describes the structure of a system by showing the system's classes, their
attributes, and the relationships between the classes.
In the Unified Modeling Language, an activity diagram represents the business and
operational step-by-step workflows of components in a system. An activity diagram shows the
overall flow of control.
The Message Sequence Chart technique has been incorporated into the Unified Modeling
Language (UML) diagram under the name of Sequence Diagram. A sequence diagram
shows, as parallel vertical lines, different processes or objects that live simultaneously, and as
horizontal arrows, the messages exchanged between them, in the order in which they occur.
This allows the specification of simple runtime scenarios in a graphical manner.
A collaboration diagram is an interaction diagram that emphasizes the structural
organization of the objects that send and receive messages.

29

Explanation
In the figure 3.2.1.1 the user and the server are the actors. The GPS location service runs
on the central server. The device coordinates are updated on the central server. They are used
by the GPS client.
In the figure 3.2.1.2 the user and the server are the actors. The Race Course Map is
monitored by the user on the Footrace Application Server.
In the figure 3.2.1.3 the user, server and the GPS Device are the actors. The Race Course
Display is updated on the Central Server using the Real-Time Updates i.e., the latitude and
longitude values provided by the GPS Device. The Real-Time Updates will be in the form of
an XML file.
In the figure 3.2.1.4 the user and the Advertisement Server are the actors. The
advertisement content of various Companies and Sponsors for the event is displayed on the
advertisement Server as well as on GPS enabled Mobile devices.

30

3.3.1 Use Case Diagrams

GPS Services

User

Checks information
on central server

Updates the
device coordinates
Figure 3.3.1.1 GPS Communication Subsystem

31

Server

User

Server

Course map display

Figure 3.3.1.2 Race Course Drawing Subsystem

32

Information about
latitudes and longitudes

GPS device

Real-Time
updates

Server

User

Figure 3.3.1.3 Real-Time Updates

33

User

Advertisement
content

GPS device

Figure 3.3.1.4 Advertisement Subsystem

34

Advertisement
server

3.3.2 Sequence Diagram

: User

GPS
Communication

Race Course

Real Time
Updates

Advertisement

Communicates

get services information

invokes map information

displays the map

access latitude and longitude information

updates latitude and longitude information

communicates with advertisement system

displays advertisement content

stores and updates information

gives updated information with advertisement content

Figure 3.3.2.1 Sequence Diagram

35

3.3.3 Collaboration Diagram

Race Course
Drawing System

GPS Communication
Subsystem

4:Gets Service Info

6:Gets Initial
longitude &
latitude values

1:Establish Connection
2:Get service info
3:Access longitude
& latitude values

Real Time Updates

5:*Display Map
8:*Gets Updated longitude
& latitude information

7:*Gets Updated longitude


& latitude information

Server

Figure 3.3.3.1 Collaboration Diagram

36

3.3.4 Class Diagram

GPS communication Subsystem


location : String
latitude : number
longitude : number
................

Footarce(CentralServer)
display()

cal_coordinates()
get_updcoordinates()

Race-Course subsystem
location : String
latitude : number
longitude : number

RealTimeUpdates
location : String
latitude : number
longitude : number

Get_coordinates()
Get_updcoordinates()
drawsmap()

Get_Coordinates()
perform_updations()

Figure 3.3.4.1 Class Diagram

37

3.3.5 Activity Diagram

Server

GPS communication Drawing Subsystem


Updating Subsystem
subsystem
Find Location

Constructs the
map

Access
Information

Display
Map
Updates of latitude
And longitude

Yes

Access longitude&
Latitude values

Any
Updates
No

Figure 3.3.5.1 Activity Diagram

38

4. ARCHITECTURE

39

4. ARCHITECTURE
4.1 Software Architecture
The software architecture of a program or computing system is the structure or structures
of the system, which comprise software components, the externally visible properties of those
components, and the relationships between them. The term also refers to documentation of a
system's software architecture. Documenting software architecture facilitates communication
between stakeholders, documents early decisions about high-level design, and allows reuse of
design components and patterns between projects.
4.2 Working
In all there are 4 modules,namely
a) GPS Communication Subsystem
b) Race Course Drawing Subsystem
c) Real-Time Updates
d) Advertisement Subsystem
Initially the GPS Communication Subsystem communicates with the Footrace Application
Server by sending a request for Device Co-ordinates.The Footrace Application Server
requests the Race Course Drawing Subsystem for mapping service.The Race Course Drawing
Subsystem displays the map.
The Footrace Application Server gets context information from the Real-Time Updates
module. The athletes position is forwarded to the Footrace Application Server in the form of
an XML file. Finally the advertisement content of various companies, organizations and
sponsors for the event is displayed on the Footrace Application Server.

40

Figure 4.2.1 Architecture

41

5. CODE

42

5. CODE
/* Code for GPS Communication Subsystem */
using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using System.Xml.Serialization;
using System.IO;
using gps;
namespace gpstest
{
class Program
{
static void Main(string[] args)
{
XmlSerializer ser = new XmlSerializer(typeof(gpxType));
using (FileStream str = new FileStream("DamLoop.gpx", FileMode.Open))
{
gpxType info = (gpxType)ser.Deserialize(str);
if (info.trk != null)
{
OutputTracks(info.trk);
}
}
XmlSerializer ser1 = new XmlSerializer(typeof(gpxType));
using (FileStream str1 = new FileStream("DamLoop2.gpx", FileMode.Open))
{
gpxType info = (gpxType)ser1.Deserialize(str1);
if (info.trk != null)
{
OutputTracks(info.trk);
}
}
}
static void OutputTracks(trkType[] tracks)
{
Console.WriteLine("{0} Tracks", tracks.Length);

43

foreach (trkType track in tracks)


{
OutputTrack(track);
}
}
static void OutputTrack(trkType track)
{
Console.WriteLine("Track '{0}'", track.name);
if (track.trkseg.Length > 0)
{
Console.WriteLine("{0} Segments", track.trkseg.Length);
foreach (trksegType seg in track.trkseg)
{
Console.WriteLine("{0} Points", seg.trkpt.Length);
wptType wptPrev = seg.trkpt[0];
double totalDist = 0;
double elevationGain = 0;
foreach (wptType wpt in seg.trkpt)
{
double course = 0;
double dist = 0;
GetCourseAndDistance(wptPrev, wpt, ref course, ref dist);
totalDist += dist;
if (wpt.ele > wptPrev.ele)
{
elevationGain += (double)(wpt.ele - wptPrev.ele);
}
Console.WriteLine("{0} {1} {2} {3} {4} {5}", wpt.time, wpt.lat, wpt.lon,
wpt.ele, course, dist);
wptPrev = wpt;
Console.WriteLine("Total distance={0} kilometers. Elevation gain={1}
meters.", totalDist / 1000,
elevationGain);
}
}
}
}

static void GetCourseAndDistance(wptType pt1, wptType pt2, ref double course, ref
double dist)
{

44

double lat1 = DegreesToRadians((double)pt1.lat);


double lon1 = DegreesToRadians((double)pt1.lon);
double lat2 = DegreesToRadians((double)pt2.lat);
double lon2 = DegreesToRadians((double)pt2.lon);
double dlat = lat2 - lat1;
double dlon = lon2 - lon1;
double distanceNorth = dlat;
double distanceEast = dlon * Math.Cos(lat1);
dist = Math.Sqrt(distanceNorth * distanceNorth + distanceEast * distanceEast);
dist = RadiansToMeters(dist);
double dele = (double)pt2.ele - (double)pt1.ele;
dist = Math.Sqrt(dist * dist + dele * dele);
course = Math.Atan2(distanceEast, distanceNorth) % (2 * Math.PI);
course = RadiansToMeters(course);
if (course < 0)
course += 360;
}
static double DegreesToRadians(double degrees)
{
return degrees * Math.PI / 180.0;
}
static double RadiansToDegrees(double radians)
{
return radians * 180.0 / Math.PI;
}
static double RadiansToNauticalMiles(double radians)
{
return radians * 60 * 180 / Math.PI;
}
static double RadiansToMeters(double radians)
{
return 1852 * RadiansToNauticalMiles(radians);
}
}
}

/* Code for Race-Course Drawing Subsystem (GPSUtil.cs) */


using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Xml;

45

using System.Xml.Serialization;
using gps;
using gpstest;
namespace gps
{
class gpxutil
{
private gpxutil()
{
}
public static string LatLonToString(double lat, double lon)
{
string latDir = (lat >= 0) ? "N" : "s";
string lonDir = (lon >= 0) ? "E" : "W";
double tLat = Math.Abs(lat);
double tLon = Math.Abs(lon);
double flat = (tLat - Math.Truncate(tLat)) * 60;
double flon = (tLon - Math.Truncate(tLon)) * 60;
string slat = string.Format("{0}{1}{2}", latDir, Math.Truncate(tLat),
flat.ToString("#.000"));
string slon = string.Format("{0}{1}{2}", lonDir, Math.Truncate(tLon),
flon.ToString("#.000"));
return string.Format("{0}{1}", slat, slon);
}
public static void GetCourseAndDistance(wptType pt1, wptType pt2, ref double course,
ref double dist)
{
double lat1 = DegreesToRadians((double)pt1.lat);
double lon1 = DegreesToRadians((double)pt1.lon);
double lat2 = DegreesToRadians((double)pt2.lat);
double lon2 = DegreesToRadians((double)pt2.lon);
double dlat = lat2 - lat1;
double dlon = lon2 - lon1;
double distanceNorth = dlat;
double distanceEast = dlon * Math.Cos(lat1);
dist = Math.Sqrt(distanceNorth * distanceNorth + distanceEast * distanceEast);

46

dist = RadiansToMeters(dist);
double dele = (double)pt2.ele - (double)pt1.ele;
dist = Math.Sqrt(dist * dist + dele * dele);
course = Math.Atan2(distanceEast, distanceNorth) % (2 * Math.PI);
course = RadiansToMeters(course);
if (course < 0)
course += 360;
}
static double DegreesToRadians(double degrees)
{
return degrees * Math.PI / 180.0;
}
static double RadiansToDegrees(double radians)
{
return radians * 180.0 / Math.PI;
}
static double RadiansToNauticalMiles(double radians)
{
return radians * 60 * 180 / Math.PI;
}
static double RadiansToMeters(double radians)
{
return 1852 * RadiansToNauticalMiles(radians);
}
}
}

47

6. TESTING

48

6. TESTING
Once the source code has been generated, the software must be tested to uncover as
many errors as possible before delivery to the customer. Software testing is a critical
element of software quality assurance and represents the ultimate review of
specification design and code generation.

6.1 Testing Objectives

Testing is a process of executing a program with the intent of finding


an error.

A good test case is one that has a high probability of finding an as yet
Undiscovered.

A successful test is one that uncovers an as yet undiscovered error.

6.2 Testing Principles


1. All tests should be traceable to customer requirements.
2. Tests should be planned large before testing begins.
3. Testing should begin In the Small and progress towards In the Large.
The system can be tested in one of the following two ways:1. White-Box Testing
2. Black-Box Testing

6.3 Manual Testing


Manual testing is the oldest and most rigorous type of software testing. Manual testing
requires a tester to perform manual test operations on the test software without the help of
Test automation. Manual testing is a laborious activity that requires the tester to possess a
certain set of qualities; to be patient, observant, speculative, creative, innovative, openminded, resourceful, unopinionated, and skillful.
As a tester, it is always advisable to use manual white box testing and black-box testing
techniques on the test software. Manual testing helps discover and record any software bugs
or discrepancies related to the functionality of the product.

49

Manual testing can be replaced by test automation. It is possible to record and playback
manual steps and write automated test script(s) using Test automation tools. Although, test
automation tools will only help execute test scripts written primarily for executing a particular
specification and functionality. Test automation tools lack the ability of decision-making and
recording any unscripted discrepancies during program execution. It is recommended that one
should perform manual testing of the entire product at least a couple of times before actually
deciding to automate the more mundane activities of the product.
Despite the proliferation of automated solutions, manual testing still accounts for at least
80% of all testing. Automation can only be justified where repeatable consistent tests can be
run over a stable environment. When this isn't the case (i.e. during the early stages of the test
cycle), then testing teams almost always revert back to manual testing. So manual testing is
here to stay! Here are some reasons why...
Business critical / Heavily tested software
With constantly changing applications, automation can simply be too daunting. New to
testing, those that are new to testing may not want to dive right in to complex automation
tools. Using a tool such as TestDrive-Assist can provide an easy and cost effective way to gain
real advantages in a short space of time and use it as a springboard to full automation. Script
based automation tools not living up to their hype: Many people still find that despite
investing in script based automation solutions this only covers 10-20% of their total testing.
The rest is still carried out manually. Full Automation simply not appropriate: You may be
testing new functionality, or a new platforms/OS. Or there maybe insufficient time and/or
skills to develop test scripts. Agile Development: With Agile development techniques, there is
no place for traditional automation tools because they take too long to set up and need to be
re-scripted after the first change to the application.
Manual testing helps discover defects related to the usability testing and GUI testing area.
While performing manual tests the software application can be validated whether it meets the
various standards defined for effective and efficient usage and accessibility. For example, the
standard location of the OK button on a screen is on the left and of CANCEL button on the
right. During manual testing you might discover that on some screen, it is not. This is a new

50

defect related to the usability of the screen. In addition, there could be many cases where the
GUI is not displayed correctly and the basic functionality of the program is correct. Such bugs
are not detectable using test automation tools.
Repetitive manual testing can be difficult to perform on large software applications or
applications having very large dataset coverage. This drawback is compensated for by using
manual black-box testing techniques including equivalence partitioning and boundary value
analysis. Using which, the vast dataset specifications can be divided and converted into a
more manageable and achievable set of test suites.

A manual tester would typically perform the following steps for manual testing:
1. Understand the functionality of program
2. Prepare a test environment
3. Execute test case(s) manually
4. Verify the actual result
5. Record the result as Pass or Fail
6. Make a summary report of the Pass and Fail test cases
7. Publish the report
8. Record any new defects uncovered during the test case execution
Test automation has become a necessity mainly due to shorter deadlines for performing
test activities, such as regression testing, performance testing, and load testing.

51

6.4 Test Cases


Table 6.4.1 Generation of C# file
Test Case: #1

Test Objective: With the Gpx schema file as input generating c# file.
Test setup precondition: Entering the correct command at the command prompt
Actions
Saving schema file with .xsd

Expected Result
Xml format

extension
Writing a command at the

C# file

command prompt.
Incorrect command at the

C# generation is not possible

command prompt.
Problems/Issues: None

Notes: Successfully tested and executed.

52

Table 6.4.2 Designing Central Server


Test Case: #2
Test Objective: Creating the form so that latitude and longitude values, course
map and advertisements are displayed on it.
Test setup precondition: Latitude and longitude values.
Actions

Expected Result

Clicking on the button and choosing

Latitude and longitude values of

the appropriate file of the runners .

runners and advertisements are


displayed.

Clicking on radio button.

Map is displayed.

Problems/Issues: None
Notes: Successfully tested and executed.

53

Table 6.4.3 Debugging of c# file


Test Case: #3
Test Objective: Debugging the c# file and console application to get speed,
distance, location of the athlete.
Test setup precondition: Running correct applications.
Actions

Expected Result

Executing c# file and console

Command prompt showing all the

application.

values with respect to the athlete.

Incorrect applications.

Incorrect values.

Problems/Issues: None

Notes: Successfully tested and executed.

54

7. SCREEN SHOTS

55

7. SCREEN SHOTS

Screen 7.1

GPX.xsd is the XML file which is downloaded from the internet.

56

Screen 7.2
The command xsd gpx.xsd /classes /languages:cs /namespace:gpstest is used to generate
the C# file.

57

Screen 7.3
Upon running the C# file we get the latitude, longitude, elevation, time, distance values.

58

Screen 7.4
Pocket PC is the device on which race updates and alarms can be received.

59

Screen 7.5
Initially, the values are set to Zero.

60

Screen 7.6
Raw Data that is being relayed by the GPS device tied to the contestants wrist.

61

Screen 7.7
The location of the runner in terms of latitude, longitude, altitude, direction. The speed of the
runner can also be viewed. Apart from this the satellite time & local time can also be viewed.

62

Screen 7.8
As the race progresses the speed, direction, latitude, longitude values keep changing.

63

Screen 7.9
Configuring the data source as XML file.

64

Screen 7.10
Selecting the XML File.

65

Screen 7.11
Selecting the 1st Damloop file.

66

Screen 7.12
Selecting the 2nd Damloop file.

67

Screen 7.13
The map of the race course with the advertisements of the sponsors.

68

8. CONCLUSION

69

8. CONCLUSION
Only GPS enabled mobile users are facilitated to get the updates of the race.
It is expensive, as all the participants should be provided GPS Devices.
Only the status of the participant can be known but the original picture cannot be viewed.
If the communication with the satellites fails then the whole process gets crashed.
A satellite signals down as it passes through inclement weather.
At times, the satellites may provide inaccurate information.

70

9. APPENDIX

71

9. APPENDIX
ABBREVIATIONS

a. GPS: Global Positioning System


b. GPX: GPS Exchange Format
c. XML: Extensible Markup Language
d. GDI: Graphical Display Interface
e. IIS: Internet Information Service.
DEFINITIONS
a. Axis
An imaginary line through the centre of an object, around which the object turns.
b. Course
A course, in navigation, is the intended path of a vehicle over the surface of the Earth.
c. Data Logging
Data logging is the practice of recording sequential data, often chronologically.
d. Degree
A unit of measurement for angles.It represents 1/360 of a full rotation. Denoted by 0.
e. Earths Axis
The earths axis is the line between the North and South Poles.
f. Elevation
Distance of something above a reference point (such as sea level).

72

g. Equator
An imaginary line, or one drawn on a map, around the earth at an equal distance from North
and South Poles.

h. Footrace
Footrace is defined as the race run by contestants on foot.

i. GPS (Global Positioning System)


It is a satellite navigation system. More than two dozen GPS satellites orbit round the earth
transmitting radio signals which allow GPS receivers to determine location, speed and
direction.

j. GPX
GPX (the GPS Exchange Format) is a light-weight XML data format for the interchange of
GPS data (waypoints, routes, and tracks) between applications and Web services on the
Internet.
k. Greenwich Meridian
00 LONGITUDE which passes through the North and South Poles and Greenwich, England.
l. Latitude
Lines of Latitude are the horizontal lines running from east-to-west on maps. It is the distance
of a place north or south of the EQUATOR, measured in degrees.
m. Log
A written record of events on a voyage (of a ship or plane).
n. Longitude
Lines of Longitude are the lines running from north-to-south on maps. It is the distance east or
west of the Greenwich MERIDIAN, measured in degrees.
o. Meridian
Any imaginary circle round the earth that passes through both the North and South Poles.
p. Nautical Mile
A nautical mile or sea mile is a unit of length.It corresponds approximately to one minute of
latitude along any meridian. 1 nautical mile = 1,852 meters.

73

q. North Pole
The northernmost point of the Earth's axis.
r. Radian
The unit of plane angle adopted under the Systeme International d'Unites. Equal to the angle
at the centre of a circle subtended by an arc equal in length to the radius (approximately
57.295 degrees).
s. Route
In GPS navigation, a route is usually defined as a series of one or more waypoints.
t. South Pole
The southernmost point of the Earth's axis.
u. Track
A track, also course over ground, is the actual path followed by a moving body.

v. Tracking Devices
A GPS tracking unit is a device that uses the GPS to determine the precise location of person
to which it is attached and to record the position of the asset at regular intervals. The recorded
location data can be stored within the tracking unit or it may be transmitted to a central
location database.
w. Waypoint
A waypoint is a reference point in physical space used for purposes of navigation. Waypoints
are sets of coordinates that identify a point in physical space.
x. XML
XML is a makup language for documents containing structured information. A markup
language is a mechanism to identify structures in a document.
y. XML Schema
An XML schema describes the structure of an XML document and also describes the various
constraints on the data in the document.

74

z. XML Serialization
It is the process of converting XML documents and streams to common language runtime
objects and vice versa.

75

10. BIBLIOGRAPHY

76

BIBLIOGRAPHY
Book References

SQL SERVER 2005


By Microsoft Press

SOFTWARE ENGINEERING
By Roger .S. Pressman

Mastering C#.NET
By Microsoft Press
C# Complete Reference

Programming ASP.NET 2.0


Wrox Publication

MSDN 2003
By Microsoft
Web References
http://msdn.Microsoft.com MSDN for Dotnet
http://ASP.NET
http://www.google.com
http://www.wikipedia.org
http://www.mhhe.com
http://c-charpcorner.com

77

Potrebbero piacerti anche