CSMI15 -SOFTWARE

ENGINEERING
C.Vinoth
Research Scholar
Dept CSE
NIT Trichy
UNIT –I Software Engineering Modeling
The Evolving role of Software - The changing Nature of Software -
Legacy software - A generic view of process - A layered Technology - A
Process Framework - Software Development Life cycle (SDLC) Models:
WaterFall Model - Prototype Model - Spiral Model - Evolutionary
Development Models - Iterative Enhancement Models - Incremental
Process Model - Concurrent Development Model - The Unified Process.
Introduction to software Engineering
The Evolving role of software
• Dual role of Software
A Product
- Information transformer-producing, managing and displaying
A Vehicle for delivering a product
- Control of computer(operating system),the communication of
information(networks) and the creation of other programs
Introduction to software Engineering
• Software is defined as
1. Instructions
- Programs that when executed provide desired function
2. Data structures
-Enable the programs to adequately manipulate information
3. Documents
-Describe the operation and use of the programs.
What Careers Are There in Software
Engineering ?
• Career opportunities in software engineering are driven by new
technologies in automobiles, aviation, data management,
telecommunications, factory control, robotics, defense, and security.
Software engineers may develop computer games, business
applications, operating systems, network control systems, and more.
• Two common jobs within software engineering are Applications
developers and Systems developers.
• Applications developers design computer applications, such as
games, for consumers. They may create custom software for a specific
customer or commercial software to be sold to the general public.
Some applications developers create databases or programs for use
internally or online.

• Systems developers create operating systems, either for the public or

for an organization. These operating systems keep computers
functioning and control most of the consumer electronics in use today,
including those in cell phones and cars. Often, systems developers also
build the interface that allows users to interact with the computer.
Some common job titles for software engineers include:
• Applications Architect
• Applications Developer
• Computer Applications Engineer
• Database Administrator
• Mobile Developer
• Program Manager
• Programmer
• Project Leader
• Quality Assurance Analyst
• Software Engineer
• Software Quality Engineer
• Systems Analyst
• Systems Developer
Introduction to software Engineering
• Definition of Engineering
-Application of science, tools and methods to find cost effective
solution to problems
Definition of SOFTWARE ENGINEERING
- SE is defined as systematic, disciplined and quantifiable approach for
the development, operation and maintenance of software
Characteristics of software

• Software is developed or engineered, it is not manufactured in the

classical sense.
• Software does not wear out. However it deteriorates due to change.
• Software is custom built rather than assembling existing
components.
-Although the industry is moving towards component based
construction, most software continues to be custom built
CHARACTERISTICS OF HARDWARE

“Infant
Failure rate

mortality” “Wear out”

Time

Fig: FAILURE CURVE FOR HARDWARE

CHARACTERISTICS OF SOFTWARE

Fig: FAILURE CURVE FOR SOFTWARE

11
THE CHANGING NATURE OF SOFTWARE
• Seven Broad Categories of software are challenges for software
engineers
➢System software
➢Application software
➢Engineering and scientific software
➢Embedded software
➢Product-line software
➢Web-applications
➢Artificial intelligence software
THE CHANGING NATURE OF SOFTWARE
• System software. System software is a collection of programs written
to service other programs
• Embedded software
-- resides in read-only memory
--is used to control products and systems for the consumer and
industrial markets.
• Artificial intelligence software. Artificial intelligence (AI) software
makes use of nonnumeric algorithms to solve complex problems that
are not amenable to computation or straightforward analysis
• Engineering and scientific software. Engineering and scientific
software have been characterized by "number crunching" algorithms.
LEGACY SOFTWARE
• Legacy software are older programs that are developed decades ago.
• Legacy software refers to outdated software systems that are still in
use because they are critical for the organization, despite having been
developed using older technologies or methodologies. These systems
are often difficult to maintain, upgrade, or integrate with modern
applications.

• The quality of legacy software is poor because it has inextensible

design, convoluted code, poor and nonexistent documentation, test
cases and results that are not achieved.
Characteristics of Legacy Software:
1. Obsolete Technology: Built using old programming languages and
technologies that are no longer widely supported.
2. Complex Codebase: Often poorly documented, making it difficult for
developers to understand and modify.
3. High Maintenance Costs: Requires significant resources to keep
running.
4. Critical Role: Despite challenges, it often supports key business
processes.
5. Inflexibility: Hard to adapt to changing business requirements or
integrate with new systems.
• As time passes legacy systems evolve due to following reasons:
➢ADOPTABILITY: The software must be adapted to meet the needs of new
computing environment or technology.

➢ENHANCEMENT: The software must be enhanced to implement new business

requirements.

