SOFTWARE ENGINEERING LAB MANUAL

Software for business applications, whether it is intended to perform a single task or

it is intended for use as a company-wide, integrated system, should be tailored to fit
the companys unique needs and goals. In the simplest terms, the software should
be capable of performing all the functions necessary to perform a task efficiently.
While the software should be inclusive, it should not be unduly cumbersome. Careful
attention is required to develop software that is both functional and efficient. Once
the software is in use, it must be maintained. We will discuss several processes
which can serve as guidelines for software development.
The software has seen many changes since its inception. After all, it has evolved
over the period of time against all odds and adverse circumstances. Computer
industry has also progressed at a break neck speed through the computer
revolution, and recently , the network revolution triggered by the explosive spread
of the internet and most recently the web. Computer industry has been delivering
exponential improvement in price performance , but the problems with software
have not been decreasing.Software still come late ,exceed budget and are full of
residual faults.
A major problem of industry is to build a bug free software.As
hardware cost continues to decline drastically.

we all know the

The hard part of building software is the specification, design and testing of this
conceptual construct and not the labour of representing it and testing the
correctness of representation. The software is evolving day by day and its effect is
also increasing on every facet of human life.
The art of programing only is no longer sufficient to construct large programs .There
are serious problems in the cost, timeliness and maintenance of quality of many
software products.
At the first conference engineering in 1968 ,Fritz Bauer defined software
engineering as The establishment and use of sound engineering principles in order
to obtain economically developed software that is reliable and works efficiently on
real machines.
It is also defined a s a discipline whose aim is the production of quality software ,
software that is delievered on time , within budget and that satisfies its
requirements.
PHASES:
Requirements-gathering:

During the requirements-gathering phase, the needs of the company are outlined.
Managers and users (and in some cases, clients) make their wish-lists about what
they would like the software to do. Analysts ask questions about the intended use of
the software, what type of data will be processed, how the software should handle
the data, and how the data can be accessed once in the system. Following the
requirements phase, the software development team should have a detailed list of
functions that the system will perform. Emphasis is on the system's goals, rather
than the way in which the system will achieve those goals.
There are some essential requirement gathering techniques that you must be aware of in order to manage the
projects in a better way and run your business successfully are:
1.Brainstorming
2.Document Analysis
3.Prototyping
4.Revese Engineering
Brainstorming:
Project Managers use brainstorming to solve problems. Hymes and Olson define the problem solving stages as:

Problem Identification
Idea Generation
Idea Selection (decision making)
Implementation

Idea Generation and Idea Selection are part of a brainstorming session, while Problem Identification occurs before
the session and Implementation occurs after the session.
Since brainstorming requires multiple people, the Project Manager functions as a facilitator of the session. As
afacilitator, you are the most influential figure in the brainstorming session.Many researchers have delved into the
topic of optimizing brainstorming sessions. Some research-based guidelines to follow during brainstorming are:
1.
2.
3.
4.
5.
6.

Ensure there are enough whiteboards in the room. You will document the ideas on whiteboards and
categorize them.
Combine the ideas wherever possible.
Divide complex problems into simpler, smaller problems. Then, examine each smaller problem
independently.
Disperse the group so that each member can brainstorm independently. Group brainstorming followed by
independent brainstorming yields better results.
After ranking the ideas, agree on the solution.
Assign an owner to ensure the solution is performed.

Document Analysis
When you first start a project or join an existing one, analyzing existing documentation is a great way to familiarize
yourself with how the business currently functions. This is especially important when the subject matter experts are
too busy to dedicate enough time to meet with you to describe the current process or when experts have left the
organization and all that is left is documentation.
A great source for requirements in that case is looking at old requirement definition documents and reusing
requirements. It is important to make sure that if you are reusing requirements that they are up to date and have not
been made obsolete by other enhancements to the system.Some documents that would be worth reviewing include

