Software engineering for IV sem BCA ,RCU Belgavi.Syllabus

Software Engineering BCA IV semester by Prof: N.C.Hiremath
1.Introduction.
National infrastructures and utilities are controlled by computer-based
systems and most electrical products include a computer and controlling software.
Industrial manufacturing and distribution is completely computerized, as is the
financial system. Entertainment, including the music industry, computer games,
and film and television, is software intensive. Therefore, software engineering is
essential for the functioning of national and international societies.
There are many different types of software systems, from simple embedded
systems to complex, worldwide information systems. It is pointless to look for
universal notations, methods, or techniques for software engineering because
different types of software require different approaches. Developing an
organizational information system is completely different from developing a
controller for a scientific instrument.Neither of these systems has much in common
with a graphics-intensive computer game. All of these applications need software
engineering; they do not all need the same software engineering techniques.
Professional software development
Software engineering is intended to support professional software
development, rather than individual programming. It includes techniques that
support program specification, design, and evolution, none of which are normally
relevant for personal software development.
A professionally developed software system is often more than a single
program. The system usually consists of a number of separate programs and
configuration files that are used to set up these programs. It may include system
documentation, which describes the structure of the system; user documentation,
which explains how to use the system, and websites for users to download recent
product information.
This is one of the important differences between professional and amateur
software development. If you are writing a program for yourself, no one else will
use it and you don’t have to worry about writing program guides, documenting the
program design, etc. However, if you are writing software that other people will
use and other engineers will change then you usually have to provide additional
information as well as the code of the program.
SSBCA College Gokak Page 1

Frequently asked questions about software:

There are two kinds of software products:
1. Generic products
These are stand-alone systems that are produced by a development
organization and sold on the open market to any customer who is able to buy them.
Examples of this type of product include software for PCs such as databases, word
processors, drawing packages, and project-management tools.It also includes so-
called vertical applications designed for some specific purpose such as library
information systems, accounting systems, or systems for maintaining dental
records.
2. Customized (or bespoke) products
These are systems that are commissioned by
a particular customer. A software contractor develops the software especially for
that customer. Examples of this type of software include control systems for
electronic devices, systems written to support a particular business process, and air
traffic control systems.
An important difference between these types of software is that, in generic
products,the organization that develops the software controls the software
specification. For custom products, the specification is usually developed and
controlled by the organization that is buying the software.
Software engineering;
“Software engineering is an engineering discipline that is concerned with all
aspects of software production from the early stages of system specification
through to maintaining the system after it has gone into use.”

Essential attributes of good software:
There are four fundamental activities that are common to all software
processes. These activities are:
1. Software specification, where customers and engineers define the software that
is to be produced and the constraints on its operation.
2. Software development, where the software is designed and programmed.
3. Software validation, where the software is checked to ensure that it is what the
customer requires.
4. Software evolution, where the software is modified to reflect changing
customer and market requirements.
Differences between Software engineering and Computer science
 Computer science is concerned with the theories and methods that
underlie computers and software systems, whereas software
engineering is concerned with the practical problems of producing
software.

 Some knowledge of computer science is essential for software
engineers in the same way that some knowledge of physics is
essential for electrical engineers.
 Computer science theory, however, is often most applicable to
relatively small programs. Elegant theories of computerscience cannot
always be applied to large, complex problems that require a software
solution..
Differences between Software engineering and System Engineering
 System engineering is therefore concerned with hardware
development, policy and process design and system deployment, as
well as software engineering.
 System engineers are involved in specifying the system, defining its
overall architecture, and then integrating the different parts to create
the finished system.
Issues that affect many different types of software:
1. Heterogeneity Increasingly, systems are required to operate as distributed
systems across networks that include different types of computer and mobile
devices. As well as running on general-purpose computers, software may also have
to execute on mobile phones. You often have to integrate new software with older
legacy systems written in different programming languages. The challenge here is
to develop techniques for building dependable software that is flexible enough to
cope with this heterogeneity.
2. Business and social change Business and society are changing incredibly
quickly as emerging economies develop and new technologies become available.
They need to be able to change their existing software and to rapidly develop new
software.Many traditional software engineering techniques are time consuming and
delivery of new systems often takes longer than planned. They need to evolve so
that the time required for software to deliver value to its customers is reduced.
3. Security and trust As software is intertwined with all aspects of our lives, it is
essential that we can trust that software. This is especially true for remote software

