UNIT I SOFTWARE PROCESS AND AGILE DEVELOPMENT

Introduction to Software Engineering - Software Process - Perspective and Specialized Process Models-
Introduction to Agility-Agile process-Extreme Programming-XP Process.

INTRODUCTION TO SOFTWARE ENGINEERING

Software is a program or set of programs containing instructions that provide desired functionality.
Engineering is the process of designing and building something that serves a particular purpose and finds
a cost-effective solution to problems.

What is Software Engineering?

Software Engineering is the process of designing, developing, testing, and maintaining software. It is a
systematic and disciplined approach to software development that aims to create high-quality, reliable,
and maintainable software.

Software engineering includes a variety of techniques, tools, and methodologies, including requirements
analysis, design, testing, and maintenance.

The main goal of Software Engineering is to develop software applications for improving quality,
budget, and time efficiency.

Key Principles of Software Engineering

Modularity: Breaking the software into smaller, reusable components that can be developed and tested
independently.

Abstraction: Hiding the implementation details of a component and exposing only the necessary
functionality to other parts of the software.

Encapsulation: Wrapping up the data and functions of an object into a single unit, and protecting the
internal state of an object from external modifications.

Reusability: Creating components that can be used in multiple projects, which can save time and
resources.

Maintenance: Regularly updating and improving the software to fix bugs, add new features, and address
security vulnerabilities.

Testing: Verifying that the software meets its requirements and is free of bugs.

Design Patterns: Solving recurring problems in software design by providing templates for solving them.
Agile methodologies: Using iterative and incremental development processes that focus on customer
satisfaction, rapid delivery, and flexibility.

Continuous Integration & Deployment: Continuously integrating the code changes and deploying them
into the production environment.

Main Attributes of Software Engineering

Software Engineering is a systematic, disciplined, quantifiable study and approach to the design,
development, operation, and maintenance of a software system. There are four main Attributes of
Software Engineering.

Efficiency: It provides a measure of the resource requirement of a software product in an efficient way.

Reliability: It provides the assurance that the product will deliver the same results when used in similar
working environment.

Reusability: This attribute makes sure that the module can be used in multiple applications.

Maintainability: It is the ability of the software to be modified, repaired, or enhanced easily with changing
requirements.

Objectives of Software Engineering

Maintainability: It should be feasible for the software to evolve to meet changing requirements.

Efficiency: The software should not make wasteful use of computing devices such as memory, processor
cycles, etc.

Correctness: A software product is correct if the different requirements specified in the SRS Document
have been correctly implemented.

Reusability: A software product has good reusability if the different modules of the product can easily be
reused to develop new products.

Testability: Here software facilitates both the establishment of test criteria and the evaluation of the
software with respect to those criteria.

Reliability: It is an attribute of software quality. The extent to which a program can be expected to
perform its desired function, over an arbitrary time period.

Portability: In this case, the software can be transferred from one computer system or environment to
another.

Adaptability: In this case, the software allows differing system constraints and the user needs to be
satisfied by making changes to the software.

Interoperability: Capability of 2 or more functional units to process data cooperatively.

Advantages of Software Engineering

There are several advantages to using a systematic and disciplined approach to software development,
such as:

Improved Quality: By following established software engineering principles and techniques, the software
can be developed with fewer bugs and higher reliability.

Increased Productivity: Using modern tools and methodologies can streamline the development process,
allowing developers to be more productive and complete projects faster.

Better Maintainability: Software that is designed and developed using sound software engineering
practices is easier to maintain and update over time.

Reduced Costs: By identifying and addressing potential problems early in the development process,
software engineering can help to reduce the cost of fixing bugs and adding new features later on.

Increased Customer Satisfaction: By involving customers in the development process and developing
software that meets their needs, software engineering can help to increase customer satisfaction.

Better Team Collaboration: By using Agile methodologies and continuous integration, software
engineering allows for better collaboration among development teams.

Better Scalability: By designing software with scalability in mind, software engineering can help to
ensure that software can handle an increasing number of users and transactions.

Better Security: By following the Software Development Life Cycle (SDLC) and performing security
testing, software engineering can help to prevent security breaches and protect sensitive data.

Disadvantages of Software Engineering

While Software Engineering offers many advantages, there are also some potential disadvantages to
consider:

High upfront costs: Implementing a systematic and disciplined approach to software development can be
resource-intensive and require a significant investment in tools and training.

Limited flexibility: Following established software engineering principles and methodologies can be rigid
and may limit the ability to quickly adapt to changing requirements.

Bureaucratic: Software Engineering can create an environment that is bureaucratic, with a lot of processes
and paperwork, which may slow down the development process.

Complexity: With the increase in the number of tools and methodologies, software engineering can be
complex and difficult to navigate.

Limited creativity: The focus on structure and process can stifle creativity and innovation among
developers.
High learning curve: The development process can be complex, and it requires a lot of learning and
training, which can be challenging for new developers.

High dependence on tools: Software engineering heavily depends on the tools, and if the tools are not
properly configured or are not compatible with the software, it can cause issues.

High maintenance: The software engineering process requires regular maintenance to ensure that the
software is running efficiently, which can be costly and time-consuming.

SOFTWARE PROCESS

A process is a collection of activities, actions and tasks that are performed when some product is to
created.

Software process is a structural(well defined) set of activities required to develop a software design.

❖ Activity – used to achieve broad objective [eg. Communication with stakeholders], applied for all
domains of project

❖ Action – set of tasks that produce a major work product [eg. Architectural design]

