UNIT-1

Software is more than just a program code. A program is an executable code, which serves
some computational purpose. Software is considered to be a collection of executable
programming code, associated libraries and documentations. Software, when made for a
specific requirement is called software product.
A program, also called an application or software, is a set of instructions that process input,
manipulate data, and output a result.
Engineering on the other hand, is all about developing products, using well-defined,
scientific principles and methods.
So, we can define software engineering as an engineering branch associated with the
development of software product using well-defined scientific principles, methods and
procedures. The outcome of software engineering is an efficient and reliable software
product.
1.3: Types of Software
Software is used to control a computer. There are different types of software that can
run on a computer: system software, utility software, and application software.
1. System software: It aids a user and the hardware to function and interact with
each other. Basically, it is software to manage computer hardware behavior to provide
basic functionalities to users. Examples: windows, IOS, Linux.
2. Utility software: Utility software is part of the system software and performs
specific tasks to keep the computer running. Utility software is always running in the
background. Examples of utility software are security and optimization programs.
3. Application Software: also known as end-user programs or productivity
programs, help the user in completing tasks such as doing online research, jotting down
notes, setting the alarm, designing graphics, keeping an account log, doing calculations,
or even playing games. They lie above the system software.
1.4: History of Software:
Computer scientist Tom Kilburn is responsible for writing the world’s very first piece of software,
which was run at 11 a.m. on June 21, 1948, at the University of Manchester in England.
The SSEM was programmed to perform mathematical calculations using machine code
instructions. This first piece of software took “only” 52 minutes to correctly compute the
greatest divisor of 2 to the power of 18 (262,144).
In the 1970s and 1980s, software hit the big time with the arrival of personal computers. Apple
released the Apple II, its revolutionary product, to the public in April 1977. VisiCalc, the first
spreadsheet software for personal computing, was wildly popular and known as the Apple II’s
killer app. The software was written in specialized assembly language and appeared in 1979.
Other companies like IBM soon entered the market with computers such as the IBM PC, which
first launched in 1981.
SDLC: Software Development Lifecycle
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

Requirements Analysis:
“What are the current problems?” This stage of the SDLC means getting input from all
stakeholders, including customers, salespeople, industry experts, and programmers. Learn the
strengths and weaknesses of the current system with improvement as the goal.
Planning phase
The planning phase encompasses all aspects of project and product management. This typically
includes resource allocation, capacity planning, project scheduling, cost estimation, and
provisioning.
Design
In this phase, the requirement gathered in the software requirements specification (SRS)
document is used as an input and software architecture that is used for implementing system
development is derived.
Implementation or Coding (software development)
Implementation/Coding starts once the developer gets the Design document. The Software
design is translated into source code. All the components of the software are implemented in
this phase.
Testing
Testing starts once the coding is complete and the modules are released for testing. In this
phase, the developed software is tested thoroughly and any defects found are assigned to
developers to get them fixed.
Deployment
Once the product is tested, it is deployed in the production environment or first UAT (User
Acceptance testing) is done depending on the customer expectation.
1.5: Software Process and Framework:
Framework is a Standard way to build and deploy applications. Software Process Framework is a
foundation of complete software engineering process. Software process framework includes all
set of umbrella activities. It also includes number of framework activities that are applicable to
all software projects.
Software processes in software engineering refer to the methods and techniques used to
develop and maintain software. A software process (also known as software methodology) is a
set of related activities that leads to the production of the software. These activities may
involve the development of the software from the scratch, or, modifying an existing system.
Any software process must include the following four activities:
• Software specification (or requirements engineering): Define the main functionalities of the
software and the constraints around them.
• Software design and implementation: The software is to be designed and programmed.
• Software verification and validation: The software must conform to its specification and meet
the customer's needs.
• Software evolution (software maintenance): The software is being modified to meet customer
and market requirements changes.

Umbrella activities include:

