Sie sind auf Seite 1von 17

Testing Object Oriented Software

The traditional programming consists of procedures operating on data, while the object-oriented
paradigm focuses on objects that are instances of classes. In object-oriented (OO) paradigm,
software engineers identify and specify the objects and services provided by each object. In addition,
interaction of any two objects and constraints on each identified object are also determined. The
main advantages of OO paradigm include increased reusability, reliability, interoperability, and
extendibility.

With the adoption of OO paradigm, almost all the phases of software development have changed in
their approach, environments, and tools. Though OO paradigm helps make the designing and
development of software easier, it may pose new kind of problems. Thus, testing of software
developed using OO paradigm has to deal with the new problems also. Note that object-oriented
testing can be used to test the object-oriented software as well as conventional software.

OO program should be tested at different levels to uncover all the errors. At the algorithmic level,
each module (or method) of every class in the program should be tested in isolation. For this, white-
box testing can be applied easily. As classes form the main unit of object-oriented program, testing
of classes is the main concern while testing an OO program. At the class level, every class should be
tested as an individual entity. At this level, programmers who are involved in the development of
class conduct the testing. Test cases can be drawn from requirements specifications, models, and
the language used. In addition, structural testing methods such as boundary value analysis are
extremely used. After performing the testing at class level, cluster level testing should be performed.
As classes are collaborated (or integrated) to form a small subsystem (also known as cluster), testing
each cluster individually is necessary. At this level, focus is on testing the components that execute
concurrently as well as on the interclass interaction. Hence, testing at this level may be viewed as
integration testing where units to be integrated are classes. Once all the clusters in the system are
tested, system level testing begins. At this level, interaction among clusters is tested.

Developing Test Cases in Object-oriented Testing


The methods used to design test cases in OO testing are based on the conventional methods.
However, these test cases should encompass special features so that they can be used in the object-
oriented environment. The points that should be noted while developing test cases in an object-
oriented environment are listed below.
1. It should be explicitly specified with each test case which class it should test.
2. Purpose of each test case should be mentioned.
3. External conditions that should exist while conducting a test should be clearly stated with each test
case.
4. All the states of object that is to be tested should be specified.
5. Instructions to understand and conduct the test cases should be provided with each test case.

Object-oriented Testing Methods


As many organizations are currently using or targeting to switch to the OO paradigm, the importance
of OO software testing is increasing. The methods used for performing object-oriented testing are
discussed in this section.
State-based testing is used to verify whether the methods (a procedure that is executed by an
object) of a class are interacting properly with each other. This testing seeks to exercise the
transitions among the states of objects based upon the identified inputs.
For this testing, finite-state machine (FSM) or state-transition diagram representing the possible
states of the object and how state transition occurs is built. In addition, state-based testing
generates test cases, which check whether the method is able to change the state of object as
expected. If any method of the class does not change the object state as expected, the method is
said to contain errors.
To perform state-based testing, a number of steps are followed, which are listed below.
1. Derive a new class from an existing class with some additional features, which are used to examine
and set the state of the object.
2. Next, the test driver is written. This test driver contains a main program to create an object, send
messages to set the state of the object, send messages to invoke methods of the class that is being
tested and send messages to check the final state of the object.
3. Finally, stubs are written. These stubs call the untested methods.
Fault-based Testing
Fault-based testing is used to determine or uncover a set of plausible faults. In other words, the
focus of tester in this testing is to detect the presence of possible faults. Fault-based testing starts by
examining the analysis and design models of OO software as these models may provide an idea of
problems in the implementation of software. With the knowledge of system under test and
experience in the application domain, tester designs test cases where each test case targets to
uncover some particular faults.
The effectiveness of this testing depends highly on tester experience in application domain and the
system under test. This is because if he fails to perceive real faults in the system to be plausible,
testing may leave many faults undetected. However, examining analysis and design models may
enable tester to detect large number of errors with less effort. As testing only proves the existence
and not the absence of errors, this testing approach is considered to be an effective method and
hence is often used when security or safety of a system is to be tested.
Integration testing applied for OO software targets to uncover the possible faults in both operation
calls and various types of messages (like a message sent to invoke an object). These faults may be
unexpected outputs, incorrect messages or operations, and incorrect invocation. The faults can be
recognized by determining the behavior of all operations performed to invoke the methods of a
class.
Scenario-based Testing
Scenario-based testing is used to detect errors that are caused due to incorrect specifications and
improper interactions among various segments of the software. Incorrect interactions often lead to
incorrect outputs that can cause malfunctioning of some segments of the software. The use of
scenarios in testing is a common way of describing how a user might accomplish a task or achieve a
goal within a specific context or environment. Note that these scenarios are more context- and user
specific instead of being product-specific. Generally, the structure of a scenario includes the
following points.
1. A condition under which the scenario runs.
2. A goal to achieve, which can also be a name of the scenario.
3. A set of steps of actions.
4. An end condition at which the goal is achieved.
5. A possible set of extensions written as scenario fragments.
Scenario- based testing combines all the classes that support a use-case (scenarios are subset of use-
cases) and executes a test case to test them. Execution of all the test cases ensures that all methods
in all the classes are executed at least once during testing. However, testing all the objects (present
in the classes combined together) collectively is difficult. Thus, rather than testing all objects
collectively, they are tested using either top-down or bottom-up integration approach.
This testing is considered to be the most effective method as scenarios can be organized in such a
manner that the most likely scenarios are tested first with unusual or exceptional scenarios
considered later in the testing process. This satisfies a fundamental principle of testing that most
testing effort should be devoted to those paths of the system that are mostly used.
Challenges in Testing Object-oriented Programs
Traditional testing methods are not directly applicable to OO programs as they involve OO concepts
including encapsulation, inheritance, and polymorphism. These concepts lead to issues, which are
yet to be resolved. Some of these issues are listed below.
1. Encapsulation of attributes and methods in class may create obstacles while testing. As methods are
invoked through the object of corresponding class, testing cannot be accomplished without object.
In addition, the state of object at the time of invocation of method affects its behavior. Hence,
testing depends not only on the object but on the state of object also, which is very difficult to
acquire.
2. Inheritance and polymorphism also introduce problems that are not found in traditional software.
Test cases designed for base class are not applicable to derived class always (especially, when
derived class is used in different context). Thus, most testing methods require some kind of
adaptation in order to function properly in an OO environment.

