C.

Abdul Hakeem College of Engineering and Technology

Department of MCA
MC4102 - Object Oriented Software Engineering

Unit - 1
Software Development and Process Models

Introduction to Software Development

“Software development refers to a set of computer science activities dedicated to the

process of creating, designing, deploying and supporting software.”

Software itself is the set of instructions or programs that tell a computer what to do. It
is independent of hardware and makes computers programmable. There are three
basic types:

System software to provide core functions such as operating systems, disk

management, utilities, hardware management and other operational necessities.

Programming software to give programmers tools such as text editors, compilers,

linkers, debuggers and other tools to create code.

Application software (applications or apps) to help users perform tasks. Office

productivity suites, data management software, media players and security programs
are examples. Applications also refers to web and mobile applications like those used
to shop on Amazon.com, socialize with Facebook or post pictures to Instagram. 1

A possible fourth type is embedded software. Embedded systems software is used to

control machines and devices not typically considered computers —
telecommunications networks, cars, industrial robots and more. These devices, and
their software, can be connected as part of the Internet of Things (IoT).2

Software development is primarily conducted by programmers, software engineers

and software developers. These roles interact and overlap, and the dynamics between
them vary greatly across development departments and communities.

Programmers, or coders, write source code to program computers for specific tasks
like merging databases, processing online orders, routing communications,
conducting searches or displaying text and graphics. Programmers typically interpret
instructions from software developers and engineers and use programming languages
like C++ or Java to carry them out.

Software engineers apply engineering principles to build software and systems to

solve problems. They use modeling language and other tools to devise solutions that
can often be applied to problems in a general way, as opposed to merely solving for a
specific instance or client. Software engineering solutions adhere to the scientific
method and must work in the real world, as with bridges or elevators. Their
responsibility has grown as products have become increasingly more intelligent with
the addition of microprocessors, sensors and software. Not only are more products

1
relying on software for market differentiation, but their software development must be
coordinated with the product’s mechanical and electrical development work.

Software developers have a less formal role than engineers and can be closely
involved with specific project areas — including writing code. At the same time, they
drive the overall software development lifecycle — including working across
functional teams to transform requirements into features, managing development
teams and processes, and conducting software testing and maintenance.

An important distinction is custom software development as opposed to commercial

software development. Custom software development is the process of designing,
creating, deploying and maintaining software for a specific set of users, functions or
organizations. In contrast, commercial off-the-shelf software (COTS) is designed for a
broad set of requirements, allowing it to be packaged and commercially marketed and
distributed.

Steps in the software development process

Developing software typically involves the following steps:

 Selecting a methodology to establish a framework in which the steps of

software development are applied. It describes an overall work process or
roadmap for the project. Methodologies can include Agile development,
DevOps, Rapid Application Development (RAD), Scaled Agile Framework
(SAFe), Waterfall and others. (See the glossary.)

 Gathering requirements to understand and document what is required by

users and other stakeholders.

 Choosing or building an architecture as the underlying structure within

which the software will operate.

 Developing a design around solutions to the problems presented by

requirements, often involving process models and storyboards.

 Building a model with a modeling tool that uses a modeling language like
SysML or UML to conduct early validation, prototyping and simulation of the
design.

 Constructing code in the appropriate programming language. Involves peer

and team review to eliminate problems early and produce quality software
faster.

 Testing with pre-planned scenarios as part of software design and coding —

and conducting performance testing to simulate load testing on the applicatio.

 Managing configuration and defects to understand all the software artifacts

(requirements, design, code, test) and build distinct versions of the software.
Establish quality assurance priorities and release criteria to address and track
defects.

2
  Deploying the software for use and responding to and resolving user
problems.

 Migrating data to the new or updated software from existing applications or

data sources if necessary.

 Managing and measuring the project to maintain quality and delivery over
the application lifecycle, and to evaluate the development process with models
such as the Capability Maturity Model (CMM).

The steps of the software development process fit into application lifecycle
management (ALM). The IBM Engineering Management solution is a superset of
ALM that enables the management of parallel mechanical, electrical and software
development.

 Requirements analysis and specification

 Design and development

 Testing

 Deployment

 Maintenance and support

Software development process steps can be grouped into the phases of the lifecycle,
but the importance of the lifecycle is that it recycles to enable continuous
improvement. For example, user issues that surface in the maintenance and support
phase can become requirements at the beginning of the next cycle.

Software development is the process of conceiving, specifying,

designing, programming, documenting, testing, and bug fixing involved in creating
and maintaining applications, frameworks, or other software components.
The Software Development Life Cycle (SDLC) refers to a methodology with clearly
defined processes for creating high-quality software. In detail, the SDLC
methodology focuses on the following phases of software development:
• Requirement analysis
• Planning
• Software design such as architectural design
• Software development
• Testing
• Deployment

3
In an object-oriented system, all data is represented as discrete objects with which
the user and other objects may interact. Each object contains data as well as
information about the executable file needed to interpret that data. An object-oriented
system allows the user to focus completely on tasks rather than tools.
Object-Oriented Development uses "objects" to model real world objects. A car or a
laptop can be considered as object.
While traditional programming views software as a collection of functions, an object
oriented system concentrates on the objects that combines data and functionality
together.
In Object-Oriented Development, we apply object orientation across every system
development activity such as requirement analysis, design, programming, testing, and
maintenance.
For instance, an object oriented analysis (OOA) will usually have the following steps:
• Identifying the system functionality
• Identifying the involved objects
• Recognizing the object classes
• Analysing the objects to fulfil the system functionality

Object-Oriented System Development Life Cycle