• Risk management
• Software quality
assurance(SQA)
• Software configuration
management(SCM)
• Measurement
• Formal technical
reviews(FTR)
1.6 Perspective Process Models:
Perspective process model were originally proposed to bring order to the chaos of software
development. Perspective process model define a prescribed set of process elements and a
predictable process work flow.
The Waterfall Model:
The waterfall model, sometimes called the classic life cycle, suggests a systematic, sequential
approach to software development that begins with customer specification of requirements
and progresses through planning, modeling, construction, and deployment. In the waterfall
model, you must plan and schedule all of the activities before starting working on them (plan-
driven process).

The phases of the waterfall model are: Requirements, Design, Implementation, Testing, and
Maintenance.

Advantages of the Waterfall Model:

• Waterfall model is the simple model which can be easily understood and is the
one in which all the phases are done step by step.
• Deliverables of each phase are well defined, and this leads to no complexity and
makes the project easily manageable.
Disadvantages of Waterfall model:
• Waterfall model is time-consuming & cannot be used in the short duration
projects as in this model a new phase cannot be started until the ongoing phase is
completed.
• Waterfall model cannot be used for the projects which have uncertain
requirement or wherein the requirement keeps on changing as this model
expects the requirement to be clear in the requirement gathering and analysis
phase itself and any change in the later stages would lead to cost higher as the
changes would be required in all the phases.
The V-Model:

A variation in the representation of the waterfall model is called the V-model. V- Model is also
known as Verification and Validation Model. In this model Verification & Validation goes hand in
hand i.e. development and testing goes parallel. V model and waterfall model are the same
except that the test planning and testing start at an early stage in V-Model.
Advantages of V – Model:

• It is a simple and easily understandable model.

• V –model approach is good for smaller projects wherein the requirement is defined and
it freezes in the early stage.
• It is a systematic and disciplined model which results in a high-quality product.

Disadvantages of V-Model:

• V-shaped model is not good for ongoing projects.

• Requirement change at the later stage would cost too high.

Spiral Model:
Spiral model phases are followed in the iterations. The loops in the model represent the phase
of the SDLC process i.e. the innermost loop is of requirement gathering & analysis which follows
the Planning, Risk analysis, development, and evaluation. Next loop is Designing followed by
Implementation & then testing.

Spiral Model has four phases:

• Planning
 • Risk Analysis
• Engineering
• Evaluation

• It includes estimating the cost, schedule and resources for the iteration. It
also involves understanding the system requirements for continuous
Planning
communication between the system analyst and the customer

• Identification of potential risk is done while risk mitigation strategy is

Risk
planned and finalized
Analysis
• It includes testing, coding and deploying software at the customer site
Engineering
• Evaluation of software by the customer. Also, includes identifying and
Evaluation monitoring risks such as schedule slippage and cost overrun

Advantages of Spiral Model:

• Risk Analysis is done extensively using the prototype models.
• Any enhancement or change in the functionality can be done in the next iteration.
Disadvantages of Spiral Model:
• The spiral model is best suited for large projects only.
• The cost can be high as it might take a large number of iterations which can lead to high
time to reach the final product.

Incremental Model?
Incremental Model is a process of software development where requirements are broken down
into multiple standalone modules of software development cycle. Incremental development is
done in steps from analysis design, implementation, testing/verification, maintenance.
Advantage:
• This model permits the client to respond to and provide feedback on every build.
• Identifying errors becomes easy with incremental models.
• The product’s most important and useful functional capabilities can be identified at an
early stage of the development process.

Disadvantage:
• This model requires meticulous planning and designing.
• In order to break it down and build it incrementally, it needs a complete and clear
definition of the whole system.

Evolutionary models
Evolutionary models are iterative. They are characterized in a manner that enables you to
develop increasingly more complete versions of the software with each iteration. There are two
common evolutionary process models. Iterative” + “Incremental model” = Evolutionary model
It is very useful in a large project where you can easily find a module for step by step
implementation. The evolutionary model is used when the users need to start using the many
features instead of waiting for the complete software.
Advantage:
• There are fewer chances of errors because all the modules are well seen.
• It helps to reduce the risk of software projects.
• It also reduces the cost of development.
• Minimize serious problems during testing.
Disadvantage:
• The delivery of full software can be late due to different changes by customers during
development.
• It is difficult to divide the problem into several parts, that would be acceptable to the
customer which can be incrementally implemented and delivered.