Web-based systems

Client Server and 2 tier Web Architectures


Typically, when you are browsing the Internet, you will be using Web Browser software such as
Internet Explorer or Mozilla Firefox. The computer which is running a browser is called a client,
whilst the machine which is providing Web pages is called a server.
When you dial up to an Internet Service Provider ( ISP ) e.g. Blue Yonder, Aol, your computer is
forming a network connection to a Web server. In this situation, your computer is in effect a client,
which is linked to an ISP Web server. The web server, as the name suggests, serves your browser
with Web pages (e.g. HTML, ASPX, JSP pages etc).

This simple scenario, where the Web server is connected to one or more clients is known as a 2 tier
architecture model.

Figure B below demonstrates how Web pages are accessed via a browser, using a 2 tier architecture.

Figure B - A simple diagram of 2 tier Client/server architecture

The
Web Server Internet Client

Page Page Enter Web


Request Request Address

Web page
Web Page Web page

3-Tier architectures

Generally computing applications consist of three different and distinct types of functionalities.

Presentation Services Functional Data Management


Logic

 Presentation Services: These manifest themselves in the form of information display and
user data input facilities. Generally the front-end for user interaction. For example logging
in requires interaction in the form of collecting username and password information using a
HTML-form.
 Functional logic: Every application includes some data processing and this may also involve
database interactivity. For example user authentication requires the logic unit to read
username-password combinations from a database and compare until a good comparison
(hopefully) is arrived at.
 Data Management: Data, its storage, insertion and retrieval, its management and alteration
is central to computing applications. For example a database management system (DBMS) is
required for the management of usernames and associated passwords, their owners, etc.
Figure C - An illustration of a 3 tier architecture model

n-Tier Architectures
It is also important to note that Web application architecture sometimes is referred to as multi-tier.
In effect we could have more than 3-tiers in circumstances when the Web server requires to access
one or more application servers for specialised services. This is known as n-Tier architecture

Each layer within an N-tier architecture could be thought of as 'logical components' interacting with
the layer above or below. Layers provide a means of grouping functionality within the application
structure.

Some benefits of this approach include flexibility of component location - each layer may be held on
a different server, this facilitates scalable applications capable of handling heavier server loads.
Additionally each layer is encapsulated making it possible to change one layer without affecting
another.

What is Web based Testing?

Web Testing in simple terms is checking your web application for potential bugs before its made live
or before code is moved into the production environment.