The Object-Oriented approach of Building Systems takes the objects as the basis.
For this, first the system to be developed is observed and analyzed and the
requirements are defined as in any other method of system development. Once
this is often done, the objects in the required system are identified.
For example, in the case of a Banking System, a customer is an object, a chequebook
is an object, and even an account is an object.
Object-oriented model employs an object-oriented strategy. The primary objectives
are:
1. Object-oriented analysis,
2. Object-oriented design,
3. Object-oriented programming
Obiect-oriented analysis develops an object-oriented model of the application domain.
Object-oriented design develops an object-oriented model of the software system.
Object oriented programming realizes the software design with an object-oriented

4
programming language that supports direct implementation of objects, classes, and
inheritance.

Challenges

Major Challenges in Software Development

Rapid technology advancement

Every technology advancement is a blessing for the IT industry. But at the same time,
technology evolving at a phenomenal rate leads to an added pressure for software
development professionals to leverage these upcoming technology trends in software
product development to gain a cutting edge over competitors and stand out in the
market.

Increasing customer demands

Software projects are generally conceptual and are aimed at designing and developing
software products that meet varied customer demands. To develop even the simplest
application or product, developers must clearly understand the underlying business
concept and bring in the required features to satisfy the growing customer demands.

Time limitations

Software development is a time-game. Developers work under pressured

environments and strive to complete project requirements within strict and scanty
timelines. This is especially a challenge when working with international clients on
multiple time-zones. Time constraints often bring down efficiencies of development
teams and lead to mediocre quality software products in the end.

Limited infrastructure/resources

Another challenge faced by majority of software development companies is a lack of

resources or IT infrastructure to execute projects effectively. This could mean a lack
of high performance software development tools, powerful computing platforms,
inefficient data storage architectures or improper networks and connectivity. Such
hindrances bring down productivity and performance of software development teams
and impact the overall result.

Conflicts with software testing teams

In a classic software development project, interpersonal conflicts occur inevitably

between software development and testing teams. Several factors contribute to such
conflicts like working under high performance pressure, different mindsets, difference
in job roles and the very opposite nature of development and testing. If not controlled
and managed effectively, these conflicts could hamper the overall project adversely.

To succeed in a dynamic software industry that is driven by changing technology

trends and challenged by multiple internal and external factors, your development

5
teams must have a clear understanding of the problems that lie ahead of them and a
roadmap to overcome them.

Implementing software development best practices could help reduce these problems
to a large extent. Introducing a DevOps team to handle the testing-development crisis,
adopting Cloud for seamless network and infrastructure and constantly enhancing the
technical knowhow of your software development teams could help you fight some of
these major software development challenges and establish a good position in the
software market.

Challenges of Software Developers :

Here is the list of some top challenges every Software Product Developer faces –

1. Changing Requirements during the development process brings challenges for

the software developers. Sometimes they won’t be able to deal with changing
requirements.

2. Providing complete Security to the software applications is a major challenge

for developers as hackers are trying each moment there to hack the software
applications and to steal the data.

3. Some times Misinterpreted requirements gives rise to a problem as a result the

software product fails gives the actual result to the end users.

4. Many times software developers face problem during System and Application
integration leading to failure of software projects also.

5. Further Maintenance and Upgradation becomes a problem for software

developers for some software projects.

6. Adapting latest Technology becomes a big challenge for the software

developers when they don’t have sufficient experience on latest market
trends.

7. Sometimes when the developers don’t get appropriate Project infrastructure

for development and deployment of project they face problem in delivering
the product.

8. Getting Defects or Errors in the product during its last stage creates an
unwanted challenge for the software developers.

9. Time limitations plays a vital role in software development. When there is no

sufficient time for the development some times the product don’t meet the
quality standards as the developers works under pressure and output
decreases.

10. When a new developer lacks proper Communication and Coordination with
the other developers of the same development team it creates a problem at

6
 some point.

11. It feels like a common problem when one developer Works with another
developer’s code This situation creates a problem for the developer as it takes
lot time of the new developer to understand the code.

12. In last most of the software developers face this problem if they Don’t get
required support from Project Manger/Leader and sometimes it gets difficult
to handle the relation between colleagues and managers which in terms
decrease the productivity.

An Engineering Perspective

What is Software Engineering?

Software engineering is defined as a process of analyzing user requirements and then

designing, building, and testing software application which will satisfy those
requirements.

Let’s look at the various definitions of software engineering:

 IEEE, in its standard 610.12-1990, defines software engineering as the

application of a systematic, disciplined, which is a computable approach for
the development, operation, and maintenance of software.
 Fritz Bauer defined it as ‘the establishment and used standard engineering
principles. It helps you to obtain, economically, software which is reliable and
works efficiently on the real machines’.
 Boehm defines software engineering, which involves, ‘the practical
application of scientific knowledge to the creative design and building of
computer programs. It also includes associated documentation needed for
developing, operating, and maintaining them.’

Why Software Engineering? Software Crisis & its Solution:

What was the Software Crisis?

 It was in the late 1960s when many software projects failed.

 Many software became over budget. Output was an unreliable software which
is expensive to maintain.
 Larger software was difficult and quite expensive to maintain.
 Lots of software not able to satisfy the growing requirements of the customer.
 Complexities of software projects increased whenever its hardware capability
increased.
 Demand for new software increased faster compared with the ability to
generate new software.

All the above issues lead to ‘Software Crisis.’

7
The Solution

Solution was to the problem was transforming unorganized coding effort into a
software engineering discipline. These engineering models helped companies to
streamline operations and deliver software meeting customer requirements.

 The late 1970s saw the widespread uses of software engineering principles.
 In the 1980s saw the automation of software engineering process and growth
of (CASE) Computer-Aided Software Engineering.
 The 1990s have seen an increased emphasis on the ‘management’ aspects of
projects standard of quality and processes just like ISO 9001

Why Software Engineering is Popular?