training guides, system specifications, and other product literature. It is even a good idea to research how other
organizations have handled the same tasks and problems they may have encountered. While reviewing the existing
documentation it is important to jot down questions that arise that can be brought to the stakeholders. This is a great
first step as you prepare for interviews or other interaction based elicitation methods.
Prototyping
A prototype represents the shell of an actual production application. Prototypes are built early in the development
lifecycle, and they're used to provide valuable insight into the look, feel, and general workflow of an application. The
main purpose of a prototype is to gather and document requirements. The prototype starts off as a shell that contains
the online screens. There should be very little programming of the core business processes and only enough
program code to allow the prototype to go from screen to screen.
There are two options for what happens to the prototype once it's built.

Complete or partial throw-away:If you build a prototype, you'll throw it away after the requirements

have been gathered.in reality, the team members built the prototype in PowerPoint or Excel. There was no
thought that somehow this PowerPoint prototype would be reused further as the project progresses. On the
other hand, in many instances you'll build a prototype using the same technology as the final solution.
Iteratively develop into final application:If you're using an iterative development approach, the
first prototype should still be put together quickly. In the second pass, more business logic is also placed
into the application. At this point, it's no longer called a prototype. Instead, the prototype shell is used as the
basis for developing the final solution.

Reverse Engineering
An incremental reverse engineering approach has the advantages of a quicker return on investment, reduced risk,
and more flexibility. There are two basic approaches to reverse engineering requirements:

Total System Documentation:he entire system needs to be documented so that it can be

redeveloped. Although an expensive option, redevelopment has the advantage of using modern tools,
platforms, languages, and methods. If you need to go down this path, then be aware of a pitfall.Managing
requirements of both the existing legacy system and its continual changes is extremely difficult and feasible
only if the system is small. Some functional changes cannot wait until the old system has been documented.
Thus, modifications to the legacy system must be continually updated in the documentation. This requires
significantly more resources .
Incremental Reverse Engineering Requirements:A key decision when planning incremental
reverse engineering requirements is how to decompose the legacy system to its components like physical
site, functional or basic need, interconnectivity ,data and business rules and a central repository.

Software Planning

Before

starting a software project, it is essential to determine the tasks to be performed and properly manage

allocation of tasks among individuals involved in the software development. Hence, planning is important as it results
in effective software development.Project planning is an organized and integrated management process, which
focuses on activities required for successful completion of the project. It prevents obstacles that arise in the project
such as changes in projects or organization's objectives, non-availability of resources, and so on. Project planning
also helps in better utilization of resources and optimal usage of the allotted time for a project. The other objectives of
project planning are listed below.

It defines the roles and responsibilities of the project management team members.

It ensures that the project management team works according to the business objectives.

It checks feasibility of the schedule and user requirements.

It determines project constraints.

For effective project planning, some principles are followed. These principles are listed below.

Planning is necessary: Planning should be done before a project begins. For effective planning, objectives
and schedules should be clear and understandable.

Risk analysis: Before starting the project, senior management and the project management team should
consider the risks that may affect the project. For example, the user may desire changes in requirements while the
project is in progress. In such a case, the estimation of time and cost should be done according to those
requirements (new requirements).

Tracking of project plan: Once the project plan is prepared, it should be tracked and modified accordingly.

Meet quality standards and produce quality deliverables: The project plan should identify processes by
which the project management team can ensure quality in software. Based on the process selected for ensuring
quality, the time and cost for the project is estimated.

Description of flexibility to accommodate changes: The result of project planning is recorded in the form
of a project plan, which should allow new changes to be accommodated when the project is in progress.

Software Design:
Software design is a process to transform user requirements into some suitable form, which helps the programmer
in software coding and implementation.For assessing user requirements, an SRS (Software Requirement
Specification) document is created whereas for coding and implementation, there is a need of more specific and
detailed requirements in software terms. The output of this process can directly be used into implementation in
programming languages.
Software design yields three levels of results:

Architectural Design : At this level, the designers get the idea of proposed solution domain.

High-level design: It focuses on how the system along with all of its components can be implemented in
forms of modules.