During this stage issues such as that of web application security, the functioning of the site, its access
to handicapped as well as regular users and its ability to handle traffic is checked.

In Software Engineering, the following testing types/technique may be performed depending on


your web testing requirements.

1. Functionality Testing:

This is used to check if your product is as per the specifications you intended for it as well as the
functional requirements you charted out for it in your developmental documentation. Web based
Testing Activities includes:

Test all links in your webpages are working correctly and make sure there are no broken links. Links
to be checked will include -

 Outgoing links
 Internal links
 Anchor Links
 MailTo Links

Test Forms are working as expected. This will include-

 Scripting checks on the form are working as expected. For example- if a user does not fill a
mandatory field in a form an error message is shown.
 Check default values are being populated
 Once submitted, the data in the forms is submitted to a live database or is linked to a
working email address
 Forms are optimally formatted for better readability

Test Cookies are working as expected. Cookies are small files used by websites to primarily
remember active user sessions so you do not need to log in every time you visit a website. Cookie
Testing will include

 Testing cookies (sessions) are deleted either when cache is cleared or when they reach their
expiry.
 Delete cookies (sessions) and test that login credentials are asked for when you next visit the
site.

Test HTML and CSS to ensure that search engines can crawl your site easily. This will include

 Checking for Syntax Errors


 Readable Color Schemas
 Standard Compliance. Ensure standards such W3C, OASIS, IETF, ISO, ECMA, or WS-I are
followed.

2. Usability testing:

Usability Testing has now become a vital part of any web based project. It can be carried out by
testers like you or a small focus group similar to the target audience of the web application.

Test the site Navigation:

 Menus, buttons or Links to different pages on your site should be easily visible and
consistent on all webpages
 Content should be legible with no spelling or grammatical errors.
 Images if present should contain an "alt" text

3.Interface Testing:

Three areas to be tested here are - Application, Web and Database Server

 Application: Test requests are sent correctly to the Database and output at the client side is
displayed correctly. Errors if any must be caught by the application and must be only shown
to the administrator and not the end user.
 Web Server: Test Web server is handling all application requests without any service denial.
 Database Server: Make sure queries sent to the database give expected results.

Test system response when connection between the three layers (Application, Web and
Database) cannot be established and appropriate message is shown to the end user.

4. Database Testing:

Database is one critical component of your web application and stress must be laid to test it
thoroughly. Testing activities will include-
 Test if any errors are shown while executing queries
 Data Integrity is maintained while creating, updating or deleting data in database.
 Check response time of queries and fine tune them if necessary.
 Test data retrieved from your database is shown accurately in your web application

5. Compatibility testing.

Compatibility tests ensures that your web application displays correctly across different devices. This
would include-

Browser Compatibility Test: Same website in different browsers will display differently. You need to
test if your web application is being displayed correctly across browsers, JavaScript, AJAX and
authentication is working fine. You may also check for Mobile Browser Compatibility.

The rendering of web elements like buttons, text fields etc. changes with change in Operating
System. Make sure your website works fine for various combination of Operating systems such as
Windows, Linux, Mac and Browsers such as Firefox, Internet Explorer, Safari etc.

6. Performance Testing:

This will ensure your site works under all loads. Software Testing activities will include but not
limited to -

 Website application response times at different connection speeds


 Load test your web application to determine its behavior under normal and peak loads
 Stress test your web site to determine its break point when pushed to beyond normal loads
at peak time.
 Test if a crash occurs due to peak load, how does the site recover from such an event
 Make sure optimization techniques like gzip compression, browser and server side cache
enabled to reduce load times

7. Security testing:

Security Testing is vital for e-commerce website that store sensitive customer information like credit
cards. Testing Activities will include-

 Test unauthorized access to secure pages should not be permitted


 Restricted files should not be downloadable without appropriate access
 Check sessions are automatically killed after prolonged user inactivity
 On use of SSL certificates, website should re-direct to encrypted SSL pages.

WEB TECHNOLOGY EVOLUTION

Web 1.0:

Web 1.0 was first implementation of the web and lasted from 1989 to 2005.It was define as web of
information connection. According to the innovator of World Wide Web, Tim Berners-Lee considers
the web as ―read-only‖ Web [1]. It provides very little interaction where consumer can exchange
the information together but it was not possible to interact with the website. The role of the web
was very passive in nature.
Web 1.0 was referred as the first generation of World Wide Web which was basically defined as ―It
is an information space in which the items of interest referred to as resources are identified by
global identifier called as Uniform Resources Identifiers(URLs)‘‘