Here are important reasons behind the popularity of software engineering:

 Large software – In our real life, it is quite more comfortable to build a wall
than a house or building. In the same manner, as the size of the software
becomes large, software engineering helps you to build software.
 Scalability- If the software development process were based on scientific and
engineering concepts, it is easier to re-create new software to scale an existing
one.
 Adaptability: Whenever the software process was based on scientific and
engineering, it is easy to re-create new software with the help of software
engineering.

8
  Cost- Hardware industry has shown its skills and huge manufacturing has
lower the cost of the computer and electronic hardware.
 Dynamic Nature– Always growing and adapting nature of the software. It
depends on the environment in which the user works.
 Quality Management: Offers better method of software development to
provide quality software products.

Relationship of Software Engineering with Other Disciplines

Here, how software engineering related to other disciplines:

 Computer Science: Gives the scientific foundation for the software as

electrical engineering mainly depends on physics.
 Management Science: Software engineering is labor-intensive work which
demands both technical and managerial control. Therefore, it is widely used in
management science.
 Economics: In this sector, software engineering helps you in resource
estimation and cost control. Computing system must be developed, and data
should be maintained regularly within a given budget.
 System Engineering: Most software is a component of a much larger system.
For example, the software in an Industry monitoring system or the flight
software on an airplane. Software engineering methods should be applied to
the study of this type of systems.

Challenges of Software Engineering

Here are some critical challenges faced by software engineers:

 In safety-critical areas such as space, aviation, nuclear power plants, etc. the
cost of software failure can be massive because lives are at risk.
 Increased market demands for fast turnaround time.
 Dealing with the increased complexity of software need for new applications.
 The diversity of software systems should be communicating with each other.

Attributes for Software Products

The characteristics of any software product include features which are displayed by
the product when it is installed and put in use.

They are not the services which are provided by the product. Instead, they have
related to the products dynamic behavior and the use made of the product.

Examples of these attributes are:

Efficiency, reliability, robustness, maintainability, etc.

However, the relative importance of these characteristics varies from one software
system to another.

9
Product
Description
Characteristics
The software should evolve to meet the changing demands of the
Maintainability
clients.
Dependability includes various characteristics. Dependable
Dependability software should never cause any physical or economic damage at
the time of system failure.
The software application should overuse system resources like
Efficiency
memory and processor cycle.
The software application should have specific UI and
Usability
documentation.

Optimizing the above attribute is very challenging. For example, offering a better UI
can reduce system efficiency.

Characteristics of Good Software

Any software should be judged by what it offers and what are the methods which help
you to use it.

Every software must satisfy the following attributes:

 Operational
 Transitional
 Maintenance

Here are some important characteristics of good software developed by software

professionals

Operational

This characteristic let us know about how well software works in the operations
which can be measured on:

 Budget
 Efficiency
 Usability
 Dependability
 Correctness
 Functionality
 Safety
 Security

Transitional

This is an essential aspect when the software is moved from one platform to another:

 Interoperability
 Reusability

10
  Portability
 Adaptability

Maintenance

This aspect talks about how well software has the capabilities to adapt itself in the
quickly changing environment:

 Flexibility
 Maintainability
 Modularity
 Scalability

Object Orientation
Object-oriented refers to a programming language, system or software methodology
that is built on the concepts of logical objects.
It works through the creation, utilization and manipulation of reusable objects to
perform a specific task, process or objective.

In the past, information systems used to be defined primarily by their functions: data
and functions were kept separate and associated using input and output relations.

The object-oriented approach, however, focuses on objects that represent abstract or

concrete things in the real world. These objects are first defined by their character and
their properties, which are represented by their internal structure and their attributes
(data). The behavior of these objects is described by methods (functions).

11
Objects form a capsule, which combines the characteristics with behavior. Objects are
intended to enable programmers to map a real problem and its proposed software
solution on a one-to-one basis.
This documentation introduces a selection of terms that are used universally in object
orientation.

Objects

Objects are instances of classes. They contain data and provides services. The data
forms the attributes of the object. The services are known as methods (also known as
operations or functions). Typically, methods operate on private data (the attributes, or
state of the object), which is only visible to the methods of the object. Thus the
attributes of an object cannot be changed directly by the user, but only by the methods
of the object. This guarantees the internal consistency of the object.

Classes

Classes describe objects. From a technical point of view, objects are runtime instances
of a class. In theory, you can create any number of objects based on a single class. Each
instance (object) of a class has a unique identity and its own set of values for its
attributes.

Object References

In a program, you identify and address objects using unique object references. Object
references allow you to access the attributes and methods of an object.

In object-oriented programming, objects usually have the following properties:

Encapsulation

Objects restrict the visibility of their resources (attributes and methods) to other users.
Every object has an interface, which determines how other objects can interact with it.
The implementation of the object is encapsulated, that is, invisible outside the object
itself.

12
Inheritance

You can use an existing class to derive a new class. Derived classes inherit the data and
methods of the superclass. However, they can overwrite existing methods, and also add
new ones.

Polymorphism

Identical (identically named) methods behave differently in different classes. In ABAP

Objects, polymorphism is implemented by redefining methods during inheritance and
by using constructs called interfaces.

Uses of Object Orientation

Below are some of the advantages of object-oriented programming:

 Complex software systems become easier to understand, since object-oriented

structuring provides a closer representation of reality than other programming
techniques.
 In a well-designed object-oriented system, it should be possible to implement
changes at class level, without having to make alterations at other points in the
system. This reduces the overall amount of maintenance required.
 Using polymorphism and inheritance, object-oriented programming allows you
to reuse individual components.
 In an object-oriented system, the amount of work involved in revising and
maintaining the system is reduced, since many problems can be detected and
corrected in the design phase.

Achieving these goals requires:

 Object-oriented programming languages