systems accessed through a web page or web service interface. We have to make
sure that malicious users cannot attack our software and that information security
is maintained.
Different types of application
1. Stand-alone applications These are application systems that run on a local
computer, such as a PC. They include all necessary functionality and do not need
to be connected to a network. Examples of such applications are office applications
on a PC, CAD programs, photo manipulation software, etc.
2. Interactive transaction-based applications These are applications that execute
on a remote computer and that are accessed by users from their own PCs or
terminals. Obviously, these include web applications such as e-commerce
applications where you can interact with a remote system to buy goods and
services.This class of application also includes business systems, where a business
provides access to its systems through a web browser or special-purpose client
program and cloud-based services, such as mail and photo sharing. Interactive
applications often incorporate a large data store that is accessed and updated in
each transaction.
2. Interactive transaction-based applications These are applications that execute
on a remote computer and that are accessed by users from their own PCs or
terminals. Obviously, these include web applications such as e-commerce
applications where you can interact with a remote system to buy goods and
services. This class of application also includes business systems, where a business
provides access to its systems through a web browser or special-purpose client
program and cloud-based services, such as mail and photo sharing. Interactive
applications often incorporate a large data store that is accessed and updated in
each transaction.
3. Embedded control systems These are software control systems that control and
manage hardware devices. Numerically, there are probably more embedded
systems than any other type of system. Examples of embedded systems include the
software in a mobile (cell) phone, software that controls anti-lock braking in a car,
and software in a microwave oven to control the cooking process.

4. Batch processing systems These are business systems that are designed to
process data in large batches. They process large numbers of individual inputs to
create corresponding outputs. Examples of batch systems include periodic billing
systems, such as phone billing systems, and salary payment systems.
5. Entertainment systems These are systems that are primarily for personal use and
which are intended to entertain the user. Most of these systems are games of one
kind or another. The quality of the user interaction offered is the most important
distinguishing characteristic of entertainment systems.
6. Systems for modeling and simulation These are systems that are developed by
scientists and engineers to model physical processes or situations, which include
many, separate, interacting objects. These are often computationally intensive and
require high-performance parallel systems for execution.
7. Data collection systems These are systems that collect data from their
environment using a set of sensors and send that data to other systems for
processing. The software has to interact with sensors and often is installed in a
hostile environment such as inside an engine or in a remote location.
8. Systems of systems These are systems that are composed of a number of other
software systems. Some of these may be generic software products, such as a
spreadsheet program. O Other systems in the assembly may be specially written for
that environment.
Software engineering Ethics
In software engineering discipline there are some Professional responsibility.
and these are:
1. Confidentiality You should normally respect the confidentiality of your
employers or clients irrespective of whether or not a formal confidentiality
agreement has been signed.
2. Competence You should not misrepresent your level of competence. You should
not knowingly accept work that is outside your competence.
3. Intellectual property rights You should be aware of local laws governing the use
of intellectual property such as patents and copyright. You should be careful to
ensure that the intellectual property of employers and clients is protected.
4. Computer misuse You should not use your technical skills to misuse other
people’s computers. Computer misuse ranges from relatively trivial (game playing

on an employer’s machine, say) to extremely serious (dissemination of viruses or
other malware).