➢EXTENSIBILITY: The software must be extended to make it interoperable with

more modern systems or database

➢REARCHITECTURE: The software must be rearchitected to make it viable

within a network environment.
Challenges with Legacy Software:
• Maintenance: Due to a lack of documentation and expertise,
maintaining legacy systems can be challenging.
• Scalability Issues: Legacy systems may not support modern scalability
needs.
• Security Risks: Often more vulnerable to security breaches due to
outdated security mechanisms.
• Integration Problems: Difficulty in connecting with newer software or
systems.
Strategies to Handle Legacy Software:
1. Encapsulation: Wrapping the legacy system with an interface to
allow integration with new systems.
2. Rehosting: Migrating the application to a modern platform without
changing its functionality.
3. Reengineering: Redesigning the application to improve its structure,
performance, or maintainability.
4. Replacement: Developing a completely new system to replace the
legacy software.
Software Evolution
• Software evolves due to changes
• Changes occur due to correction,adaption and enhancement
• 8 Laws of unified theory
▪ The Law of Continuing Change.

▪ The Law of Increasing Complexity.

▪ The Law of Self-Regulation

▪ The Law of Conservation of Organizational Stability.

▪ The Law of Conservation of Familiarity

▪ The Law of Continuing Growth

▪ The Law of Declining Quality

A Generic View of Process
• A software process provides a framework for building software
products, focusing on tasks, activities, and the sequence necessary for
software development.
• Key Elements:
• Methods: Techniques used to create and refine models for software
development.
• Tools: Automated or semi-automated systems that aid the methods.
• Process Models: Organized methods that provide structure to software
development tasks.
SOFTWARE ENGINEERING-A LAYERED TECHNOLOGY

Basic
Forms Principles
basic SW

Fig: Software Engineering-A layered technology

Increases more effective

apporach
SOFTWARE ENGINEERING-A LAYERED TECHNOLOGY
Software engineering is built upon a foundation of layered technology that provides a
structured framework to develop high-quality software systems. The layers include a
quality focus at the core, surrounded by a process layer that establishes the tasks and
activities required. Above this, the methods layer defines the technical procedures
necessary for software development, and the tools layer offers automated or semi-
automated support to enhance productivity and consistency.
• Quality focus:
- Core that supports software Engineering.
• Process:
- Foundation for software Engineering
• Methods:
- Provide technical How-to’s for building software
• Tools:
- Provide semi-automatic and automatic support to methods-Automation
A PROCESS FRAMEWORK
A process framework is a structured approach that guides the planning,
modeling, construction, and deployment of software systems. This framework is
flexible and adaptable to meet the specific needs of different software projects. It
emphasizes essential activities such as communication, planning, modeling,
construction, and deployment while ensuring that high-quality outcomes are
achieved through iterative feedback and improvement.
• Establishes the foundation for a complete software process
• Identifies a number of framework activities applicable to all software projects
• Also include a set of umbrella activities that are applicable across the entire
software process.
A PROCESS FRAMEWORK
• Software process must be established for effective delivery of software engineering
technology.

• A process framework establishes the foundation for a complete software process by

identifying a small number of framework activities that are applicable to all
software projects, regardless of their size or complexity.

• The process framework encompasses a set of umbrella activities that are applicable
across the entire software process.

• Each framework activity is populated by a set of software engineering actions .

• Each software engineering action is represented by a number of different task sets-

each a collection of software engineering work tasks, related work products,
quality assurance points, and project milestones .
A PROCESS FRAMEWORK

Common process framework

Framework activities

TTTasks

Milestones,delierables

SQA points

Umbrella activities
A PROCESS FRAMEWORK

• Used as a basis for the description of process models

Generic process activities

Process Framework Activities:
• Communication: Engaging with stakeholders to gather requirements.
• Planning: Establishing work plans, timelines, and resource allocation.
• Modeling: Creating models to visualize system structures and behaviors.
• Construction: Actual coding and testing of software products.
• Deployment: Delivering the product to the user and receiving feedback.
Umbrella Activities
These are activities that span across all stages of the software development process
to manage progress, ensure quality, and mitigate risks:
• Software Project Tracking and Control: Monitoring progress and ensuring
adherence to project timelines.
• Risk Management: Identifying and addressing potential issues that could impact
project success.
• Software Quality Assurance (SQA): Conducting activities to maintain product
quality.
• Technical Reviews: Reviewing work products to uncover and correct errors early.
• Measurement: Collecting metrics to guide improvements and evaluate
performance.
• Software Configuration Management (SCM): Controlling changes in project
artifacts.
• Work Product Preparation and Production: Creating necessary documentation,
models, and logs​
Generic Process Framework: It is applicable to the vast majority of software
projects
Communication activity
Planning activity
Modeling activity
analysis action
requirements gathering work task
elaboration work task
negotiation work task
specification work task
validation work task
design action
data design work task
architectural design work task
interface design work task
component-level design work task
Construction activity
Deployment activity
 Software Development Life Cycle (SDLC)