Object-oriented programming techniques do not necessarily depend on

object-oriented programming languages. However, the efficiency of
object-oriented programming depends directly on how object-oriented
language techniques are implemented in the system kernel.

13
  Object-oriented tools

Object-oriented tools allow you to create object-oriented programs in

object-oriented languages. They allow you to model and store development
objects and the relationships between them.

 Object-oriented modeling

The object-orientation modeling of a software system is the most important,

most time-consuming, and most difficult requirement for attaining the above
goals. Object-oriented design involves more than just object-oriented
programming, and provides logical advantages that are independent of the
actual implementation.

Software Development Process

What is Software Development?

Software development refers to an iterative logical process that aims to create a

programmed software to meet unique business or personal objectives, goals, or
processes. The objective is achieved by a software developer writing computer code.
However, it also involves multiple steps such as research, designing a data and
process flow, writing technical documentation, comprehensively testing, debugging
and pushing it iteratively to live. This process is known as the software development
life cycle (SDLC).

Software is developed for a variety of purposes. The three most common ones are:

1. To meet the specific needs of a specific client/business (the case with custom
software)
To solve a real-world problem
2. For personal use (e.g., a pharmacy owner may require inventory managing and
billing software.)
3. The demand for better quality management of the software development
process has enforced the discipline of software engineering, which focuses on
applying the systematic approach exemplified in the engineering paradigm to
the process of software development.

There are several methodologies available for software project management like Agile,
Waterfall, Scrum, Kanban, and a few others.

Usually, any software development is categorized into two types:

1. Backend Development
2. Frontend Development

14
What is PDLC (Product Development Lifecycle)

The product development life cycle (PDLC) is the complete process of creating and
bringing a new product into the market. It includes the following 5 steps:

1. Product Conceptualization
2. Product Architecture and Design
3. Product Construction or Development
4. Product Release
5. Product Realization and Future Upgrade

1. Product Conceptualisation: Every product has to start with an idea. In some

cases, this might be reasonably simple, conceptualizing a new product on
something that already exists. In a few cases, it may be something out of the
box. Many of the leading tech companies have innovation departments that
focus solely on the task of coming up with ‘the next big thing.’ Once the idea
is selected, significant time is spent on Market research, Functional analysis,
Technical analysis, Feasibility analysis, ROI, and Prototype development.
2. Product Architecture and Design: The next phase is to design the technical
architecture of the product. In this phase, the business team provides the
business specification to technical teams who then build the architecture of the
product, create workflow diagrams, and DB design.
3. Product Development: In this phase, development teams start developing the
product. Development teams may use Waterfall or Agile methodologies to
develop a product. Most of the software companies are now moving towards
an Agile development methodology to make the product development process
faster. In this phase, teams develop, perform unit tests, integration tests,
performance tests, and any other testing types depending on the product type.
Once this phase is completed, the team creates an Alpha release which may be
mostly internal and limited to a few external users.
4. Product Release: Once the team is confident about the functionality, usability,
and stability of the product based on the Alpha release and receives feedback,
the team moves towards the Beta release phase. In the beta release, companies
may choose to open it to all the customers or choose to provide access to
limited customers who request for Beta access. In this phase, the team wants
to get feedback from external customers and make any changes accordingly.
Once the team is satisfied with the beta feedback and necessary changes are
made to the product, a public release of the product takes place. Public release
involves broad announcements, PR, and so forth to create an impact
depending on the product.
5. Product Realization and Future Upgrade: The next phase is continuous
monitoring of the product, its usage, and growth. Along with future
enhancements, teams also need to prioritize the bug fixes based on the
customer impact.

Example:
Most companies adopt these stages to bring a new product to the market. For example,
when PayPal came up with the in-context checkout product, they went through all
these stages to make sure of a successful launch of the product.

15
 1. They did a thorough market research of why In-context is essential compared
to out of context
2. Defined the primary objective of the new product, which is the reduction in
drop-off rate
3. Did a thorough analysis of tech feasibility and shoppers adoption
4. Worked with the design teams to create a seamless in-context experience
5. For a project this big they created three delivery teams each running its scrum
managed by a central program
6. They released the product MVP in a limited market and kept monitoring the
metrics
7. The product was refined based on the feedback before launching it to a
broader market

What is SDLC (Software Development Lifecycle)

Software Development Life Cycle is defined as a systematic approach used by the

software industry to design, develop, and test high-quality software. The main goal
behind SDLC is to produce high-quality software that meets or exceeds customer
expectations, reaches completion within times and cost estimates.

SDLC consists of the following activities:

 Planning: The most crucial aspect of software development, requirement

analysis is done by the most skilled and experienced software engineers in the
organization. After gathering and analyzing requirements from the client, the
scope document is generated.
 Implementation: Here, the software engineers start writing the code as per the
analyzed requirements
 Testing: It is a crucial stage which aims to discover any error, bugs, or flaws
in the software
 Documentation: Each activity performed in the project is documented for
future reference and enhancement in the development process
 Deployment and maintenance: The software is deployed once it is approved
for release.
 Maintaining: This phase occurs once the product is operational. It involves
modification of few features over some time. This phase also focuses on
monitoring the system performance, bug rectification, and implementing
requested changes

Software Development Methodologies

Usually, there are 2 types of software development methodologies –

1. Waterfall model
2. Agile model

What is the Waterfall model?

A waterfall model represents a linear and sequential approach to software

development. The following steps are carried out sequentially in a waterfall approach.

16
  Requirements: gather, analyze, document
 Design: resulting in the software architecture
 Code: the development, proving, and integration of software
 Testing: the systematic discovery and debugging of defects
 Operations: the installation, support, and maintenance of complete systems

In an actual Waterfall implementation, each of the above steps represents a different