Software processes:
A software process is a set of related activities that leads to the production of
a software product. These activities may involve the development of software from
scratch in a standard programming language like Java or C.
There are many different software processes but all must include four
activities that are fundamental to software engineering:
1. Software specification The functionality of the software and constraints on its
operation must be defined.
2. Software design and implementation The software to meet the specification
must be produced.
3. Software validation The software must be validated to ensure that it does what
the customer wants.
4. Software evolution The software must evolve to meet changing customer needs.
2.1 Software process models
A software process model is a simplified representation of a software
process. Each process model represents a process from a particular perspective,and
thus provides only partial information about that process. For example,a process
activity model shows the activities and their sequence but may not show the roles
of the people involved in these activities.
I.The waterfall model This takes the fundamental process activities of
specification, development, validation, and evolution and represents them as
separate process phases such as requirements specification, software design,
implementation, testing, and so on.
This model is illustrated in below figure . Because of the cascade from one
phase to another, this model is known as the ‘waterfall model’ or software life
cycle. The waterfall model is an example of a plan-driven process—in principle,

you must plan and schedule all of the process activities before starting work on
them.
1. Requirements analysis and definition The system’s services, constraints, and
goals are established by consultation with system users. They are then defined
in detail and serve as a system specification.
2. System and software design The systems design process allocates the
requirements to either hardware or software systems by establishing an overall
system architecture. Software design involves identifying and describing the
fundamental software system abstractions and their relationships.
3. Implementation and unit testing During this stage, the software design is
realized as a set of programs or program units. Unit testing involves verifying that
each unit meets its specification.
4. Integration and system testing The individual program units or programs are
integrated and tested as a complete system to ensure that the software requirements
have been met. After testing, the software system is delivered to the customer.
5. Operation and maintenance Normally (although not necessarily), this is the
longest life cycle phase. The system is installed and put into practical use.
Maintenance involves correcting errors which were not discovered in earlier stages

of the life cycle, improving the implementation of system units and enhancing the
system’s services as new requirements are discovered.
• Advantages:
1. Simple & easy to understand & use.
2. Documentation is produced at each stage.
3. Stages are processed & completed one at a time.
4. Clearly defined stages.
5. Suitable for development of large-sized systems.
• Disadvantages:
1. Inflexible partitioning of the project into distinct stages.
2. Difficult to respond to changing customer-requirements.
3. Not a good model for complex and object-oriented projects.
4. No working software is produced until late in the life cycle.
II.Incremental development:
Incremental development is based on the idea of developing an initial
implementation, exposing this to user comment and evolving it through several
versions until an adequate system has been developed. Specification, development,
and validation activities are interleaved rather than separate, with rapid feedback
across activities. This better for most business, e-commerce and personal systems
than waterfall approaches

Benefits(advantages) compared to waterfall model
 Reduced cost of accommodating changing customer requirements
 Easier to get customer feedback on the development work that has been done
 Possibly more rapid delivery and deployment of useful software to the customer.
Customers use and gain value from the software earlier than with water model
Problems (Disadvantages)
 Process is not visible
o How to measure progress (see managers)
o Producing documents that reflect every version of the system is not cost-effective
 System structure tends to degrade as new increments are added
o Time and money is required on refactoring to improve the software
o Regular changes tend to corrupt its structure
o Further software changes become increasingly difficult and costly
III.Reuse-oriented software engineering.
In the majority of software projects, there is some software reuse. This often
happens informally when people working on the project know of designs or code
that are similar to what is required. They look for these, modify them as needed,
and incorporate them into their system.
A general process model for reuse-based development is shown in
Figure.Although the initial requirements specification stage and the validation
stage are comparable with other software processes, the intermediate stages in a
reuseoriented process are different. These stages are:

1. Component analysis Given the requirements specification, a search is made for
components to implement that specification. Usually, there is no exact match and
the components that may be used only provide some of the functionality required.
2. Requirements modification During this stage, the requirements are analyzed
using information about the components that have been discovered. They are then
modified to reflect the available components. Where modifications are impossible,
the component analysis activity may be re-entered to search for alternative
solutions.
3. System design with reuse During this phase, the framework of the system is
designed or an existing framework is reused. The designers take into account the
components that are reused and organize the framework to cater for this. Some new
software may have to be designed if reusable components are not available.
4. Development and integration Software that cannot be externally procured is
developed, and the components and COTS systems are integrated to create the new
system. System integration, in this model, may be part of the development process
rather than a separate activity.
There are three types of software component that may be used in a reuse-
oriented process:
1. Web services that are developed according to service standards and which are
available for remote invocation.
2. Collections of objects that are developed as a package to be integrated with a
component framework such as .NET or J2EE.
3. Stand-alone software systems that are configured for use in a particular
environment.
Advantages
 Reduce the amount of software to be developed
 Reduce cost and risks
 Usually leads to faster delivery of the software