SDLC is a process followed for the development, deployment, and maintenance of high-quality
software. It consists of the following key phases:
1.Planning: Define objectives, feasibility, and requirements.
2.Requirements Analysis: Gather and analyze user and system requirements.
3.Design: Develop architectural and detailed designs of the software.
4.Implementation (Coding): Write and compile the source code.
5.Testing: Detect and fix defects to ensure the software functions as expected.
6.Deployment: Deliver the software to the end users.
7.Maintenance: Provide ongoing support and enhancements.
Key Benefits:
•Improves project management.
•Ensures software quality and reliability.
•Helps track project progress.
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.

• Context: Used when requirements are reasonably well understood.

Advantage:

• It can serve as a useful process model in situations where requirements are fixed and work is to
proceed to complete in a linear manner.
The problems that are sometimes encountered when the waterfall model is applied are:

1. Real projects rarely follow the sequential flow that the model proposes. Although the linear
model can accommodate iteration, it does so indirectly. As a result, changes can cause confusion
as the project team proceeds.

2. It is often difficult for the customer to state all requirements explicitly. The waterfall model
requires this and has difficulty accommodating the natural uncertainty that exist at the beginning
of many projects.

3. The customer must have patience. A working version of the programs will not be available until
late in the project time-span. If a major blunder is undetected then it can be disastrous until the
program is reviewed.
 Prototype Model
Concept: Build a quick working model (prototype) to understand user requirements
better.
Prototyping is more commonly used as a technique that can be implemented within
the context of anyone of the process model.
Steps:
1.Build a prototype.
2.Get user feedback.
3.Refine and develop the final system.
Key Features:
•Reduces misunderstandings.
•Useful for unclear requirements.
The prototyping paradigm
• The prototyping paradigm begins with communication. The software engineer and
customer meet and define the overall objectives for the software, identify whatever
requirements are known, and outline areas where further definition is mandatory.
• Prototyping iteration is planned quickly and modeling occurs. The quick design leads to
the construction of a prototype. The prototype is deployed and then evaluated by the
customer/user.
• Iteration occurs as the prototype is tuned to satisfy the needs of the customer, while at
the same time enabling the developer to better understand what needs to be done.
• Disadvantages of Prototyping in Software Development
• Misleading Perception of Product Readiness:
• The prototype may appear as a fully functional product to the customer.
• Underlying issues like poor quality and lack of maintainability are hidden.
• Rebuilding for quality is often Feel dissatisfied, leading to demands for quick fixes.
• Compromised Development Decisions:
• Quick implementation may involve suboptimal choices (e.g., unsuitable OS,
programming language, or inefficient algorithms).
• Temporary decisions may become permanent, negatively affecting the final product's
quality and performance.
Spiral Model
Concept: A risk-driven model combining iterative development with systematic
stages.
Phases (Repeated in spirals):
1.Planning → 2. Risk Analysis → 3. Engineering → 4. Evaluation
Key Features:
•Focuses on risk management.
•Flexible for complex projects.
Analogy: Like climbing a spiral staircase—revisiting each phase but at a higher level.
Spiral Model Overview
1.Introduction:
•Proposed by Boehm, it combines prototyping's iterative nature with the systematic approach
of the waterfall model.
•Adaptable across the entire software life cycle, from concept to maintenance.
2.Development Process:
•Software evolves through a series of evolutionary releases.
•Early iterations: Paper models or prototypes.
•Later iterations: More complete engineered systems.
3.Key Features:
•Anchor Point Milestones: Work products and conditions marked at each spiral pass.
•Iterative adjustments in project plan, cost, and schedule based on customer feedback.
4.Application of the Spiral:
•First Circuit: Concept development, starting at the spiral's core.
•Subsequent Circuits: New product development or product enhancement projects.
5.Advantages:
•Combines systematic, stepwise progress with real-world iterative adaptability.
•Operative throughout the software life cycle until product retirement.
Drawbacks of the Spiral Model

1.Not a Universal Solution:

•The spiral model is not suitable for all projects or scenarios.
2.Customer Convincing:
•Customers may find it hard to believe that the evolutionary approach is
well-controlled.
3.Dependency on Risk Expertise:
•Requires significant expertise in risk assessment and management.
•Success heavily depends on identifying and addressing major risks.
4.Risk of Undetected Problems:
•Failure to uncover and manage critical risks can lead to significant project
issues.
Evolutionary Development Models
• Concept: Software evolves over time through multiple versions.
• Introduction:
• Software evolves over time due to changing business and product requirements.
• Straight-line development is unrealistic due to tight market deadlines and evolving needs.
• Evolutionary models accommodate products that grow and adapt over time.
• Key Features:
• Iterative Development: Software evolves through multiple iterations.
• Evolutionary process models produce an increasingly more complete version of the
software with each iteration.
• Start with a simple version.
• Add features progressively based on feedback.

• Examples: Agile, Iterative Models.

• Benefit: Fast delivery of usable software.

• Evolutionary Development Models
• Process Overview:
• Core Activities in Each Iteration:
• Communication
• Planning
• Modeling (analysis and design)
• Construction (coding and testing)
• Deployment (delivery and feedback)
• Iterations deliver incremental functionality over project calendar time.
• Advantages:
• Supports delivery of a limited version to meet market or business pressures.
• Allows for gradual development as system extensions are defined.
• Aligns with agile principles, emphasizing incremental progress.
• Examples of Evolutionary Models:
• Incremental Model
• Spiral Model
Iterative Enhancement Models

Concept: Build software step by step, improving with each iteration.

In software development, the Iterative Enhancement Model stands out due to its

incremental and iterative nature, it is also known as an incremental model.

Key Features:

•Feedback-driven improvements.

•Handles changes easily.

Example: Updating mobile apps with new features in each version.

Advantages of Iterative Enhancement Model

• Adaptation to changing requirements is made possible by its flexibility in

accomodating modifications and improvement during each iteration.
• Early software iterations provide clients with functional portions of the
product, facilitating prompt feedback and validation.
• Problems and risks can be identified and addressed early in the
developement process, reduces chances of issue for future stages.
• Feedback and constant client involvement are encouraged to make sure
the finished product lives up to user expectations.
• Every iteration is put through testing and improvement, leading to higher
quality product.
Disadvantages of Iterative Enhancement Model

• Especially in larger projects, managing several iterations at once can

add complexity.
• Higher cost
• Due to constant changes, there may be delays in documentation,
making it more difficult to maintain comprehensive documentation.
• Continuous customer engagement may not be possible in all
scenarios, which impacts the effectiveness of the model.
Specific use cases where this model proves beneficial include:

• Mobile app developement: Updates and improvements are often needed for mobile
apps to stay current with new devices, operating system versions and user preferences.
By using an iterative process developers can release the beta versions of their apps, get
user feedback and then improve functionality of those iterations in future release.
• Web Application Development: The requirements for developing web applications
frequently change as a result of shifting user demand and advancements in technology.
The Iterative Enhancement Model makes it possible to developed features incrementally
and guaranteeing that the application can be modified to satisfy changing user and
market demands. In later iterations it also makes it easier to incorporate new features
based on input from users.
• E-commerce Platforms: Developement in e-commerece field often involves constant
updates. Implementing an iterative approach enables the introduction of new
functionality.
Incremental Process Model
• Concept: Develop the software in small, manageable pieces (increments).
• The incremental model combines elements of linear and parallel process flows.
• The incremental model applies linear sequences in a staggered fashion as
calendar time progresses.
• When an incremental model is used, the first increment is often a core product.
• That is, basic requirements are addressed but many supplementary features
(some known, others unknown) remain undelivered.
• The core product is used by the customer (or undergoes detailed evaluation).
• As a result of use and/or evaluation, a plan is developed for the next increment.
• The plan addresses the modification of the core product to better meet the
needs of the customer and the delivery of additional features and functionality.
This process is repeated following the delivery of each increment, until the
complete product is produced
Incremental Process Model
1.Focus on Incremental Delivery:
•Each increment delivers an operational product.
•Early increments are simplified versions but provide useful capabilities to users.
•Offers a platform for user evaluation and feedback.
2.Advantages for Staffing:
•Useful when full project staffing is unavailable by the business deadline.
•Early increments can be developed with a smaller team.
•Additional staff can be added for subsequent increments if the core product is well-
received.
3.Risk Management:
•Increments can be planned to address technical risks.
•Allows functionality delivery without delays caused by dependencies (e.g., new
hardware under development).
4.Key Benefits:
•Early delivery of partial functionality.
•User feedback incorporated into subsequent increments.
•Flexible and adaptive to changing requirements and constraints.
Incremental Process Model
Concurrent Development Model
• Concept: Develop multiple parts of the software simultaneously.
• The concurrent development model, sometimes called concurrent
engineering, allows a software team to represent iterative and
concurrent elements of any of the process models described in this
SDLC Models .
• For example, the modeling activity defined for the spiral model is
accomplished by invoking one or more of the following software
engineering actions: prototyping, analysis, and design.
The concurrent model is often more appropriate for product
engineering projects where different engineering teams are involved.
Why Use This Model?