stage of software development, and every stage generally terminates before the next
stage begins. There exists a stage-gate between each; e.g., before the designing stage
can commence, it’s necessary to have customer’s approval.

What is the Agile model?

Agile methodology evolved from different lightweight software approaches in the

1990s and is a response to some project managers’ dislike of the rigid, linear waterfall
methodology. It focuses on flexibility, continuous improvement, and speed. The Agile
methodology follows an incremental approach.

Developers start with simplistic project design and then begin to work on small
modules. The work on these modules is carried out in weekly or monthly sprints, and
at the end of each sprint, project priorities are evaluated, and tests are executed. Thus,
the equivalent stages of the waterfall model are completed at every single sprint.
These sprints allow for exploring bugs, and customer feedback to be incorporated into
the design before the next sprint begins.

That said, the process must be well-managed and documentation enforced, as the
rapid pace of development can lend itself towards dis-organization. However, if done
correctly, it results in a fast, low-risk, and efficient workflow.

Most of the matured companies now use Agile methodology. Most of the customers
you speak with talk in terms of Agile processes unless they specifically mention that
they are not agile. Though no companies truly follow complete agile methods, they
might be using some hybrid model.

Iterative Development Process

In this Model, you can start with some of the software specifications and develop the
first version of the software. After the first version if there is a need to change the
software, then a new version of the software is created with a new iteration. Every
release of the Iterative Model finishes in an exact and fixed period that is called
iteration.

The Iterative Model allows the accessing earlier phases, in which the variations made
respectively. The final output of the project renewed at the end of the Software
Development Life Cycle (SDLC) process.

17
The various phases of Iterative model are as follows:

1. Requirement gathering & analysis: In this phase, requirements are gathered from
customers and check by an analyst whether requirements will fulfil or not. Analyst
checks that need will achieve within budget or not. After all of this, the software team
skips to the next phase.

2. Design: In the design phase, team design the software by the different diagrams
like Data Flow diagram, activity diagram, class diagram, state transition diagram, etc.

3. Implementation: In the implementation, requirements are written in the coding

language and transformed into computer programmes which are called Software.

4. Testing: After completing the coding phase, software testing starts using different
test methods. There are many test methods, but the most common are white box,
black box, and grey box test methods.

5. Deployment: After completing all the phases, software is deployed to its work
environment.

6. Review: In this phase, after the product deployment, review phase is performed to
check the behaviour and validity of the developed product. And if there are any error
found then the process starts again from the requirement gathering.

7. Maintenance: In the maintenance phase, after deployment of the software in the

working environment there may be some bugs, some errors or new updates are
required. Maintenance involves debugging and new addition options.

18
When to use the Iterative Model?

1. When requirements are defined clearly and easy to understand.

2. When the software application is large.
3. When there is a requirement of changes in future.

Advantage(Pros) of Iterative Model:

1. Testing and debugging during smaller iteration is easy.

2. A Parallel development can plan.
3. It is easily acceptable to ever-changing needs of the project.
4. Risks are identified and resolved during iteration.
5. Limited time spent on documentation and extra time on designing.

Disadvantage(Cons) of Iterative Model:

1. It is not suitable for smaller projects.

2. More Resources may be required.
3. Design can be changed again and again because of imperfect requirements.
4. Requirement changes can cause over budget.
5. Project completion date not confirmed because of changing requirements.

Process Models

Software Processes

The term software specifies to the set of computer programs, procedures and
associated documents (Flowcharts, manuals, etc.) that describe the program and how
they are to be used.

A software process is the set of activities and associated outcome that produce a
software product. Software engineers mostly carry out these activities. These are four
key process activities, which are common to all software processes. These activities
are:

1. Software specifications: The functionality of the software and constraints on

its operation must be defined.
2. Software development: The software to meet the requirement 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 client needs.

The Software Process Model

A software process model is a specified definition of a software process, which is

presented from a particular perspective. Models, by their nature, are a simplification,
so a software process model is an abstraction of the actual process, which is being
described. Process models may contain activities, which are part of the software

19
process, software product, and the roles of people involved in software engineering.
Some examples of the types of software process models that may be produced are:

1. A workflow model: This shows the series of activities in the process along
with their inputs, outputs and dependencies. The activities in this model
perform human actions.
2. 2. A dataflow or activity model: This represents the process as a set of
activities, each of which carries out some data transformations. It shows how
the input to the process, such as a specification is converted to an output such
as a design. The activities here may be at a lower level than activities in a
workflow model. They may perform transformations carried out by people or
by computers.
3. 3. A role/action model: This means the roles of the people involved in the
software process and the activities for which they are responsible.

There are several various general models or paradigms of software development:

1. The waterfall approach: This takes the above activities and produces them as
separate process phases such as requirements specification, software design,
implementation, testing, and so on. After each stage is defined, it is "signed
off" and development goes onto the following stage.
2. Evolutionary development: This method interleaves the activities of
specification, development, and validation. An initial system is rapidly
developed from a very abstract specification.
3. Formal transformation: This method is based on producing a formal
mathematical system specification and transforming this specification, using
mathematical methods to a program. These transformations are 'correctness
preserving.' This means that you can be sure that the developed programs meet
its specification.
4. System assembly from reusable components: This method assumes the
parts of the system already exist. The system development process target on
integrating these parts rather than developing them from scratch.

Software Crisis

1. Size: Software is becoming more expensive and more complex with the
growing complexity and expectation out of software. For example, the code in
the consumer product is doubling every couple of years.
2. Quality: Many software products have poor quality, i.e., the software products
defects after putting into use due to ineffective testing technique. For example,
Software testing typically finds 25 errors per 1000 lines of code.
3. Cost: Software development is costly i.e. in terms of time taken to develop
and the money involved. For example, Development of the FAA's Advanced
Automation System cost over $700 per lines of code.
4. Delayed Delivery: Serious schedule overruns are common. Very often the
software takes longer than the estimated time to develop, which in turn leads
to cost shooting up. For example, one in four large-scale development projects
is never completed.