First generation web was era static pages and content delivery purpose only. In other world, the
early web allowed us to search for information and read it. There was very little in the way of user
interaction or content contribution.

3.1 Characteristics Web 1.0:

Web 1.0 Technologies includes core web protocols, HTML, HTTP, and URI. The major characteristics
of web 1.0 are as follow:

They have read only content.

 Establish an online presence and make their information available to anyone at any time.

It includes static web pages and use basic Hypertext Mark-Up Language.

Web 2.0:

Web 2.0 is the second generation of web. It was defined by Dale Dougherty in 2004 as a read-write
web [1]. The concept began with a conference brainstorming session between O‘ Reilly and Media
live International. The technologies of web 2.0 allow assembling and managing large global crowds
with common interests in social interactions.

Web 2.0 is the business revolution in the computer industry caused by the move to the internet as
platform, and an attempt to understand the rules for success on that new platform. Chief among
those rules is this. Build applications that harness network effects to get better the more people use
them.‘‘

Web 2.0 facilitates major properties like participatory, collaborative, and distributed practices which
enable formal and in formal spheres of daily activities on going on web. In other terms it resemble
major distinct characteristics of Web 2.0 include ―relationship‘‘ technologies, participatory media
and a social digital technology which in term can also defined as the wisdom web. People-centric
web and participative web is taken in to concern and which facilities reading and writing on the web
which makes the web transaction bi-directional.

Characteristics of Web 2.0:

Technology Centric Characteristics: Web has become a platform with software above the level of a
single device. Technology that is associated with blogs wikis, podcasts, RSS feeds etc.

Business Centric Characteristics: It is a way of architecting software and businesses. The business
revolution in the computer industry is caused by the move to internet as platform and an attempt to
understand the rules for success on that of new platform.

User Centric Characteristics: The Social Web is often used to characterize sites that consist of
communities. It is all about content management and new ways of communication and interaction
between users. Web application is facilitates collective knowledge production, social networking and
increases user to user information exchanges.
Web 3.0:

Web 3.0 is one of modern and evolutionary topics associated with the following initiatives of web
2.0. Web 3.0 was first coined by John Mark off of the New York Times and he suggested web 3.0 as
third generation of the web in 2006 [18]. Web 3.0 can be also stated as ―Executable Web‘‘.

The Basic idea of 3.0 is to define structure data and link them in order to more effective discovery,
automation, integration, and reuse across various applications [6]. It is able to improve data
management, support accessibility of mobile internet, simulate creativity and innovation, encourage
factor of globalization phenomena, enhance customers‘ satisfaction and help to organize
collaboration in social web.

Web 3.0 is also known as semantic web. Semantic web was thought up by Tim BernersLee, inventor
of the World Wide Web [1]. A dedicated team at the World Wide Web consortium was working to
improve, extend and standardize the system, languages publications and tools have already been
developed [3]. Web 3.0 is a web where the concept of website or webpage disappears, where data
isn‘t owned but instead shared, where services show different views for the same web or the same
data. Those services can be applications devices or other, and have to be focused on context and
personalization, and both will be reached by using vertical search. Web 3.0 supports world wide
database and web oriented architecture which in earlier stage was described as a web of document.

Semantic Web:

The semantic web is a collaborative movement led by international standards body the World Wide
Web consortium. According to the W3C [4], ―The Semantic web provides a common framework
that allows data to be shared and reused across application, enterprise, and community boundaries

Web 4.0:

Web 4.0 can be considered as an Ultra-Intelligent Electronic Agent, Symbiotic web and Ubiquitous
web. Interaction between humans and machines in symbiosis was motive behind the symbiotic web.
It is powerful as human brain. Progress in the development of telecommunication, advancement on
nanotechnology in the world and controlled interfaces are using web 4.0. In simple words, machines
would be clever on reading the contents of the web, and react in the form of executing and deciding
what to execute first to load the websites fast with superior quality and performance and build more
commanding interfaces .

Web 4.0 will be read write concurrency web. It ensures global transparency governance,
distribution, participation, collaboration in to key communities such as industry, political, social and
other communities. Web OS will be such as a middleware in which will start functioning like an
operating system. Web OS will be parallel to the human brain and implies a massive web of highly
intelligent interaction.
Web 5.0:

Web 5.0 is still an underground idea in progress and there is no exact definition of how it would be.
Web 5.0 can be considered as Symbiotic web, decentralized i.e. it is not possible to have a Personal
Server (PS) for any personal data or information stored on the net, and people tries to get
interconnected via Smart Communicator (SC), like Smart phones, Tablets or Personal Robots i.e. is
represented as its own avatar inside the SC, that will be able to surf alone in the 3D Virtual world of
the Symbiotic. The Symbiotic servers will be able to use a part of "memory and calculation power" of
each interconnected SC, in order to calculate the billions and billions needed data to build the 3D
world, and to feed it's Artificial Intelligence surf alone.

Web 6.0

A new node named web Service Extensions has been added to the Internet Information Services
Manager (ISM) in Internet Information Services (IIS) 6.0. Web service extensions are programs that
extend the basic IIS functionality of serving static content. Examples of Web service extensions are,
Active Server Pages (ASP), ASP.NET, FrontPage Server Extensions, Server-side includes (SSI), Internet
Database Connector, Web Distributed Authoring and Versioning (Web DAV), Common Gateway
Interface (CGI).

Traditional Software and Web based Software

Web systems are based on client server architecture wherein a client typically enables users to
communicate with server.

 Client of traditional client server system are platform specific but web client is operating
within web browsers environment. Web browsers already consists of operating system
specific client software running on client computer.

In making, these software components various browsers and their

 Web based system have more dynamic environment as compare to client server system. In
client server system, the role of client and servers and their interactions are predefined and
static as compared to web applications where client side programs and contents may be
generated dynamically. The environment for web application is not predefined and it
changes dynamically i.e. hardware, s/w, are changing, configuration changing etc.

Web applications often affected by these factors that may cause incompatibility and interoperability
issues.
 In traditional client server systems normal flow of control is not affected by user.
 But in web applications user can break the normal control flow.
For example :
User can press back or refresh button in web browsers.
 Due to dynamic environment web system demands more frequent maintenance.
 The user profile for web systems is very diverse as compared to client systems. Therefore,
the load on web access sue to this diversity is not predictable.
Challenges in Testing for Web-based Software

Testing is a fundamental challenge when developing web applications. Different browsers,


interfaces, security threats, and overall app integration are just a few of the issues faced by
developers. Since testing is a crucial phase in the development process, the developer should expect
to run into unforeseen issues associated with both the web application, and the testing process
itself. Each primary issue associated with testing has the potential to branch into uncountable
related issues, all of which can be solved if properly identified. Below are five web application testing
challenges faced by web developers during the development process.

Integration

Integration testing exposes problems with interfaces among different program components before
deployment. Additionally, integration testing can show the different issues an application may have
when interacting with other applications, allowing the developer to tweak things. Environment and
infrastructure inconsistency, different interaction models, and overall performance are just a few of
the issues associated with integration testing.

Interoperability

Proving end-to-end functionality between communicating systems is always a challenging obstacle.


Different users utilize different browsers and operating systems. To pull data, testing each one to
confirm a clear information pathway is very important. Even if the browsers are similar, the web
application may be rendered differently based on screen resolution and overall software
configuration. This can present some serious issues for developers.

Security

In one of the most important tests, the developer must make sure that the continually evolving
cyber threat can be countered and neutralized. Additionally, tests associated with data integrity
before and after an attack are equally important when considering data breaches or lost
information. Some of the challenges associated with security testing include dealing with unsecured
communications, removing malicious files (if security firewalls have been breached), and the
utilization (and integration) of different authentication procedures.

Performance

Slow applications are not successful. Developers understand that the speed of the app is defined by
the need of the user, and with more users expecting more speed, the requirement of performance is
non-negotiable. Testing large applications on minimal hardware, underestimating software
requirements, and overextending application features are just a few of the issues associated with
performance testing. Integration and interoperability issues can also have a direct effect on
performance, and because of that, should be tested at the beginning.

Usability

Since web-based applications are dependent on different browsers, consistent usability is crucial.
Additionally, since the app is the brand (or a component thereof), any inconsistency within the user
experience may translate into a negative experience, affecting the brand and its potential growth.
When testing usability, developers face issues with scalability and interactivity. Since every user is
different, it is important for developers to utilize a representative group to test the application
across different browsers, using different hardware.