• Adaptable to Changes: Easily handles evolving customer needs or

newly discovered problems.
• Supports Complex Projects: Useful when different teams work on
multiple aspects of the project at the same time.
• Improved Collaboration: Encourages teams to share progress and
identify issues early.
One element of the concurrent process model
• States in the Diagram
• Inactive:
• The activity is not started yet.
• Example: The modeling phase has not begun because other tasks, such as requirement gathering, are still
ongoing.
• Under Development:
• The activity is actively being worked on.
• Example: Developers are creating a model of the system architecture.
• Awaiting Changes:
• The activity is paused because it is waiting for updates or changes.
• Example: The customer requests modifications to the system requirements, so modeling is halted until the
changes are provided.
• Under Revision:
• The activity is being revised to address changes or corrections.
• Example: After receiving updated requirements, the modeling team adjusts the system model accordingly.
• Under Review:
• The work done is being evaluated or validated.
• Example: The system model is being reviewed by stakeholders or a quality assurance team.
• Baselined:
• The activity is finalized and approved as the baseline version.
• Example: The completed and reviewed system model is accepted as the foundation for further development.
• Done:
• The activity is fully completed.
• Example: The modeling phase is successfully finished and no further work is required.
Disadvantages
•Complexity in Management:
Handling multiple activities in parallel requires careful coordination and can
become complex, especially in large-scale projects.
•Dependency Issues:
Since different tasks are happening simultaneously, dependencies between tasks
can cause delays if one task needs changes or revisions.
•Requires Skilled Team:
A team must be highly skilled in communication and multitasking to effectively
manage overlapping tasks.
•Risk of Miscommunication:
As tasks are concurrent, misunderstandings or incomplete information sharing
among team members may lead to errors.
•Frequent Revisions:
Since changes can happen at any stage, frequent revisions may lead to higher costs
and longer timelines if not managed properly.
 Unified Process (UP)

UP combines the best features of traditional models and agile principles.

Emphasizes customer communication, iterative progress, and strong architecture.
Key Characteristics:
• Iterative and incremental
• Customer-driven approach
• Strong focus on software architecture
Example: Developing a ride-sharing app like Uber, with continuous updates and user feedback.
Timeline:
• 1980s–1990s: Rise of Object-Oriented (OO) methods
• Early 1990s: James Rumbaugh, Grady Booch, and Ivar Jacobson developed Unified Modeling
Language (UML).
• 1997: UML became an industry standard; UP framework was developed.
• Example: UML diagrams are used in modern apps like e-commerce platforms (Amazon) to model
functionality.
 Key Phases of Unified Process
•Inception Phase:
Establish project vision, business case, and risks.
10–20% of use-case model is created.
Example: For a food delivery app, this phase identifies core features like restaurant search, order
placement, and payment processing.
•Elaboration Phase:
Refine use-cases, define architecture, and expand design.
80–90% of use-case model is developed.
Example: Designing database tables for users, restaurants, and orders.
•Construction Phase:
Develop software components and finalize the design.
Example: Coding the login and payment systems for the app.
•Transition Phase:
Deliver beta version, gather feedback, and make final changes.
Example: Beta testing with users to fix bugs in the delivery tracking system.
•Production Phase:
Monitor software use and address defects.
Example: Continuous updates and customer support for the app.
Work Products of Unified Process

• Inception Phase:
• Vision document, business case, use-case model (10–20%).
• Elaboration Phase:
• Refined use-case model, analysis model, and architectural design.
• Construction Phase:
• Implementation model, test cases, final software increment.
• Transition Phase:
• Beta software, user feedback reports.
• Example: During elaboration, create wireframes for a messaging app's
user interface.
Unified Process with UML

• Role of UML:
• Use-case diagrams for user interactions.
• Class diagrams for system architecture.
• Sequence diagrams for process flow.
• Example: For a banking app:
• Use-case: "Transfer Funds" feature.
• Class: "Account" and "Transaction."
Advantages of Unified Process

• Iterative and flexible for changing requirements.

• Focus on risk management.
• Encourages reuse of components.
• Example: Feature updates in social media apps (like Instagram's
Stories feature).
Challenges of Unified Process

• Complexity in managing iterative processes.

• Requires skilled team members.
• Can be time-consuming.
• Example: Coordinating multiple workflows in a large-scale ERP
system.