20
Program vs. Software

Software is more than programs. Any program is a subset of software, and it becomes
software only if documentation & operating procedures manuals are prepared.

There are three components of the software as shown in fig:

1. Program: Program is a combination of source code & object code.

2. Documentation: Documentation consists of different types of manuals. Examples

of documentation manuals are: Data Flow Diagram, Flow Charts, ER diagrams, etc.

21
3. Operating Procedures: Operating Procedures consist of instructions to set up and
use the software system and instructions on how react to the system failure. Example
of operating system procedures manuals is: installation guide, Beginner's guide,
reference guide, system administration guide, etc.

Life Cycle Models

Software Development life cycle (SDLC) is a spiritual model used in project

management that defines the stages include in an information system development
project, from an initial feasibility study to the maintenance of the completed
application.

There are different software development life cycle models specify and design, which
are followed during the software development phase. These models are also called
"Software Development Process Models." Each process model follows a series of
phase unique to its type to ensure success in the step of software development.

Here, are some important phases of SDLC life cycle:

22
Waterfall Model

The waterfall is a universally accepted SDLC model. In this method, the whole
process of software development is divided into various phases.

The waterfall model is a continuous software development model in which

development is seen as flowing steadily downwards (like a waterfall) through the
steps of requirements analysis, design, implementation, testing (validation),
integration, and maintenance.

Linear ordering of activities has some significant consequences. First, to identify the
end of a phase and the beginning of the next, some certification techniques have to be
employed at the end of each step. Some verification and validation usually do this
mean that will ensure that the output of the stage is consistent with its input (which is
the output of the previous step), and that the output of the stage is consistent with the
overall requirements of the system.

RAD Model

RAD or Rapid Application Development process is an adoption of the waterfall

model; it targets developing software in a short period. The RAD model is based on
the concept that a better system can be developed in lesser time by using focus groups
to gather system requirements.

 Business Modeling
 Data Modeling
 Process Modeling
 Application Generation
 Testing and Turnover

Spiral Model

The spiral model is a risk-driven process model. This SDLC model helps the group
to adopt elements of one or more process models like a waterfall, incremental,
waterfall, etc. The spiral technique is a combination of rapid prototyping and
concurrency in design and development activities.

Each cycle in the spiral begins with the identification of objectives for that cycle, the
different alternatives that are possible for achieving the goals, and the constraints that
exist. This is the first quadrant of the cycle (upper-left quadrant).

The next step in the cycle is to evaluate these different alternatives based on the
objectives and constraints. The focus of evaluation in this step is based on the risk
perception for the project.

The next step is to develop strategies that solve uncertainties and risks. This step may
involve activities such as benchmarking, simulation, and prototyping.

23
V-Model

In this type of SDLC model testing and the development, the step is planned in
parallel. So, there are verification phases on the side and the validation phase on the
other side. V-Model joins by Coding phase.

Incremental Model

The incremental model is not a separate model. It is necessarily a series of waterfall

cycles. The requirements are divided into groups at the start of the project. For each
group, the SDLC model is followed to develop software. The SDLC process is
repeated, with each release adding more functionality until all requirements are met.
In this method, each cycle act as the maintenance phase for the previous software
release. Modification to the incremental model allows development cycles to overlap.
After that subsequent cycle may begin before the previous cycle is complete.

Agile Model

Agile methodology is a practice which promotes continues interaction of development

and testing during the SDLC process of any project. In the Agile method, the entire
project is divided into small incremental builds. All of these builds are provided in
iterations, and each iteration lasts from one to three weeks.

Any agile software phase is characterized in a manner that addresses several key
assumptions about the bulk of software projects:

1. It is difficult to think in advance which software requirements will persist and

which will change. It is equally difficult to predict how user priorities will
change as the project proceeds.
2. For many types of software, design and development are interleaved. That is,
both activities should be performed in tandem so that design models are
proven as they are created. It is difficult to think about how much design is
necessary before construction is used to test the configuration.
3. Analysis, design, development, and testing are not as predictable (from a
planning point of view) as we might like.

Iterative Model

It is a particular implementation of a software development life cycle that focuses on

an initial, simplified implementation, which then progressively gains more complexity
and a broader feature set until the final system is complete. In short, iterative
development is a way of breaking down the software development of a large
application into smaller pieces.

Big bang model

Big bang model is focusing on all types of resources in software development and
coding, with no or very little planning. The requirements are understood and
implemented when they come.

24
This model works best for small projects with smaller size development team which
are working together. It is also useful for academic software development projects. It
is an ideal model where requirements are either unknown or final release date is not
given.

Prototype Model

The prototyping model starts with the requirements gathering. The developer and the
user meet and define the purpose of the software, identify the needs, etc.

A 'quick design' is then created. This design focuses on those aspects of the software
that will be visible to the user. It then leads to the development of a prototype. The
customer then checks the prototype, and any modifications or changes that are needed
are made to the prototype.

Looping takes place in this step, and better versions of the prototype are created.
These are continuously shown to the user so that any new changes can be updated in
the prototype. This process continue until the customer is satisfied with the system.
Once a user is satisfied, the prototype is converted to the actual system with all
considerations for quality and security.

Unified Process

Unified process (UP) is an architecture centric, use case driven, iterative and
incremental development process. UP is also referred to as the unified software
development process.

25
The Unified Process is an attempt to draw on the best features and characteristics of
traditional software process models, but characterize them in a way that implements
many of the best principles of agile software development. The Unified Process
recognizes the importance of customer communication and streamlined methods for
describing the customer’s view of a system. It emphasizes the important role of
software architecture and “helps the architect focus on the right goals, such as
understandability, reliance to future changes, and reuse” . It suggests a process flow
that is iterative and incremental, providing the evolutionary feel that is essential in
modern software development.