RAD model:
RAD model in software engineering is the rapid application development model.
Rapid Application Development (RAD) is a form of agile methodology that prioritizes the rapid
prototype releases and iterations. RAD emphasizes the use of software and user feedback.
Instead of starting a development schedule from scratch each time, developers can make
multiple iterations and updates to a software rapidly by following the RAD.

Advantage:
-Encourages and priorities customer feedback.
-Requirements can be changed at any time because in start there is no detailed and strong requirement
management.
-Reviews are quick in RAD to facilitate the customer.
-Time between prototypes and iterations is short so team need to do it rapidly.
Disadvantage:
-RAD Needs highly skilled developers who can word rapidly.
-RAD is more complex to manage as compared to other SDLC models.
-RAD Needs user requirement throughout the life cycle of the product.

1.7 Specialized Process Models

Special process models take on many of the characteristics of one or more of the conventional
models. However, specialized models tend to be applied when a narrowly defined software
engineering approach is chosen.
Components Based Development :
In this approach, Commercial Off-The-Shelf (COTS) S/W components, developed by vendors
who offer them as products are used in the development of software. Characteristics resemble
to spiral model.
Merits:
 ➢ Leads to software reuse, which provides number of
benefits
• 70% reduction in development cycle time
• 84 % reduction in project cost
• Productivity index goes up to 26.2 ( Norm : 16.9)
Demerits:
➢ Component Library must be robust.
➢ Performance may degrade

The Formal Methods Model:

• The formal methods model encompasses a set of activities that
lead to formal mathematical specification of computer software.
• It consists of specifications, development & verification by applying
rigorous mathematical notation. Example, Clean Room S/W
Engineering (CRSE)
Merits:
➢ Removes many of the problems that are difficult to remove using other
S/W Engg. Paradigms.
➢ Ambiguity, Incompleteness & Inconsistency can be discovered &
corrected easily by using formal methods of mathematical analysis.
Demerits:
➢ Development is time consuming & expensive
➢ Extensive training is required
➢ Difficult to use with technically unsophisticated customers

Aspect Oriented Software Development (AOSD):

• A set of localized features, functions & information contents

are used while building complex software.
• These localized s/w characteristics are modeled as components
(e.g. OO classes) & then constructed within the context of a system architecture.
• Certain “concerns” (Customer required properties or areas of
technical interest) span the entire architecture i.e. Cross cutting
Concerns like system security, fault tolerance etc.
Merits:
➢ It is similar to component based development for aspects
Demerits:
➢ Component Library must be robust.
➢ Performance may degrade

clean-room software engineering

• It is an engineering approach which is used to build correctness in developed software.
• The main concept behind the clean-room software engineering is to remove the dependency on the
costly processes.
• The clean-room software engineering includes the quality approach of writing the code from the
beginning of the system and finally gathers into a complete a system.
Following tasks occur in clean-room engineering
1 Incremental planning
• The functionality of each increment, projected size of the increment and the clean-room development
schedule is created.

2. Requirements gathering
• Requirement gathering is done using the traditional techniques like analysis, design, code, test and
debug.

3. Box structure specification

• The specification method uses box structure.
• Box structure is used to describe the functional specification.
• The box structure separate and isolate the behavior, data and procedure in each increment.

4. Formal design
• The clean-room design is a natural specification by using the black box structure approach.
• The specification is called as state boxes and the component level diagram called as the clear boxes.

5. Correctness verification
• The clean-room conducts the exact correctness verification activities on the design and then the code.
• Verification starts with the highest level testing box structure and then moves toward the design detail
and code.

6. Code generation, inspection and verification

• The box structure specification is represented in a specialized language and these are translated into
the appropriate programming language.
• Use the technical reviews for the syntactic correctness of the code.

7. Statical test planning

• Analyzed, planned and designed the projected usages of the software.
• The clean-room activity is organized in parallel with specification, verification and code generation.

8 Statistical use testing

• The exhaustive testing of computer software is impossible. It is compulsory to design a limited number
of test cases.

9. Certification
• After the verification, inspection and correctness of all errors, the increments are certified and ready
for integration.

1.8 Unified Process and UML (Unified Modelling Language):