Disadvantages
 May lead to a system that does not meet the real needs of users (requirements
compromises are inevitable)
 Lost control over the system evolution as new versions of the reusable
components are not under the control of the organization using them .

Process activities:
The four basic process activities of specification, development, validation,
and evolution are organized differently in different development processes.
A) Software specification or Requirements engineering :
Software Specification
• This is also called requirements engineering.
• The basic idea:
1. Understand & define what services are required from the system and
2. Identify the constraints on the system's operation & development.
• Errors at this stage lead to later problems in the system-design and
-implementation.
• Four phases of requirements engineering (Figure 4.6):
1. Feasibility Study
 An estimate is made of whether the identified-user needs may be satisfied using
current software- and hardware-technologies.
 The result should inform the decision of whether to go ahead with a more
detailed analysis.
 This study should be relatively cheap & quick.
2. Requirements Elicitation & Analysis
 This is the process of deriving the system-requirements through
→ observation of existing-systems and
→ discussions with potential users.
 This may involve the development of one or more system-models and
prototypes.
3. Requirements Specification
 This activity translates the information gathered in analysis phase into a
document.

 The document defines a set of requirements.
 Two types of requirements:
i) User requirements are abstract statements of the system-requirements for the
enduser
of the system.
ii) System requirements are more detailed description of the functionality to be
provided.
4. Requirements Validation
 This activity checks the requirements for consistency and completeness.
 Errors in the requirements document are discovered.
B) Software Design & Implementation
• The implementation-stage is the process of converting a system-specification into
an executable system.
• A software-design is a description of
→ structure of the software
→ interfaces between the components and
→ algorithms used.

• Six activities of software-design (Figure 4.7):
1. Architectural Design
 The subsystems making up the system and their relationships are identified and
documented.
2. Abstract Specification
 For each subsystem, an abstract specification of its services & constraints are
produced.
3. Interface Design
 For each subsystem, its interface with other subsystems is designed and
documented.
4. Component Design
 Services are allocated to components.
 The interfaces of these components are designed.
5. Data structure Design
 The data structures used in the system-implementation are designed in detail and
specified.
6. Algorithm Design

 The algorithms used to provide services are designed in detail and
specified.
C) Software validation
Software validation or, more generally, verification and validation (V&V) is
intended to show that a system both conforms to its specification and that it meets
the expectations of the system customer.
Figure shows a three-stage testing process in which system components are
tested then the integrated system is tested and, finally, the system is tested with the
customer’s data.

The stages in the testing process are:
1. Development testing The components making up the system are tested by the
people developing the system. Each component is tested independently, without
other system components. Components may be simple entities such as functions or
object classes, or may be coherent groupings of these entities. Test automation
tools, such as JUnit (Massol and Husted, 2003), that can re-run component tests
when new versions of the component are created, are commonly used.
2. System testing System components are integrated to create a complete system.
This process is concerned with finding errors that result from unanticipated
interactions between components and component interface problems. It is also
concerned with showing that the system meets its functional and non-functional
requirements, and testing the emergent system properties. For large systems, this
may be a multi-stage process where components are integrated to form subsystems
that are individually tested before these sub-systems are themselves
integrated to form the final system.
3. Acceptance testing This is the final stage in the testing process before the
system is accepted for operational use. The system is tested with data supplied by
the system customer rather than with simulated test data. Acceptance testing may
reveal errors and omissions in the system requirements definition, because the real
data exercise the system in different ways from the test data. Acceptance testing
may also reveal requirements problems where the system’s facilities do not really
meet the user’s needs or the system performance is unacceptable.
D) Software evolution:
The flexibility of software systems is one of the main reasons why more and more
software is being incorporated in large, complex systems. Once a decision has been
made to manufacture hardware, it is very expensive to make changes to the
hardware design. However, changes can be made to software at any time during or
after the system development. Even extensive changes are still much cheaper than
corresponding changes to system hardware.shown below