Phases of the Unified Process

This process divides the development process into five phases:

 Inception
 Elaboration
 Conception
 Transition
 Production

The inception phase of the UP encompasses both customer communication and

planning activities. By collaborating with stakeholders, business requirements for the
software are identified; a rough architecture for the system is proposed; and a plan for
the iterative, incremental nature of the ensuing project is developed.

The elaboration phase encompasses the communication and modeling activities of the
generic process model. Elaboration refines and expands the preliminary use cases that
were developed as part of the inception phase and expands the architectural
representation to include five different views of the software the use case model, the
requirements model, the design model, the implementation model, and the
deployment model. Elaboration creates an “executable architectural baseline” that
represents a “first cut” executable system.

The construction phase of the UP is identical to the construction activity defined for
the generic software process. Using the architectural model as input, the construction
phase develops or acquires the software components that will make each use case
operational for end users. To accomplish this, requirements and design models that
were started during the elaboration phase are completed to reflect the final version of
the software increment. All necessary and required features and functions for the
software increment (the release) are then implemented in source code.

The transition phase of the UP encompasses the latter stages of the generic
construction activity and the first part of the generic deployment (delivery and
feedback) activity. Software is given to end users for beta testing and user feedback
reports both defects and necessary changes. At the conclusion of the transition phase,
the software increment becomes a usable software release.

The production phase of the UP coincides with the deployment activity of the generic
process. During this phase, the ongoing use of the software is monitored, support for
the operating environment (infrastructure) is provided, and defect reports and requests

26
for changes are submitted and evaluated. It is likely that at the same time the
construction, transition, and production phases are being conducted, work may have
already begun on the next software increment. This means that the five UP phases do
not occur in a sequence, but rather with staggered concurrency.

Iterative and Incremental

As the name indicates, Iterative and incremental development (IID) is a model that
is an incremental model that is developed in multiple cycles of iterations. Project is
started with a comparatively small task or component and increments are made in
each cycle of the iterations until desired product is reached. During this process,
developers have advantage of evaluating and testing components at each stage and
gaining information that would be useful at end stages as well. This knowledge is
used to also improve design of final product.

Iteration includes update and execution of cycles are to be basic, direct, and particular,
supporting overhaul at that stage or as an errand added to task control list. Degree of
configuration detail isn’t directed by iterative methodology.

In a low processing iterative project, code may speak to significant source of

documentation of framework; nonetheless, in a basic iterative task, a conventional
software design document might be utilized. Examination of a cycle depends on client
input, and program investigation offices accessible. It includes investigation of
structure, seclusion, convenience, unwavering quality, effectiveness, and
accomplishment of objectives. Undertaking control list is changed considering
investigation results.

Phases in IID :
As development is incremental and iterative, different functions are applied in
different phases. According to prerequisites of organization, at each phase,
functionalities are implemented. There are four phases in IID :

 Inception –
In this phase reorganization of project scope, prerequisites, and risks at an
elevated level yet in enough detail that work can be assessed are done.
 Elaboration –
In this phase, conveying a working structure that mitigates top dangers and
satisfies non-functional necessities is done.
 Construction –
In this phase, functionalities are incremented gradually with codes for
functional requirements. Whole architecture is built in this phase.
 Transition –
In this phase, project is transitioned into production and then deployment.

In this cyclic process, architects work one iteration early than testers, which creates a
flow in workspace. Each phase is one or more iterations long.

27
Advantages of IID :

 Each delivery is an item increment, with goal that client will have a working
item within reach constantly.
 You can create organized prerequisites first.
 If the requirements are changed midway, new requirements can be augmented
without any issue.
 Clients get significant functionality faster.
 Client can give input to every item increment, accordingly maintaining a
strategic distance from differences toward finish of improvement.
 Brings down introductory delivery cost.
 Initial item delivery is quicker.

Disadvantages of IID :

 Requires the early meaning of a total and completely functional framework to

permit the meaning of additions.
 Absolute expense of the total framework isn’t lower.
 Requires an effective plan to guarantee incorporation of the necessary
functionalities and arrangement for changes later.
 Requires successful arranging of cycles.
 Very characterized module interfaces are needed, as some are made some time
before others are created.

Where and when to use IID model ?

IID can be used when :

 There is a requirement to get fundamental functionality conveyed quick.

 There is new advancement in technology to implement a project.
 Prerequisites are organized.
 Vast majority of requirements are known in advance however are required to
advance after some time.
 Domain is new to working group.
 There is a venture with extensive improvement plans.

Agile Processes

The meaning of Agile is swift or versatile."Agile process model" refers to a software

development approach based on iterative development. Agile methods break tasks
into smaller iterations, or parts do not directly involve long term planning. The project
scope and requirements are laid down at the beginning of the development process.
Plans regarding the number of iterations, the duration and the scope of each iteration
are clearly defined in advance.

Each iteration is considered as a short time "frame" in the Agile process model, which
typically lasts from one to four weeks. The division of the entire project into smaller
parts helps to minimize the project risk and to reduce the overall project delivery time
requirements. Each iteration involves a team working through a full software

28
development life cycle including planning, requirements analysis, design, coding, and
testing before a working product is demonstrated to the client.

Phases of Agile Model:

Following are the phases in the Agile model are as follows:

1. Requirements gathering
2. Design the requirements
3. Construction/ iteration
4. Testing/ Quality assurance
5. Deployment
6. Feedback

1. Requirements gathering: In this phase, you must define the requirements. You
should explain business opportunities and plan the time and effort needed to build the
project. Based on this information, you can evaluate technical and economic
feasibility.