Detailed Design- Detailed design deals with the implementation part of what is seen as a system and its
sub-systems in the previous two designs.

Software Testing:
Software testing is the process of evaluation a software item to detect differences between given input and expected
output. Also to assess the feature of A software item. Testing assesses the quality of the product. Software testing is a
process that should be done during the development process. In other words software testing is a verification and
validation process
Verification is the process to make sure the product satisfies the conditions imposed at the start of the development
phase. In other words, to make sure the product behaves the way we want it to.
Validation is the process to make sure the product satisfies the specified requirements at the end of the development
phase. In other words, to make sure the product is built as per customer requirement
There are many types of testing like

Unit Testing
Integration Testing
Functional Testing
System Testing
Unit Testing
Unit testing is the testing of an individual unit or group of related units. It falls under the class of white box testing. It is
often done by the programmer to test that the unit he/she has implemented is producing expected output against
given input.
Integration Testing
Integration testing is testing in which a group of components are combined to produce output. Also, the interaction
between software and hardware is tested in integration testing if software and hardware components have any
relation. It may fall underboth white box testing and black box testing.
Functional Testing
Functional testing is the testing to ensure that the specified functionality required in the system requirements works. It
falls under the class of black box testing.
System Testing
System testing is the testing to ensure that by putting the software in different environments (e.g., Operating
Systems) it still works. System testing is done with full system implementation and environment. It falls under the
class of black box testing.
There are many testing tools available now days. Some of them are :
GUI Test Drivers Tools that automate execution of tests for products with graphical user interfaces. Client/server test
automation tools, including load testers, also go here.

Load and Performance ToolsTools that specialize in putting a heavy load on systems (especially client-server
systems). These tools are often also GUI test drivers.
Test Management ToolsTools that automate execution of tests for products without graphical user interfaces. Also
tools that help you work with large test suites.
Test Implementation Tools Miscellaneous tools that help you implement tests. For example, tools that automatically
generate stub routines go here, as do tools that attempt to make failures more obvious (assertion generators, etc.)
Test Evaluation Tools Tools that help you evaluate the quality of your tests. Code coverage tools go here. Total 31
tools. Static Analysis Tools Tools that analyze programs without running them. Metrics tools fall in this category.
Requirement Tools Requirement-based or requirement definition related tools. Design: Caliber-RBT (No 1) is a
test case design system for requirement-based testing

Component Tools Tools, which have some relationships with component-programming

There are several ways in which test tools can be classified. They can be classified according to:
their purpose:

The activities within the fundamental test process and the software life cycle with which they are primarily
associated;
The type of testing that they support (types of testing are );
The source of tools (shareware, open source, free or commercial);
The technology used;
Who uses them.

Software Maintenance:
Software maintenance is widely accepted part of SDLC now a days. It stands for all the modifications and updations
done after the delivery of software product. There are number of reasons, why modifications are required, some of
them are briefly mentioned below:

Market Conditions - Policies, which changes over the time, such as taxation and newly introduced
constraints like, how to maintain bookkeeping, may trigger need for modification.

Client Requirements - Over the time, customer may ask for new features or functions in the software.

Host Modifications - If any of the hardware and/or platform (such as operating system) of the target host
changes, software changes are needed to keep adaptability.

Organization Changes - If there is any business level change at client end, such as reduction of
organization strength, acquiring another company, organization venturing into new business, need to modify
in the original software may arise.

Following are some types of maintenance based on their characteristics:

Corrective Maintenance - This includes modifications and updations done in order to correct or fix
problems, which are either discovered by user or concluded by user error reports.

Adaptive Maintenance - This includes modifications and updations applied to keep the software product
up-to date and tuned to the ever changing world of technology and business environment.

Perfective Maintenance - This includes modifications and updates done in order to keep the software
usable over long period of time. It includes new features, new user requirements for refining the software
and improve its reliability and performance.

Preventive Maintenance - This includes modifications and updations to prevent future problems of the
software. It aims to attend problems, which are not significant at this moment but may cause serious issues
in future.