The Unified Process (UP) is a software development framework used for object-oriented
modeling.
Some of the key features of this process include:
-It defines the order of phases.
-It is component-based, meaning a software system is built as a set of software components.
There must be well-defined interfaces between the components for smooth communication.
-It follows an iterative, incremental, architecture-centric, and use-case driven approach
The Unified Modeling Language (UML) was created to forge a common, semantically, and
syntactically rich visual modeling language for the architecture, design, and implementation of
complex software systems both structurally and behaviorally.
UML uses elements and associates them in different ways to form diagrams that represent
static, or structural aspects of a system, and behavioral diagrams, which capture the dynamic
aspects of a system.
Structural UML diagrams
• Class Diagram
• Component Diagram
• Object Diagram
• Activity Diagrams
• Communication Diagram
• Interaction Overview Diagram
• Sequence Diagram
• State Diagram
• Timing Diagram
• Use Case Diagram

1.9 Agile Development

Agility:
• Effective (rapid and adaptive) response to change

• Effective communication among all stakeholders

• Drawing the customer onto the team

• Organizing a team so that it is in control of the work performed

Yielding …

• Rapid, incremental delivery of software

1.9.1 An Agile Process:

• Is driven by customer descriptions of what is required (scenarios)

• Recognizes that plans are short-lived

• Develops software iteratively with a heavy emphasis on construction activities

• Delivers multiple ‘software increments’

• Adapts as changes occur

1.9.2 Principles of Agility

1. Satisfy customers through early, continuous improvement and delivery. When

customers receive new updates regularly, they're more likely to see the changes they
 want within the product. This leads to happier, more satisfied customers—and more
recurring revenue.
2. Welcome changing requirements, even late in the project. The Agile framework is all
about adaptability. In iterative processes like Agile, being inflexible causes more harm
than good.
3. Deliver value frequently. Similar to principle #1, delivering value to your customers or
stakeholders frequently makes it less likely for them to churn.
4. Break the silos of your projects. Collaboration is key in the Agile framework. The goal is
for people to break out of their own individual projects and collaborate together more
frequently.
5. Build projects around motivated individuals. Agile works best when teams are
committed and actively working to achieve a goal.
6. The most effective way to communicate is face-to-face. If you’re working on a
distributed team, spend time communicating in ways that involve face-to-face
communication like Zoom calls.
7. Working software is the primary measure of progress. The most important thing that
teams should strive for with the Agile framework is the product. The goal here is to
prioritize functional software over everything else.
8. Maintain a sustainable working pace. Some aspects of Agile can be fast-paced, but it
shouldn't be so fast that team members burn out. The goal is to maintain sustainability
throughout the project.
9. Continuous excellence enhances agility. If the team develops excellent code in one
sprint, they can continue to build off of it the next. Continually creating great work
allows teams to move faster in the future.
10. Simplicity is essential. Sometimes the simplest solution is the best solution. Agile aims
to not overcomplicate things and find simple answers to complex problems.
11. Self-organizing teams generate the most value. Similar to principle #5, proactive teams
become valuable assets to the company as they strive to deliver value.
12. Regularly reflect and adjust your way of work to boost effectiveness. Retrospective
meetings are a common Agile practice. It's a dedicated time for teams to look back and
reflect on their performance and adapt their behaviors for the future.
1.9.3 Extreme Programming:

Extreme Programming (XP) is an agile software development framework that aims to produce
higher quality software, and higher quality of life for the development team. XP is the most
specific of the agile frameworks regarding appropriate engineering practices for software
development.
When applicable?

• Dynamically changing software requirements

• Risks caused by fixed time projects using new technology
• Small, co-located extended development team
• The technology you are using allows for automated unit and functional tests

The five values of XP include:

• Communication
• Simplicity
• Feedback
• Courage
• Respect