2. Design the requirements: When you have identified the project, work with
stakeholders to define requirements. You can use the user flow diagram or the
high-level UML diagram to show the work of new features and show how it will
apply to your existing system.

3. Construction/ iteration: When the team defines the requirements, the work begins.
Designers and developers start working on their project, which aims to deploy a

29
working product. The product will undergo various stages of improvement, so it
includes simple, minimal functionality.

4. Testing: In this phase, the Quality Assurance team examines the product's
performance and looks for the bug.

5. Deployment: In this phase, the team issues a product for the user's work
environment.

6. Feedback: After releasing the product, the last step is feedback. In this, the team
receives feedback about the product and works through the feedback.

Agile Testing Methods:

 Scrum
 Crystal
 Dynamic Software Development Method(DSDM)
 Feature Driven Development(FDD)
 Lean Software Development
 eXtreme Programming(XP)

Scrum

SCRUM is an agile development process focused primarily on ways to manage tasks

in team-based development conditions.

There are three roles in it, and their responsibilities are:

 Scrum Master: The scrum can set up the master team, arrange the meeting
and remove obstacles for the process
 Product owner: The product owner makes the product backlog, prioritizes the
delay and is responsible for the distribution of functionality on each repetition.
 Scrum Team: The team manages its work and organizes the work to complete
the sprint or cycle.

eXtreme Programming(XP)

This type of methodology is used when customers are constantly changing demands
or requirements, or when they are not sure about the system's performance.

Crystal:

There are three concepts of this method-

1. Chartering: Multi activities are involved in this phase such as making a

development team, performing feasibility analysis, developing plans, etc.
2. Cyclic delivery: under this, two more cycles consist, these are:

o Team updates the release plan.

o Integrated product delivers to the users.

30
 3. Wrap up: According to the user environment, this phase performs deployment,
post-deployment.

Dynamic Software Development Method(DSDM):

DSDM is a rapid application development strategy for software development and

gives an agile project distribution structure. The essential features of DSDM are that
users must be actively connected, and teams have been given the right to make
decisions. The techniques used in DSDM are:

1. Time Boxing
2. MoSCoW Rules
3. Prototyping

The DSDM project contains seven stages:

1. Pre-project
2. Feasibility Study
3. Business Study
4. Functional Model Iteration
5. Design and build Iteration
6. Implementation
7. Post-project

Feature Driven Development(FDD):

This method focuses on "Designing and Building" features. In contrast to other smart
methods, FDD describes the small steps of the work that should be obtained
separately per function.

Lean Software Development:

Lean software development methodology follows the principle "just in time

production." The lean method indicates the increasing speed of software development
and reducing costs. Lean development can be summarized in seven phases.

1. Eliminating Waste
2. Amplifying learning
3. Defer commitment (deciding as late as possible)
4. Early delivery
5. Empowering the team
6. Building Integrity
7. Optimize the whole

When to use the Agile Model?

 When frequent changes are required.

 When a highly qualified and experienced team is available.
 When a customer is ready to have a meeting with a software team all the time.
 When project size is small.

31
Advantage(Pros) of Agile Method:

1. Frequent Delivery
2. Face-to-Face Communication with clients.
3. Efficient design and fulfils the business requirement.
4. Anytime changes are acceptable.
5. It reduces total development time.

Disadvantages(Cons) of Agile Model:

1. Due to the shortage of formal documents, it creates confusion and crucial

decisions taken throughout various phases can be misinterpreted at any time
by different team members.
2. Due to the lack of proper documentation, once the project completes and the
developers allotted to another project, maintenance of the finished project can
become a difficulty.

Example: Let’s go through an example to understand clearly how agile actually

works.
A Software company named ABC wants to make a new web browser for the latest
release of its operating system. The deadline for the task is 10 months. The company’s
head assigned two teams named Team A and Team B for this task. In order to
motivate the teams, the company head says that the first team to develop the browser
would be given a salary hike and a one-week full-sponsored travel plan. With the
dreams of their wild travel fantasies, the two teams set out on the journey of the web
browser. Team A decided to play by the book and decided to choose the Waterfall
model for the development. Team B after a heavy discussion decided to take a leap of
faith and choose Agile as their development model.

The Development plan of the Team A is as follows:

 Requirement analysis and Gathering – 1.5 Months

 Design of System – 2 Months
 Coding phase – 4 Months
 System Integration and Testing – 2 Months
 User Acceptance Testing – 5 Weeks

The Development plan for the Team B is as follows:

 Since this was an Agile, the project was broken up into several iterations.
 The iterations are all of the same time duration.
 At the end of each iteration, a working product with a new feature has to be
delivered.
 Instead of Spending 1.5 months on requirements gathering, They will decide
the core features that are required in the product and decide which of these
features can be developed in the first iteration.
 Any remaining features that cannot be delivered in the first iteration will be
delivered in the next subsequent iteration, based on the priority
 At the end of the first iterations, the team will deliver working software with
the core basic features.

32
Both the team have put their best efforts to get the product to a complete stage. But
then out of blue due to the rapidly changing environment, the company’s head come
up with an entirely new set of features and want to be implemented as quickly as
possible and wanted to push out a working model in 2 days. Team A was now in a fix,
they were still in their design phase and did not yet start coding and they had no
working model to display. And moreover, it was practically impossible for them to
implement new features since waterfall model there is not reverting back to the old
phase once you proceed to the next stage, which means they would have to start from
the square one again. That would incur their heavy cost and a lot of overtime. Team B
was ahead of Team A in a lot of aspects, all thanks to Agile Development. They also
had the working product with most of the core requirements since the first increment.
And it was a piece of cake for them to add the new requirements. All they had to do is
schedule these requirements for the next increment and then implement them.

33