Quality Aspects

With software or anything else, assessing quality means measuring value. Something of higher
quality has more value than something that’s of lower quality. Yet measuring value requires
answering another question: value to whom? In thinking about software quality, it’s useful to focus
on three groups of people who care about its value, as Figure 1 shows

As the figure illustrates, a development process converts an idea into usable software. The three
groups of people who care about the software’s quality during and after this process are:

The software’s users, who apply this software to some problem.

The development team that creates the software.

The sponsors of the project, who are the people paying for the software’s creation. For software
developed by an organization for its own use, for example, these sponsors are commonly business
people within that organization.

All three of these groups care about software quality. The aspects of quality that each finds most
important aren’t the same, however. Understanding these differences requires taking a closer look
at what software quality really means.

Defining Software Quality: Three Aspects

There’s no one right way to think about software quality—it’s a complicated area. It is useful,
however, to group its various components into three broad aspects. Figure 2 illustrates this idea.

The three aspects of software quality are functional quality, structural quality, and process quality.
Each one is worth looking at in more detail.

Functional quality means that the software correctly performs the tasks it’s intended to do for its
users. Among the attributes of functional quality are:
Meeting the specified requirements. Whether they come from the project’s sponsors or the
software’s intended users, meeting requirements is the sine qua non of functional quality. In some
cases, this might even include compliance with applicable laws and regulations. And since
requirements commonly change throughout the development process, achieving this goal requires
the development team to understand and implement the correct requirements throughout, not just
those initially defined for the project.

Creating software that has few defects.

Among these are bugs that reduce the software’s reliability, compromise its security, or limit
its functionality. Achieving zero defects is too much to ask for most projects, but users are
rarely happy with software they perceive as buggy.

Good enough performance.

From a user’s point of view, there’s no such thing as a good, slow application.

Ease of learning and ease of use.

To its users, the software’s user interface is the application, and so these attributes of
functional quality are most commonly provided by an effective interface and a well-thought-
out user workflow. The aesthetics of the interface—how beautiful it is—can also be
important, especially in consumer applications.

The second aspect of software quality, structural quality, means that the code itself is well
structured. Unlike functional quality, structural quality is hard to test for (although there are tools to
help measure it, as described later). The attributes of this type of quality include:

Code testability. Is the code organized in a way that makes testing easy?

Code maintainability. How easy is it to add new code or change existing code without introducing
bugs?

Code understandability. Is the code readable? Is it more complex than it needs to be? These have a
large impact on how quickly new developers can begin working with an existing code base.

Code efficiency. Especially in resource-constrained situations, writing efficient code can be critically
important.

Code security. Does the software allow common attacks such as buffer overruns and SQL injection?
Is it insecure in other ways?

The most obvious attributes of process quality include these:

Meeting delivery dates. Was the software delivered on time?

Meeting budgets. Was the software delivered for the expected amount of money?

A repeatable development process that reliably delivers quality software. If a process has the first
two attributes—software delivered on time and on budget—but so stresses the development team
that its best members quit, it isn’t a quality process. True process quality means being consistent
from one project to the next.

The third group, sponsors, cares about everything:

functional quality, structural quality, and process quality. If they’re smart, the people paying for the
project know that slacking off in any area is a poor long-term strategy. In the end, sponsors are
striving to create business value, and the best way to do this is by taking a broad view of software
quality. They must also understand the connection between quality and risk. The risk of accepting
lower software quality in, say, a community website, is much less than the risk of allowing lower
quality in an airplane’s flight control system. Making the choice appropriately commonly requires
trade-offs among competing goals.

WEB ENGINEERING

Web Engineering, an emerging new discipline, advocates a process and a systematic approach to
development of high quality Internet- and Web-based systems.

Web engineering is the establishment and use of sound scientific, engineering and management
principles and disciplined and systematic approaches to the successful development, deployment
and maintenance of high quality Web-based systems and applications.

Web engineering principles and approaches can bring the potential chaos in Web-based system
development under control, minimise risks, and enhance maintainability and quality.

3.3 Web Engineering and Software Engineering

Though Web engineering involves some programming and software development, and adopts some
of the principles of the software engineering, Web-based system development is different from
software development, and also Web engineering is different from software engineering.

1. Most Web-based systems, at least as of now, are document-oriented containing static or dynamic
Web pages.