Communication
Software development is inherently a team sport that relies on communication to transfer
knowledge from one team member to everyone else on the team. XP stresses the importance
of the appropriate kind of communication – face to face discussion with the aid of a white
board or other drawing mechanism.
Simplicity
The purpose of this is to avoid waste and do only absolutely necessary things such as keep the
design of the system as simple as possible so that it is easier to maintain, support, and revise.
Feedback
Through constant feedback about their previous efforts, teams can identify areas for
improvement and revise their practices.
Courage
You need courage to raise organizational issues that reduce your team’s effectiveness. You
need courage to stop doing something that doesn’t work and try something else. You need
courage to accept and act on feedback, even when it’s difficult to accept.
Respect
The members of your team need to respect each other to communicate with each other,
provide and accept feedback that honors your relationship, and to work together to identify
simple designs and solutions.
Practices
While it is possible to do these practices in isolation, many teams have found some practices
reinforce the others and should be done in conjunction to fully eliminate the risks you often
face in software development.

1.9.4 Adaptive Software Development:

This Agile methodology enables teams to quickly adapt to changing requirements. The focus of
this process is continuous adaptation. The phases of this project type—speculate, collaborate,
and learn—allow for continuous learning as the project progresses.
It’s not uncommon for teams running ASD to be in all three phases of ASD at once. Because of
its non-linear structure, it’s common for the phases to overlap. Because of the fluidity of this
type of management, there’s a higher likelihood that the constant repetition of the three
phases helps team members identify and solve problems much quicker than standard project
management methods.

1.9.5 SCRUM
Scrum is a common Agile methodology for small teams and also involves sprints. The team is
led by a Scrum master whose main job is to clear all obstacles for others executing the day-to-
day work.
Scrum teams meet daily to discuss active tasks, roadblocks, and anything else that may affect
the development team.
 • Sprint planning: This event kicks off the sprint. Sprint planning outlines what can be
delivered in a sprint (and how).
• Sprint retrospective: This recurring meeting acts as a sprint review—to iterate on
learnings from a previous sprint that will improve and streamline the next one.

Extreme programming Scrum

Extreme programming focuses on programming, coding, and test-driven

Scrum focuses largely on management.
methodology.

In Scrum, teams work in “sprints,” which can last

Extreme programming requires just one to two weeks of teamwork.
from a few weeks to a few months.

Extreme programming uses story cards to keep track of tasks. Scrum uses task boards to track tasks.

Scrum does not permit changes to its timeline or

Extreme programming permits changes to predetermined timelines.
principles.

The purpose of an extreme programming sprint is not product release, Scrum sprints are intended to result in a
but rather the creation of bug-free software. functional product.

The customer prioritizes the features to be built,

Extreme programming works strictly in order of sequential priority. and the team is expected to execute them in that
order.

Extreme programming practices include simple design, pair

Scrum does not prescribe any engineering
programming, constant testing, ongoing integration, refactoring, coding
practices but emphasizes self-organization.
standards, and small releases.

1.9.6 Dynamic System Development Methods

The Dynamic Systems Development Method is an Agile method that focuses on a full project
lifecycle. Because of this, DSDM has a more rigorous structure and foundation, unlike other
Agile methods.
There are four main phases of DSDM:
• Feasibility and business study
• Functional mode or prototype iteration
 • Design and build iteration.
• Implementation

1.9.7 Feature Driven Development (FDD)

Feature Driven Development blends different Agile best practices. While still an iterative
method of project management, this model focuses more on the exact features of a software
that the team is working to develop. Feature-driven development relies heavily on customer
input, as the features the team prioritizes are the features that the customers need.
This model also allows teams to update projects frequently. If there is an error, it's quick to
cycle through and implement a fix as the phases of this framework are constantly moving.

1.9.8 Lean Software Development

Lean Software Development (LSD) is an agile framework based on optimizing development time
and resources, eliminating waste, and ultimately delivering only what the product needs. The
Lean approach is also often referred to as the Minimum Viable Product (MVP) strategy, in
which a team releases a bare-minimum version of its product to the market, learns from users
what they like, don’t like and want to be added, and then iterates based on this feedback.
Lean Principles:

LSD’s strengths include:

• Streamlined approach allows more functionality to be delivered in less time
• Eliminates unnecessary activity, and as a result, can reduce costs
 • Empowers the development team to make decisions, which can also boost morale
LSD’s weaknesses include:
• Heavily depends on the team involved, making it not as scalable as other frameworks
• Depends on strong documentation, and failure to do so can result in development
mistakes