❖ Tasks – focuses on small, but well defined objective that produces tangible outcome
[eg.Conducting a unit testing]

Many different software process activities but all involve

Specification: define what the system should do.

Design & Implementation: defining the organization requirement of the system and implementing the
system.

Validation: checks software that its what customer wants

Evaluation: changing the software in response to changing customers demand.

Five Generic Process Framework activities

Communication, planning, modeling or design, construction, deployment.

Communication : Communicate and collaborate with customer before commencement of project. To

understand the objectives of the project and to gather requirements which helps to define software
features and functions

Planning : Planning for software, gathering Risk information , work product.

Modeling or design: Create modules to better understand s/w requirements and the design that will
achieve those requirements – E.g - Carpenter, Civil Engineer works with models everyday. Create a
Sketch

Construction or implementation or coding: Actual code perform/ code testing

Deployment or delivery :Work product is delivered to customer provides feedback based their
evaluation Framework activities are applied iteratively to all projects, regardless of their size, complexity.
These s/w process framework activities are complemented by number of umbrella activities

PERSPECTIVE AND SPECIALIZED PROCESS MODELS

Prescriptive process models are sometimes referred to as “traditional” process models. A prescriptive
process model strives for structure and order in software development. Activities and tasks occur
sequentially with defined guidelines for progress. The prescriptive process approach in which order and
project consistency are dominant issues.

Waterfall model

 Waterfall model is the basic software development life cycle model. It is very simple but
idealistic.
 It is oldest model in software engineering.
 No overlapping in phase
 Each of process is executed in sequence.
 It is a linear sequential model.
 All activities are well planned.
 Output of one phase serves as the input of other phase.

1. Requirements analysis : 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. Development/ Implementation : 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. Deployment 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

 It is simple and easy

 It can be used for small scale of the project. Not applicable for large project.
 Rich in terms of documentation.
 Control over cost and schedule

Disadvantages

 Not good for big and complex projects and also where the requirements are change.
 The amount of risk is high.
 Risk and uncertainly, bug fixes and corrections are performed only at maintenance phase.
Incremental process model

The whole requirements is divided into various builds. It also called multi water fall model/ multi
development cycle that take place here.

It is used when requirements are well understand.

Multi independent delivers are identified. Workflow in a linear fashion. Iterative in nature.

When to use : when the customer demand a quick response of the project.

Advantages

 Prepares the software fast.

 Clients have clear idea of the project.
 Changes are easy to implement.
  Provides risk handling support, because of its iterations.
 It is less expensive. Identification of error is simple.
 In this model customer can be respond to each built.

Disadvantages

 Needs good planning and design.

 Needs a clear and complete definition of the whole system before it can be broken down and built
incrementally.

Rapid application development model

RAD is an incremental software development process model.

• It emphasizes short development cycle

• “high speed” adaptation of linear sequential model in which rapid application is achieved by
using component-based construction.
• If requirements are well understood and project scope is constrained, the RAD process enables a
development team to create a “fully functional system” within very short time periods (e.g., 60 to
90 days)
• It uses multiple teams on scalable project. Man power important. It requires heavy resources.

The phases are

❖ Business modeling

❖ Data modeling

❖ Process modeling

❖ Application generation

❖ Testing & turnover

1. Business modeling: The information flow among business functions is modeled in a way that answers
the following questions:

What information drives the business process?

What information is generated?

Who generates it?

Where does the information go?

Who processes it?

2. Data modeling: The information flow defined as part of the business modeling phase is refined into a
set of data objects that are needed to support the business. The characteristics (called attributes) of each
object are identified and the relationships between these objects defined.

3. Process modeling: The data objects defined in the data modeling phase are transformed to achieve the
information flow necessary to implement a business function. Processing descriptions are created for
adding, modifying, deleting, or retrieving a data object.
4. Application generation: RAD assumes the use of fourth generation techniques. Rather than creating
software using conventional third generation programming languages the RAD process works to reuse
existing program components (when possible) or create reusable components (when necessary). In all
cases, automated tools are used to facilitate construction of the software.

5. Testing and turnover: Since the RAD process emphasizes reuse, many of the program components
have already been tested. This reduces overall testing time. However, new components must be tested and
all interfaces must be fully exercised.

Advantages

• Use of reusable components helps to reduce the cycle time of the project.
• Encourages user involvement
• Reduced cost.
• Flexible and adaptable to changes

Disadvantages

• For large scalable projects, RAD requires sufficient human resources to create the right number
of RAD teams.
• If developers and customers are not committed to the rapid-fire activities, then project will fail. If
a system cannot properly be modularized, building the components necessary for RAD will be
problematic.
• The use of powerful and efficient tools requires highly skilled professionals.
• Customer involvement is required throughout the life cycle.

Evolutionary process model

Evolutionary process models produce an increasingly more complete version of the software with each
iteration. It is based on the idea of developing an initial implementation.
The objective of the process is to work with the customer in order to explore their requirements and
deliver a final system. The developer start with the part of the system that are well understand. The
system evolves by adding new features proposed by the customer.

Types of evolutionary approaches are

 Prototyping
 Spiral models
• concurrent model

Prototyping

Prototyping is an initial version of software system that is used to demonstrate concepts, try out design
options, and find out more about the problems and its possible solution.

A software prototype can be used in a software development process to help anticipate changes that may
be required:
1. In the requirements engineering process, a prototype can help with the elicitation and validation of
system requirements.

2. In the system design process, a prototype can be used to explore particular software solutions and to
support user interface design.