2. Web-based systems will continue to be focussed on look and feel, favouring visual creativity and
incorporation of multimedia (in varying degrees) in presentation and interface. More emphasis will
be placed on visual creativity and presentation as regards to the front-end interface with which a
user interacts.

3. Most Web-based systems will continue to be content-driven – often Web-based systems


development include development of the content presented.

4. Multiplicity of user profiles – Most Web-based systems need to cater to users with diverse skills
and capability, complicating human-computer interaction, user interface and information
presentation.

5. The nature and characteristics of the medium of Web is not well understood as the software
medium.
6. The Web exemplifies a greater bond between art and science than generally encountered in
software development.

7. Most Web-based systems need to be developed within a short time, making it difficult to apply
the same level of formal planning and testing as used in software development. 8. Also Web is
different from software as related to the delivery medium.

9. Further, the type of individuals who build/develop Web-based systems are vastly varied in their
background, skills, knowledge and system understanding, and as well as their perception of Web and
quality Web-based system.

3.3 Web Engineering:

Web-based systems “involve a mixture between print publishing and software development,
between marketing and computing, between internal communications and external relations, and
between art and technology.”

In view of the nature of the Web and Web-based applications, Web engineering is bound to be a
multidisciplinary field, with encompassing inputs from diverse areas such as human-computer
interaction, user interface, systems analysis and design, software engineering, requirements
engineering, hypermedia engineering, information structures, testing, modeling and simulation and
project management, as well as social sciences, arts and graphic design (Figure 2).

3.4 Web Engineering Activities

Web Engineering is not a single activity or task. It deals with all aspects of Web-based system
development, starting from conception and development to implementation, performance
evaluation, and continual maintenance. Major Web engineering include:

· Requirements specification and analysis

· Web-based system development methodologies and techniques

· Migration of legacy system to Web environments

· Web-based real-time applications development

· Testing, verification and validation

.Quality assessment, control and assurance


· Performance specification and evaluation

· Update and maintenance

· User-centric development, user modeling and user involvement and feedback

· End-user application development

4. WEB-BASED SYSTEMS DEVELOPMENT

Web engineering activities span the entire Web life cycle from conception of an application to
development and deployment, and continual refinement and update/upgrade systems. The
following highlights some of the work and development in the area of Web engineering.

4.1 Web Development Process Models

To help to reduce the difficulty in building Web-based systems we need a process model that
describe the phases of Web-based system development - some of the aspects that make Web-
system difficult include complexity, changeability, invisibility and unrealistic schedule . A process
model should help developers “to address the complexities of Web-based systems, minimise risks of
development, deal with likelihood of change, and deliver the site quickly, while providing feedback
for management as the project goes along .”

Further, the progress of Web-based development should be monitorable and trackable. The process
besides being easy to apply should facilitate continual update/refinement and evolution, based on
feedback from users/clients. For information some of the hypermedia/Web development process
models see. An object-oriented model for the Web application development process, which uses
XML technology to support modularity and reuse of Web document.

4.2 Analysis and Web Design

Requirement analysis and Web-based system design is a very important activity and calls for a
systematic and disciplined approach. Some of the approaches and design considerations are
described.

Object Orientation in Web-Based Systems.

Integration of Web and object technologies offer foundation for expanding the Web to a new
generation of applications. Web must improve its data structuring capabilities, and integrate aspects
of object technology with the basis infrastructure of the Web. He also argues that if the Web is to
support complex enterprise applications, it must support generic capabilities similar to those
provided by the OMA (Object management Architecture), but adapted to the more open, flexible
nature of the Web and to the specific requirements of Web applications. Technologies for Web
object model are described in , and proposes an object-oriented model for the Web application
development process.

Usability and User-Centered Designs.

Effective Web site design requires attention to usability. Web-based systems need to be designed
for easy navigation, and also they need to be attractive and useful [25]. User-centered design
methods for Web sites is presented in [26], while [27] presents a User-Centric Approach to Modeling
Web Information Systems.

4.3 Testing of Web-Based Systems

Testing, and verification and validation (V & V) of Web-based systems is an important and
challenging task in the Web engineering process. And, yet very little attention is given by Web
developers to testing and evaluation. Webbased system testing differs from conventional software
testing and poses new challenges. Web-based systems need to be tested not only to check and
verify whether it does what it is designed to do but also to evaluate how well it appears on
(different) Web browsers. Importantly, they need to be tested for security and also for usability,
from the ultimate user’s perspective.