Boehm’s Spiral Model :
• This is a software development approach which is a combination of
→ an iterative nature of prototyping and
→ systematic aspects of waterfall model.
• Each loop represents a stage of the software-process.
• Each loop is split into four sectors (Figure 4.5):
1. Objective Setting
 Objectives for each stage of the project are defined.
 Constraints on the process are identified.
 A detailed management plan is drawn up.
 Project-risks are identified.
 Alternative strategies are planned.
2. Risk Assessment & Reduction
 This involves
→ identifying the risks associated with activities and
→ taking steps to reduce those risks.
3. Development and Validation
 A development model for the system is chosen which can be any of the generic
models (waterfall model, spiral model etc).
4. Planning
 The project is reviewed and the next phase of the spiral is planned.

Advantages:
 Explicit recognition of risk
Characteristics:
 Begin of cycle of the spiral: elaborating objectives such as performance and
functionality
 Enumerate alternative ways of achieving these objectives and dealing with the
constraints
 Development is carried out after risks have been assessed .
Prototyping:
Prototype: an initial version of a software system that is used to demonstrate
concepts, try out design options and find out more about the problem and its
possible solutions. Rapid, iterative development of the prototype is essential (to

control costs; system stakeholders can experiment with the prototype early in the
software process).
How software prototyping can help:
 Requirements engineering process: elicitation and validation of system
requirements
 System design process: explore particular software solutions; support user
interface design
 Get new ideas for requirements
 Find areas of strength and weakness in the software (to propose new system
requirements)
 May reveal errors and omissions in the requirements
 Carry out design experiments to check the feasibility of a proposed design
 Essential part of the user interface design process (dynamic nature of user
interfaces) .
The below figure shows a process model for prototype development.
The Early stage in the process is to decide what to put into and, perhaps
more importantly, what to leave out of the prototype system. To reduce prototyping
cost and accelerate the delivery schedule, you may leave some functionality out of
the prototype. You may decide to relax non-functional requirements such as
response time and memory utilization. Error handling and management may be
ignored unless the objective of the prototype is to establish a user interface.
Standards of reliability and program quality may be reduced.
The final stage of the process is prototype evaluation. Provision must be
made during this stage for user training and the prototype objectives should be
used to derive a plan for evaluation. Users need time to become comfortable with a

new system and to settle into a normal pattern of usage. Once they are using the
system normally, they then discover requirements errors and omissions.
A general problem with prototyping is that the prototype may not necessarily be
used in the same way as the final system. The tester of the prototype may not be
typical of system users. The training time during prototype evaluation may be
insufficient. If the prototype is slow, the evaluators may adjust their way of
working and avoid those system features that have slow response times. When
provided with better response in the final system, they may use it in a different
way. Developers are sometimes pressured by managers to deliver throwaway
prototypes, particularly when there are delays in delivering the final version of the
software.
Delivering throwaway prototypes is usually unwise:
 May be impossible to tune the prototype to meet non-functional requirements:
performance, security, robustness, reliability requirements
 Undocumented prototype due to rapid change during development; prototype
code as the only design specification (bad for long-time maintenance)
 probably degraded system structure due to changes made during prototype
development. System will be difficult and expensive to maintain.
 Relaxed organizational quality standards for prototype development
Examples:
 Paper-based mock-ups of the system user interface (help users refine an
interface design and work through usage scenarios)
 Wizard of Oz prototype (extension to the one above): only the user interface is
developed.

Software engineering for IV sem BCA ,RCU Belgavi.Syllabus

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Software engineering for IV sem BCA ,RCU Belgavi.Syllabus (20)

Recently uploaded (20)

Software engineering for IV sem BCA ,RCU Belgavi.Syllabus